gcc/java/builtins.c

   1 /* Built-in and inline functions for gcj
   2    Copyright (C) 2001-2016 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 GCC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 .
  17
  18 .
  19
  20 Java and all Java-based marks are trademarks or registered trademarks
  21 of Sun Microsystems, Inc. in the United States and other countries.
  22 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  23
  24 /* Written by Tom Tromey <tromey@redhat.com>.  */
  25
  26 /* FIXME: Still need to include rtl.h here (see below).  */
  27 #undef IN_GCC_FRONTEND
  28
  29 #include "config.h"
  30 #include "system.h"
  31 #include "coretypes.h"
  32 #include "tm.h"
  33 #include "rtl.h"
  34 #include "tree.h"
  35 #include "stringpool.h"
  36 #include "expmed.h"
  37 #include "optabs.h"
  38 #include "fold-const.h"
  39 #include "stor-layout.h"
  40 #include "java-tree.h"
  41
  42 /* FIXME: All these headers are necessary for sync_compare_and_swap.
  43    Front ends should never have to look at that.  */
  44
  45 static tree max_builtin (tree, tree);
  46 static tree min_builtin (tree, tree);
  47 static tree abs_builtin (tree, tree);
  48 static tree convert_real (tree, tree);
  49
  50 static tree java_build_function_call_expr (tree, tree);
  51
  52 static tree putObject_builtin (tree, tree);
  53 static tree compareAndSwapInt_builtin (tree, tree);
  54 static tree compareAndSwapLong_builtin (tree, tree);
  55 static tree compareAndSwapObject_builtin (tree, tree);
  56 static tree putVolatile_builtin (tree, tree);
  57 static tree getVolatile_builtin (tree, tree);
  58 static tree VMSupportsCS8_builtin (tree, tree);
  59 \f
  60
  61 /* Functions of this type are used to inline a given call.  Such a
  62    function should either return an expression, if the call is to be
  63    inlined, or NULL_TREE if a real call should be emitted.  Arguments
  64    are method return type and the original CALL_EXPR containing the
  65    arguments to the call.  */
  66 typedef tree builtin_creator_function (tree, tree);
  67
  68 /* Hold a char*, before initialization, or a tree, after
  69    initialization.  */
  70 union GTY(()) string_or_tree {
  71   const char * GTY ((tag ("0"))) s;
  72   tree GTY ((tag ("1"))) t;
  73 };
  74
  75 /* Used to hold a single builtin record.  */
  76 struct GTY(()) builtin_record {
  77   union string_or_tree GTY ((desc ("1"))) class_name;
  78   union string_or_tree GTY ((desc ("1"))) method_name;
  79   builtin_creator_function * GTY((skip)) creator;
  80   enum built_in_function builtin_code;
  81 };
  82
  83 static GTY(()) struct builtin_record java_builtins[] =
  84 {
  85   { { "java.lang.Math" }, { "min" }, min_builtin, (enum built_in_function) 0 },
  86   { { "java.lang.Math" }, { "max" }, max_builtin, (enum built_in_function) 0 },
  87   { { "java.lang.Math" }, { "abs" }, abs_builtin, (enum built_in_function) 0 },
  88   { { "java.lang.Math" }, { "acos" }, NULL, BUILT_IN_ACOS },
  89   { { "java.lang.Math" }, { "asin" }, NULL, BUILT_IN_ASIN },
  90   { { "java.lang.Math" }, { "atan" }, NULL, BUILT_IN_ATAN },
  91   { { "java.lang.Math" }, { "atan2" }, NULL, BUILT_IN_ATAN2 },
  92   { { "java.lang.Math" }, { "ceil" }, NULL, BUILT_IN_CEIL },
  93   { { "java.lang.Math" }, { "cos" }, NULL, BUILT_IN_COS },
  94   { { "java.lang.Math" }, { "exp" }, NULL, BUILT_IN_EXP },
  95   { { "java.lang.Math" }, { "floor" }, NULL, BUILT_IN_FLOOR },
  96   { { "java.lang.Math" }, { "log" }, NULL, BUILT_IN_LOG },
  97   { { "java.lang.Math" }, { "pow" }, NULL, BUILT_IN_POW },
  98   { { "java.lang.Math" }, { "sin" }, NULL, BUILT_IN_SIN },
  99   { { "java.lang.Math" }, { "sqrt" }, NULL, BUILT_IN_SQRT },
 100   { { "java.lang.Math" }, { "tan" }, NULL, BUILT_IN_TAN },
 101   { { "java.lang.Float" }, { "intBitsToFloat" }, convert_real,
 102     (enum built_in_function) 0 },
 103   { { "java.lang.Double" }, { "longBitsToDouble" }, convert_real,
 104     (enum built_in_function) 0 },
 105   { { "java.lang.Float" }, { "floatToRawIntBits" }, convert_real,
 106     (enum built_in_function) 0 },
 107   { { "java.lang.Double" }, { "doubleToRawLongBits" }, convert_real,
 108     (enum built_in_function) 0 },
 109   { { "sun.misc.Unsafe" }, { "putInt" }, putObject_builtin,
 110     (enum built_in_function) 0},
 111   { { "sun.misc.Unsafe" }, { "putLong" }, putObject_builtin,
 112     (enum built_in_function) 0},
 113   { { "sun.misc.Unsafe" }, { "putObject" }, putObject_builtin,
 114   (enum built_in_function) 0},
 115   { { "sun.misc.Unsafe" }, { "compareAndSwapInt" },
 116     compareAndSwapInt_builtin, (enum built_in_function) 0},
 117   { { "sun.misc.Unsafe" }, { "compareAndSwapLong" },
 118     compareAndSwapLong_builtin, (enum built_in_function) 0},
 119   { { "sun.misc.Unsafe" }, { "compareAndSwapObject" },
 120     compareAndSwapObject_builtin, (enum built_in_function) 0},
 121   { { "sun.misc.Unsafe" }, { "putOrderedInt" }, putVolatile_builtin,
 122     (enum built_in_function) 0},
 123   { { "sun.misc.Unsafe" }, { "putOrderedLong" }, putVolatile_builtin,
 124     (enum built_in_function) 0},
 125   { { "sun.misc.Unsafe" }, { "putOrderedObject" }, putVolatile_builtin,
 126     (enum built_in_function) 0},
 127   { { "sun.misc.Unsafe" }, { "putIntVolatile" }, putVolatile_builtin,
 128     (enum built_in_function) 0},
 129   { { "sun.misc.Unsafe" }, { "putLongVolatile" }, putVolatile_builtin,
 130     (enum built_in_function) 0},
 131   { { "sun.misc.Unsafe" }, { "putObjectVolatile" }, putVolatile_builtin,
 132     (enum built_in_function) 0},
 133   { { "sun.misc.Unsafe" }, { "getObjectVolatile" }, getVolatile_builtin,
 134     (enum built_in_function) 0},
 135   { { "sun.misc.Unsafe" }, { "getIntVolatile" }, getVolatile_builtin,
 136     (enum built_in_function) 0},
 137   { { "sun.misc.Unsafe" }, { "getLongVolatile" }, getVolatile_builtin, (enum built_in_function) 0},
 138   { { "sun.misc.Unsafe" }, { "getLong" }, getVolatile_builtin,
 139     (enum built_in_function) 0},
 140   { { "java.util.concurrent.atomic.AtomicLong" }, { "VMSupportsCS8" },
 141     VMSupportsCS8_builtin, (enum built_in_function) 0},
 142   { { NULL }, { NULL }, NULL, END_BUILTINS }
 143 };
 144
 145 \f
 146 /* Internal functions which implement various builtin conversions.  */
 147
 148 static tree
 149 max_builtin (tree method_return_type, tree orig_call)
 150 {
 151   /* MAX_EXPR does not handle -0.0 in the Java style.  */
 152   if (TREE_CODE (method_return_type) == REAL_TYPE)
 153     return NULL_TREE;
 154   return fold_build2 (MAX_EXPR, method_return_type,
 155                       CALL_EXPR_ARG (orig_call, 0),
 156                       CALL_EXPR_ARG (orig_call, 1));
 157 }
 158
 159 static tree
 160 min_builtin (tree method_return_type, tree orig_call)
 161 {
 162   /* MIN_EXPR does not handle -0.0 in the Java style.  */
 163   if (TREE_CODE (method_return_type) == REAL_TYPE)
 164     return NULL_TREE;
 165   return fold_build2 (MIN_EXPR, method_return_type,
 166                       CALL_EXPR_ARG (orig_call, 0),
 167                       CALL_EXPR_ARG (orig_call, 1));
 168 }
 169
 170 static tree
 171 abs_builtin (tree method_return_type, tree orig_call)
 172 {
 173   return fold_build1 (ABS_EXPR, method_return_type,
 174                       CALL_EXPR_ARG (orig_call, 0));
 175 }
 176
 177 /* Construct a new call to FN using the arguments from ORIG_CALL.  */
 178
 179 static tree
 180 java_build_function_call_expr (tree fn, tree orig_call)
 181 {
 182   int nargs = call_expr_nargs (orig_call);
 183   switch (nargs)
 184     {
 185       /* Although we could handle the 0-3 argument cases using the general
 186          logic in the default case, splitting them out permits folding to
 187          be performed without constructing a temporary CALL_EXPR.  */
 188     case 0:
 189       return build_call_expr (fn, 0);
 190     case 1:
 191       return build_call_expr (fn, 1, CALL_EXPR_ARG (orig_call, 0));
 192     case 2:
 193       return build_call_expr (fn, 2,
 194                               CALL_EXPR_ARG (orig_call, 0),
 195                               CALL_EXPR_ARG (orig_call, 1));
 196     case 3:
 197       return build_call_expr (fn, 3,
 198                               CALL_EXPR_ARG (orig_call, 0),
 199                               CALL_EXPR_ARG (orig_call, 1),
 200                               CALL_EXPR_ARG (orig_call, 2));
 201     default:
 202       {
 203         tree fntype = TREE_TYPE (fn);
 204         fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fn);
 205         return fold (build_call_array (TREE_TYPE (fntype),
 206                                        fn, nargs, CALL_EXPR_ARGP (orig_call)));
 207       }
 208     }
 209 }
 210
 211 static tree
 212 convert_real (tree method_return_type, tree orig_call)
 213 {
 214   return build1 (VIEW_CONVERT_EXPR, method_return_type,
 215                  CALL_EXPR_ARG (orig_call, 0));
 216 }
 217
 218 \f
 219
 220 /* Provide builtin support for atomic operations.  These are
 221    documented at length in libjava/sun/misc/Unsafe.java.  */
 222
 223 /* FIXME.  There are still a few things wrong with this logic.  In
 224    particular, atomic writes of multi-word integers are not truly
 225    atomic: this requires more work.
 226
 227    In general, double-word compare-and-swap cannot portably be
 228    implemented, so we need some kind of fallback for 32-bit machines.
 229
 230 */
 231
 232
 233 /* Macros to unmarshal arguments from a CALL_EXPR into a few
 234    variables.  We also convert the offset arg from a long to an
 235    integer that is the same size as a pointer.  */
 236
 237 #define UNMARSHAL3(METHOD_CALL)                                 \
 238 tree this_arg, obj_arg, offset_arg;                                     \
 239 do                                                                      \
 240 {                                                                       \
 241   tree orig_method_call = METHOD_CALL;                                  \
 242   this_arg = CALL_EXPR_ARG (orig_method_call, 0);                       \
 243   obj_arg = CALL_EXPR_ARG (orig_method_call, 1);                        \
 244   offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0),      \
 245                              CALL_EXPR_ARG (orig_method_call, 2));      \
 246 }                                                                       \
 247 while (0)
 248
 249 #define UNMARSHAL4(METHOD_CALL)                                 \
 250 tree value_type, this_arg, obj_arg, offset_arg, value_arg;              \
 251 do                                                                      \
 252 {                                                                       \
 253   tree orig_method_call = METHOD_CALL;                                  \
 254   this_arg = CALL_EXPR_ARG (orig_method_call, 0);                       \
 255   obj_arg = CALL_EXPR_ARG (orig_method_call, 1);                        \
 256   offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0),      \
 257                              CALL_EXPR_ARG (orig_method_call, 2));      \
 258   value_arg = CALL_EXPR_ARG (orig_method_call, 3);                      \
 259   value_type = TREE_TYPE (value_arg);                                   \
 260 }                                                                       \
 261 while (0)
 262
 263 #define UNMARSHAL5(METHOD_CALL)                                 \
 264 tree value_type, this_arg, obj_arg, offset_arg, expected_arg, value_arg; \
 265 do                                                                      \
 266 {                                                                       \
 267   tree orig_method_call = METHOD_CALL;                                  \
 268   this_arg = CALL_EXPR_ARG (orig_method_call, 0);                       \
 269   obj_arg = CALL_EXPR_ARG (orig_method_call, 1);                        \
 270   offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0),      \
 271                              CALL_EXPR_ARG (orig_method_call, 2));      \
 272   expected_arg = CALL_EXPR_ARG (orig_method_call, 3);                   \
 273   value_arg = CALL_EXPR_ARG (orig_method_call, 4);                      \
 274   value_type = TREE_TYPE (value_arg);                                   \
 275 }                                                                       \
 276 while (0)
 277
 278 /* Add an address to an offset, forming a sum.  */
 279
 280 static tree
 281 build_addr_sum (tree type, tree addr, tree offset)
 282 {
 283   tree ptr_type = build_pointer_type (type);
 284   return fold_build_pointer_plus (fold_convert (ptr_type, addr), offset);
 285 }
 286
 287 /* Make sure that this-arg is non-NULL.  This is a security check.  */
 288
 289 static tree
 290 build_check_this (tree stmt, tree this_arg)
 291 {
 292   return build2 (COMPOUND_EXPR, TREE_TYPE (stmt),
 293                  java_check_reference (this_arg, 1), stmt);
 294 }
 295
 296 /* Now the builtins.  These correspond to the primitive functions in
 297    libjava/sun/misc/natUnsafe.cc.  */
 298
 299 static tree
 300 putObject_builtin (tree method_return_type ATTRIBUTE_UNUSED,
 301                    tree orig_call)
 302 {
 303   tree addr, stmt;
 304   UNMARSHAL4 (orig_call);
 305
 306   addr = build_addr_sum (value_type, obj_arg, offset_arg);
 307   stmt = fold_build2 (MODIFY_EXPR, value_type,
 308                       build_java_indirect_ref (value_type, addr,
 309                                                flag_check_references),
 310                       value_arg);
 311
 312   return build_check_this (stmt, this_arg);
 313 }
 314
 315 static tree
 316 compareAndSwapInt_builtin (tree method_return_type ATTRIBUTE_UNUSED,
 317                            tree orig_call)
 318 {
 319   machine_mode mode = TYPE_MODE (int_type_node);
 320   if (can_compare_and_swap_p (mode, flag_use_atomic_builtins))
 321     {
 322       tree addr, stmt;
 323       enum built_in_function fncode = BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4;
 324       UNMARSHAL5 (orig_call);
 325       (void) value_type; /* Avoid set but not used warning.  */
 326
 327       addr = build_addr_sum (int_type_node, obj_arg, offset_arg);
 328       stmt = build_call_expr (builtin_decl_explicit (fncode),
 329                               3, addr, expected_arg, value_arg);
 330
 331       return build_check_this (stmt, this_arg);
 332     }
 333   return NULL_TREE;
 334 }
 335
 336 static tree
 337 compareAndSwapLong_builtin (tree method_return_type ATTRIBUTE_UNUSED,
 338                             tree orig_call)
 339 {
 340   machine_mode mode = TYPE_MODE (long_type_node);
 341   /* We don't trust flag_use_atomic_builtins for multi-word compareAndSwap.
 342      Some machines such as ARM have atomic libfuncs but not the multi-word
 343      versions.  */
 344   if (can_compare_and_swap_p (mode,
 345                               (flag_use_atomic_builtins
 346                                && GET_MODE_SIZE (mode) <= UNITS_PER_WORD)))
 347     {
 348       tree addr, stmt;
 349       enum built_in_function fncode = BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8;
 350       UNMARSHAL5 (orig_call);
 351       (void) value_type; /* Avoid set but not used warning.  */
 352
 353       addr = build_addr_sum (long_type_node, obj_arg, offset_arg);
 354       stmt = build_call_expr (builtin_decl_explicit (fncode),
 355                               3, addr, expected_arg, value_arg);
 356
 357       return build_check_this (stmt, this_arg);
 358     }
 359   return NULL_TREE;
 360 }
 361 static tree
 362 compareAndSwapObject_builtin (tree method_return_type ATTRIBUTE_UNUSED,
 363                               tree orig_call)
 364 {
 365   machine_mode mode = TYPE_MODE (ptr_type_node);
 366   if (can_compare_and_swap_p (mode, flag_use_atomic_builtins))
 367   {
 368     tree addr, stmt;
 369     enum built_in_function builtin;
 370
 371     UNMARSHAL5 (orig_call);
 372     builtin = (POINTER_SIZE == 32
 373                ? BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4
 374                : BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8);
 375
 376     addr = build_addr_sum (value_type, obj_arg, offset_arg);
 377     stmt = build_call_expr (builtin_decl_explicit (builtin),
 378                             3, addr, expected_arg, value_arg);
 379
 380     return build_check_this (stmt, this_arg);
 381   }
 382   return NULL_TREE;
 383 }
 384
 385 static tree
 386 putVolatile_builtin (tree method_return_type ATTRIBUTE_UNUSED,
 387                      tree orig_call)
 388 {
 389   tree addr, stmt, modify_stmt;
 390   UNMARSHAL4 (orig_call);
 391
 392   addr = build_addr_sum (value_type, obj_arg, offset_arg);
 393   addr
 394     = fold_convert (build_pointer_type (build_qualified_type
 395                                         (value_type, TYPE_QUAL_VOLATILE)),
 396                     addr);
 397
 398   stmt = build_call_expr (builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE), 0);
 399   modify_stmt = fold_build2 (MODIFY_EXPR, value_type,
 400                              build_java_indirect_ref (value_type, addr,
 401                                                       flag_check_references),
 402                              value_arg);
 403   stmt = build2 (COMPOUND_EXPR, TREE_TYPE (modify_stmt),
 404                  stmt, modify_stmt);
 405
 406   return build_check_this (stmt, this_arg);
 407 }
 408
 409 static tree
 410 getVolatile_builtin (tree method_return_type ATTRIBUTE_UNUSED,
 411                      tree orig_call)
 412 {
 413   tree addr, stmt, modify_stmt, tmp;
 414   UNMARSHAL3 (orig_call);
 415   (void) this_arg; /* Avoid set but not used warning.  */
 416
 417   addr = build_addr_sum (method_return_type, obj_arg, offset_arg);
 418   addr
 419     = fold_convert (build_pointer_type (build_qualified_type
 420                                         (method_return_type,
 421                                          TYPE_QUAL_VOLATILE)), addr);
 422
 423   stmt = build_call_expr (builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE), 0);
 424   tmp = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL, method_return_type);
 425   DECL_IGNORED_P (tmp) = 1;
 426   DECL_ARTIFICIAL (tmp) = 1;
 427   pushdecl (tmp);
 428
 429   modify_stmt = fold_build2 (MODIFY_EXPR, method_return_type,
 430                              tmp,
 431                              build_java_indirect_ref (method_return_type, addr,
 432                                                       flag_check_references));
 433
 434   stmt = build2 (COMPOUND_EXPR, void_type_node, modify_stmt, stmt);
 435   stmt = build2 (COMPOUND_EXPR, method_return_type, stmt, tmp);
 436
 437   return stmt;
 438 }
 439
 440 static tree
 441 VMSupportsCS8_builtin (tree method_return_type,
 442                        tree orig_call ATTRIBUTE_UNUSED)
 443 {
 444   machine_mode mode = TYPE_MODE (long_type_node);
 445   gcc_assert (method_return_type == boolean_type_node);
 446   if (can_compare_and_swap_p (mode, false))
 447     return boolean_true_node;
 448   else
 449     return boolean_false_node;
 450 }
 451
 452 \f
 453
 454 /* Define a single builtin.  */
 455 static void
 456 define_builtin (enum built_in_function val,
 457                 const char *name,
 458                 tree type,
 459                 const char *libname,
 460                 int flags)
 461 {
 462   tree decl;
 463
 464   decl = build_decl (BUILTINS_LOCATION,
 465                      FUNCTION_DECL, get_identifier (name), type);
 466   DECL_EXTERNAL (decl) = 1;
 467   TREE_PUBLIC (decl) = 1;
 468   SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
 469   pushdecl (decl);
 470   DECL_BUILT_IN_CLASS (decl) = BUILT_IN_NORMAL;
 471   DECL_FUNCTION_CODE (decl) = val;
 472   set_call_expr_flags (decl, flags);
 473
 474   set_builtin_decl (val, decl, true);
 475 }
 476
 477 \f
 478
 479 /* Initialize the builtins.  */
 480 void
 481 initialize_builtins (void)
 482 {
 483   tree double_ftype_double, double_ftype_double_double;
 484   tree float_ftype_float_float;
 485   tree boolean_ftype_boolean_boolean;
 486   int i;
 487
 488   for (i = 0; java_builtins[i].builtin_code != END_BUILTINS; ++i)
 489     {
 490       tree klass_id = get_identifier (java_builtins[i].class_name.s);
 491       tree m = get_identifier (java_builtins[i].method_name.s);
 492
 493       java_builtins[i].class_name.t = klass_id;
 494       java_builtins[i].method_name.t = m;
 495     }
 496
 497   void_list_node = end_params_node;
 498
 499   float_ftype_float_float
 500     = build_function_type_list (float_type_node,
 501                                 float_type_node, float_type_node, NULL_TREE);
 502
 503   double_ftype_double
 504     = build_function_type_list (double_type_node, double_type_node, NULL_TREE);
 505   double_ftype_double_double
 506     = build_function_type_list (double_type_node,
 507                                 double_type_node, double_type_node, NULL_TREE);
 508
 509   define_builtin (BUILT_IN_FMOD, "__builtin_fmod",
 510                   double_ftype_double_double, "fmod", ECF_CONST);
 511   define_builtin (BUILT_IN_FMODF, "__builtin_fmodf",
 512                   float_ftype_float_float, "fmodf", ECF_CONST);
 513
 514   define_builtin (BUILT_IN_ACOS, "__builtin_acos",
 515                   double_ftype_double, "_ZN4java4lang4Math4acosEJdd",
 516                   ECF_CONST);
 517   define_builtin (BUILT_IN_ASIN, "__builtin_asin",
 518                   double_ftype_double, "_ZN4java4lang4Math4asinEJdd",
 519                   ECF_CONST);
 520   define_builtin (BUILT_IN_ATAN, "__builtin_atan",
 521                   double_ftype_double, "_ZN4java4lang4Math4atanEJdd",
 522                   ECF_CONST);
 523   define_builtin (BUILT_IN_ATAN2, "__builtin_atan2",
 524                   double_ftype_double_double, "_ZN4java4lang4Math5atan2EJddd",
 525                   ECF_CONST);
 526   define_builtin (BUILT_IN_CEIL, "__builtin_ceil",
 527                   double_ftype_double, "_ZN4java4lang4Math4ceilEJdd",
 528                   ECF_CONST);
 529   define_builtin (BUILT_IN_COS, "__builtin_cos",
 530                   double_ftype_double, "_ZN4java4lang4Math3cosEJdd",
 531                   ECF_CONST);
 532   define_builtin (BUILT_IN_EXP, "__builtin_exp",
 533                   double_ftype_double, "_ZN4java4lang4Math3expEJdd",
 534                   ECF_CONST);
 535   define_builtin (BUILT_IN_FLOOR, "__builtin_floor",
 536                   double_ftype_double, "_ZN4java4lang4Math5floorEJdd",
 537                   ECF_CONST);
 538   define_builtin (BUILT_IN_LOG, "__builtin_log",
 539                   double_ftype_double, "_ZN4java4lang4Math3logEJdd",
 540                   ECF_CONST);
 541   define_builtin (BUILT_IN_POW, "__builtin_pow",
 542                   double_ftype_double_double, "_ZN4java4lang4Math3powEJddd",
 543                   ECF_CONST);
 544   define_builtin (BUILT_IN_SIN, "__builtin_sin",
 545                   double_ftype_double, "_ZN4java4lang4Math3sinEJdd",
 546                   ECF_CONST);
 547   define_builtin (BUILT_IN_SQRT, "__builtin_sqrt",
 548                   double_ftype_double, "_ZN4java4lang4Math4sqrtEJdd",
 549                   ECF_CONST);
 550   define_builtin (BUILT_IN_TAN, "__builtin_tan",
 551                   double_ftype_double, "_ZN4java4lang4Math3tanEJdd",
 552                   ECF_CONST);
 553
 554   boolean_ftype_boolean_boolean
 555     = build_function_type_list (boolean_type_node,
 556                                 boolean_type_node, boolean_type_node,
 557                                 NULL_TREE);
 558   define_builtin (BUILT_IN_EXPECT, "__builtin_expect",
 559                   boolean_ftype_boolean_boolean,
 560                   "__builtin_expect",
 561                   ECF_CONST | ECF_NOTHROW);
 562   define_builtin (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4,
 563                   "__sync_bool_compare_and_swap_4",
 564                   build_function_type_list (boolean_type_node,
 565                                             int_type_node,
 566                                             build_pointer_type (int_type_node),
 567                                             int_type_node, NULL_TREE),
 568                   "__sync_bool_compare_and_swap_4", ECF_NOTHROW | ECF_LEAF);
 569   define_builtin (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8,
 570                   "__sync_bool_compare_and_swap_8",
 571                   build_function_type_list (boolean_type_node,
 572                                             long_type_node,
 573                                             build_pointer_type (long_type_node),
 574                                             int_type_node, NULL_TREE),
 575                   "__sync_bool_compare_and_swap_8", ECF_NOTHROW | ECF_LEAF);
 576   define_builtin (BUILT_IN_SYNC_SYNCHRONIZE, "__sync_synchronize",
 577                   build_function_type_list (void_type_node, NULL_TREE),
 578                   "__sync_synchronize", ECF_NOTHROW | ECF_LEAF);
 579
 580   define_builtin (BUILT_IN_RETURN_ADDRESS, "__builtin_return_address",
 581                   build_function_type_list (ptr_type_node, int_type_node, NULL_TREE),
 582                   "__builtin_return_address", ECF_NOTHROW | ECF_LEAF);
 583   define_builtin (BUILT_IN_TRAP, "__builtin_trap",
 584                   build_function_type_list (void_type_node, NULL_TREE),
 585                   "__builtin_trap", ECF_NOTHROW | ECF_LEAF | ECF_NORETURN);
 586   build_common_builtin_nodes ();
 587 }
 588
 589 /* If the call matches a builtin, return the
 590    appropriate builtin expression instead.  */
 591 tree
 592 check_for_builtin (tree method, tree call)
 593 {
 594   if (optimize && TREE_CODE (call) == CALL_EXPR)
 595     {
 596       int i;
 597       tree method_class = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
 598       tree method_name = DECL_NAME (method);
 599       tree method_return_type = TREE_TYPE (TREE_TYPE (method));
 600
 601       for (i = 0; java_builtins[i].builtin_code != END_BUILTINS; ++i)
 602         {
 603           if (method_class == java_builtins[i].class_name.t
 604               && method_name == java_builtins[i].method_name.t)
 605             {
 606               tree fn;
 607
 608               if (java_builtins[i].creator != NULL)
 609                 {
 610                   tree result
 611                     = (*java_builtins[i].creator) (method_return_type, call);
 612                   return result == NULL_TREE ? call : result;
 613                 }
 614
 615               /* Builtin functions emit a direct call which is incompatible
 616                  with the BC-ABI.  */
 617               if (flag_indirect_dispatch)
 618                 return call;
 619               fn = builtin_decl_explicit (java_builtins[i].builtin_code);
 620               if (fn == NULL_TREE)
 621                 return call;
 622               return java_build_function_call_expr (fn, call);
 623             }
 624         }
 625     }
 626   return call;
 627 }
 628
 629 #include "gt-java-builtins.h"