1 /* Built-in and inline functions for gcj
2 Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2009
3 Free Software Foundation, Inc.
5 This file is part of GCC.
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)
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.
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. */
25 /* Written by Tom Tromey <tromey@redhat.com>. */
29 #include "coretypes.h"
34 #include "langhooks.h"
35 #include "java-tree.h"
39 #include "insn-codes.h"
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);
48 static tree java_build_function_call_expr (tree, tree);
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);
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);
66 /* Hold a char*, before initialization, or a tree, after
68 union string_or_tree GTY(())
70 const char * GTY ((tag ("0"))) s;
71 tree GTY ((tag ("1"))) t;
74 /* Used to hold a single builtin record. */
75 struct builtin_record GTY(())
77 union string_or_tree GTY ((desc ("1"))) class_name;
78 union string_or_tree GTY ((desc ("1"))) method_name;
79 builtin_creator_function * GTY((skip)) creator;
80 enum built_in_function builtin_code;
83 static GTY(()) struct builtin_record java_builtins[] =
85 { { "java.lang.Math" }, { "min" }, min_builtin, 0 },
86 { { "java.lang.Math" }, { "max" }, max_builtin, 0 },
87 { { "java.lang.Math" }, { "abs" }, abs_builtin, 0 },
88 { { "java.lang.Math" }, { "acos" }, NULL, BUILT_IN_ACOS },
89 { { "java.lang.Math" }, { "asin" }, NULL, BUILT_IN_ASIN },
90 { { "java.lang.Math" }, { "atan" }, NULL, BUILT_IN_ATAN },
91 { { "java.lang.Math" }, { "atan2" }, NULL, BUILT_IN_ATAN2 },
92 { { "java.lang.Math" }, { "ceil" }, NULL, BUILT_IN_CEIL },
93 { { "java.lang.Math" }, { "cos" }, NULL, BUILT_IN_COS },
94 { { "java.lang.Math" }, { "exp" }, NULL, BUILT_IN_EXP },
95 { { "java.lang.Math" }, { "floor" }, NULL, BUILT_IN_FLOOR },
96 { { "java.lang.Math" }, { "log" }, NULL, BUILT_IN_LOG },
97 { { "java.lang.Math" }, { "pow" }, NULL, BUILT_IN_POW },
98 { { "java.lang.Math" }, { "sin" }, NULL, BUILT_IN_SIN },
99 { { "java.lang.Math" }, { "sqrt" }, NULL, BUILT_IN_SQRT },
100 { { "java.lang.Math" }, { "tan" }, NULL, BUILT_IN_TAN },
101 { { "java.lang.Float" }, { "intBitsToFloat" }, convert_real, 0 },
102 { { "java.lang.Double" }, { "longBitsToDouble" }, convert_real, 0 },
103 { { "java.lang.Float" }, { "floatToRawIntBits" }, convert_real, 0 },
104 { { "java.lang.Double" }, { "doubleToRawLongBits" }, convert_real, 0 },
105 { { "sun.misc.Unsafe" }, { "putInt" }, putObject_builtin, 0},
106 { { "sun.misc.Unsafe" }, { "putLong" }, putObject_builtin, 0},
107 { { "sun.misc.Unsafe" }, { "putObject" }, putObject_builtin, 0},
108 { { "sun.misc.Unsafe" }, { "compareAndSwapInt" },
109 compareAndSwapInt_builtin, 0},
110 { { "sun.misc.Unsafe" }, { "compareAndSwapLong" },
111 compareAndSwapLong_builtin, 0},
112 { { "sun.misc.Unsafe" }, { "compareAndSwapObject" },
113 compareAndSwapObject_builtin, 0},
114 { { "sun.misc.Unsafe" }, { "putOrderedInt" }, putVolatile_builtin, 0},
115 { { "sun.misc.Unsafe" }, { "putOrderedLong" }, putVolatile_builtin, 0},
116 { { "sun.misc.Unsafe" }, { "putOrderedObject" }, putVolatile_builtin, 0},
117 { { "sun.misc.Unsafe" }, { "putIntVolatile" }, putVolatile_builtin, 0},
118 { { "sun.misc.Unsafe" }, { "putLongVolatile" }, putVolatile_builtin, 0},
119 { { "sun.misc.Unsafe" }, { "putObjectVolatile" }, putVolatile_builtin, 0},
120 { { "sun.misc.Unsafe" }, { "getObjectVolatile" }, getVolatile_builtin, 0},
121 { { "sun.misc.Unsafe" }, { "getIntVolatile" }, getVolatile_builtin, 0},
122 { { "sun.misc.Unsafe" }, { "getLongVolatile" }, getVolatile_builtin, 0},
123 { { "sun.misc.Unsafe" }, { "getLong" }, getVolatile_builtin, 0},
124 { { "java.util.concurrent.atomic.AtomicLong" }, { "VMSupportsCS8" },
125 VMSupportsCS8_builtin, 0},
126 { { NULL }, { NULL }, NULL, END_BUILTINS }
130 /* Internal functions which implement various builtin conversions. */
133 max_builtin (tree method_return_type, tree orig_call)
135 /* MAX_EXPR does not handle -0.0 in the Java style. */
136 if (TREE_CODE (method_return_type) == REAL_TYPE)
138 return fold_build2 (MAX_EXPR, method_return_type,
139 CALL_EXPR_ARG (orig_call, 0),
140 CALL_EXPR_ARG (orig_call, 1));
144 min_builtin (tree method_return_type, tree orig_call)
146 /* MIN_EXPR does not handle -0.0 in the Java style. */
147 if (TREE_CODE (method_return_type) == REAL_TYPE)
149 return fold_build2 (MIN_EXPR, method_return_type,
150 CALL_EXPR_ARG (orig_call, 0),
151 CALL_EXPR_ARG (orig_call, 1));
155 abs_builtin (tree method_return_type, tree orig_call)
157 return fold_build1 (ABS_EXPR, method_return_type,
158 CALL_EXPR_ARG (orig_call, 0));
161 /* Construct a new call to FN using the arguments from ORIG_CALL. */
164 java_build_function_call_expr (tree fn, tree orig_call)
166 int nargs = call_expr_nargs (orig_call);
169 /* Although we could handle the 0-3 argument cases using the general
170 logic in the default case, splitting them out permits folding to
171 be performed without constructing a temporary CALL_EXPR. */
173 return build_call_expr (fn, 0);
175 return build_call_expr (fn, 1, CALL_EXPR_ARG (orig_call, 0));
177 return build_call_expr (fn, 2,
178 CALL_EXPR_ARG (orig_call, 0),
179 CALL_EXPR_ARG (orig_call, 1));
181 return build_call_expr (fn, 3,
182 CALL_EXPR_ARG (orig_call, 0),
183 CALL_EXPR_ARG (orig_call, 1),
184 CALL_EXPR_ARG (orig_call, 2));
187 tree fntype = TREE_TYPE (fn);
188 fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fn);
189 return fold (build_call_array (TREE_TYPE (fntype),
190 fn, nargs, CALL_EXPR_ARGP (orig_call)));
196 convert_real (tree method_return_type, tree orig_call)
198 return build1 (VIEW_CONVERT_EXPR, method_return_type,
199 CALL_EXPR_ARG (orig_call, 0));
204 /* Provide builtin support for atomic operations. These are
205 documented at length in libjava/sun/misc/Unsafe.java. */
207 /* FIXME. There are still a few things wrong with this logic. In
208 particular, atomic writes of multi-word integers are not truly
209 atomic: this requires more work.
211 In general, double-word compare-and-swap cannot portably be
212 implemented, so we need some kind of fallback for 32-bit machines.
217 /* Macros to unmarshal arguments from a CALL_EXPR into a few
218 variables. We also convert the offset arg from a long to an
219 integer that is the same size as a pointer. */
221 #define UNMARSHAL3(METHOD_CALL) \
222 tree this_arg, obj_arg, offset_arg; \
225 tree orig_method_call = METHOD_CALL; \
226 this_arg = CALL_EXPR_ARG (orig_method_call, 0); \
227 obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \
228 offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \
229 CALL_EXPR_ARG (orig_method_call, 2)); \
233 #define UNMARSHAL4(METHOD_CALL) \
234 tree value_type, this_arg, obj_arg, offset_arg, value_arg; \
237 tree orig_method_call = METHOD_CALL; \
238 this_arg = CALL_EXPR_ARG (orig_method_call, 0); \
239 obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \
240 offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \
241 CALL_EXPR_ARG (orig_method_call, 2)); \
242 value_arg = CALL_EXPR_ARG (orig_method_call, 3); \
243 value_type = TREE_TYPE (value_arg); \
247 #define UNMARSHAL5(METHOD_CALL) \
248 tree value_type, this_arg, obj_arg, offset_arg, expected_arg, value_arg; \
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 expected_arg = CALL_EXPR_ARG (orig_method_call, 3); \
257 value_arg = CALL_EXPR_ARG (orig_method_call, 4); \
258 value_type = TREE_TYPE (value_arg); \
262 /* Add an address to an offset, forming a sum. */
265 build_addr_sum (tree type, tree addr, tree offset)
267 tree ptr_type = build_pointer_type (type);
268 return fold_build2 (POINTER_PLUS_EXPR,
270 fold_convert (ptr_type, addr),
271 fold_convert (sizetype, offset));
274 /* Make sure that this-arg is non-NULL. This is a security check. */
277 build_check_this (tree stmt, tree this_arg)
279 return build2 (COMPOUND_EXPR, TREE_TYPE (stmt),
280 java_check_reference (this_arg, 1), stmt);
283 /* Now the builtins. These correspond to the primitive functions in
284 libjava/sun/misc/natUnsafe.cc. */
287 putObject_builtin (tree method_return_type ATTRIBUTE_UNUSED,
291 UNMARSHAL4 (orig_call);
293 addr = build_addr_sum (value_type, obj_arg, offset_arg);
294 stmt = fold_build2 (MODIFY_EXPR, value_type,
295 build_java_indirect_ref (value_type, addr,
296 flag_check_references),
299 return build_check_this (stmt, this_arg);
303 compareAndSwapInt_builtin (tree method_return_type ATTRIBUTE_UNUSED,
306 enum machine_mode mode = TYPE_MODE (int_type_node);
307 if (sync_compare_and_swap[mode] != CODE_FOR_nothing)
310 UNMARSHAL5 (orig_call);
312 addr = build_addr_sum (int_type_node, obj_arg, offset_arg);
313 stmt = build_call_expr (built_in_decls[BUILT_IN_BOOL_COMPARE_AND_SWAP_4],
314 3, addr, expected_arg, value_arg);
316 return build_check_this (stmt, this_arg);
322 compareAndSwapLong_builtin (tree method_return_type ATTRIBUTE_UNUSED,
325 enum machine_mode mode = TYPE_MODE (long_type_node);
326 if (sync_compare_and_swap[mode] != CODE_FOR_nothing)
329 UNMARSHAL5 (orig_call);
331 addr = build_addr_sum (long_type_node, obj_arg, offset_arg);
332 stmt = build_call_expr (built_in_decls[BUILT_IN_BOOL_COMPARE_AND_SWAP_8],
333 3, addr, expected_arg, value_arg);
335 return build_check_this (stmt, this_arg);
340 compareAndSwapObject_builtin (tree method_return_type ATTRIBUTE_UNUSED,
343 enum machine_mode mode = TYPE_MODE (ptr_type_node);
344 if (sync_compare_and_swap[mode] != CODE_FOR_nothing)
349 UNMARSHAL5 (orig_call);
350 builtin = (POINTER_SIZE == 32
351 ? BUILT_IN_BOOL_COMPARE_AND_SWAP_4
352 : BUILT_IN_BOOL_COMPARE_AND_SWAP_8);
354 addr = build_addr_sum (value_type, obj_arg, offset_arg);
355 stmt = build_call_expr (built_in_decls[builtin],
356 3, addr, expected_arg, value_arg);
358 return build_check_this (stmt, this_arg);
364 putVolatile_builtin (tree method_return_type ATTRIBUTE_UNUSED,
367 tree addr, stmt, modify_stmt;
368 UNMARSHAL4 (orig_call);
370 addr = build_addr_sum (value_type, obj_arg, offset_arg);
372 = fold_convert (build_pointer_type (build_type_variant (value_type, 0, 1)),
375 stmt = build_call_expr (built_in_decls[BUILT_IN_SYNCHRONIZE], 0);
376 modify_stmt = fold_build2 (MODIFY_EXPR, value_type,
377 build_java_indirect_ref (value_type, addr,
378 flag_check_references),
380 stmt = build2 (COMPOUND_EXPR, TREE_TYPE (modify_stmt),
383 return build_check_this (stmt, this_arg);
387 getVolatile_builtin (tree method_return_type ATTRIBUTE_UNUSED,
390 tree addr, stmt, modify_stmt, tmp;
391 UNMARSHAL3 (orig_call);
393 addr = build_addr_sum (method_return_type, obj_arg, offset_arg);
395 = fold_convert (build_pointer_type (build_type_variant
396 (method_return_type, 0, 1)), addr);
398 stmt = build_call_expr (built_in_decls[BUILT_IN_SYNCHRONIZE], 0);
400 tmp = build_decl (VAR_DECL, NULL, method_return_type);
401 DECL_IGNORED_P (tmp) = 1;
402 DECL_ARTIFICIAL (tmp) = 1;
405 modify_stmt = fold_build2 (MODIFY_EXPR, method_return_type,
407 build_java_indirect_ref (method_return_type, addr,
408 flag_check_references));
410 stmt = build2 (COMPOUND_EXPR, void_type_node, modify_stmt, stmt);
411 stmt = build2 (COMPOUND_EXPR, method_return_type, stmt, tmp);
417 VMSupportsCS8_builtin (tree method_return_type,
418 tree orig_call ATTRIBUTE_UNUSED)
420 enum machine_mode mode = TYPE_MODE (long_type_node);
421 gcc_assert (method_return_type == boolean_type_node);
422 if (sync_compare_and_swap[mode] != CODE_FOR_nothing)
423 return boolean_true_node;
425 return boolean_false_node;
430 #define BUILTIN_NOTHROW 1
431 #define BUILTIN_CONST 2
432 /* Define a single builtin. */
434 define_builtin (enum built_in_function val,
442 decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
443 DECL_EXTERNAL (decl) = 1;
444 TREE_PUBLIC (decl) = 1;
445 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
447 DECL_BUILT_IN_CLASS (decl) = BUILT_IN_NORMAL;
448 DECL_FUNCTION_CODE (decl) = val;
449 if (flags & BUILTIN_NOTHROW)
450 TREE_NOTHROW (decl) = 1;
451 if (flags & BUILTIN_CONST)
452 TREE_READONLY (decl) = 1;
454 implicit_built_in_decls[val] = decl;
455 built_in_decls[val] = decl;
460 /* Initialize the builtins. */
462 initialize_builtins (void)
464 tree double_ftype_double, double_ftype_double_double;
465 tree float_ftype_float, float_ftype_float_float;
466 tree boolean_ftype_boolean_boolean;
470 for (i = 0; java_builtins[i].builtin_code != END_BUILTINS; ++i)
472 tree klass_id = get_identifier (java_builtins[i].class_name.s);
473 tree m = get_identifier (java_builtins[i].method_name.s);
475 java_builtins[i].class_name.t = klass_id;
476 java_builtins[i].method_name.t = m;
479 void_list_node = end_params_node;
481 t = tree_cons (NULL_TREE, float_type_node, end_params_node);
482 float_ftype_float = build_function_type (float_type_node, t);
483 t = tree_cons (NULL_TREE, float_type_node, t);
484 float_ftype_float_float = build_function_type (float_type_node, t);
486 t = tree_cons (NULL_TREE, double_type_node, end_params_node);
487 double_ftype_double = build_function_type (double_type_node, t);
488 t = tree_cons (NULL_TREE, double_type_node, t);
489 double_ftype_double_double = build_function_type (double_type_node, t);
491 define_builtin (BUILT_IN_FMOD, "__builtin_fmod",
492 double_ftype_double_double, "fmod", BUILTIN_CONST);
493 define_builtin (BUILT_IN_FMODF, "__builtin_fmodf",
494 float_ftype_float_float, "fmodf", BUILTIN_CONST);
496 define_builtin (BUILT_IN_ACOS, "__builtin_acos",
497 double_ftype_double, "_ZN4java4lang4Math4acosEJdd",
499 define_builtin (BUILT_IN_ASIN, "__builtin_asin",
500 double_ftype_double, "_ZN4java4lang4Math4asinEJdd",
502 define_builtin (BUILT_IN_ATAN, "__builtin_atan",
503 double_ftype_double, "_ZN4java4lang4Math4atanEJdd",
505 define_builtin (BUILT_IN_ATAN2, "__builtin_atan2",
506 double_ftype_double_double, "_ZN4java4lang4Math5atan2EJddd",
508 define_builtin (BUILT_IN_CEIL, "__builtin_ceil",
509 double_ftype_double, "_ZN4java4lang4Math4ceilEJdd",
511 define_builtin (BUILT_IN_COS, "__builtin_cos",
512 double_ftype_double, "_ZN4java4lang4Math3cosEJdd",
514 define_builtin (BUILT_IN_EXP, "__builtin_exp",
515 double_ftype_double, "_ZN4java4lang4Math3expEJdd",
517 define_builtin (BUILT_IN_FLOOR, "__builtin_floor",
518 double_ftype_double, "_ZN4java4lang4Math5floorEJdd",
520 define_builtin (BUILT_IN_LOG, "__builtin_log",
521 double_ftype_double, "_ZN4java4lang4Math3logEJdd",
523 define_builtin (BUILT_IN_POW, "__builtin_pow",
524 double_ftype_double_double, "_ZN4java4lang4Math3powEJddd",
526 define_builtin (BUILT_IN_SIN, "__builtin_sin",
527 double_ftype_double, "_ZN4java4lang4Math3sinEJdd",
529 define_builtin (BUILT_IN_SQRT, "__builtin_sqrt",
530 double_ftype_double, "_ZN4java4lang4Math4sqrtEJdd",
532 define_builtin (BUILT_IN_TAN, "__builtin_tan",
533 double_ftype_double, "_ZN4java4lang4Math3tanEJdd",
536 t = tree_cons (NULL_TREE, boolean_type_node, end_params_node);
537 t = tree_cons (NULL_TREE, boolean_type_node, t);
538 boolean_ftype_boolean_boolean = build_function_type (boolean_type_node, t);
539 define_builtin (BUILT_IN_EXPECT, "__builtin_expect",
540 boolean_ftype_boolean_boolean,
542 BUILTIN_CONST | BUILTIN_NOTHROW);
543 define_builtin (BUILT_IN_BOOL_COMPARE_AND_SWAP_4,
544 "__sync_bool_compare_and_swap_4",
545 build_function_type_list (boolean_type_node,
547 build_pointer_type (int_type_node),
548 int_type_node, NULL_TREE),
549 "__sync_bool_compare_and_swap_4", 0);
550 define_builtin (BUILT_IN_BOOL_COMPARE_AND_SWAP_8,
551 "__sync_bool_compare_and_swap_8",
552 build_function_type_list (boolean_type_node,
554 build_pointer_type (long_type_node),
555 int_type_node, NULL_TREE),
556 "__sync_bool_compare_and_swap_8", 0);
557 define_builtin (BUILT_IN_SYNCHRONIZE, "__sync_synchronize",
558 build_function_type (void_type_node, void_list_node),
559 "__sync_synchronize", BUILTIN_NOTHROW);
561 define_builtin (BUILT_IN_RETURN_ADDRESS, "__builtin_return_address",
562 build_function_type_list (ptr_type_node, int_type_node, NULL_TREE),
563 "__builtin_return_address", BUILTIN_NOTHROW);
565 build_common_builtin_nodes ();
568 /* If the call matches a builtin, return the
569 appropriate builtin expression instead. */
571 check_for_builtin (tree method, tree call)
573 if (optimize && TREE_CODE (call) == CALL_EXPR)
576 tree method_class = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
577 tree method_name = DECL_NAME (method);
578 tree method_return_type = TREE_TYPE (TREE_TYPE (method));
580 for (i = 0; java_builtins[i].builtin_code != END_BUILTINS; ++i)
582 if (method_class == java_builtins[i].class_name.t
583 && method_name == java_builtins[i].method_name.t)
587 if (java_builtins[i].creator != NULL)
590 = (*java_builtins[i].creator) (method_return_type, call);
591 return result == NULL_TREE ? call : result;
594 /* Builtin functions emit a direct call which is incompatible
596 if (flag_indirect_dispatch)
598 fn = built_in_decls[java_builtins[i].builtin_code];
601 return java_build_function_call_expr (fn, call);
608 #include "gt-java-builtins.h"