gcc/java/builtins.c

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