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