obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 641 insertions, 0 deletions

diff --git a/gcc/java/builtins.c b/gcc/java/builtins.c
new file mode 100644
index 000000000..2100f093a
--- /dev/null
+++ b/gcc/java/builtins.c
@@ -0,0 +1,641 @@
+/* Built-in and inline functions for gcj
+   Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2009, 2010
+   Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+.
+
+.  
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc.  */
+
+/* Written by Tom Tromey <tromey@redhat.com>.  */
+
+/* FIXME: Still need to include rtl.h here (see below).  */
+#undef IN_GCC_FRONTEND
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "tree.h"
+#include "ggc.h"
+#include "flags.h"
+#include "langhooks.h"
+#include "java-tree.h"
+
+/* FIXME: All these headers are necessary for sync_compare_and_swap.
+   Front ends should never have to look at that.  */
+#include "rtl.h"
+#include "insn-codes.h"
+#include "expr.h"
+#include "optabs.h"
+
+static tree max_builtin (tree, tree);
+static tree min_builtin (tree, tree);
+static tree abs_builtin (tree, tree);
+static tree convert_real (tree, tree);
+
+static tree java_build_function_call_expr (tree, tree);
+
+static tree putObject_builtin (tree, tree);
+static tree compareAndSwapInt_builtin (tree, tree);
+static tree compareAndSwapLong_builtin (tree, tree);
+static tree compareAndSwapObject_builtin (tree, tree);
+static tree putVolatile_builtin (tree, tree);
+static tree getVolatile_builtin (tree, tree);
+static tree VMSupportsCS8_builtin (tree, tree);
+
+
+/* Functions of this type are used to inline a given call.  Such a
+   function should either return an expression, if the call is to be
+   inlined, or NULL_TREE if a real call should be emitted.  Arguments
+   are method return type and the original CALL_EXPR containing the
+   arguments to the call.  */
+typedef tree builtin_creator_function (tree, tree);
+
+/* Hold a char*, before initialization, or a tree, after
+   initialization.  */
+union GTY(()) string_or_tree {
+  const char * GTY ((tag ("0"))) s;
+  tree GTY ((tag ("1"))) t;
+};
+
+/* Used to hold a single builtin record.  */
+struct GTY(()) builtin_record {
+  union string_or_tree GTY ((desc ("1"))) class_name;
+  union string_or_tree GTY ((desc ("1"))) method_name;
+  builtin_creator_function * GTY((skip)) creator;
+  enum built_in_function builtin_code;
+};
+
+static GTY(()) struct builtin_record java_builtins[] =
+{
+  { { "java.lang.Math" }, { "min" }, min_builtin, (enum built_in_function) 0 },
+  { { "java.lang.Math" }, { "max" }, max_builtin, (enum built_in_function) 0 },
+  { { "java.lang.Math" }, { "abs" }, abs_builtin, (enum built_in_function) 0 },
+  { { "java.lang.Math" }, { "acos" }, NULL, BUILT_IN_ACOS },
+  { { "java.lang.Math" }, { "asin" }, NULL, BUILT_IN_ASIN },
+  { { "java.lang.Math" }, { "atan" }, NULL, BUILT_IN_ATAN },
+  { { "java.lang.Math" }, { "atan2" }, NULL, BUILT_IN_ATAN2 },
+  { { "java.lang.Math" }, { "ceil" }, NULL, BUILT_IN_CEIL },
+  { { "java.lang.Math" }, { "cos" }, NULL, BUILT_IN_COS },
+  { { "java.lang.Math" }, { "exp" }, NULL, BUILT_IN_EXP },
+  { { "java.lang.Math" }, { "floor" }, NULL, BUILT_IN_FLOOR },
+  { { "java.lang.Math" }, { "log" }, NULL, BUILT_IN_LOG },
+  { { "java.lang.Math" }, { "pow" }, NULL, BUILT_IN_POW },
+  { { "java.lang.Math" }, { "sin" }, NULL, BUILT_IN_SIN },
+  { { "java.lang.Math" }, { "sqrt" }, NULL, BUILT_IN_SQRT },
+  { { "java.lang.Math" }, { "tan" }, NULL, BUILT_IN_TAN },
+  { { "java.lang.Float" }, { "intBitsToFloat" }, convert_real,
+    (enum built_in_function) 0 },
+  { { "java.lang.Double" }, { "longBitsToDouble" }, convert_real,
+    (enum built_in_function) 0 },
+  { { "java.lang.Float" }, { "floatToRawIntBits" }, convert_real,
+    (enum built_in_function) 0 },
+  { { "java.lang.Double" }, { "doubleToRawLongBits" }, convert_real,
+    (enum built_in_function) 0 },
+  { { "sun.misc.Unsafe" }, { "putInt" }, putObject_builtin,
+    (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "putLong" }, putObject_builtin,
+    (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "putObject" }, putObject_builtin,
+  (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "compareAndSwapInt" },
+    compareAndSwapInt_builtin, (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "compareAndSwapLong" },
+    compareAndSwapLong_builtin, (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "compareAndSwapObject" },
+    compareAndSwapObject_builtin, (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "putOrderedInt" }, putVolatile_builtin,
+    (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "putOrderedLong" }, putVolatile_builtin,
+    (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "putOrderedObject" }, putVolatile_builtin,
+    (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "putIntVolatile" }, putVolatile_builtin,
+    (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "putLongVolatile" }, putVolatile_builtin,
+    (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "putObjectVolatile" }, putVolatile_builtin,
+    (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "getObjectVolatile" }, getVolatile_builtin,
+    (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "getIntVolatile" }, getVolatile_builtin,
+    (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "getLongVolatile" }, getVolatile_builtin, (enum built_in_function) 0},
+  { { "sun.misc.Unsafe" }, { "getLong" }, getVolatile_builtin,
+    (enum built_in_function) 0},
+  { { "java.util.concurrent.atomic.AtomicLong" }, { "VMSupportsCS8" },
+    VMSupportsCS8_builtin, (enum built_in_function) 0},
+  { { NULL }, { NULL }, NULL, END_BUILTINS }
+};
+
+
+/* Internal functions which implement various builtin conversions.  */
+
+static tree
+max_builtin (tree method_return_type, tree orig_call)
+{
+  /* MAX_EXPR does not handle -0.0 in the Java style.  */
+  if (TREE_CODE (method_return_type) == REAL_TYPE)
+    return NULL_TREE;
+  return fold_build2 (MAX_EXPR, method_return_type,
+		      CALL_EXPR_ARG (orig_call, 0),
+		      CALL_EXPR_ARG (orig_call, 1));
+}
+
+static tree
+min_builtin (tree method_return_type, tree orig_call)
+{
+  /* MIN_EXPR does not handle -0.0 in the Java style.  */
+  if (TREE_CODE (method_return_type) == REAL_TYPE)
+    return NULL_TREE;
+  return fold_build2 (MIN_EXPR, method_return_type,
+		      CALL_EXPR_ARG (orig_call, 0),
+		      CALL_EXPR_ARG (orig_call, 1));
+}
+
+static tree
+abs_builtin (tree method_return_type, tree orig_call)
+{
+  return fold_build1 (ABS_EXPR, method_return_type,
+		      CALL_EXPR_ARG (orig_call, 0));
+}
+
+/* Construct a new call to FN using the arguments from ORIG_CALL.  */
+
+static tree
+java_build_function_call_expr (tree fn, tree orig_call)
+{
+  int nargs = call_expr_nargs (orig_call);
+  switch (nargs)
+    {
+      /* Although we could handle the 0-3 argument cases using the general
+	 logic in the default case, splitting them out permits folding to
+	 be performed without constructing a temporary CALL_EXPR.  */
+    case 0:
+      return build_call_expr (fn, 0);
+    case 1:
+      return build_call_expr (fn, 1, CALL_EXPR_ARG (orig_call, 0));
+    case 2:
+      return build_call_expr (fn, 2,
+			      CALL_EXPR_ARG (orig_call, 0),
+			      CALL_EXPR_ARG (orig_call, 1));
+    case 3:
+      return build_call_expr (fn, 3,
+			      CALL_EXPR_ARG (orig_call, 0),
+			      CALL_EXPR_ARG (orig_call, 1),
+			      CALL_EXPR_ARG (orig_call, 2));
+    default:
+      {
+	tree fntype = TREE_TYPE (fn);
+	fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fn);
+	return fold (build_call_array (TREE_TYPE (fntype),
+				       fn, nargs, CALL_EXPR_ARGP (orig_call)));
+      }
+    }
+}
+
+static tree
+convert_real (tree method_return_type, tree orig_call)
+{
+  return build1 (VIEW_CONVERT_EXPR, method_return_type,
+		 CALL_EXPR_ARG (orig_call, 0));
+}
+
+
+
+/* Provide builtin support for atomic operations.  These are
+   documented at length in libjava/sun/misc/Unsafe.java.  */
+
+/* FIXME.  There are still a few things wrong with this logic.  In
+   particular, atomic writes of multi-word integers are not truly
+   atomic: this requires more work.
+
+   In general, double-word compare-and-swap cannot portably be
+   implemented, so we need some kind of fallback for 32-bit machines.
+
+*/
+
+
+/* Macros to unmarshal arguments from a CALL_EXPR into a few
+   variables.  We also convert the offset arg from a long to an
+   integer that is the same size as a pointer.  */
+
+#define UNMARSHAL3(METHOD_CALL)					\
+tree this_arg, obj_arg, offset_arg;					\
+do									\
+{									\
+  tree orig_method_call = METHOD_CALL;					\
+  this_arg = CALL_EXPR_ARG (orig_method_call, 0);			\
+  obj_arg = CALL_EXPR_ARG (orig_method_call, 1);			\
+  offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0),	\
+			     CALL_EXPR_ARG (orig_method_call, 2));	\
+}									\
+while (0)
+
+#define UNMARSHAL4(METHOD_CALL)					\
+tree value_type, this_arg, obj_arg, offset_arg, value_arg;		\
+do									\
+{									\
+  tree orig_method_call = METHOD_CALL;					\
+  this_arg = CALL_EXPR_ARG (orig_method_call, 0);			\
+  obj_arg = CALL_EXPR_ARG (orig_method_call, 1);			\
+  offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0),	\
+			     CALL_EXPR_ARG (orig_method_call, 2));	\
+  value_arg = CALL_EXPR_ARG (orig_method_call, 3);			\
+  value_type = TREE_TYPE (value_arg);					\
+}									\
+while (0)
+
+#define UNMARSHAL5(METHOD_CALL)					\
+tree value_type, this_arg, obj_arg, offset_arg, expected_arg, value_arg; \
+do									\
+{									\
+  tree orig_method_call = METHOD_CALL;					\
+  this_arg = CALL_EXPR_ARG (orig_method_call, 0);			\
+  obj_arg = CALL_EXPR_ARG (orig_method_call, 1);			\
+  offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0),	\
+			     CALL_EXPR_ARG (orig_method_call, 2));	\
+  expected_arg = CALL_EXPR_ARG (orig_method_call, 3);			\
+  value_arg = CALL_EXPR_ARG (orig_method_call, 4);			\
+  value_type = TREE_TYPE (value_arg);					\
+}									\
+while (0)
+
+/* Add an address to an offset, forming a sum.  */
+
+static tree
+build_addr_sum (tree type, tree addr, tree offset)
+{
+  tree ptr_type = build_pointer_type (type);
+  return fold_build2 (POINTER_PLUS_EXPR,
+		      ptr_type,
+		      fold_convert (ptr_type, addr),
+		      fold_convert (sizetype, offset));
+}
+
+/* Make sure that this-arg is non-NULL.  This is a security check.  */
+
+static tree
+build_check_this (tree stmt, tree this_arg)
+{
+  return build2 (COMPOUND_EXPR, TREE_TYPE (stmt), 
+		 java_check_reference (this_arg, 1), stmt);
+}
+
+/* Now the builtins.  These correspond to the primitive functions in
+   libjava/sun/misc/natUnsafe.cc.  */
+
+static tree
+putObject_builtin (tree method_return_type ATTRIBUTE_UNUSED, 
+		   tree orig_call)
+{
+  tree addr, stmt;
+  UNMARSHAL4 (orig_call);
+
+  addr = build_addr_sum (value_type, obj_arg, offset_arg);
+  stmt = fold_build2 (MODIFY_EXPR, value_type,
+		      build_java_indirect_ref (value_type, addr,
+					       flag_check_references),
+		      value_arg);
+
+  return build_check_this (stmt, this_arg);
+}
+
+static tree
+compareAndSwapInt_builtin (tree method_return_type ATTRIBUTE_UNUSED,
+			   tree orig_call)
+{
+  enum machine_mode mode = TYPE_MODE (int_type_node);
+  if (direct_optab_handler (sync_compare_and_swap_optab, mode)
+      != CODE_FOR_nothing
+      || flag_use_atomic_builtins)
+    {
+      tree addr, stmt;
+      UNMARSHAL5 (orig_call);
+      (void) value_type; /* Avoid set but not used warning.  */
+
+      addr = build_addr_sum (int_type_node, obj_arg, offset_arg);
+      stmt = build_call_expr (built_in_decls[BUILT_IN_BOOL_COMPARE_AND_SWAP_4],
+			      3, addr, expected_arg, value_arg);
+
+      return build_check_this (stmt, this_arg);
+    }
+  return NULL_TREE;
+}
+
+static tree
+compareAndSwapLong_builtin (tree method_return_type ATTRIBUTE_UNUSED,
+			    tree orig_call)
+{
+  enum machine_mode mode = TYPE_MODE (long_type_node);
+  if (direct_optab_handler (sync_compare_and_swap_optab, mode)
+      != CODE_FOR_nothing
+      || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (word_mode)
+	  && flag_use_atomic_builtins))
+    /* We don't trust flag_use_atomic_builtins for multi-word
+       compareAndSwap.  Some machines such as ARM have atomic libfuncs
+       but not the multi-word versions.  */
+    {
+      tree addr, stmt;
+      UNMARSHAL5 (orig_call);
+      (void) value_type; /* Avoid set but not used warning.  */
+
+      addr = build_addr_sum (long_type_node, obj_arg, offset_arg);
+      stmt = build_call_expr (built_in_decls[BUILT_IN_BOOL_COMPARE_AND_SWAP_8],
+			      3, addr, expected_arg, value_arg);
+
+      return build_check_this (stmt, this_arg);
+    }
+  return NULL_TREE;
+}
+static tree
+compareAndSwapObject_builtin (tree method_return_type ATTRIBUTE_UNUSED, 
+			      tree orig_call)
+{
+  enum machine_mode mode = TYPE_MODE (ptr_type_node);
+  if (direct_optab_handler (sync_compare_and_swap_optab, mode)
+      != CODE_FOR_nothing
+      || flag_use_atomic_builtins)
+  {
+    tree addr, stmt;
+    int builtin;
+
+    UNMARSHAL5 (orig_call);
+    builtin = (POINTER_SIZE == 32 
+	       ? BUILT_IN_BOOL_COMPARE_AND_SWAP_4 
+	       : BUILT_IN_BOOL_COMPARE_AND_SWAP_8);
+
+    addr = build_addr_sum (value_type, obj_arg, offset_arg);
+    stmt = build_call_expr (built_in_decls[builtin],
+			    3, addr, expected_arg, value_arg);
+
+    return build_check_this (stmt, this_arg);
+  }
+  return NULL_TREE;
+}
+
+static tree
+putVolatile_builtin (tree method_return_type ATTRIBUTE_UNUSED, 
+		     tree orig_call)
+{
+  tree addr, stmt, modify_stmt;
+  UNMARSHAL4 (orig_call);
+  
+  addr = build_addr_sum (value_type, obj_arg, offset_arg);
+  addr 
+    = fold_convert (build_pointer_type (build_type_variant (value_type, 0, 1)),
+		    addr);
+  
+  stmt = build_call_expr (built_in_decls[BUILT_IN_SYNCHRONIZE], 0);
+  modify_stmt = fold_build2 (MODIFY_EXPR, value_type,
+			     build_java_indirect_ref (value_type, addr,
+						      flag_check_references),
+			     value_arg);
+  stmt = build2 (COMPOUND_EXPR, TREE_TYPE (modify_stmt), 
+		 stmt, modify_stmt);
+
+  return build_check_this (stmt, this_arg);
+}
+
+static tree
+getVolatile_builtin (tree method_return_type ATTRIBUTE_UNUSED, 
+		     tree orig_call)
+{
+  tree addr, stmt, modify_stmt, tmp;
+  UNMARSHAL3 (orig_call);
+  (void) this_arg; /* Avoid set but not used warning.  */
+
+  addr = build_addr_sum (method_return_type, obj_arg, offset_arg);
+  addr 
+    = fold_convert (build_pointer_type (build_type_variant 
+					(method_return_type, 0, 1)), addr);
+  
+  stmt = build_call_expr (built_in_decls[BUILT_IN_SYNCHRONIZE], 0);
+  
+  tmp = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL, method_return_type);
+  DECL_IGNORED_P (tmp) = 1;
+  DECL_ARTIFICIAL (tmp) = 1;
+  pushdecl (tmp);
+
+  modify_stmt = fold_build2 (MODIFY_EXPR, method_return_type,
+			     tmp,
+			     build_java_indirect_ref (method_return_type, addr,
+						      flag_check_references));
+
+  stmt = build2 (COMPOUND_EXPR, void_type_node, modify_stmt, stmt);
+  stmt = build2 (COMPOUND_EXPR, method_return_type, stmt, tmp);
+  
+  return stmt;
+}
+
+static tree
+VMSupportsCS8_builtin (tree method_return_type, 
+		       tree orig_call ATTRIBUTE_UNUSED)
+{
+  enum machine_mode mode = TYPE_MODE (long_type_node);
+  gcc_assert (method_return_type == boolean_type_node);
+  if (direct_optab_handler (sync_compare_and_swap_optab, mode)
+      != CODE_FOR_nothing)
+    return boolean_true_node;
+  else
+    return boolean_false_node;
+}  
+
+
+
+#define BUILTIN_NOTHROW 1
+#define BUILTIN_CONST 2
+/* Define a single builtin.  */
+static void
+define_builtin (enum built_in_function val,
+		const char *name,
+		tree type,
+		const char *libname,
+		int flags)
+{
+  tree decl;
+
+  decl = build_decl (BUILTINS_LOCATION,
+		     FUNCTION_DECL, get_identifier (name), type);
+  DECL_EXTERNAL (decl) = 1;
+  TREE_PUBLIC (decl) = 1;
+  SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
+  pushdecl (decl);
+  DECL_BUILT_IN_CLASS (decl) = BUILT_IN_NORMAL;
+  DECL_FUNCTION_CODE (decl) = val;
+  if (flags & BUILTIN_NOTHROW)
+    TREE_NOTHROW (decl) = 1;
+  if (flags & BUILTIN_CONST)
+    TREE_READONLY (decl) = 1;
+
+  implicit_built_in_decls[val] = decl;
+  built_in_decls[val] = decl;
+}
+
+
+
+/* Initialize the builtins.  */
+void
+initialize_builtins (void)
+{
+  tree double_ftype_double, double_ftype_double_double;
+  tree float_ftype_float_float;
+  tree boolean_ftype_boolean_boolean;
+  int i;
+
+  for (i = 0; java_builtins[i].builtin_code != END_BUILTINS; ++i)
+    {
+      tree klass_id = get_identifier (java_builtins[i].class_name.s);
+      tree m = get_identifier (java_builtins[i].method_name.s);
+
+      java_builtins[i].class_name.t = klass_id;
+      java_builtins[i].method_name.t = m;
+    }
+
+  void_list_node = end_params_node;
+
+  float_ftype_float_float
+    = build_function_type_list (float_type_node,
+				float_type_node, float_type_node, NULL_TREE);
+
+  double_ftype_double
+    = build_function_type_list (double_type_node, double_type_node, NULL_TREE);
+  double_ftype_double_double
+    = build_function_type_list (double_type_node,
+				double_type_node, double_type_node, NULL_TREE);
+
+  define_builtin (BUILT_IN_FMOD, "__builtin_fmod",
+		  double_ftype_double_double, "fmod", BUILTIN_CONST);
+  define_builtin (BUILT_IN_FMODF, "__builtin_fmodf",
+		  float_ftype_float_float, "fmodf", BUILTIN_CONST);
+
+  define_builtin (BUILT_IN_ACOS, "__builtin_acos",
+		  double_ftype_double, "_ZN4java4lang4Math4acosEJdd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_ASIN, "__builtin_asin",
+		  double_ftype_double, "_ZN4java4lang4Math4asinEJdd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_ATAN, "__builtin_atan",
+		  double_ftype_double, "_ZN4java4lang4Math4atanEJdd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_ATAN2, "__builtin_atan2",
+		  double_ftype_double_double, "_ZN4java4lang4Math5atan2EJddd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_CEIL, "__builtin_ceil",
+		  double_ftype_double, "_ZN4java4lang4Math4ceilEJdd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_COS, "__builtin_cos",
+		  double_ftype_double, "_ZN4java4lang4Math3cosEJdd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_EXP, "__builtin_exp",
+		  double_ftype_double, "_ZN4java4lang4Math3expEJdd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_FLOOR, "__builtin_floor",
+		  double_ftype_double, "_ZN4java4lang4Math5floorEJdd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_LOG, "__builtin_log",
+		  double_ftype_double, "_ZN4java4lang4Math3logEJdd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_POW, "__builtin_pow",
+		  double_ftype_double_double, "_ZN4java4lang4Math3powEJddd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_SIN, "__builtin_sin",
+		  double_ftype_double, "_ZN4java4lang4Math3sinEJdd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_SQRT, "__builtin_sqrt",
+		  double_ftype_double, "_ZN4java4lang4Math4sqrtEJdd",
+		  BUILTIN_CONST);
+  define_builtin (BUILT_IN_TAN, "__builtin_tan",
+		  double_ftype_double, "_ZN4java4lang4Math3tanEJdd",
+		  BUILTIN_CONST);
+  
+  boolean_ftype_boolean_boolean
+    = build_function_type_list (boolean_type_node,
+				boolean_type_node, boolean_type_node,
+				NULL_TREE);
+  define_builtin (BUILT_IN_EXPECT, "__builtin_expect", 
+		  boolean_ftype_boolean_boolean,
+		  "__builtin_expect",
+		  BUILTIN_CONST | BUILTIN_NOTHROW);
+  define_builtin (BUILT_IN_BOOL_COMPARE_AND_SWAP_4, 
+		  "__sync_bool_compare_and_swap_4",
+		  build_function_type_list (boolean_type_node,
+					    int_type_node, 
+					    build_pointer_type (int_type_node),
+					    int_type_node, NULL_TREE), 
+		  "__sync_bool_compare_and_swap_4", 0);
+  define_builtin (BUILT_IN_BOOL_COMPARE_AND_SWAP_8, 
+		  "__sync_bool_compare_and_swap_8",
+		  build_function_type_list (boolean_type_node,
+					    long_type_node, 
+					    build_pointer_type (long_type_node),
+					    int_type_node, NULL_TREE), 
+		  "__sync_bool_compare_and_swap_8", 0);
+  define_builtin (BUILT_IN_SYNCHRONIZE, "__sync_synchronize",
+		  build_function_type_list (void_type_node, NULL_TREE),
+		  "__sync_synchronize", BUILTIN_NOTHROW);
+  
+  define_builtin (BUILT_IN_RETURN_ADDRESS, "__builtin_return_address",
+		  build_function_type_list (ptr_type_node, int_type_node, NULL_TREE),
+		  "__builtin_return_address", BUILTIN_NOTHROW);
+
+  build_common_builtin_nodes ();
+}
+
+/* If the call matches a builtin, return the
+   appropriate builtin expression instead.  */
+tree
+check_for_builtin (tree method, tree call)
+{
+  if (optimize && TREE_CODE (call) == CALL_EXPR)
+    {
+      int i;
+      tree method_class = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
+      tree method_name = DECL_NAME (method);
+      tree method_return_type = TREE_TYPE (TREE_TYPE (method));
+
+      for (i = 0; java_builtins[i].builtin_code != END_BUILTINS; ++i)
+	{
+	  if (method_class == java_builtins[i].class_name.t
+	      && method_name == java_builtins[i].method_name.t)
+	    {
+	      tree fn;
+
+	      if (java_builtins[i].creator != NULL)
+		{
+		  tree result
+		    = (*java_builtins[i].creator) (method_return_type, call);
+		  return result == NULL_TREE ? call : result;
+		}
+
+	      /* Builtin functions emit a direct call which is incompatible
+	         with the BC-ABI.  */
+	      if (flag_indirect_dispatch)
+	        return call;
+	      fn = built_in_decls[java_builtins[i].builtin_code];
+	      if (fn == NULL_TREE)
+		return call;
+	      return java_build_function_call_expr (fn, call);
+	    }
+	}
+    }
+  return call;
+}
+
+#include "gt-java-builtins.h"