1 /* Built-in and inline functions for gcj
2 Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2009, 2010
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>. */
27 /* FIXME: Still need to include rtl.h here (see below). */
28 #undef IN_GCC_FRONTEND
32 #include "coretypes.h"
37 #include "langhooks.h"
38 #include "java-tree.h"
40 /* FIXME: All these headers are necessary for sync_compare_and_swap.
41 Front ends should never have to look at that. */
43 #include "insn-codes.h"
47 static tree max_builtin (tree, tree);
48 static tree min_builtin (tree, tree);
49 static tree abs_builtin (tree, tree);
50 static tree convert_real (tree, tree);
52 static tree java_build_function_call_expr (tree, tree);
54 static tree putObject_builtin (tree, tree);
55 static tree compareAndSwapInt_builtin (tree, tree);
56 static tree compareAndSwapLong_builtin (tree, tree);
57 static tree compareAndSwapObject_builtin (tree, tree);
58 static tree putVolatile_builtin (tree, tree);
59 static tree getVolatile_builtin (tree, tree);
60 static tree VMSupportsCS8_builtin (tree, tree);
63 /* Functions of this type are used to inline a given call. Such a
64 function should either return an expression, if the call is to be
65 inlined, or NULL_TREE if a real call should be emitted. Arguments
66 are method return type and the original CALL_EXPR containing the
67 arguments to the call. */
68 typedef tree builtin_creator_function (tree, tree);
70 /* Hold a char*, before initialization, or a tree, after
72 union GTY(()) string_or_tree {
73 const char * GTY ((tag ("0"))) s;
74 tree GTY ((tag ("1"))) t;
77 /* Used to hold a single builtin record. */
78 struct GTY(()) builtin_record {
79 union string_or_tree GTY ((desc ("1"))) class_name;
80 union string_or_tree GTY ((desc ("1"))) method_name;
81 builtin_creator_function * GTY((skip)) creator;
82 enum built_in_function builtin_code;
85 static GTY(()) struct builtin_record java_builtins[] =
87 { { "java.lang.Math" }, { "min" }, min_builtin, (enum built_in_function) 0 },
88 { { "java.lang.Math" }, { "max" }, max_builtin, (enum built_in_function) 0 },
89 { { "java.lang.Math" }, { "abs" }, abs_builtin, (enum built_in_function) 0 },
90 { { "java.lang.Math" }, { "acos" }, NULL, BUILT_IN_ACOS },
91 { { "java.lang.Math" }, { "asin" }, NULL, BUILT_IN_ASIN },
92 { { "java.lang.Math" }, { "atan" }, NULL, BUILT_IN_ATAN },
93 { { "java.lang.Math" }, { "atan2" }, NULL, BUILT_IN_ATAN2 },
94 { { "java.lang.Math" }, { "ceil" }, NULL, BUILT_IN_CEIL },
95 { { "java.lang.Math" }, { "cos" }, NULL, BUILT_IN_COS },
96 { { "java.lang.Math" }, { "exp" }, NULL, BUILT_IN_EXP },
97 { { "java.lang.Math" }, { "floor" }, NULL, BUILT_IN_FLOOR },
98 { { "java.lang.Math" }, { "log" }, NULL, BUILT_IN_LOG },
99 { { "java.lang.Math" }, { "pow" }, NULL, BUILT_IN_POW },
100 { { "java.lang.Math" }, { "sin" }, NULL, BUILT_IN_SIN },
101 { { "java.lang.Math" }, { "sqrt" }, NULL, BUILT_IN_SQRT },
102 { { "java.lang.Math" }, { "tan" }, NULL, BUILT_IN_TAN },
103 { { "java.lang.Float" }, { "intBitsToFloat" }, convert_real,
104 (enum built_in_function) 0 },
105 { { "java.lang.Double" }, { "longBitsToDouble" }, convert_real,
106 (enum built_in_function) 0 },
107 { { "java.lang.Float" }, { "floatToRawIntBits" }, convert_real,
108 (enum built_in_function) 0 },
109 { { "java.lang.Double" }, { "doubleToRawLongBits" }, convert_real,
110 (enum built_in_function) 0 },
111 { { "sun.misc.Unsafe" }, { "putInt" }, putObject_builtin,
112 (enum built_in_function) 0},
113 { { "sun.misc.Unsafe" }, { "putLong" }, putObject_builtin,
114 (enum built_in_function) 0},
115 { { "sun.misc.Unsafe" }, { "putObject" }, putObject_builtin,
116 (enum built_in_function) 0},
117 { { "sun.misc.Unsafe" }, { "compareAndSwapInt" },
118 compareAndSwapInt_builtin, (enum built_in_function) 0},
119 { { "sun.misc.Unsafe" }, { "compareAndSwapLong" },
120 compareAndSwapLong_builtin, (enum built_in_function) 0},
121 { { "sun.misc.Unsafe" }, { "compareAndSwapObject" },
122 compareAndSwapObject_builtin, (enum built_in_function) 0},
123 { { "sun.misc.Unsafe" }, { "putOrderedInt" }, putVolatile_builtin,
124 (enum built_in_function) 0},
125 { { "sun.misc.Unsafe" }, { "putOrderedLong" }, putVolatile_builtin,
126 (enum built_in_function) 0},
127 { { "sun.misc.Unsafe" }, { "putOrderedObject" }, putVolatile_builtin,
128 (enum built_in_function) 0},
129 { { "sun.misc.Unsafe" }, { "putIntVolatile" }, putVolatile_builtin,
130 (enum built_in_function) 0},
131 { { "sun.misc.Unsafe" }, { "putLongVolatile" }, putVolatile_builtin,
132 (enum built_in_function) 0},
133 { { "sun.misc.Unsafe" }, { "putObjectVolatile" }, putVolatile_builtin,
134 (enum built_in_function) 0},
135 { { "sun.misc.Unsafe" }, { "getObjectVolatile" }, getVolatile_builtin,
136 (enum built_in_function) 0},
137 { { "sun.misc.Unsafe" }, { "getIntVolatile" }, getVolatile_builtin,
138 (enum built_in_function) 0},
139 { { "sun.misc.Unsafe" }, { "getLongVolatile" }, getVolatile_builtin, (enum built_in_function) 0},
140 { { "sun.misc.Unsafe" }, { "getLong" }, getVolatile_builtin,
141 (enum built_in_function) 0},
142 { { "java.util.concurrent.atomic.AtomicLong" }, { "VMSupportsCS8" },
143 VMSupportsCS8_builtin, (enum built_in_function) 0},
144 { { NULL }, { NULL }, NULL, END_BUILTINS }
148 /* Internal functions which implement various builtin conversions. */
151 max_builtin (tree method_return_type, tree orig_call)
153 /* MAX_EXPR does not handle -0.0 in the Java style. */
154 if (TREE_CODE (method_return_type) == REAL_TYPE)
156 return fold_build2 (MAX_EXPR, method_return_type,
157 CALL_EXPR_ARG (orig_call, 0),
158 CALL_EXPR_ARG (orig_call, 1));
162 min_builtin (tree method_return_type, tree orig_call)
164 /* MIN_EXPR does not handle -0.0 in the Java style. */
165 if (TREE_CODE (method_return_type) == REAL_TYPE)
167 return fold_build2 (MIN_EXPR, method_return_type,
168 CALL_EXPR_ARG (orig_call, 0),
169 CALL_EXPR_ARG (orig_call, 1));
173 abs_builtin (tree method_return_type, tree orig_call)
175 return fold_build1 (ABS_EXPR, method_return_type,
176 CALL_EXPR_ARG (orig_call, 0));
179 /* Construct a new call to FN using the arguments from ORIG_CALL. */
182 java_build_function_call_expr (tree fn, tree orig_call)
184 int nargs = call_expr_nargs (orig_call);
187 /* Although we could handle the 0-3 argument cases using the general
188 logic in the default case, splitting them out permits folding to
189 be performed without constructing a temporary CALL_EXPR. */
191 return build_call_expr (fn, 0);
193 return build_call_expr (fn, 1, CALL_EXPR_ARG (orig_call, 0));
195 return build_call_expr (fn, 2,
196 CALL_EXPR_ARG (orig_call, 0),
197 CALL_EXPR_ARG (orig_call, 1));
199 return build_call_expr (fn, 3,
200 CALL_EXPR_ARG (orig_call, 0),
201 CALL_EXPR_ARG (orig_call, 1),
202 CALL_EXPR_ARG (orig_call, 2));
205 tree fntype = TREE_TYPE (fn);
206 fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fn);
207 return fold (build_call_array (TREE_TYPE (fntype),
208 fn, nargs, CALL_EXPR_ARGP (orig_call)));
214 convert_real (tree method_return_type, tree orig_call)
216 return build1 (VIEW_CONVERT_EXPR, method_return_type,
217 CALL_EXPR_ARG (orig_call, 0));
222 /* Provide builtin support for atomic operations. These are
223 documented at length in libjava/sun/misc/Unsafe.java. */
225 /* FIXME. There are still a few things wrong with this logic. In
226 particular, atomic writes of multi-word integers are not truly
227 atomic: this requires more work.
229 In general, double-word compare-and-swap cannot portably be
230 implemented, so we need some kind of fallback for 32-bit machines.
235 /* Macros to unmarshal arguments from a CALL_EXPR into a few
236 variables. We also convert the offset arg from a long to an
237 integer that is the same size as a pointer. */
239 #define UNMARSHAL3(METHOD_CALL) \
240 tree this_arg, obj_arg, offset_arg; \
243 tree orig_method_call = METHOD_CALL; \
244 this_arg = CALL_EXPR_ARG (orig_method_call, 0); \
245 obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \
246 offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \
247 CALL_EXPR_ARG (orig_method_call, 2)); \
251 #define UNMARSHAL4(METHOD_CALL) \
252 tree value_type, this_arg, obj_arg, offset_arg, value_arg; \
255 tree orig_method_call = METHOD_CALL; \
256 this_arg = CALL_EXPR_ARG (orig_method_call, 0); \
257 obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \
258 offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \
259 CALL_EXPR_ARG (orig_method_call, 2)); \
260 value_arg = CALL_EXPR_ARG (orig_method_call, 3); \
261 value_type = TREE_TYPE (value_arg); \
265 #define UNMARSHAL5(METHOD_CALL) \
266 tree value_type, this_arg, obj_arg, offset_arg, expected_arg, value_arg; \
269 tree orig_method_call = METHOD_CALL; \
270 this_arg = CALL_EXPR_ARG (orig_method_call, 0); \
271 obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \
272 offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \
273 CALL_EXPR_ARG (orig_method_call, 2)); \
274 expected_arg = CALL_EXPR_ARG (orig_method_call, 3); \
275 value_arg = CALL_EXPR_ARG (orig_method_call, 4); \
276 value_type = TREE_TYPE (value_arg); \
280 /* Add an address to an offset, forming a sum. */
283 build_addr_sum (tree type, tree addr, tree offset)
285 tree ptr_type = build_pointer_type (type);
286 return fold_build2 (POINTER_PLUS_EXPR,
288 fold_convert (ptr_type, addr),
289 fold_convert (sizetype, offset));
292 /* Make sure that this-arg is non-NULL. This is a security check. */
295 build_check_this (tree stmt, tree this_arg)
297 return build2 (COMPOUND_EXPR, TREE_TYPE (stmt),
298 java_check_reference (this_arg, 1), stmt);
301 /* Now the builtins. These correspond to the primitive functions in
302 libjava/sun/misc/natUnsafe.cc. */
305 putObject_builtin (tree method_return_type ATTRIBUTE_UNUSED,
309 UNMARSHAL4 (orig_call);
311 addr = build_addr_sum (value_type, obj_arg, offset_arg);
312 stmt = fold_build2 (MODIFY_EXPR, value_type,
313 build_java_indirect_ref (value_type, addr,
314 flag_check_references),
317 return build_check_this (stmt, this_arg);
321 compareAndSwapInt_builtin (tree method_return_type ATTRIBUTE_UNUSED,
324 enum machine_mode mode = TYPE_MODE (int_type_node);
325 if (direct_optab_handler (sync_compare_and_swap_optab, mode)
327 || flag_use_atomic_builtins)
330 UNMARSHAL5 (orig_call);
331 (void) value_type; /* Avoid set but not used warning. */
333 addr = build_addr_sum (int_type_node, obj_arg, offset_arg);
334 stmt = build_call_expr
335 (built_in_decls[BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4],
336 3, addr, expected_arg, value_arg);
338 return build_check_this (stmt, this_arg);
344 compareAndSwapLong_builtin (tree method_return_type ATTRIBUTE_UNUSED,
347 enum machine_mode mode = TYPE_MODE (long_type_node);
348 if (direct_optab_handler (sync_compare_and_swap_optab, mode)
350 || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (word_mode)
351 && flag_use_atomic_builtins))
352 /* We don't trust flag_use_atomic_builtins for multi-word
353 compareAndSwap. Some machines such as ARM have atomic libfuncs
354 but not the multi-word versions. */
357 UNMARSHAL5 (orig_call);
358 (void) value_type; /* Avoid set but not used warning. */
360 addr = build_addr_sum (long_type_node, obj_arg, offset_arg);
361 stmt = build_call_expr
362 (built_in_decls[BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8],
363 3, addr, expected_arg, value_arg);
365 return build_check_this (stmt, this_arg);
370 compareAndSwapObject_builtin (tree method_return_type ATTRIBUTE_UNUSED,
373 enum machine_mode mode = TYPE_MODE (ptr_type_node);
374 if (direct_optab_handler (sync_compare_and_swap_optab, mode)
376 || flag_use_atomic_builtins)
381 UNMARSHAL5 (orig_call);
382 builtin = (POINTER_SIZE == 32
383 ? BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4
384 : BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8);
386 addr = build_addr_sum (value_type, obj_arg, offset_arg);
387 stmt = build_call_expr (built_in_decls[builtin],
388 3, addr, expected_arg, value_arg);
390 return build_check_this (stmt, this_arg);
396 putVolatile_builtin (tree method_return_type ATTRIBUTE_UNUSED,
399 tree addr, stmt, modify_stmt;
400 UNMARSHAL4 (orig_call);
402 addr = build_addr_sum (value_type, obj_arg, offset_arg);
404 = fold_convert (build_pointer_type (build_type_variant (value_type, 0, 1)),
407 stmt = build_call_expr (built_in_decls[BUILT_IN_SYNC_SYNCHRONIZE], 0);
408 modify_stmt = fold_build2 (MODIFY_EXPR, value_type,
409 build_java_indirect_ref (value_type, addr,
410 flag_check_references),
412 stmt = build2 (COMPOUND_EXPR, TREE_TYPE (modify_stmt),
415 return build_check_this (stmt, this_arg);
419 getVolatile_builtin (tree method_return_type ATTRIBUTE_UNUSED,
422 tree addr, stmt, modify_stmt, tmp;
423 UNMARSHAL3 (orig_call);
424 (void) this_arg; /* Avoid set but not used warning. */
426 addr = build_addr_sum (method_return_type, obj_arg, offset_arg);
428 = fold_convert (build_pointer_type (build_type_variant
429 (method_return_type, 0, 1)), addr);
431 stmt = build_call_expr (built_in_decls[BUILT_IN_SYNC_SYNCHRONIZE], 0);
433 tmp = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL, method_return_type);
434 DECL_IGNORED_P (tmp) = 1;
435 DECL_ARTIFICIAL (tmp) = 1;
438 modify_stmt = fold_build2 (MODIFY_EXPR, method_return_type,
440 build_java_indirect_ref (method_return_type, addr,
441 flag_check_references));
443 stmt = build2 (COMPOUND_EXPR, void_type_node, modify_stmt, stmt);
444 stmt = build2 (COMPOUND_EXPR, method_return_type, stmt, tmp);
450 VMSupportsCS8_builtin (tree method_return_type,
451 tree orig_call ATTRIBUTE_UNUSED)
453 enum machine_mode mode = TYPE_MODE (long_type_node);
454 gcc_assert (method_return_type == boolean_type_node);
455 if (direct_optab_handler (sync_compare_and_swap_optab, mode)
457 return boolean_true_node;
459 return boolean_false_node;
464 #define BUILTIN_NOTHROW 1
465 #define BUILTIN_CONST 2
466 /* Define a single builtin. */
468 define_builtin (enum built_in_function val,
476 decl = build_decl (BUILTINS_LOCATION,
477 FUNCTION_DECL, get_identifier (name), type);
478 DECL_EXTERNAL (decl) = 1;
479 TREE_PUBLIC (decl) = 1;
480 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
482 DECL_BUILT_IN_CLASS (decl) = BUILT_IN_NORMAL;
483 DECL_FUNCTION_CODE (decl) = val;
484 if (flags & BUILTIN_NOTHROW)
485 TREE_NOTHROW (decl) = 1;
486 if (flags & BUILTIN_CONST)
487 TREE_READONLY (decl) = 1;
489 implicit_built_in_decls[val] = decl;
490 built_in_decls[val] = decl;
495 /* Initialize the builtins. */
497 initialize_builtins (void)
499 tree double_ftype_double, double_ftype_double_double;
500 tree float_ftype_float_float;
501 tree boolean_ftype_boolean_boolean;
504 for (i = 0; java_builtins[i].builtin_code != END_BUILTINS; ++i)
506 tree klass_id = get_identifier (java_builtins[i].class_name.s);
507 tree m = get_identifier (java_builtins[i].method_name.s);
509 java_builtins[i].class_name.t = klass_id;
510 java_builtins[i].method_name.t = m;
513 void_list_node = end_params_node;
515 float_ftype_float_float
516 = build_function_type_list (float_type_node,
517 float_type_node, float_type_node, NULL_TREE);
520 = build_function_type_list (double_type_node, double_type_node, NULL_TREE);
521 double_ftype_double_double
522 = build_function_type_list (double_type_node,
523 double_type_node, double_type_node, NULL_TREE);
525 define_builtin (BUILT_IN_FMOD, "__builtin_fmod",
526 double_ftype_double_double, "fmod", BUILTIN_CONST);
527 define_builtin (BUILT_IN_FMODF, "__builtin_fmodf",
528 float_ftype_float_float, "fmodf", BUILTIN_CONST);
530 define_builtin (BUILT_IN_ACOS, "__builtin_acos",
531 double_ftype_double, "_ZN4java4lang4Math4acosEJdd",
533 define_builtin (BUILT_IN_ASIN, "__builtin_asin",
534 double_ftype_double, "_ZN4java4lang4Math4asinEJdd",
536 define_builtin (BUILT_IN_ATAN, "__builtin_atan",
537 double_ftype_double, "_ZN4java4lang4Math4atanEJdd",
539 define_builtin (BUILT_IN_ATAN2, "__builtin_atan2",
540 double_ftype_double_double, "_ZN4java4lang4Math5atan2EJddd",
542 define_builtin (BUILT_IN_CEIL, "__builtin_ceil",
543 double_ftype_double, "_ZN4java4lang4Math4ceilEJdd",
545 define_builtin (BUILT_IN_COS, "__builtin_cos",
546 double_ftype_double, "_ZN4java4lang4Math3cosEJdd",
548 define_builtin (BUILT_IN_EXP, "__builtin_exp",
549 double_ftype_double, "_ZN4java4lang4Math3expEJdd",
551 define_builtin (BUILT_IN_FLOOR, "__builtin_floor",
552 double_ftype_double, "_ZN4java4lang4Math5floorEJdd",
554 define_builtin (BUILT_IN_LOG, "__builtin_log",
555 double_ftype_double, "_ZN4java4lang4Math3logEJdd",
557 define_builtin (BUILT_IN_POW, "__builtin_pow",
558 double_ftype_double_double, "_ZN4java4lang4Math3powEJddd",
560 define_builtin (BUILT_IN_SIN, "__builtin_sin",
561 double_ftype_double, "_ZN4java4lang4Math3sinEJdd",
563 define_builtin (BUILT_IN_SQRT, "__builtin_sqrt",
564 double_ftype_double, "_ZN4java4lang4Math4sqrtEJdd",
566 define_builtin (BUILT_IN_TAN, "__builtin_tan",
567 double_ftype_double, "_ZN4java4lang4Math3tanEJdd",
570 boolean_ftype_boolean_boolean
571 = build_function_type_list (boolean_type_node,
572 boolean_type_node, boolean_type_node,
574 define_builtin (BUILT_IN_EXPECT, "__builtin_expect",
575 boolean_ftype_boolean_boolean,
577 BUILTIN_CONST | BUILTIN_NOTHROW);
578 define_builtin (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4,
579 "__sync_bool_compare_and_swap_4",
580 build_function_type_list (boolean_type_node,
582 build_pointer_type (int_type_node),
583 int_type_node, NULL_TREE),
584 "__sync_bool_compare_and_swap_4", 0);
585 define_builtin (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8,
586 "__sync_bool_compare_and_swap_8",
587 build_function_type_list (boolean_type_node,
589 build_pointer_type (long_type_node),
590 int_type_node, NULL_TREE),
591 "__sync_bool_compare_and_swap_8", 0);
592 define_builtin (BUILT_IN_SYNC_SYNCHRONIZE, "__sync_synchronize",
593 build_function_type_list (void_type_node, NULL_TREE),
594 "__sync_synchronize", BUILTIN_NOTHROW);
596 define_builtin (BUILT_IN_RETURN_ADDRESS, "__builtin_return_address",
597 build_function_type_list (ptr_type_node, int_type_node, NULL_TREE),
598 "__builtin_return_address", BUILTIN_NOTHROW);
600 build_common_builtin_nodes ();
603 /* If the call matches a builtin, return the
604 appropriate builtin expression instead. */
606 check_for_builtin (tree method, tree call)
608 if (optimize && TREE_CODE (call) == CALL_EXPR)
611 tree method_class = DECL_NAME (TYPE_NAME (DECL_CONTEXT (method)));
612 tree method_name = DECL_NAME (method);
613 tree method_return_type = TREE_TYPE (TREE_TYPE (method));
615 for (i = 0; java_builtins[i].builtin_code != END_BUILTINS; ++i)
617 if (method_class == java_builtins[i].class_name.t
618 && method_name == java_builtins[i].method_name.t)
622 if (java_builtins[i].creator != NULL)
625 = (*java_builtins[i].creator) (method_return_type, call);
626 return result == NULL_TREE ? call : result;
629 /* Builtin functions emit a direct call which is incompatible
631 if (flag_indirect_dispatch)
633 fn = built_in_decls[java_builtins[i].builtin_code];
636 return java_build_function_call_expr (fn, call);
643 #include "gt-java-builtins.h"