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"
41 /* FIXME: All these headers are necessary for sync_compare_and_swap.
42 Front ends should never have to look at that. */
44 #include "insn-codes.h"
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
);
53 static tree
java_build_function_call_expr (tree
, tree
);
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
);
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
);
71 /* Hold a char*, before initialization, or a tree, after
73 union GTY(()) string_or_tree
{
74 const char * GTY ((tag ("0"))) s
;
75 tree
GTY ((tag ("1"))) t
;
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
;
86 static GTY(()) struct builtin_record java_builtins
[] =
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
}
149 /* Internal functions which implement various builtin conversions. */
152 max_builtin (tree method_return_type
, tree orig_call
)
154 /* MAX_EXPR does not handle -0.0 in the Java style. */
155 if (TREE_CODE (method_return_type
) == REAL_TYPE
)
157 return fold_build2 (MAX_EXPR
, method_return_type
,
158 CALL_EXPR_ARG (orig_call
, 0),
159 CALL_EXPR_ARG (orig_call
, 1));
163 min_builtin (tree method_return_type
, tree orig_call
)
165 /* MIN_EXPR does not handle -0.0 in the Java style. */
166 if (TREE_CODE (method_return_type
) == REAL_TYPE
)
168 return fold_build2 (MIN_EXPR
, method_return_type
,
169 CALL_EXPR_ARG (orig_call
, 0),
170 CALL_EXPR_ARG (orig_call
, 1));
174 abs_builtin (tree method_return_type
, tree orig_call
)
176 return fold_build1 (ABS_EXPR
, method_return_type
,
177 CALL_EXPR_ARG (orig_call
, 0));
180 /* Construct a new call to FN using the arguments from ORIG_CALL. */
183 java_build_function_call_expr (tree fn
, tree orig_call
)
185 int nargs
= call_expr_nargs (orig_call
);
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. */
192 return build_call_expr (fn
, 0);
194 return build_call_expr (fn
, 1, CALL_EXPR_ARG (orig_call
, 0));
196 return build_call_expr (fn
, 2,
197 CALL_EXPR_ARG (orig_call
, 0),
198 CALL_EXPR_ARG (orig_call
, 1));
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));
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
)));
215 convert_real (tree method_return_type
, tree orig_call
)
217 return build1 (VIEW_CONVERT_EXPR
, method_return_type
,
218 CALL_EXPR_ARG (orig_call
, 0));
223 /* Provide builtin support for atomic operations. These are
224 documented at length in libjava/sun/misc/Unsafe.java. */
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.
230 In general, double-word compare-and-swap cannot portably be
231 implemented, so we need some kind of fallback for 32-bit machines.
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. */
240 #define UNMARSHAL3(METHOD_CALL) \
241 tree this_arg, obj_arg, offset_arg; \
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)); \
252 #define UNMARSHAL4(METHOD_CALL) \
253 tree value_type, this_arg, obj_arg, offset_arg, value_arg; \
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); \
266 #define UNMARSHAL5(METHOD_CALL) \
267 tree value_type, this_arg, obj_arg, offset_arg, expected_arg, value_arg; \
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); \
281 /* Add an address to an offset, forming a sum. */
284 build_addr_sum (tree type
, tree addr
, tree offset
)
286 tree ptr_type
= build_pointer_type (type
);
287 return fold_build2 (POINTER_PLUS_EXPR
,
289 fold_convert (ptr_type
, addr
),
290 fold_convert (sizetype
, offset
));
293 /* Make sure that this-arg is non-NULL. This is a security check. */
296 build_check_this (tree stmt
, tree this_arg
)
298 return build2 (COMPOUND_EXPR
, TREE_TYPE (stmt
),
299 java_check_reference (this_arg
, 1), stmt
);
302 /* Now the builtins. These correspond to the primitive functions in
303 libjava/sun/misc/natUnsafe.cc. */
306 putObject_builtin (tree method_return_type ATTRIBUTE_UNUSED
,
310 UNMARSHAL4 (orig_call
);
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
),
318 return build_check_this (stmt
, this_arg
);
322 compareAndSwapInt_builtin (tree method_return_type ATTRIBUTE_UNUSED
,
325 enum machine_mode mode
= TYPE_MODE (int_type_node
);
326 if (direct_optab_handler (sync_compare_and_swap_optab
, mode
)
328 || flag_use_atomic_builtins
)
331 UNMARSHAL5 (orig_call
);
332 (void) value_type
; /* Avoid set but not used warning. */
334 addr
= build_addr_sum (int_type_node
, obj_arg
, offset_arg
);
335 stmt
= build_call_expr (built_in_decls
[BUILT_IN_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 (built_in_decls
[BUILT_IN_BOOL_COMPARE_AND_SWAP_8
],
362 3, addr
, expected_arg
, value_arg
);
364 return build_check_this (stmt
, this_arg
);
369 compareAndSwapObject_builtin (tree method_return_type ATTRIBUTE_UNUSED
,
372 enum machine_mode mode
= TYPE_MODE (ptr_type_node
);
373 if (direct_optab_handler (sync_compare_and_swap_optab
, mode
)
375 || flag_use_atomic_builtins
)
380 UNMARSHAL5 (orig_call
);
381 builtin
= (POINTER_SIZE
== 32
382 ? BUILT_IN_BOOL_COMPARE_AND_SWAP_4
383 : BUILT_IN_BOOL_COMPARE_AND_SWAP_8
);
385 addr
= build_addr_sum (value_type
, obj_arg
, offset_arg
);
386 stmt
= build_call_expr (built_in_decls
[builtin
],
387 3, addr
, expected_arg
, value_arg
);
389 return build_check_this (stmt
, this_arg
);
395 putVolatile_builtin (tree method_return_type ATTRIBUTE_UNUSED
,
398 tree addr
, stmt
, modify_stmt
;
399 UNMARSHAL4 (orig_call
);
401 addr
= build_addr_sum (value_type
, obj_arg
, offset_arg
);
403 = fold_convert (build_pointer_type (build_type_variant (value_type
, 0, 1)),
406 stmt
= build_call_expr (built_in_decls
[BUILT_IN_SYNCHRONIZE
], 0);
407 modify_stmt
= fold_build2 (MODIFY_EXPR
, value_type
,
408 build_java_indirect_ref (value_type
, addr
,
409 flag_check_references
),
411 stmt
= build2 (COMPOUND_EXPR
, TREE_TYPE (modify_stmt
),
414 return build_check_this (stmt
, this_arg
);
418 getVolatile_builtin (tree method_return_type ATTRIBUTE_UNUSED
,
421 tree addr
, stmt
, modify_stmt
, tmp
;
422 UNMARSHAL3 (orig_call
);
423 (void) this_arg
; /* Avoid set but not used warning. */
425 addr
= build_addr_sum (method_return_type
, obj_arg
, offset_arg
);
427 = fold_convert (build_pointer_type (build_type_variant
428 (method_return_type
, 0, 1)), addr
);
430 stmt
= build_call_expr (built_in_decls
[BUILT_IN_SYNCHRONIZE
], 0);
432 tmp
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL
, method_return_type
);
433 DECL_IGNORED_P (tmp
) = 1;
434 DECL_ARTIFICIAL (tmp
) = 1;
437 modify_stmt
= fold_build2 (MODIFY_EXPR
, method_return_type
,
439 build_java_indirect_ref (method_return_type
, addr
,
440 flag_check_references
));
442 stmt
= build2 (COMPOUND_EXPR
, void_type_node
, modify_stmt
, stmt
);
443 stmt
= build2 (COMPOUND_EXPR
, method_return_type
, stmt
, tmp
);
449 VMSupportsCS8_builtin (tree method_return_type
,
450 tree orig_call ATTRIBUTE_UNUSED
)
452 enum machine_mode mode
= TYPE_MODE (long_type_node
);
453 gcc_assert (method_return_type
== boolean_type_node
);
454 if (direct_optab_handler (sync_compare_and_swap_optab
, mode
)
456 return boolean_true_node
;
458 return boolean_false_node
;
463 #define BUILTIN_NOTHROW 1
464 #define BUILTIN_CONST 2
465 /* Define a single builtin. */
467 define_builtin (enum built_in_function val
,
475 decl
= build_decl (BUILTINS_LOCATION
,
476 FUNCTION_DECL
, get_identifier (name
), type
);
477 DECL_EXTERNAL (decl
) = 1;
478 TREE_PUBLIC (decl
) = 1;
479 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (libname
));
481 DECL_BUILT_IN_CLASS (decl
) = BUILT_IN_NORMAL
;
482 DECL_FUNCTION_CODE (decl
) = val
;
483 if (flags
& BUILTIN_NOTHROW
)
484 TREE_NOTHROW (decl
) = 1;
485 if (flags
& BUILTIN_CONST
)
486 TREE_READONLY (decl
) = 1;
488 implicit_built_in_decls
[val
] = decl
;
489 built_in_decls
[val
] = decl
;
494 /* Initialize the builtins. */
496 initialize_builtins (void)
498 tree double_ftype_double
, double_ftype_double_double
;
499 tree float_ftype_float_float
;
500 tree boolean_ftype_boolean_boolean
;
503 for (i
= 0; java_builtins
[i
].builtin_code
!= END_BUILTINS
; ++i
)
505 tree klass_id
= get_identifier (java_builtins
[i
].class_name
.s
);
506 tree m
= get_identifier (java_builtins
[i
].method_name
.s
);
508 java_builtins
[i
].class_name
.t
= klass_id
;
509 java_builtins
[i
].method_name
.t
= m
;
512 void_list_node
= end_params_node
;
514 float_ftype_float_float
515 = build_function_type_list (float_type_node
,
516 float_type_node
, float_type_node
, NULL_TREE
);
519 = build_function_type_list (double_type_node
, double_type_node
, NULL_TREE
);
520 double_ftype_double_double
521 = build_function_type_list (double_type_node
,
522 double_type_node
, double_type_node
, NULL_TREE
);
524 define_builtin (BUILT_IN_FMOD
, "__builtin_fmod",
525 double_ftype_double_double
, "fmod", BUILTIN_CONST
);
526 define_builtin (BUILT_IN_FMODF
, "__builtin_fmodf",
527 float_ftype_float_float
, "fmodf", BUILTIN_CONST
);
529 define_builtin (BUILT_IN_ACOS
, "__builtin_acos",
530 double_ftype_double
, "_ZN4java4lang4Math4acosEJdd",
532 define_builtin (BUILT_IN_ASIN
, "__builtin_asin",
533 double_ftype_double
, "_ZN4java4lang4Math4asinEJdd",
535 define_builtin (BUILT_IN_ATAN
, "__builtin_atan",
536 double_ftype_double
, "_ZN4java4lang4Math4atanEJdd",
538 define_builtin (BUILT_IN_ATAN2
, "__builtin_atan2",
539 double_ftype_double_double
, "_ZN4java4lang4Math5atan2EJddd",
541 define_builtin (BUILT_IN_CEIL
, "__builtin_ceil",
542 double_ftype_double
, "_ZN4java4lang4Math4ceilEJdd",
544 define_builtin (BUILT_IN_COS
, "__builtin_cos",
545 double_ftype_double
, "_ZN4java4lang4Math3cosEJdd",
547 define_builtin (BUILT_IN_EXP
, "__builtin_exp",
548 double_ftype_double
, "_ZN4java4lang4Math3expEJdd",
550 define_builtin (BUILT_IN_FLOOR
, "__builtin_floor",
551 double_ftype_double
, "_ZN4java4lang4Math5floorEJdd",
553 define_builtin (BUILT_IN_LOG
, "__builtin_log",
554 double_ftype_double
, "_ZN4java4lang4Math3logEJdd",
556 define_builtin (BUILT_IN_POW
, "__builtin_pow",
557 double_ftype_double_double
, "_ZN4java4lang4Math3powEJddd",
559 define_builtin (BUILT_IN_SIN
, "__builtin_sin",
560 double_ftype_double
, "_ZN4java4lang4Math3sinEJdd",
562 define_builtin (BUILT_IN_SQRT
, "__builtin_sqrt",
563 double_ftype_double
, "_ZN4java4lang4Math4sqrtEJdd",
565 define_builtin (BUILT_IN_TAN
, "__builtin_tan",
566 double_ftype_double
, "_ZN4java4lang4Math3tanEJdd",
569 boolean_ftype_boolean_boolean
570 = build_function_type_list (boolean_type_node
,
571 boolean_type_node
, boolean_type_node
,
573 define_builtin (BUILT_IN_EXPECT
, "__builtin_expect",
574 boolean_ftype_boolean_boolean
,
576 BUILTIN_CONST
| BUILTIN_NOTHROW
);
577 define_builtin (BUILT_IN_BOOL_COMPARE_AND_SWAP_4
,
578 "__sync_bool_compare_and_swap_4",
579 build_function_type_list (boolean_type_node
,
581 build_pointer_type (int_type_node
),
582 int_type_node
, NULL_TREE
),
583 "__sync_bool_compare_and_swap_4", 0);
584 define_builtin (BUILT_IN_BOOL_COMPARE_AND_SWAP_8
,
585 "__sync_bool_compare_and_swap_8",
586 build_function_type_list (boolean_type_node
,
588 build_pointer_type (long_type_node
),
589 int_type_node
, NULL_TREE
),
590 "__sync_bool_compare_and_swap_8", 0);
591 define_builtin (BUILT_IN_SYNCHRONIZE
, "__sync_synchronize",
592 build_function_type_list (void_type_node
, NULL_TREE
),
593 "__sync_synchronize", BUILTIN_NOTHROW
);
595 define_builtin (BUILT_IN_RETURN_ADDRESS
, "__builtin_return_address",
596 build_function_type_list (ptr_type_node
, int_type_node
, NULL_TREE
),
597 "__builtin_return_address", BUILTIN_NOTHROW
);
599 build_common_builtin_nodes ();
602 /* If the call matches a builtin, return the
603 appropriate builtin expression instead. */
605 check_for_builtin (tree method
, tree call
)
607 if (optimize
&& TREE_CODE (call
) == CALL_EXPR
)
610 tree method_class
= DECL_NAME (TYPE_NAME (DECL_CONTEXT (method
)));
611 tree method_name
= DECL_NAME (method
);
612 tree method_return_type
= TREE_TYPE (TREE_TYPE (method
));
614 for (i
= 0; java_builtins
[i
].builtin_code
!= END_BUILTINS
; ++i
)
616 if (method_class
== java_builtins
[i
].class_name
.t
617 && method_name
== java_builtins
[i
].method_name
.t
)
621 if (java_builtins
[i
].creator
!= NULL
)
624 = (*java_builtins
[i
].creator
) (method_return_type
, call
);
625 return result
== NULL_TREE
? call
: result
;
628 /* Builtin functions emit a direct call which is incompatible
630 if (flag_indirect_dispatch
)
632 fn
= built_in_decls
[java_builtins
[i
].builtin_code
];
635 return java_build_function_call_expr (fn
, call
);
642 #include "gt-java-builtins.h"