gcc/java/builtins.c

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