gcc/java/builtins.c

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