1 /* Process expressions for the GNU compiler for the Java(TM) language.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
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 2, 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.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc. */
26 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
30 #include "coretypes.h"
37 #include "java-tree.h"
39 #include "java-opcodes.h"
41 #include "java-except.h"
47 static void flush_quick_stack (void);
48 static void push_value (tree);
49 static tree pop_value (tree);
50 static void java_stack_swap (void);
51 static void java_stack_dup (int, int);
52 static void build_java_athrow (tree);
53 static void build_java_jsr (int, int);
54 static void build_java_ret (tree);
55 static void expand_java_multianewarray (tree, int);
56 static void expand_java_arraystore (tree);
57 static void expand_java_arrayload (tree);
58 static void expand_java_array_length (void);
59 static tree build_java_monitor (tree, tree);
60 static void expand_java_pushc (int, tree);
61 static void expand_java_return (tree);
62 static void expand_load_internal (int, tree, int);
63 static void expand_java_NEW (tree);
64 static void expand_java_INSTANCEOF (tree);
65 static void expand_java_CHECKCAST (tree);
66 static void expand_iinc (unsigned int, int, int);
67 static void expand_java_binop (tree, enum tree_code);
68 static void note_label (int, int);
69 static void expand_compare (enum tree_code, tree, tree, int);
70 static void expand_test (enum tree_code, tree, int);
71 static void expand_cond (enum tree_code, tree, int);
72 static void expand_java_goto (int);
74 static void expand_java_call (int, int);
75 static void expand_java_ret (tree);
77 static tree pop_arguments (tree);
78 static void expand_invoke (int, int, int);
79 static void expand_java_field_op (int, int, int);
80 static void java_push_constant_from_pool (struct JCF *, int);
81 static void java_stack_pop (int);
82 static tree build_java_throw_out_of_bounds_exception (tree);
83 static tree build_java_check_indexed_type (tree, tree);
84 static tree case_identity (tree, tree);
85 static unsigned char peek_opcode_at_pc (struct JCF *, int, int);
86 static int emit_init_test_initialization (void **entry, void * ptr);
87 static int get_offset_table_index (tree);
89 static GTY(()) tree operand_type[59];
91 static GTY(()) tree methods_ident;
92 static GTY(()) tree ncode_ident;
93 tree dtable_ident = NULL_TREE;
95 /* Set to nonzero value in order to emit class initilization code
96 before static field references. */
97 int always_initialize_class_p;
99 /* We store the stack state in two places:
100 Within a basic block, we use the quick_stack, which is a
101 pushdown list (TREE_LISTs) of expression nodes.
102 This is the top part of the stack; below that we use find_stack_slot.
103 At the end of a basic block, the quick_stack must be flushed
104 to the stack slot array (as handled by find_stack_slot).
105 Using quick_stack generates better code (especially when
106 compiled without optimization), because we do not have to
107 explicitly store and load trees to temporary variables.
109 If a variable is on the quick stack, it means the value of variable
110 when the quick stack was last flushed. Conceptually, flush_quick_stack
111 saves all the the quick_stack elements in parellel. However, that is
112 complicated, so it actually saves them (i.e. copies each stack value
113 to is home virtual register) from low indexes. This allows a quick_stack
114 element at index i (counting from the bottom of stack the) to references
115 slot virtuals for register that are >= i, but not those that are deeper.
116 This convention makes most operations easier. For example iadd works
117 even when the stack contains (reg[0], reg[1]): It results in the
118 stack containing (reg[0]+reg[1]), which is OK. However, some stack
119 operations are more complicated. For example dup given a stack
120 containing (reg[0]) would yield (reg[0], reg[0]), which would violate
121 the convention, since stack value 1 would refer to a register with
122 lower index (reg[0]), which flush_quick_stack does not safely handle.
123 So dup cannot just add an extra element to the quick_stack, but iadd can.
126 static GTY(()) tree quick_stack;
128 /* A free-list of unused permamnet TREE_LIST nodes. */
129 static GTY((deletable (""))) tree tree_list_free_list;
131 /* The stack pointer of the Java virtual machine.
132 This does include the size of the quick_stack. */
136 const unsigned char *linenumber_table;
137 int linenumber_count;
140 init_expr_processing (void)
142 operand_type[21] = operand_type[54] = int_type_node;
143 operand_type[22] = operand_type[55] = long_type_node;
144 operand_type[23] = operand_type[56] = float_type_node;
145 operand_type[24] = operand_type[57] = double_type_node;
146 operand_type[25] = operand_type[58] = ptr_type_node;
150 java_truthvalue_conversion (tree expr)
152 /* It is simpler and generates better code to have only TRUTH_*_EXPR
153 or comparison expressions as truth values at this level.
155 This function should normally be identity for Java. */
157 switch (TREE_CODE (expr))
160 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
161 case TRUTH_ANDIF_EXPR:
162 case TRUTH_ORIF_EXPR:
169 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
172 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
174 /* are these legal? XXX JH */
179 /* These don't change whether an object is nonzero or zero. */
180 return java_truthvalue_conversion (TREE_OPERAND (expr, 0));
183 /* Distribute the conversion into the arms of a COND_EXPR. */
184 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
185 java_truthvalue_conversion (TREE_OPERAND (expr, 1)),
186 java_truthvalue_conversion (TREE_OPERAND (expr, 2))));
189 /* If this is widening the argument, we can ignore it. */
190 if (TYPE_PRECISION (TREE_TYPE (expr))
191 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
192 return java_truthvalue_conversion (TREE_OPERAND (expr, 0));
193 /* fall through to default */
196 return fold (build (NE_EXPR, boolean_type_node, expr, boolean_false_node));
200 /* Save any stack slots that happen to be in the quick_stack into their
201 home virtual register slots.
203 The copy order is from low stack index to high, to support the invariant
204 that the expression for a slot may contain decls for stack slots with
205 higher (or the same) index, but not lower. */
208 flush_quick_stack (void)
210 int stack_index = stack_pointer;
211 register tree prev, cur, next;
213 /* First reverse the quick_stack, and count the number of slots it has. */
214 for (cur = quick_stack, prev = NULL_TREE; cur != NULL_TREE; cur = next)
216 next = TREE_CHAIN (cur);
217 TREE_CHAIN (cur) = prev;
219 stack_index -= 1 + TYPE_IS_WIDE (TREE_TYPE (TREE_VALUE (cur)));
223 while (quick_stack != NULL_TREE)
226 tree node = quick_stack, type;
227 quick_stack = TREE_CHAIN (node);
228 TREE_CHAIN (node) = tree_list_free_list;
229 tree_list_free_list = node;
230 node = TREE_VALUE (node);
231 type = TREE_TYPE (node);
233 decl = find_stack_slot (stack_index, type);
235 expand_assignment (decl, node, 0, 0);
236 stack_index += 1 + TYPE_IS_WIDE (type);
240 /* Push TYPE on the type stack.
241 Return true on success, 0 on overflow. */
244 push_type_0 (tree type)
247 type = promote_type (type);
248 n_words = 1 + TYPE_IS_WIDE (type);
249 if (stack_pointer + n_words > DECL_MAX_STACK (current_function_decl))
251 stack_type_map[stack_pointer++] = type;
253 while (--n_words >= 0)
254 stack_type_map[stack_pointer++] = TYPE_SECOND;
259 push_type (tree type)
261 if (! push_type_0 (type))
266 push_value (tree value)
268 tree type = TREE_TYPE (value);
269 if (TYPE_PRECISION (type) < 32 && INTEGRAL_TYPE_P (type))
271 type = promote_type (type);
272 value = convert (type, value);
275 if (tree_list_free_list == NULL_TREE)
276 quick_stack = tree_cons (NULL_TREE, value, quick_stack);
279 tree node = tree_list_free_list;
280 tree_list_free_list = TREE_CHAIN (tree_list_free_list);
281 TREE_VALUE (node) = value;
282 TREE_CHAIN (node) = quick_stack;
287 /* Pop a type from the type stack.
288 TYPE is the expected type. Return the actual type, which must be
290 On an error, *MESSAGEP is set to a freshly malloc'd error message. */
293 pop_type_0 (tree type, char **messagep)
298 if (TREE_CODE (type) == RECORD_TYPE)
299 type = promote_type (type);
300 n_words = 1 + TYPE_IS_WIDE (type);
301 if (stack_pointer < n_words)
303 *messagep = xstrdup ("stack underflow");
306 while (--n_words > 0)
308 if (stack_type_map[--stack_pointer] != void_type_node)
310 *messagep = xstrdup ("Invalid multi-word value on type stack");
314 t = stack_type_map[--stack_pointer];
315 if (type == NULL_TREE || t == type)
317 if (INTEGRAL_TYPE_P (type) && INTEGRAL_TYPE_P (t)
318 && TYPE_PRECISION (type) <= 32 && TYPE_PRECISION (t) <= 32)
320 if (TREE_CODE (type) == POINTER_TYPE && TREE_CODE (t) == POINTER_TYPE)
322 if (type == ptr_type_node || type == object_ptr_type_node)
324 else if (t == ptr_type_node) /* Special case for null reference. */
326 else if (can_widen_reference_to (t, type))
328 /* This is a kludge, but matches what Sun's verifier does.
329 It can be tricked, but is safe as long as type errors
330 (i.e. interface method calls) are caught at run-time. */
331 else if (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (type))))
332 return object_ptr_type_node;
335 /* lang_printable_name uses a static buffer, so we must save the result
336 from calling it the first time. */
338 char *temp = xstrdup (lang_printable_name (type, 0));
339 *messagep = concat ("expected type '", temp,
340 "' but stack contains '", lang_printable_name (t, 0),
347 /* Pop a type from the type stack.
348 TYPE is the expected type. Return the actual type, which must be
349 convertible to TYPE, otherwise call error. */
354 char *message = NULL;
355 type = pop_type_0 (type, &message);
358 error ("%s", message);
364 /* Return 1f if SOURCE_TYPE can be safely widened to TARGET_TYPE.
365 Handles array types and interfaces. */
368 can_widen_reference_to (tree source_type, tree target_type)
370 if (source_type == ptr_type_node || target_type == object_ptr_type_node)
373 /* Get rid of pointers */
374 if (TREE_CODE (source_type) == POINTER_TYPE)
375 source_type = TREE_TYPE (source_type);
376 if (TREE_CODE (target_type) == POINTER_TYPE)
377 target_type = TREE_TYPE (target_type);
379 if (source_type == target_type)
383 if (TYPE_ARRAY_P (source_type) || TYPE_ARRAY_P (target_type))
385 HOST_WIDE_INT source_length, target_length;
386 if (TYPE_ARRAY_P (source_type) != TYPE_ARRAY_P (target_type))
388 /* An array implements Cloneable and Serializable. */
389 tree name = DECL_NAME (TYPE_NAME (target_type));
390 return (name == java_lang_cloneable_identifier_node
391 || name == java_io_serializable_identifier_node);
393 target_length = java_array_type_length (target_type);
394 if (target_length >= 0)
396 source_length = java_array_type_length (source_type);
397 if (source_length != target_length)
400 source_type = TYPE_ARRAY_ELEMENT (source_type);
401 target_type = TYPE_ARRAY_ELEMENT (target_type);
402 if (source_type == target_type)
404 if (TREE_CODE (source_type) != POINTER_TYPE
405 || TREE_CODE (target_type) != POINTER_TYPE)
407 return can_widen_reference_to (source_type, target_type);
411 int source_depth = class_depth (source_type);
412 int target_depth = class_depth (target_type);
414 /* class_depth can return a negative depth if an error occurred */
415 if (source_depth < 0 || target_depth < 0)
418 if (CLASS_INTERFACE (TYPE_NAME (target_type)))
420 /* target_type is OK if source_type or source_type ancestors
421 implement target_type. We handle multiple sub-interfaces */
423 tree basetype_vec = TYPE_BINFO_BASETYPES (source_type);
424 int n = TREE_VEC_LENGTH (basetype_vec), i;
425 for (i=0 ; i < n; i++)
426 if (can_widen_reference_to
427 (TREE_TYPE (TREE_VEC_ELT (basetype_vec, i)),
434 for ( ; source_depth > target_depth; source_depth--)
436 source_type = TYPE_BINFO_BASETYPE (source_type, 0);
438 return source_type == target_type;
444 pop_value (tree type)
446 type = pop_type (type);
449 tree node = quick_stack;
450 quick_stack = TREE_CHAIN (quick_stack);
451 TREE_CHAIN (node) = tree_list_free_list;
452 tree_list_free_list = node;
453 node = TREE_VALUE (node);
457 return find_stack_slot (stack_pointer, promote_type (type));
461 /* Pop and discrad the top COUNT stack slots. */
464 java_stack_pop (int count)
470 if (stack_pointer == 0)
473 type = stack_type_map[stack_pointer - 1];
474 if (type == TYPE_SECOND)
477 if (stack_pointer == 1 || count <= 0)
480 type = stack_type_map[stack_pointer - 2];
482 val = pop_value (type);
487 /* Implement the 'swap' operator (to swap two top stack slots). */
490 java_stack_swap (void)
496 if (stack_pointer < 2
497 || (type1 = stack_type_map[stack_pointer - 1]) == TYPE_UNKNOWN
498 || (type2 = stack_type_map[stack_pointer - 2]) == TYPE_UNKNOWN
499 || type1 == TYPE_SECOND || type2 == TYPE_SECOND
500 || TYPE_IS_WIDE (type1) || TYPE_IS_WIDE (type2))
501 /* Bad stack swap. */
504 flush_quick_stack ();
505 decl1 = find_stack_slot (stack_pointer - 1, type1);
506 decl2 = find_stack_slot (stack_pointer - 2, type2);
507 temp = copy_to_reg (DECL_RTL (decl1));
508 emit_move_insn (DECL_RTL (decl1), DECL_RTL (decl2));
509 emit_move_insn (DECL_RTL (decl2), temp);
510 stack_type_map[stack_pointer - 1] = type2;
511 stack_type_map[stack_pointer - 2] = type1;
515 java_stack_dup (int size, int offset)
517 int low_index = stack_pointer - size - offset;
520 error ("stack underflow - dup* operation");
522 flush_quick_stack ();
524 stack_pointer += size;
525 dst_index = stack_pointer;
527 for (dst_index = stack_pointer; --dst_index >= low_index; )
530 int src_index = dst_index - size;
531 if (src_index < low_index)
532 src_index = dst_index + size + offset;
533 type = stack_type_map [src_index];
534 if (type == TYPE_SECOND)
536 if (src_index <= low_index)
537 /* Dup operation splits 64-bit number. */
540 stack_type_map[dst_index] = type;
541 src_index--; dst_index--;
542 type = stack_type_map[src_index];
543 if (! TYPE_IS_WIDE (type))
546 else if (TYPE_IS_WIDE (type))
549 if (src_index != dst_index)
551 tree src_decl = find_stack_slot (src_index, type);
552 tree dst_decl = find_stack_slot (dst_index, type);
553 emit_move_insn (DECL_RTL (dst_decl), DECL_RTL (src_decl));
554 stack_type_map[dst_index] = type;
559 /* Calls _Jv_Throw or _Jv_Sjlj_Throw. Discard the contents of the
563 build_java_athrow (tree node)
567 call = build (CALL_EXPR,
569 build_address_of (throw_node),
570 build_tree_list (NULL_TREE, node),
572 TREE_SIDE_EFFECTS (call) = 1;
573 expand_expr_stmt (call);
574 java_stack_pop (stack_pointer);
577 /* Implementation for jsr/ret */
580 build_java_jsr (int target_pc, int return_pc)
582 tree where = lookup_label (target_pc);
583 tree ret = lookup_label (return_pc);
584 tree ret_label = fold (build1 (ADDR_EXPR, return_address_type_node, ret));
585 push_value (ret_label);
586 flush_quick_stack ();
587 emit_jump (label_rtx (where));
589 if (instruction_bits [return_pc] & BCODE_VERIFIED)
590 load_type_state (ret);
594 build_java_ret (tree location)
596 expand_computed_goto (location);
599 /* Implementation of operations on array: new, load, store, length */
602 decode_newarray_type (int atype)
606 case 4: return boolean_type_node;
607 case 5: return char_type_node;
608 case 6: return float_type_node;
609 case 7: return double_type_node;
610 case 8: return byte_type_node;
611 case 9: return short_type_node;
612 case 10: return int_type_node;
613 case 11: return long_type_node;
614 default: return NULL_TREE;
618 /* Map primitive type to the code used by OPCODE_newarray. */
621 encode_newarray_type (tree type)
623 if (type == boolean_type_node)
625 else if (type == char_type_node)
627 else if (type == float_type_node)
629 else if (type == double_type_node)
631 else if (type == byte_type_node)
633 else if (type == short_type_node)
635 else if (type == int_type_node)
637 else if (type == long_type_node)
643 /* Build a call to _Jv_ThrowBadArrayIndex(), the
644 ArrayIndexOfBoundsException exception handler. */
647 build_java_throw_out_of_bounds_exception (tree index)
649 tree node = build (CALL_EXPR, int_type_node,
650 build_address_of (soft_badarrayindex_node),
651 build_tree_list (NULL_TREE, index), NULL_TREE);
652 TREE_SIDE_EFFECTS (node) = 1; /* Allows expansion within ANDIF */
656 /* Return the length of an array. Doesn't perform any checking on the nature
657 or value of the array NODE. May be used to implement some bytecodes. */
660 build_java_array_length_access (tree node)
662 tree type = TREE_TYPE (node);
663 tree array_type = TREE_TYPE (type);
664 HOST_WIDE_INT length;
666 /* JVM spec: If the arrayref is null, the arraylength instruction
667 throws a NullPointerException. The only way we could get a node
668 of type ptr_type_node at this point is `aconst_null; arraylength'
669 or something equivalent. */
670 if (type == ptr_type_node)
671 return build (CALL_EXPR, int_type_node,
672 build_address_of (soft_nullpointer_node),
673 NULL_TREE, NULL_TREE);
675 if (!is_array_type_p (type))
678 length = java_array_type_length (type);
680 return build_int_2 (length, 0);
682 node = build (COMPONENT_REF, int_type_node,
683 build_java_indirect_ref (array_type, node,
684 flag_check_references),
685 lookup_field (&array_type, get_identifier ("length")));
686 IS_ARRAY_LENGTH_ACCESS (node) = 1;
690 /* Optionally checks a reference against the NULL pointer. ARG1: the
691 expr, ARG2: we should check the reference. Don't generate extra
692 checks if we're not generating code. */
695 java_check_reference (tree expr, int check)
697 if (!flag_syntax_only && check)
700 expr = save_expr (expr);
701 cond = build (COND_EXPR, void_type_node,
702 build (EQ_EXPR, boolean_type_node, expr, null_pointer_node),
703 build (CALL_EXPR, void_type_node,
704 build_address_of (soft_nullpointer_node),
705 NULL_TREE, NULL_TREE),
707 expr = build (COMPOUND_EXPR, TREE_TYPE (expr), cond, expr);
713 /* Reference an object: just like an INDIRECT_REF, but with checking. */
716 build_java_indirect_ref (tree type, tree expr, int check)
718 return build1 (INDIRECT_REF, type, java_check_reference (expr, check));
721 /* Implement array indexing (either as l-value or r-value).
722 Returns a tree for ARRAY[INDEX], assume TYPE is the element type.
723 Optionally performs bounds checking and/or test to NULL.
724 At this point, ARRAY should have been verified as an array. */
727 build_java_arrayaccess (tree array, tree type, tree index)
729 tree node, throw = NULL_TREE;
732 tree array_type = TREE_TYPE (TREE_TYPE (array));
734 if (flag_bounds_check)
737 * (unsigned jint) INDEX >= (unsigned jint) LEN
738 * && throw ArrayIndexOutOfBoundsException.
739 * Note this is equivalent to and more efficient than:
740 * INDEX < 0 || INDEX >= LEN && throw ... */
742 tree len = build_java_array_length_access (array);
743 TREE_TYPE (len) = unsigned_int_type_node;
744 test = fold (build (GE_EXPR, boolean_type_node,
745 convert (unsigned_int_type_node, index),
747 if (! integer_zerop (test))
749 throw = build (TRUTH_ANDIF_EXPR, int_type_node, test,
750 build_java_throw_out_of_bounds_exception (index));
751 /* allows expansion within COMPOUND */
752 TREE_SIDE_EFFECTS( throw ) = 1;
756 /* If checking bounds, wrap the index expr with a COMPOUND_EXPR in order
757 to have the bounds check evaluated first. */
758 if (throw != NULL_TREE)
759 index = build (COMPOUND_EXPR, int_type_node, throw, index);
761 data_field = lookup_field (&array_type, get_identifier ("data"));
763 ref = build (COMPONENT_REF, TREE_TYPE (data_field),
764 build_java_indirect_ref (array_type, array,
765 flag_check_references),
768 node = build (ARRAY_REF, type, ref, index);
772 /* Generate code to throw an ArrayStoreException if OBJECT is not assignable
773 (at runtime) to an element of ARRAY. A NOP_EXPR is returned if it can
774 determine that no check is required. */
777 build_java_arraystore_check (tree array, tree object)
779 tree check, element_type, source;
780 tree array_type_p = TREE_TYPE (array);
781 tree object_type = TYPE_NAME (TREE_TYPE (TREE_TYPE (object)));
783 if (! is_array_type_p (array_type_p))
786 /* Get the TYPE_DECL for ARRAY's element type. */
787 element_type = TYPE_NAME (TREE_TYPE (TREE_TYPE (TREE_TYPE (array_type_p))));
789 if (TREE_CODE (element_type) != TYPE_DECL
790 || TREE_CODE (object_type) != TYPE_DECL)
793 if (!flag_store_check)
794 return build1 (NOP_EXPR, array_type_p, array);
796 /* No check is needed if the element type is final or is itself an array.
797 Also check that element_type matches object_type, since in the bytecode
798 compilation case element_type may be the actual element type of the arra
799 rather than its declared type. */
800 if (element_type == object_type
801 && (TYPE_ARRAY_P (TREE_TYPE (element_type))
802 || CLASS_FINAL (element_type)))
803 return build1 (NOP_EXPR, array_type_p, array);
805 /* OBJECT might be wrapped by a SAVE_EXPR. */
806 if (TREE_CODE (object) == SAVE_EXPR)
807 source = TREE_OPERAND (object, 0);
811 /* Avoid the check if OBJECT was just loaded from the same array. */
812 if (TREE_CODE (source) == ARRAY_REF)
815 source = TREE_OPERAND (source, 0); /* COMPONENT_REF. */
816 source = TREE_OPERAND (source, 0); /* INDIRECT_REF. */
817 source = TREE_OPERAND (source, 0); /* Source array's DECL or SAVE_EXPR. */
818 if (TREE_CODE (source) == SAVE_EXPR)
819 source = TREE_OPERAND (source, 0);
822 if (TREE_CODE (target) == SAVE_EXPR)
823 target = TREE_OPERAND (target, 0);
825 if (source == target)
826 return build1 (NOP_EXPR, array_type_p, array);
829 /* Build an invocation of _Jv_CheckArrayStore */
830 check = build (CALL_EXPR, void_type_node,
831 build_address_of (soft_checkarraystore_node),
832 tree_cons (NULL_TREE, array,
833 build_tree_list (NULL_TREE, object)),
835 TREE_SIDE_EFFECTS (check) = 1;
840 /* Makes sure that INDEXED_TYPE is appropriate. If not, make it from
841 ARRAY_NODE. This function is used to retrieve something less vague than
842 a pointer type when indexing the first dimension of something like [[<t>.
843 May return a corrected type, if necessary, otherwise INDEXED_TYPE is
845 As a side effect, it also makes sure that ARRAY_NODE is an array. */
848 build_java_check_indexed_type (tree array_node, tree indexed_type)
852 if (!is_array_type_p (TREE_TYPE (array_node)))
855 elt_type = (TYPE_ARRAY_ELEMENT (TREE_TYPE (TREE_TYPE (array_node))));
857 if (indexed_type == ptr_type_node )
858 return promote_type (elt_type);
860 /* BYTE/BOOLEAN store and load are used for both type */
861 if (indexed_type == byte_type_node && elt_type == boolean_type_node )
862 return boolean_type_node;
864 if (indexed_type != elt_type )
870 /* newarray triggers a call to _Jv_NewPrimArray. This function should be
871 called with an integer code (the type of array to create), and the length
872 of the array to create. */
875 build_newarray (int atype_value, tree length)
879 tree prim_type = decode_newarray_type (atype_value);
881 = build_java_array_type (prim_type,
882 host_integerp (length, 0) == INTEGER_CST
883 ? tree_low_cst (length, 0) : -1);
885 /* If compiling to native, pass a reference to the primitive type class
886 and save the runtime some work. However, the bytecode generator
887 expects to find the type_code int here. */
888 if (flag_emit_class_files)
889 type_arg = build_int_2 (atype_value, 0);
891 type_arg = build_class_ref (prim_type);
893 return build (CALL_EXPR, promote_type (type),
894 build_address_of (soft_newarray_node),
895 tree_cons (NULL_TREE,
897 build_tree_list (NULL_TREE, length)),
901 /* Generates anewarray from a given CLASS_TYPE. Gets from the stack the size
905 build_anewarray (tree class_type, tree length)
908 = build_java_array_type (class_type,
909 host_integerp (length, 0)
910 ? tree_low_cst (length, 0) : -1);
912 return build (CALL_EXPR, promote_type (type),
913 build_address_of (soft_anewarray_node),
914 tree_cons (NULL_TREE, length,
915 tree_cons (NULL_TREE, build_class_ref (class_type),
916 build_tree_list (NULL_TREE,
917 null_pointer_node))),
921 /* Return a node the evaluates 'new TYPE[LENGTH]'. */
924 build_new_array (tree type, tree length)
926 if (JPRIMITIVE_TYPE_P (type))
927 return build_newarray (encode_newarray_type (type), length);
929 return build_anewarray (TREE_TYPE (type), length);
932 /* Generates a call to _Jv_NewMultiArray. multianewarray expects a
933 class pointer, a number of dimensions and the matching number of
934 dimensions. The argument list is NULL terminated. */
937 expand_java_multianewarray (tree class_type, int ndim)
940 tree args = build_tree_list( NULL_TREE, null_pointer_node );
942 for( i = 0; i < ndim; i++ )
943 args = tree_cons (NULL_TREE, pop_value (int_type_node), args);
945 push_value (build (CALL_EXPR,
946 promote_type (class_type),
947 build_address_of (soft_multianewarray_node),
948 tree_cons (NULL_TREE, build_class_ref (class_type),
949 tree_cons (NULL_TREE,
950 build_int_2 (ndim, 0), args )),
954 /* ARRAY[INDEX] <- RHS. build_java_check_indexed_type makes sure that
955 ARRAY is an array type. May expand some bound checking and NULL
956 pointer checking. RHS_TYPE_NODE we are going to store. In the case
957 of the CHAR/BYTE/BOOLEAN SHORT, the type popped of the stack is an
958 INT. In those cases, we make the convertion.
960 if ARRAy is a reference type, the assignment is checked at run-time
961 to make sure that the RHS can be assigned to the array element
962 type. It is not necessary to generate this code if ARRAY is final. */
965 expand_java_arraystore (tree rhs_type_node)
967 tree rhs_node = pop_value ((INTEGRAL_TYPE_P (rhs_type_node)
968 && TYPE_PRECISION (rhs_type_node) <= 32) ?
969 int_type_node : rhs_type_node);
970 tree index = pop_value (int_type_node);
971 tree array = pop_value (ptr_type_node);
973 rhs_type_node = build_java_check_indexed_type (array, rhs_type_node);
975 flush_quick_stack ();
977 index = save_expr (index);
978 array = save_expr (array);
980 if (TREE_CODE (rhs_type_node) == POINTER_TYPE)
982 tree check = build_java_arraystore_check (array, rhs_node);
983 expand_expr_stmt (check);
986 expand_assignment (build_java_arrayaccess (array,
992 /* Expand the evaluation of ARRAY[INDEX]. build_java_check_indexed_type makes
993 sure that LHS is an array type. May expand some bound checking and NULL
995 LHS_TYPE_NODE is the type of ARRAY[INDEX]. But in the case of CHAR/BYTE/
996 BOOLEAN/SHORT, we push a promoted type back to the stack.
1000 expand_java_arrayload (tree lhs_type_node )
1003 tree index_node = pop_value (int_type_node);
1004 tree array_node = pop_value (ptr_type_node);
1006 index_node = save_expr (index_node);
1007 array_node = save_expr (array_node);
1009 if (TREE_TYPE (array_node) == ptr_type_node)
1010 /* The only way we could get a node of type ptr_type_node at this
1011 point is `aconst_null; arraylength' or something equivalent, so
1012 unconditionally throw NullPointerException. */
1013 load_node = build (CALL_EXPR, lhs_type_node,
1014 build_address_of (soft_nullpointer_node),
1015 NULL_TREE, NULL_TREE);
1018 lhs_type_node = build_java_check_indexed_type (array_node, lhs_type_node);
1019 load_node = build_java_arrayaccess (array_node,
1023 if (INTEGRAL_TYPE_P (lhs_type_node) && TYPE_PRECISION (lhs_type_node) <= 32)
1024 load_node = fold (build1 (NOP_EXPR, int_type_node, load_node));
1025 push_value (load_node);
1028 /* Expands .length. Makes sure that we deal with and array and may expand
1029 a NULL check on the array object. */
1032 expand_java_array_length (void)
1034 tree array = pop_value (ptr_type_node);
1035 tree length = build_java_array_length_access (array);
1037 push_value (length);
1040 /* Emit code for the call to _Jv_Monitor{Enter,Exit}. CALL can be
1041 either soft_monitorenter_node or soft_monitorexit_node. */
1044 build_java_monitor (tree call, tree object)
1046 return (build (CALL_EXPR,
1048 build_address_of (call),
1049 build_tree_list (NULL_TREE, object),
1053 /* Emit code for one of the PUSHC instructions. */
1056 expand_java_pushc (int ival, tree type)
1059 if (type == ptr_type_node && ival == 0)
1060 value = null_pointer_node;
1061 else if (type == int_type_node || type == long_type_node)
1063 value = build_int_2 (ival, ival < 0 ? -1 : 0);
1064 TREE_TYPE (value) = type;
1066 else if (type == float_type_node || type == double_type_node)
1069 REAL_VALUE_FROM_INT (x, ival, 0, TYPE_MODE (type));
1070 value = build_real (type, x);
1079 expand_java_return (tree type)
1081 if (type == void_type_node)
1082 expand_null_return ();
1085 tree retval = pop_value (type);
1086 tree res = DECL_RESULT (current_function_decl);
1087 retval = build (MODIFY_EXPR, TREE_TYPE (res), res, retval);
1089 /* Handle the situation where the native integer type is smaller
1090 than the JVM integer. It can happen for many cross compilers.
1091 The whole if expression just goes away if INT_TYPE_SIZE < 32
1093 if (INT_TYPE_SIZE < 32
1094 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (res)))
1095 < GET_MODE_SIZE (TYPE_MODE (type))))
1096 retval = build1(NOP_EXPR, TREE_TYPE(res), retval);
1098 TREE_SIDE_EFFECTS (retval) = 1;
1099 expand_return (retval);
1104 expand_load_internal (int index, tree type, int pc)
1107 tree var = find_local_variable (index, type, pc);
1109 /* Now VAR is the VAR_DECL (or PARM_DECL) that we are going to push
1110 on the stack. If there is an assignment to this VAR_DECL between
1111 the stack push and the use, then the wrong code could be
1112 generated. To avoid this we create a new local and copy our
1113 value into it. Then we push this new local on the stack.
1114 Hopefully this all gets optimized out. */
1115 copy = build_decl (VAR_DECL, NULL_TREE, type);
1116 DECL_CONTEXT (copy) = current_function_decl;
1117 layout_decl (copy, 0);
1118 DECL_REGISTER (copy) = 1;
1120 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (copy);
1121 DECL_INITIAL (copy) = var;
1122 expand_decl_init (copy);
1127 build_address_of (tree value)
1129 return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (value)), value);
1132 bool class_has_finalize_method (tree type)
1134 tree super = CLASSTYPE_SUPER (type);
1136 if (super == NULL_TREE)
1137 return false; /* Every class with a real finalizer inherits */
1138 /* from java.lang.Object. */
1140 return HAS_FINALIZER_P (type) || class_has_finalize_method (super);
1144 expand_java_NEW (tree type)
1148 alloc_node = (class_has_finalize_method (type) ? alloc_object_node
1149 : alloc_no_finalizer_node);
1150 if (! CLASS_LOADED_P (type))
1151 load_class (type, 1);
1152 safe_layout_class (type);
1153 push_value (build (CALL_EXPR, promote_type (type),
1154 build_address_of (alloc_node),
1155 tree_cons (NULL_TREE, build_class_ref (type),
1156 build_tree_list (NULL_TREE,
1157 size_in_bytes (type))),
1161 /* This returns an expression which will extract the class of an
1165 build_get_class (tree value)
1167 tree class_field = lookup_field (&dtable_type, get_identifier ("class"));
1168 tree vtable_field = lookup_field (&object_type_node,
1169 get_identifier ("vtable"));
1170 return build (COMPONENT_REF, class_ptr_type,
1171 build1 (INDIRECT_REF, dtable_type,
1172 build (COMPONENT_REF, dtable_ptr_type,
1173 build_java_indirect_ref (object_type_node, value,
1174 flag_check_references),
1179 /* This builds the tree representation of the `instanceof' operator.
1180 It tries various tricks to optimize this in cases where types are
1184 build_instanceof (tree value, tree type)
1187 tree itype = TREE_TYPE (TREE_TYPE (soft_instanceof_node));
1188 tree valtype = TREE_TYPE (TREE_TYPE (value));
1189 tree valclass = TYPE_NAME (valtype);
1192 /* When compiling from bytecode, we need to ensure that TYPE has
1194 if (CLASS_P (type) && ! CLASS_LOADED_P (type))
1196 load_class (type, 1);
1197 safe_layout_class (type);
1198 if (! TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) == ERROR_MARK)
1199 return error_mark_node;
1201 klass = TYPE_NAME (type);
1203 if (type == object_type_node || inherits_from_p (valtype, type))
1205 /* Anything except `null' is an instance of Object. Likewise,
1206 if the object is known to be an instance of the class, then
1207 we only need to check for `null'. */
1208 expr = build (NE_EXPR, itype, value, null_pointer_node);
1210 else if (! TYPE_ARRAY_P (type)
1211 && ! TYPE_ARRAY_P (valtype)
1212 && DECL_P (klass) && DECL_P (valclass)
1213 && ! CLASS_INTERFACE (valclass)
1214 && ! CLASS_INTERFACE (klass)
1215 && ! inherits_from_p (type, valtype)
1216 && (CLASS_FINAL (klass)
1217 || ! inherits_from_p (valtype, type)))
1219 /* The classes are from different branches of the derivation
1220 tree, so we immediately know the answer. */
1221 expr = boolean_false_node;
1223 else if (DECL_P (klass) && CLASS_FINAL (klass))
1225 tree save = save_expr (value);
1226 expr = build (COND_EXPR, itype,
1228 build (EQ_EXPR, itype,
1229 build_get_class (save),
1230 build_class_ref (type)),
1231 boolean_false_node);
1235 expr = build (CALL_EXPR, itype,
1236 build_address_of (soft_instanceof_node),
1237 tree_cons (NULL_TREE, value,
1238 build_tree_list (NULL_TREE,
1239 build_class_ref (type))),
1242 TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (value);
1247 expand_java_INSTANCEOF (tree type)
1249 tree value = pop_value (object_ptr_type_node);
1250 value = build_instanceof (value, type);
1255 expand_java_CHECKCAST (tree type)
1257 tree value = pop_value (ptr_type_node);
1258 value = build (CALL_EXPR, promote_type (type),
1259 build_address_of (soft_checkcast_node),
1260 tree_cons (NULL_TREE, build_class_ref (type),
1261 build_tree_list (NULL_TREE, value)),
1267 expand_iinc (unsigned int local_var_index, int ival, int pc)
1269 tree local_var, res;
1270 tree constant_value;
1272 flush_quick_stack ();
1273 local_var = find_local_variable (local_var_index, int_type_node, pc);
1274 constant_value = build_int_2 (ival, ival < 0 ? -1 : 0);
1275 res = fold (build (PLUS_EXPR, int_type_node, local_var, constant_value));
1276 expand_assignment (local_var, res, 0, 0);
1281 build_java_soft_divmod (enum tree_code op, tree type, tree op1, tree op2)
1284 tree arg1 = convert (type, op1);
1285 tree arg2 = convert (type, op2);
1287 if (type == int_type_node)
1291 case TRUNC_DIV_EXPR:
1292 call = soft_idiv_node;
1294 case TRUNC_MOD_EXPR:
1295 call = soft_irem_node;
1301 else if (type == long_type_node)
1305 case TRUNC_DIV_EXPR:
1306 call = soft_ldiv_node;
1308 case TRUNC_MOD_EXPR:
1309 call = soft_lrem_node;
1319 call = build (CALL_EXPR, type,
1320 build_address_of (call),
1321 tree_cons (NULL_TREE, arg1,
1322 build_tree_list (NULL_TREE, arg2)),
1329 build_java_binop (enum tree_code op, tree type, tree arg1, tree arg2)
1336 tree u_type = java_unsigned_type (type);
1337 arg1 = convert (u_type, arg1);
1338 arg1 = build_java_binop (RSHIFT_EXPR, u_type, arg1, arg2);
1339 return convert (type, arg1);
1343 mask = build_int_2 (TYPE_PRECISION (TREE_TYPE (arg1)) - 1, 0);
1344 arg2 = fold (build (BIT_AND_EXPR, int_type_node, arg2, mask));
1347 case COMPARE_L_EXPR: /* arg1 > arg2 ? 1 : arg1 == arg2 ? 0 : -1 */
1348 case COMPARE_G_EXPR: /* arg1 < arg2 ? -1 : arg1 == arg2 ? 0 : 1 */
1349 arg1 = save_expr (arg1); arg2 = save_expr (arg2);
1351 tree ifexp1 = fold ( build (op == COMPARE_L_EXPR ? GT_EXPR : LT_EXPR,
1352 boolean_type_node, arg1, arg2));
1353 tree ifexp2 = fold ( build (EQ_EXPR, boolean_type_node, arg1, arg2));
1354 tree second_compare = fold (build (COND_EXPR, int_type_node,
1355 ifexp2, integer_zero_node,
1356 op == COMPARE_L_EXPR
1357 ? integer_minus_one_node
1358 : integer_one_node));
1359 return fold (build (COND_EXPR, int_type_node, ifexp1,
1360 op == COMPARE_L_EXPR ? integer_one_node
1361 : integer_minus_one_node,
1365 arg1 = save_expr (arg1); arg2 = save_expr (arg2);
1367 tree ifexp1 = fold ( build (LT_EXPR, boolean_type_node, arg1, arg2));
1368 tree ifexp2 = fold ( build (GT_EXPR, boolean_type_node, arg1, arg2));
1369 tree second_compare = fold ( build (COND_EXPR, int_type_node,
1370 ifexp2, integer_one_node,
1371 integer_zero_node));
1372 return fold (build (COND_EXPR, int_type_node,
1373 ifexp1, integer_minus_one_node, second_compare));
1375 case TRUNC_DIV_EXPR:
1376 case TRUNC_MOD_EXPR:
1377 if (TREE_CODE (type) == REAL_TYPE
1378 && op == TRUNC_MOD_EXPR)
1381 if (type != double_type_node)
1383 arg1 = convert (double_type_node, arg1);
1384 arg2 = convert (double_type_node, arg2);
1386 call = build (CALL_EXPR, double_type_node,
1387 build_address_of (soft_fmod_node),
1388 tree_cons (NULL_TREE, arg1,
1389 build_tree_list (NULL_TREE, arg2)),
1391 if (type != double_type_node)
1392 call = convert (type, call);
1396 if (TREE_CODE (type) == INTEGER_TYPE
1397 && flag_use_divide_subroutine
1398 && ! flag_syntax_only)
1399 return build_java_soft_divmod (op, type, arg1, arg2);
1404 return fold (build (op, type, arg1, arg2));
1408 expand_java_binop (tree type, enum tree_code op)
1418 rtype = int_type_node;
1419 rarg = pop_value (rtype);
1422 rarg = pop_value (rtype);
1424 larg = pop_value (ltype);
1425 push_value (build_java_binop (op, type, larg, rarg));
1428 /* Lookup the field named NAME in *TYPEP or its super classes.
1429 If not found, return NULL_TREE.
1430 (If the *TYPEP is not found, or if the field reference is
1431 ambiguous, return error_mark_node.)
1432 If found, return the FIELD_DECL, and set *TYPEP to the
1433 class containing the field. */
1436 lookup_field (tree *typep, tree name)
1438 if (CLASS_P (*typep) && !CLASS_LOADED_P (*typep))
1440 load_class (*typep, 1);
1441 safe_layout_class (*typep);
1442 if (!TYPE_SIZE (*typep) || TREE_CODE (TYPE_SIZE (*typep)) == ERROR_MARK)
1443 return error_mark_node;
1447 tree field, basetype_vec;
1451 for (field = TYPE_FIELDS (*typep); field; field = TREE_CHAIN (field))
1452 if (DECL_NAME (field) == name)
1455 /* Process implemented interfaces. */
1456 basetype_vec = TYPE_BINFO_BASETYPES (*typep);
1457 n = TREE_VEC_LENGTH (basetype_vec);
1458 save_field = NULL_TREE;
1459 for (i = 0; i < n; i++)
1461 tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
1462 if ((field = lookup_field (&t, name)))
1464 if (save_field == field)
1466 if (save_field == NULL_TREE)
1470 tree i1 = DECL_CONTEXT (save_field);
1471 tree i2 = DECL_CONTEXT (field);
1472 error ("reference `%s' is ambiguous: appears in interface `%s' and interface `%s'",
1473 IDENTIFIER_POINTER (name),
1474 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (i1))),
1475 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (i2))));
1476 return error_mark_node;
1481 if (save_field != NULL_TREE)
1484 *typep = CLASSTYPE_SUPER (*typep);
1489 /* Look up the field named NAME in object SELF_VALUE,
1490 which has class SELF_CLASS (a non-handle RECORD_TYPE).
1491 SELF_VALUE is NULL_TREE if looking for a static field. */
1494 build_field_ref (tree self_value, tree self_class, tree name)
1496 tree base_class = self_class;
1497 tree field_decl = lookup_field (&base_class, name);
1498 if (field_decl == NULL_TREE)
1500 error ("field `%s' not found", IDENTIFIER_POINTER (name));
1501 return error_mark_node;
1503 if (self_value == NULL_TREE)
1505 return build_static_field_ref (field_decl);
1509 int check = (flag_check_references
1510 && ! (DECL_P (self_value)
1511 && DECL_NAME (self_value) == this_identifier_node));
1513 tree base_type = promote_type (base_class);
1514 if (base_type != TREE_TYPE (self_value))
1515 self_value = fold (build1 (NOP_EXPR, base_type, self_value));
1516 self_value = build_java_indirect_ref (TREE_TYPE (TREE_TYPE (self_value)),
1518 return fold (build (COMPONENT_REF, TREE_TYPE (field_decl),
1519 self_value, field_decl));
1524 lookup_label (int pc)
1528 ASM_GENERATE_INTERNAL_LABEL(buf, "LJpc=", pc);
1529 name = get_identifier (buf);
1530 if (IDENTIFIER_LOCAL_VALUE (name))
1531 return IDENTIFIER_LOCAL_VALUE (name);
1534 /* The type of the address of a label is return_address_type_node. */
1535 tree decl = create_label_decl (name);
1536 LABEL_PC (decl) = pc;
1538 return pushdecl (decl);
1542 /* Generate a unique name for the purpose of loops and switches
1543 labels, and try-catch-finally blocks label or temporary variables. */
1546 generate_name (void)
1548 static int l_number = 0;
1550 ASM_GENERATE_INTERNAL_LABEL(buff, "LJv", l_number);
1552 return get_identifier (buff);
1556 create_label_decl (tree name)
1559 decl = build_decl (LABEL_DECL, name,
1560 TREE_TYPE (return_address_type_node));
1561 DECL_CONTEXT (decl) = current_function_decl;
1562 DECL_IGNORED_P (decl) = 1;
1566 /* This maps a bytecode offset (PC) to various flags. */
1567 char *instruction_bits;
1570 note_label (int current_pc ATTRIBUTE_UNUSED, int target_pc)
1572 lookup_label (target_pc);
1573 instruction_bits [target_pc] |= BCODE_JUMP_TARGET;
1576 /* Emit code to jump to TARGET_PC if VALUE1 CONDITION VALUE2,
1577 where CONDITION is one of one the compare operators. */
1580 expand_compare (enum tree_code condition, tree value1, tree value2,
1583 tree target = lookup_label (target_pc);
1584 tree cond = fold (build (condition, boolean_type_node, value1, value2));
1585 expand_start_cond (java_truthvalue_conversion (cond), 0);
1586 expand_goto (target);
1590 /* Emit code for a TEST-type opcode. */
1593 expand_test (enum tree_code condition, tree type, int target_pc)
1595 tree value1, value2;
1596 flush_quick_stack ();
1597 value1 = pop_value (type);
1598 value2 = (type == ptr_type_node) ? null_pointer_node : integer_zero_node;
1599 expand_compare (condition, value1, value2, target_pc);
1602 /* Emit code for a COND-type opcode. */
1605 expand_cond (enum tree_code condition, tree type, int target_pc)
1607 tree value1, value2;
1608 flush_quick_stack ();
1609 /* note: pop values in opposite order */
1610 value2 = pop_value (type);
1611 value1 = pop_value (type);
1612 /* Maybe should check value1 and value2 for type compatibility ??? */
1613 expand_compare (condition, value1, value2, target_pc);
1617 expand_java_goto (int target_pc)
1619 tree target_label = lookup_label (target_pc);
1620 flush_quick_stack ();
1621 expand_goto (target_label);
1626 expand_java_call (int target_pc, int return_address)
1627 int target_pc, return_address;
1629 tree target_label = lookup_label (target_pc);
1630 tree value = build_int_2 (return_address, return_address < 0 ? -1 : 0);
1632 flush_quick_stack ();
1633 expand_goto (target_label);
1637 expand_java_ret (tree return_address ATTRIBUTE_UNUSED)
1639 warning ("ret instruction not implemented");
1641 tree target_label = lookup_label (target_pc);
1642 flush_quick_stack ();
1643 expand_goto (target_label);
1649 pop_arguments (tree arg_types)
1651 if (arg_types == end_params_node)
1653 if (TREE_CODE (arg_types) == TREE_LIST)
1655 tree tail = pop_arguments (TREE_CHAIN (arg_types));
1656 tree type = TREE_VALUE (arg_types);
1657 tree arg = pop_value (type);
1658 if (PROMOTE_PROTOTYPES
1659 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
1660 && INTEGRAL_TYPE_P (type))
1661 arg = convert (integer_type_node, arg);
1662 return tree_cons (NULL_TREE, arg, tail);
1667 /* Build an expression to initialize the class CLAS.
1668 if EXPR is non-NULL, returns an expression to first call the initializer
1669 (if it is needed) and then calls EXPR. */
1672 build_class_init (tree clas, tree expr)
1675 if (inherits_from_p (current_class, clas))
1678 if (always_initialize_class_p)
1680 init = build (CALL_EXPR, void_type_node,
1681 build_address_of (soft_initclass_node),
1682 build_tree_list (NULL_TREE, build_class_ref (clas)),
1684 TREE_SIDE_EFFECTS (init) = 1;
1688 tree *init_test_decl;
1689 init_test_decl = java_treetreehash_new
1690 (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), clas);
1692 if (*init_test_decl == NULL)
1694 /* Build a declaration and mark it as a flag used to track
1695 static class initializations. */
1696 *init_test_decl = build_decl (VAR_DECL, NULL_TREE,
1698 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (*init_test_decl);
1699 LOCAL_CLASS_INITIALIZATION_FLAG (*init_test_decl) = 1;
1700 DECL_CONTEXT (*init_test_decl) = current_function_decl;
1701 DECL_FUNCTION_INIT_TEST_CLASS (*init_test_decl) = clas;
1702 /* Tell the check-init code to ignore this decl when not
1703 optimizing class initialization. */
1704 if (!STATIC_CLASS_INIT_OPT_P ())
1705 DECL_BIT_INDEX(*init_test_decl) = -1;
1708 init = build (CALL_EXPR, void_type_node,
1709 build_address_of (soft_initclass_node),
1710 build_tree_list (NULL_TREE, build_class_ref (clas)),
1712 TREE_SIDE_EFFECTS (init) = 1;
1713 init = build (COND_EXPR, void_type_node,
1714 build (EQ_EXPR, boolean_type_node,
1715 *init_test_decl, boolean_false_node),
1716 init, integer_zero_node);
1717 TREE_SIDE_EFFECTS (init) = 1;
1718 init = build (COMPOUND_EXPR, TREE_TYPE (expr), init,
1719 build (MODIFY_EXPR, boolean_type_node,
1720 *init_test_decl, boolean_true_node));
1721 TREE_SIDE_EFFECTS (init) = 1;
1724 if (expr != NULL_TREE)
1726 expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
1727 TREE_SIDE_EFFECTS (expr) = 1;
1734 build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED,
1735 tree self_type, tree method_signature ATTRIBUTE_UNUSED,
1736 tree arg_list ATTRIBUTE_UNUSED)
1739 if (is_compiled_class (self_type))
1741 make_decl_rtl (method, NULL);
1742 func = build1 (ADDR_EXPR, method_ptr_type_node, method);
1746 /* We don't know whether the method has been (statically) compiled.
1747 Compile this code to get a reference to the method's code:
1749 SELF_TYPE->methods[METHOD_INDEX].ncode
1751 This is guaranteed to work (assuming SELF_TYPE has
1752 been initialized), since if the method is not compiled yet,
1753 its ncode points to a trampoline that forces compilation. */
1755 int method_index = 0;
1757 tree ref = build_class_ref (self_type);
1758 ref = build1 (INDIRECT_REF, class_type_node, ref);
1759 if (ncode_ident == NULL_TREE)
1760 ncode_ident = get_identifier ("ncode");
1761 if (methods_ident == NULL_TREE)
1762 methods_ident = get_identifier ("methods");
1763 ref = build (COMPONENT_REF, method_ptr_type_node, ref,
1764 lookup_field (&class_type_node, methods_ident));
1765 for (meth = TYPE_METHODS (self_type);
1766 ; meth = TREE_CHAIN (meth))
1770 if (meth == NULL_TREE)
1771 fatal_error ("method '%s' not found in class",
1772 IDENTIFIER_POINTER (DECL_NAME (method)));
1775 method_index *= int_size_in_bytes (method_type_node);
1776 ref = fold (build (PLUS_EXPR, method_ptr_type_node,
1777 ref, build_int_2 (method_index, 0)));
1778 ref = build1 (INDIRECT_REF, method_type_node, ref);
1779 func = build (COMPONENT_REF, nativecode_ptr_type_node,
1781 lookup_field (&method_type_node, ncode_ident));
1787 invoke_build_dtable (int is_invoke_interface, tree arg_list)
1789 tree dtable, objectref;
1791 TREE_VALUE (arg_list) = save_expr (TREE_VALUE (arg_list));
1793 /* If we're dealing with interfaces and if the objectref
1794 argument is an array then get the dispatch table of the class
1795 Object rather than the one from the objectref. */
1796 objectref = (is_invoke_interface
1797 && is_array_type_p (TREE_TYPE (TREE_VALUE (arg_list))) ?
1798 object_type_node : TREE_VALUE (arg_list));
1800 if (dtable_ident == NULL_TREE)
1801 dtable_ident = get_identifier ("vtable");
1802 dtable = build_java_indirect_ref (object_type_node, objectref,
1803 flag_check_references);
1804 dtable = build (COMPONENT_REF, dtable_ptr_type, dtable,
1805 lookup_field (&object_type_node, dtable_ident));
1810 /* Determine the index in the virtual offset table (otable) for a call to
1811 METHOD. If this method has not been seen before, it will be added to the
1812 otable_methods. If it has, the existing otable slot will be reused. */
1815 get_offset_table_index (tree method)
1820 if (otable_methods == NULL_TREE)
1822 otable_methods = build_tree_list (method, method);
1826 method_list = otable_methods;
1830 if (TREE_VALUE (method_list) == method)
1833 if (TREE_CHAIN (method_list) == NULL_TREE)
1836 method_list = TREE_CHAIN (method_list);
1839 TREE_CHAIN (method_list) = build_tree_list (method, method);
1844 build_invokevirtual (tree dtable, tree method)
1847 tree nativecode_ptr_ptr_type_node
1848 = build_pointer_type (nativecode_ptr_type_node);
1852 if (flag_indirect_dispatch)
1854 otable_index = build_int_2 (get_offset_table_index (method), 0);
1855 method_index = build (ARRAY_REF, integer_type_node, otable_decl,
1860 method_index = convert (sizetype, DECL_VINDEX (method));
1862 if (TARGET_VTABLE_USES_DESCRIPTORS)
1863 /* Add one to skip bogus descriptor for class and GC descriptor. */
1864 method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
1866 /* Add 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1867 method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1869 method_index = size_binop (MULT_EXPR, method_index,
1870 TYPE_SIZE_UNIT (nativecode_ptr_ptr_type_node));
1872 if (TARGET_VTABLE_USES_DESCRIPTORS)
1873 method_index = size_binop (MULT_EXPR, method_index,
1874 size_int (TARGET_VTABLE_USES_DESCRIPTORS));
1877 func = fold (build (PLUS_EXPR, nativecode_ptr_ptr_type_node, dtable,
1878 convert (nativecode_ptr_ptr_type_node, method_index)));
1880 if (TARGET_VTABLE_USES_DESCRIPTORS)
1881 func = build1 (NOP_EXPR, nativecode_ptr_type_node, func);
1883 func = build1 (INDIRECT_REF, nativecode_ptr_type_node, func);
1888 static GTY(()) tree class_ident;
1890 build_invokeinterface (tree dtable, tree method)
1899 /* We expand invokeinterface here. _Jv_LookupInterfaceMethod() will
1900 ensure that the selected method exists, is public and not
1901 abstract nor static. */
1903 if (class_ident == NULL_TREE)
1905 class_ident = get_identifier ("class");
1908 dtable = build_java_indirect_ref (dtable_type, dtable, flag_check_references);
1909 dtable = build (COMPONENT_REF, class_ptr_type, dtable,
1910 lookup_field (&dtable_type, class_ident));
1912 interface = DECL_CONTEXT (method);
1913 layout_class_methods (interface);
1915 if (flag_indirect_dispatch)
1917 otable_index = build_int_2 (get_offset_table_index (method), 0);
1918 idx = build (ARRAY_REF, integer_type_node, otable_decl, otable_index);
1923 for (meth = TYPE_METHODS (interface); ; meth = TREE_CHAIN (meth), i++)
1927 idx = build_int_2 (i, 0);
1930 if (meth == NULL_TREE)
1935 lookup_arg = tree_cons (NULL_TREE, dtable,
1936 tree_cons (NULL_TREE, build_class_ref (interface),
1937 build_tree_list (NULL_TREE, idx)));
1939 return build (CALL_EXPR, ptr_type_node,
1940 build_address_of (soft_lookupinterfacemethod_node),
1941 lookup_arg, NULL_TREE);
1944 /* Expand one of the invoke_* opcodes.
1945 OCPODE is the specific opcode.
1946 METHOD_REF_INDEX is an index into the constant pool.
1947 NARGS is the number of arguments, or -1 if not specified. */
1950 expand_invoke (int opcode, int method_ref_index, int nargs ATTRIBUTE_UNUSED)
1952 tree method_signature = COMPONENT_REF_SIGNATURE(¤t_jcf->cpool, method_ref_index);
1953 tree method_name = COMPONENT_REF_NAME (¤t_jcf->cpool, method_ref_index);
1954 tree self_type = get_class_constant
1955 (current_jcf, COMPONENT_REF_CLASS_INDEX(¤t_jcf->cpool, method_ref_index));
1956 const char *const self_name
1957 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
1958 tree call, func, method, arg_list, method_type;
1959 tree check = NULL_TREE;
1961 if (! CLASS_LOADED_P (self_type))
1963 load_class (self_type, 1);
1964 safe_layout_class (self_type);
1965 if (TREE_CODE (TYPE_SIZE (self_type)) == ERROR_MARK)
1966 fatal_error ("failed to find class '%s'", self_name);
1968 layout_class_methods (self_type);
1970 if (ID_INIT_P (method_name))
1971 method = lookup_java_constructor (self_type, method_signature);
1973 method = lookup_java_method (self_type, method_name, method_signature);
1974 if (method == NULL_TREE)
1976 error ("class '%s' has no method named '%s' matching signature '%s'",
1978 IDENTIFIER_POINTER (method_name),
1979 IDENTIFIER_POINTER (method_signature));
1981 /* Invoke static can't invoke static/abstract method */
1982 else if (opcode == OPCODE_invokestatic)
1984 if (!METHOD_STATIC (method))
1986 error ("invokestatic on non static method");
1989 else if (METHOD_ABSTRACT (method))
1991 error ("invokestatic on abstract method");
1997 if (METHOD_STATIC (method))
1999 error ("invoke[non-static] on static method");
2004 if (method == NULL_TREE)
2006 method_type = get_type_from_signature (method_signature);
2007 pop_arguments (TYPE_ARG_TYPES (method_type));
2008 if (opcode != OPCODE_invokestatic)
2009 pop_type (self_type);
2010 method_type = promote_type (TREE_TYPE (method_type));
2011 push_value (convert (method_type, integer_zero_node));
2015 method_type = TREE_TYPE (method);
2016 arg_list = pop_arguments (TYPE_ARG_TYPES (method_type));
2017 flush_quick_stack ();
2020 if (opcode == OPCODE_invokestatic)
2021 func = build_known_method_ref (method, method_type, self_type,
2022 method_signature, arg_list);
2023 else if (opcode == OPCODE_invokespecial
2024 || (opcode == OPCODE_invokevirtual
2025 && (METHOD_PRIVATE (method)
2026 || METHOD_FINAL (method)
2027 || CLASS_FINAL (TYPE_NAME (self_type)))))
2029 /* If the object for the method call is null, we throw an
2030 exception. We don't do this if the object is the current
2031 method's `this'. In other cases we just rely on an
2032 optimization pass to eliminate redundant checks. FIXME:
2033 Unfortunately there doesn't seem to be a way to determine
2034 what the current method is right now.
2035 We do omit the check if we're calling <init>. */
2036 /* We use a SAVE_EXPR here to make sure we only evaluate
2037 the new `self' expression once. */
2038 tree save_arg = save_expr (TREE_VALUE (arg_list));
2039 TREE_VALUE (arg_list) = save_arg;
2040 check = java_check_reference (save_arg, ! DECL_INIT_P (method));
2041 func = build_known_method_ref (method, method_type, self_type,
2042 method_signature, arg_list);
2046 tree dtable = invoke_build_dtable (opcode == OPCODE_invokeinterface,
2048 if (opcode == OPCODE_invokevirtual)
2049 func = build_invokevirtual (dtable, method);
2051 func = build_invokeinterface (dtable, method);
2053 func = build1 (NOP_EXPR, build_pointer_type (method_type), func);
2055 call = build (CALL_EXPR, TREE_TYPE (method_type), func, arg_list, NULL_TREE);
2056 TREE_SIDE_EFFECTS (call) = 1;
2057 call = check_for_builtin (method, call);
2059 if (check != NULL_TREE)
2061 call = build (COMPOUND_EXPR, TREE_TYPE (call), check, call);
2062 TREE_SIDE_EFFECTS (call) = 1;
2065 if (TREE_CODE (TREE_TYPE (method_type)) == VOID_TYPE)
2066 expand_expr_stmt (call);
2070 flush_quick_stack ();
2074 /* Create a stub which will be put into the vtable but which will call
2078 build_jni_stub (tree method)
2080 tree jnifunc, call, args, body, lookup_arg, method_sig, arg_types;
2081 tree jni_func_type, tem;
2082 tree env_var, res_var = NULL_TREE, block;
2083 tree method_args, res_type;
2086 tree klass = DECL_CONTEXT (method);
2087 int from_class = ! CLASS_FROM_SOURCE_P (klass);
2088 klass = build_class_ref (klass);
2090 if (! METHOD_NATIVE (method) || ! flag_jni)
2093 DECL_ARTIFICIAL (method) = 1;
2094 DECL_EXTERNAL (method) = 0;
2096 env_var = build_decl (VAR_DECL, get_identifier ("env"), ptr_type_node);
2097 DECL_CONTEXT (env_var) = method;
2099 if (TREE_TYPE (TREE_TYPE (method)) != void_type_node)
2101 res_var = build_decl (VAR_DECL, get_identifier ("res"),
2102 TREE_TYPE (TREE_TYPE (method)));
2103 DECL_CONTEXT (res_var) = method;
2104 TREE_CHAIN (env_var) = res_var;
2107 meth_var = build_decl (VAR_DECL, get_identifier ("meth"), ptr_type_node);
2108 TREE_STATIC (meth_var) = 1;
2109 TREE_PUBLIC (meth_var) = 0;
2110 DECL_EXTERNAL (meth_var) = 0;
2111 DECL_CONTEXT (meth_var) = method;
2112 DECL_ARTIFICIAL (meth_var) = 1;
2113 DECL_INITIAL (meth_var) = null_pointer_node;
2114 TREE_USED (meth_var) = 1;
2115 chainon (env_var, meth_var);
2116 layout_decl (meth_var, 0);
2117 make_decl_rtl (meth_var, NULL);
2118 rest_of_decl_compilation (meth_var, NULL, 0, 0);
2120 /* One strange way that the front ends are different is that they
2121 store arguments differently. */
2123 method_args = DECL_ARGUMENTS (method);
2125 method_args = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (method));
2126 block = build_block (env_var, NULL_TREE, NULL_TREE,
2127 method_args, NULL_TREE);
2128 TREE_SIDE_EFFECTS (block) = 1;
2129 /* When compiling from source we don't set the type of the block,
2130 because that will prevent patch_return from ever being run. */
2132 TREE_TYPE (block) = TREE_TYPE (TREE_TYPE (method));
2134 /* Compute the local `env' by calling _Jv_GetJNIEnvNewFrame. */
2135 body = build (MODIFY_EXPR, ptr_type_node, env_var,
2136 build (CALL_EXPR, ptr_type_node,
2137 build_address_of (soft_getjnienvnewframe_node),
2138 build_tree_list (NULL_TREE, klass),
2140 CAN_COMPLETE_NORMALLY (body) = 1;
2142 /* All the arguments to this method become arguments to the
2143 underlying JNI function. If we had to wrap object arguments in a
2144 special way, we would do that here. */
2146 for (tem = method_args; tem != NULL_TREE; tem = TREE_CHAIN (tem))
2147 args = tree_cons (NULL_TREE, tem, args);
2148 args = nreverse (args);
2149 arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
2151 /* For a static method the second argument is the class. For a
2152 non-static method the second argument is `this'; that is already
2153 available in the argument list. */
2154 if (METHOD_STATIC (method))
2156 args = tree_cons (NULL_TREE, klass, args);
2157 arg_types = tree_cons (NULL_TREE, object_ptr_type_node, arg_types);
2160 /* The JNIEnv structure is the first argument to the JNI function. */
2161 args = tree_cons (NULL_TREE, env_var, args);
2162 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
2164 /* We call _Jv_LookupJNIMethod to find the actual underlying
2165 function pointer. _Jv_LookupJNIMethod will throw the appropriate
2166 exception if this function is not found at runtime. */
2167 method_sig = build_java_signature (TREE_TYPE (method));
2169 build_tree_list (NULL_TREE,
2170 build_utf8_ref (unmangle_classname
2171 (IDENTIFIER_POINTER (method_sig),
2172 IDENTIFIER_LENGTH (method_sig))));
2173 tem = DECL_NAME (method);
2175 = tree_cons (NULL_TREE, klass,
2176 tree_cons (NULL_TREE, build_utf8_ref (tem), lookup_arg));
2179 = build_pointer_type (build_function_type (TREE_TYPE (TREE_TYPE (method)),
2182 jnifunc = build (COND_EXPR, ptr_type_node,
2184 build (MODIFY_EXPR, ptr_type_node,
2186 build (CALL_EXPR, ptr_type_node,
2187 build_address_of (soft_lookupjnimethod_node),
2188 lookup_arg, NULL_TREE)));
2190 /* Now we make the actual JNI call via the resulting function
2192 call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (method)),
2193 build1 (NOP_EXPR, jni_func_type, jnifunc),
2196 /* If the JNI call returned a result, capture it here. If we had to
2197 unwrap JNI object results, we would do that here. */
2198 if (res_var != NULL_TREE)
2199 call = build (MODIFY_EXPR, TREE_TYPE (TREE_TYPE (method)),
2202 TREE_SIDE_EFFECTS (call) = 1;
2203 CAN_COMPLETE_NORMALLY (call) = 1;
2205 body = build (COMPOUND_EXPR, void_type_node, body, call);
2206 TREE_SIDE_EFFECTS (body) = 1;
2208 /* Now free the environment we allocated. */
2209 call = build (CALL_EXPR, ptr_type_node,
2210 build_address_of (soft_jnipopsystemframe_node),
2211 build_tree_list (NULL_TREE, env_var),
2213 TREE_SIDE_EFFECTS (call) = 1;
2214 CAN_COMPLETE_NORMALLY (call) = 1;
2215 body = build (COMPOUND_EXPR, void_type_node, body, call);
2216 TREE_SIDE_EFFECTS (body) = 1;
2218 /* Finally, do the return. When compiling from source we rely on
2219 patch_return to patch the return value -- because DECL_RESULT is
2220 not set at the time this function is called. */
2223 res_type = void_type_node;
2224 if (res_var != NULL_TREE)
2227 if (! DECL_RESULT (method))
2229 /* Make sure we copy the result variable to the actual
2230 result. We use the type of the DECL_RESULT because it
2231 might be different from the return type of the function:
2232 it might be promoted. */
2233 drt = TREE_TYPE (DECL_RESULT (method));
2234 if (drt != TREE_TYPE (res_var))
2235 res_var = build1 (CONVERT_EXPR, drt, res_var);
2236 res_var = build (MODIFY_EXPR, drt, DECL_RESULT (method), res_var);
2237 TREE_SIDE_EFFECTS (res_var) = 1;
2242 /* This is necessary to get patch_return to run. */
2243 res_type = NULL_TREE;
2245 body = build (COMPOUND_EXPR, void_type_node, body,
2246 build1 (RETURN_EXPR, res_type, res_var));
2247 TREE_SIDE_EFFECTS (body) = 1;
2249 BLOCK_EXPR_BODY (block) = body;
2253 /* Expand an operation to extract from or store into a field.
2254 IS_STATIC is 1 iff the field is static.
2255 IS_PUTTING is 1 for putting into a field; 0 for getting from the field.
2256 FIELD_REF_INDEX is an index into the constant pool. */
2259 expand_java_field_op (int is_static, int is_putting, int field_ref_index)
2262 get_class_constant (current_jcf,
2263 COMPONENT_REF_CLASS_INDEX (¤t_jcf->cpool,
2265 const char *self_name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
2266 tree field_name = COMPONENT_REF_NAME (¤t_jcf->cpool, field_ref_index);
2267 tree field_signature = COMPONENT_REF_SIGNATURE (¤t_jcf->cpool,
2269 tree field_type = get_type_from_signature (field_signature);
2270 tree new_value = is_putting ? pop_value (field_type) : NULL_TREE;
2273 tree field_decl = lookup_field (&self_type, field_name);
2274 if (field_decl == error_mark_node)
2278 else if (field_decl == NULL_TREE)
2280 error ("missing field '%s' in '%s'",
2281 IDENTIFIER_POINTER (field_name), self_name);
2284 else if (build_java_signature (TREE_TYPE (field_decl)) != field_signature)
2286 error ("mismatching signature for field '%s' in '%s'",
2287 IDENTIFIER_POINTER (field_name), self_name);
2290 field_ref = is_static ? NULL_TREE : pop_value (self_type);
2294 push_value (convert (field_type, integer_zero_node));
2295 flush_quick_stack ();
2299 field_ref = build_field_ref (field_ref, self_type, field_name);
2301 field_ref = build_class_init (self_type, field_ref);
2304 flush_quick_stack ();
2305 if (FIELD_FINAL (field_decl))
2307 if (DECL_CONTEXT (field_decl) != current_class)
2308 error_with_decl (field_decl,
2309 "assignment to final field `%s' not in field's class");
2310 else if (FIELD_STATIC (field_decl))
2312 if (!DECL_CLINIT_P (current_function_decl))
2313 warning_with_decl (field_decl,
2314 "assignment to final static field `%s' not in class initializer");
2318 tree cfndecl_name = DECL_NAME (current_function_decl);
2319 if (! DECL_CONSTRUCTOR_P (current_function_decl)
2320 && !ID_FINIT_P (cfndecl_name))
2321 warning_with_decl (field_decl, "assignment to final field `%s' not in constructor");
2324 expand_assignment (field_ref, new_value, 0, 0);
2327 push_value (field_ref);
2331 load_type_state (tree label)
2334 tree vec = LABEL_TYPE_STATE (label);
2335 int cur_length = TREE_VEC_LENGTH (vec);
2336 stack_pointer = cur_length - DECL_MAX_LOCALS(current_function_decl);
2337 for (i = 0; i < cur_length; i++)
2338 type_map [i] = TREE_VEC_ELT (vec, i);
2341 /* Do the expansion of a Java switch. With Gcc, switches are front-end
2342 dependent things, but they rely on gcc routines. This function is
2343 placed here because it uses things defined locally in parse.y. */
2346 case_identity (tree t __attribute__ ((__unused__)), tree v)
2351 /* Return the name of the vtable for an array of a given primitive
2354 get_primitive_array_vtable (tree elt)
2357 if (elt == boolean_type_node)
2358 r = boolean_array_vtable;
2359 else if (elt == byte_type_node)
2360 r = byte_array_vtable;
2361 else if (elt == char_type_node)
2362 r = char_array_vtable;
2363 else if (elt == short_type_node)
2364 r = short_array_vtable;
2365 else if (elt == int_type_node)
2366 r = int_array_vtable;
2367 else if (elt == long_type_node)
2368 r = long_array_vtable;
2369 else if (elt == float_type_node)
2370 r = float_array_vtable;
2371 else if (elt == double_type_node)
2372 r = double_array_vtable;
2375 return build_address_of (r);
2379 java_expand_expr (tree exp, rtx target, enum machine_mode tmode,
2380 int modifier /* Actually an enum expand_modifier. */)
2384 switch (TREE_CODE (exp))
2386 case NEW_ARRAY_INIT:
2389 tree array_type = TREE_TYPE (TREE_TYPE (exp));
2390 tree element_type = TYPE_ARRAY_ELEMENT (array_type);
2391 tree data_fld = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type)));
2392 HOST_WIDE_INT ilength = java_array_type_length (array_type);
2393 tree length = build_int_2 (ilength, 0);
2394 tree init = TREE_OPERAND (exp, 0);
2397 /* See if we can generate the array statically. */
2398 if (TREE_CONSTANT (init) && TREE_STATIC (exp)
2399 && JPRIMITIVE_TYPE_P (element_type))
2401 tree temp, value, init_decl;
2403 START_RECORD_CONSTRUCTOR (temp, object_type_node);
2404 PUSH_FIELD_VALUE (temp, "vtable",
2405 get_primitive_array_vtable (element_type));
2406 if (! flag_hash_synchronization)
2407 PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
2408 FINISH_RECORD_CONSTRUCTOR (temp);
2409 START_RECORD_CONSTRUCTOR (value, array_type);
2410 PUSH_SUPER_VALUE (value, temp);
2411 PUSH_FIELD_VALUE (value, "length", length);
2412 PUSH_FIELD_VALUE (value, "data", init);
2413 FINISH_RECORD_CONSTRUCTOR (value);
2415 init_decl = build_decl (VAR_DECL, generate_name (), array_type);
2416 pushdecl_top_level (init_decl);
2417 TREE_STATIC (init_decl) = 1;
2418 DECL_INITIAL (init_decl) = value;
2419 DECL_IGNORED_P (init_decl) = 1;
2420 TREE_READONLY (init_decl) = 1;
2421 /* Hash synchronization requires at least 64-bit alignment. */
2422 if (flag_hash_synchronization && POINTER_SIZE < 64)
2423 DECL_ALIGN (init_decl) = 64;
2424 rest_of_decl_compilation (init_decl, NULL, 1, 0);
2425 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (init_decl)) = 1;
2426 init = build1 (ADDR_EXPR, TREE_TYPE (exp), init_decl);
2427 r = expand_expr (init, target, tmode, modifier);
2431 array_decl = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (exp));
2432 expand_decl (array_decl);
2433 tmp = expand_assignment (array_decl,
2434 build_new_array (element_type, length),
2436 if (TREE_CONSTANT (init)
2437 && ilength >= 10 && JPRIMITIVE_TYPE_P (element_type))
2440 init_decl = build_decl (VAR_DECL, generate_name (),
2442 pushdecl_top_level (init_decl);
2443 TREE_STATIC (init_decl) = 1;
2444 DECL_INITIAL (init_decl) = init;
2445 DECL_IGNORED_P (init_decl) = 1;
2446 TREE_READONLY (init_decl) = 1;
2447 rest_of_decl_compilation (init_decl, NULL, 1, 0);
2448 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (init_decl)) = 1;
2451 expand_assignment (build (COMPONENT_REF, TREE_TYPE (data_fld),
2452 build_java_indirect_ref (array_type,
2453 array_decl, flag_check_references),
2454 data_fld), init, 0, 0);
2458 if (BLOCK_EXPR_BODY (exp))
2462 tree body = BLOCK_EXPR_BODY (exp);
2463 /* Set to 1 or more when we found a static class
2464 initialization flag. */
2465 int found_class_initialization_flag = 0;
2467 pushlevel (2); /* 2 and above */
2468 expand_start_bindings (0);
2469 local = BLOCK_EXPR_DECLS (exp);
2472 tree next = TREE_CHAIN (local);
2473 found_class_initialization_flag +=
2474 LOCAL_CLASS_INITIALIZATION_FLAG_P (local);
2475 layout_decl (local, 0);
2476 expand_decl (pushdecl (local));
2480 /* Emit initialization code for test flags if we saw one. */
2481 if (! always_initialize_class_p
2482 && current_function_decl
2483 && found_class_initialization_flag)
2485 (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl),
2486 emit_init_test_initialization, NULL);
2488 /* Avoid deep recursion for long block. */
2489 while (TREE_CODE (body) == COMPOUND_EXPR)
2491 expand_expr (TREE_OPERAND (body, 0), const0_rtx, VOIDmode, 0);
2493 body = TREE_OPERAND (body, 1);
2495 last = expand_expr (body, NULL_RTX, VOIDmode, 0);
2497 expand_end_bindings (getdecls (), 1, 0);
2506 if (pushcase (TREE_OPERAND (exp, 0), case_identity,
2507 build_decl (LABEL_DECL, NULL_TREE, NULL_TREE),
2510 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (exp);
2512 (wfl_operator, "Duplicate case label: `%s'",
2513 print_int_node (TREE_OPERAND (exp, 0)));
2519 pushcase (NULL_TREE, 0,
2520 build_decl (LABEL_DECL, NULL_TREE, NULL_TREE), NULL);
2524 expand_start_case (0, TREE_OPERAND (exp, 0), int_type_node, "switch");
2525 expand_expr_stmt (TREE_OPERAND (exp, 1));
2526 expand_end_case (TREE_OPERAND (exp, 0));
2530 /* We expand a try[-catch] block */
2532 /* Expand the try block */
2533 expand_eh_region_start ();
2534 expand_expr_stmt (TREE_OPERAND (exp, 0));
2535 expand_start_all_catch ();
2537 /* Expand all catch clauses (EH handlers) */
2538 for (current = TREE_OPERAND (exp, 1); current;
2539 current = TREE_CHAIN (current))
2541 tree catch = TREE_OPERAND (current, 0);
2542 tree decl = BLOCK_EXPR_DECLS (catch);
2543 tree type = (decl ? TREE_TYPE (TREE_TYPE (decl)) : NULL_TREE);
2545 expand_start_catch (type);
2546 expand_expr_stmt (TREE_OPERAND (current, 0));
2547 expand_end_catch ();
2549 expand_end_all_catch ();
2552 case JAVA_EXC_OBJ_EXPR:
2553 return expand_expr (build_exception_object_ref (TREE_TYPE (exp)),
2554 target, tmode, modifier);
2557 /* Used only by expanded inline functions. */
2558 expand_label (TREE_OPERAND (exp, 0));
2562 internal_error ("can't expand %s", tree_code_name [TREE_CODE (exp)]);
2566 /* Go over METHOD's bytecode and note instruction starts in
2567 instruction_bits[]. */
2570 note_instructions (JCF *jcf, tree method)
2573 unsigned char* byte_ops;
2574 long length = DECL_CODE_LENGTH (method);
2579 #undef RET /* Defined by config/i386/i386.h */
2581 #define BCODE byte_ops
2582 #define BYTE_type_node byte_type_node
2583 #define SHORT_type_node short_type_node
2584 #define INT_type_node int_type_node
2585 #define LONG_type_node long_type_node
2586 #define CHAR_type_node char_type_node
2587 #define PTR_type_node ptr_type_node
2588 #define FLOAT_type_node float_type_node
2589 #define DOUBLE_type_node double_type_node
2590 #define VOID_type_node void_type_node
2591 #define CONST_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
2592 #define CONST_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
2593 #define VAR_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
2594 #define VAR_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
2596 #define CHECK_PC_IN_RANGE(PC) ((void)1) /* Already handled by verifier. */
2598 JCF_SEEK (jcf, DECL_CODE_OFFSET (method));
2599 byte_ops = jcf->read_ptr;
2600 instruction_bits = xrealloc (instruction_bits, length + 1);
2601 memset (instruction_bits, 0, length + 1);
2603 /* This pass figures out which PC can be the targets of jumps. */
2604 for (PC = 0; PC < length;)
2606 int oldpc = PC; /* PC at instruction start. */
2607 instruction_bits [PC] |= BCODE_INSTRUCTION_START;
2608 switch (byte_ops[PC++])
2610 #define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
2612 PRE_##OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
2615 #define NOTE_LABEL(PC) note_label(oldpc, PC)
2617 #define PRE_PUSHC(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2618 #define PRE_LOAD(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2619 #define PRE_STORE(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2620 #define PRE_STACK(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2621 #define PRE_UNOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2622 #define PRE_BINOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2623 #define PRE_CONVERT(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2624 #define PRE_CONVERT2(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2626 #define PRE_SPECIAL(OPERAND_TYPE, INSTRUCTION) \
2627 PRE_SPECIAL_##INSTRUCTION(OPERAND_TYPE)
2628 #define PRE_SPECIAL_IINC(OPERAND_TYPE) \
2629 ((void) IMMEDIATE_u1, (void) IMMEDIATE_s1)
2630 #define PRE_SPECIAL_ENTER(IGNORE) /* nothing */
2631 #define PRE_SPECIAL_EXIT(IGNORE) /* nothing */
2632 #define PRE_SPECIAL_THROW(IGNORE) /* nothing */
2633 #define PRE_SPECIAL_BREAK(IGNORE) /* nothing */
2635 /* two forms of wide instructions */
2636 #define PRE_SPECIAL_WIDE(IGNORE) \
2638 int modified_opcode = IMMEDIATE_u1; \
2639 if (modified_opcode == OPCODE_iinc) \
2641 (void) IMMEDIATE_u2; /* indexbyte1 and indexbyte2 */ \
2642 (void) IMMEDIATE_s2; /* constbyte1 and constbyte2 */ \
2646 (void) IMMEDIATE_u2; /* indexbyte1 and indexbyte2 */ \
2650 #define PRE_IMPL(IGNORE1, IGNORE2) /* nothing */
2652 #define PRE_MONITOR(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2654 #define PRE_RETURN(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2655 #define PRE_ARRAY(OPERAND_TYPE, SUBOP) \
2656 PRE_ARRAY_##SUBOP(OPERAND_TYPE)
2657 #define PRE_ARRAY_LOAD(TYPE) /* nothing */
2658 #define PRE_ARRAY_STORE(TYPE) /* nothing */
2659 #define PRE_ARRAY_LENGTH(TYPE) /* nothing */
2660 #define PRE_ARRAY_NEW(TYPE) PRE_ARRAY_NEW_##TYPE
2661 #define PRE_ARRAY_NEW_NUM ((void) IMMEDIATE_u1)
2662 #define PRE_ARRAY_NEW_PTR ((void) IMMEDIATE_u2)
2663 #define PRE_ARRAY_NEW_MULTI ((void) IMMEDIATE_u2, (void) IMMEDIATE_u1)
2665 #define PRE_TEST(OPERAND_TYPE, OPERAND_VALUE) NOTE_LABEL (oldpc+IMMEDIATE_s2)
2666 #define PRE_COND(OPERAND_TYPE, OPERAND_VALUE) NOTE_LABEL (oldpc+IMMEDIATE_s2)
2667 #define PRE_BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
2668 saw_index = 0; INT_temp = (OPERAND_VALUE); \
2669 if (!saw_index) NOTE_LABEL(oldpc + INT_temp);
2670 #define PRE_JSR(OPERAND_TYPE, OPERAND_VALUE) \
2671 saw_index = 0; INT_temp = (OPERAND_VALUE); \
2673 if (!saw_index) NOTE_LABEL(oldpc + INT_temp);
2675 #define PRE_RET(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE)
2677 #define PRE_SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
2678 PC = (PC + 3) / 4 * 4; PRE_##TABLE_OR_LOOKUP##_SWITCH
2680 #define PRE_LOOKUP_SWITCH \
2681 { jint default_offset = IMMEDIATE_s4; jint npairs = IMMEDIATE_s4; \
2682 NOTE_LABEL (default_offset+oldpc); \
2684 while (--npairs >= 0) { \
2685 jint match ATTRIBUTE_UNUSED = IMMEDIATE_s4; \
2686 jint offset = IMMEDIATE_s4; \
2687 NOTE_LABEL (offset+oldpc); } \
2690 #define PRE_TABLE_SWITCH \
2691 { jint default_offset = IMMEDIATE_s4; \
2692 jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
2693 NOTE_LABEL (default_offset+oldpc); \
2695 while (low++ <= high) { \
2696 jint offset = IMMEDIATE_s4; \
2697 NOTE_LABEL (offset+oldpc); } \
2700 #define PRE_FIELD(MAYBE_STATIC, PUT_OR_GET) (void)(IMMEDIATE_u2);
2701 #define PRE_OBJECT(MAYBE_STATIC, PUT_OR_GET) (void)(IMMEDIATE_u2);
2702 #define PRE_INVOKE(MAYBE_STATIC, IS_INTERFACE) \
2703 (void)(IMMEDIATE_u2); \
2704 PC += 2 * IS_INTERFACE /* for invokeinterface */;
2706 #include "javaop.def"
2713 expand_byte_code (JCF *jcf, tree method)
2717 const unsigned char *linenumber_pointer;
2718 int dead_code_index = -1;
2719 unsigned char* byte_ops;
2720 long length = DECL_CODE_LENGTH (method);
2723 JCF_SEEK (jcf, DECL_CODE_OFFSET (method));
2724 byte_ops = jcf->read_ptr;
2726 /* We make an initial pass of the line number table, to note
2727 which instructions have associated line number entries. */
2728 linenumber_pointer = linenumber_table;
2729 for (i = 0; i < linenumber_count; i++)
2731 int pc = GET_u2 (linenumber_pointer);
2732 linenumber_pointer += 4;
2734 warning ("invalid PC in line number table");
2737 if ((instruction_bits[pc] & BCODE_HAS_LINENUMBER) != 0)
2738 instruction_bits[pc] |= BCODE_HAS_MULTI_LINENUMBERS;
2739 instruction_bits[pc] |= BCODE_HAS_LINENUMBER;
2743 if (! verify_jvm_instructions (jcf, byte_ops, length))
2746 /* Translate bytecodes to rtl instructions. */
2747 linenumber_pointer = linenumber_table;
2748 for (PC = 0; PC < length;)
2750 if ((instruction_bits [PC] & BCODE_TARGET) != 0 || PC == 0)
2752 tree label = lookup_label (PC);
2753 flush_quick_stack ();
2754 if ((instruction_bits [PC] & BCODE_TARGET) != 0)
2755 expand_label (label);
2756 if (LABEL_VERIFIED (label) || PC == 0)
2757 load_type_state (label);
2760 if (! (instruction_bits [PC] & BCODE_VERIFIED))
2762 if (dead_code_index == -1)
2764 /* This is the start of a region of unreachable bytecodes.
2765 They still need to be processed in order for EH ranges
2766 to get handled correctly. However, we can simply
2767 replace these bytecodes with nops. */
2768 dead_code_index = PC;
2771 /* Turn this bytecode into a nop. */
2776 if (dead_code_index != -1)
2778 /* We've just reached the end of a region of dead code. */
2779 warning ("unreachable bytecode from %d to before %d",
2780 dead_code_index, PC);
2781 dead_code_index = -1;
2785 /* Handle possible line number entry for this PC.
2787 This code handles out-of-order and multiple linenumbers per PC,
2788 but is optimized for the case of line numbers increasing
2789 monotonically with PC. */
2790 if ((instruction_bits[PC] & BCODE_HAS_LINENUMBER) != 0)
2792 if ((instruction_bits[PC] & BCODE_HAS_MULTI_LINENUMBERS) != 0
2793 || GET_u2 (linenumber_pointer) != PC)
2794 linenumber_pointer = linenumber_table;
2795 while (linenumber_pointer < linenumber_table + linenumber_count * 4)
2797 int pc = GET_u2 (linenumber_pointer);
2798 linenumber_pointer += 4;
2801 lineno = GET_u2 (linenumber_pointer - 2);
2802 emit_line_note (input_filename, lineno);
2803 if (!(instruction_bits[PC] & BCODE_HAS_MULTI_LINENUMBERS))
2808 maybe_pushlevels (PC);
2809 PC = process_jvm_instruction (PC, byte_ops, length);
2810 maybe_poplevels (PC);
2813 if (dead_code_index != -1)
2815 /* We've just reached the end of a region of dead code. */
2816 warning ("unreachable bytecode from %d to the end of the method",
2822 java_push_constant_from_pool (JCF *jcf, int index)
2825 if (JPOOL_TAG (jcf, index) == CONSTANT_String)
2828 name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index));
2829 index = alloc_name_constant (CONSTANT_String, name);
2830 c = build_ref_from_constant_pool (index);
2831 TREE_TYPE (c) = promote_type (string_type_node);
2834 c = get_constant (jcf, index);
2839 process_jvm_instruction (int PC, const unsigned char* byte_ops,
2840 long length ATTRIBUTE_UNUSED)
2842 const char *opname; /* Temporary ??? */
2843 int oldpc = PC; /* PC at instruction start. */
2845 /* If the instruction is at the beginning of a exception handler,
2846 replace the top of the stack with the thrown object reference */
2847 if (instruction_bits [PC] & BCODE_EXCEPTION_TARGET)
2849 tree type = pop_type (ptr_type_node);
2850 push_value (build (JAVA_EXC_OBJ_EXPR, type));
2853 switch (byte_ops[PC++])
2855 #define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
2858 OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
2861 #define RET(OPERAND_TYPE, OPERAND_VALUE) \
2863 int saw_index = 0; \
2864 int index = OPERAND_VALUE; \
2865 build_java_ret (find_local_variable (index, ptr_type_node, oldpc)); \
2868 #define JSR(OPERAND_TYPE, OPERAND_VALUE) \
2870 /* OPERAND_VALUE may have side-effects on PC */ \
2871 int opvalue = OPERAND_VALUE; \
2872 build_java_jsr (oldpc + opvalue, PC); \
2875 /* Push a constant onto the stack. */
2876 #define PUSHC(OPERAND_TYPE, OPERAND_VALUE) \
2877 { int saw_index = 0; int ival = (OPERAND_VALUE); \
2878 if (saw_index) java_push_constant_from_pool (current_jcf, ival); \
2879 else expand_java_pushc (ival, OPERAND_TYPE##_type_node); }
2881 /* internal macro added for use by the WIDE case */
2882 #define LOAD_INTERNAL(OPTYPE, OPVALUE) \
2883 expand_load_internal (OPVALUE, type_map[OPVALUE], oldpc);
2885 /* Push local variable onto the opcode stack. */
2886 #define LOAD(OPERAND_TYPE, OPERAND_VALUE) \
2888 /* have to do this since OPERAND_VALUE may have side-effects */ \
2889 int opvalue = OPERAND_VALUE; \
2890 LOAD_INTERNAL(OPERAND_TYPE##_type_node, opvalue); \
2893 #define RETURN(OPERAND_TYPE, OPERAND_VALUE) \
2894 expand_java_return (OPERAND_TYPE##_type_node)
2896 #define REM_EXPR TRUNC_MOD_EXPR
2897 #define BINOP(OPERAND_TYPE, OPERAND_VALUE) \
2898 expand_java_binop (OPERAND_TYPE##_type_node, OPERAND_VALUE##_EXPR)
2900 #define FIELD(IS_STATIC, IS_PUT) \
2901 expand_java_field_op (IS_STATIC, IS_PUT, IMMEDIATE_u2)
2903 #define TEST(OPERAND_TYPE, CONDITION) \
2904 expand_test (CONDITION##_EXPR, OPERAND_TYPE##_type_node, oldpc+IMMEDIATE_s2)
2906 #define COND(OPERAND_TYPE, CONDITION) \
2907 expand_cond (CONDITION##_EXPR, OPERAND_TYPE##_type_node, oldpc+IMMEDIATE_s2)
2909 #define BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
2910 BRANCH_##OPERAND_TYPE (OPERAND_VALUE)
2912 #define BRANCH_GOTO(OPERAND_VALUE) \
2913 expand_java_goto (oldpc + OPERAND_VALUE)
2915 #define BRANCH_CALL(OPERAND_VALUE) \
2916 expand_java_call (oldpc + OPERAND_VALUE, oldpc)
2919 #define BRANCH_RETURN(OPERAND_VALUE) \
2921 tree type = OPERAND_TYPE##_type_node; \
2922 tree value = find_local_variable (OPERAND_VALUE, type, oldpc); \
2923 expand_java_ret (value); \
2927 #define NOT_IMPL(OPERAND_TYPE, OPERAND_VALUE) \
2928 fprintf (stderr, "%3d: %s ", oldpc, opname); \
2929 fprintf (stderr, "(not implemented)\n")
2930 #define NOT_IMPL1(OPERAND_VALUE) \
2931 fprintf (stderr, "%3d: %s ", oldpc, opname); \
2932 fprintf (stderr, "(not implemented)\n")
2934 #define BRANCH_RETURN(OPERAND_VALUE) NOT_IMPL1(OPERAND_VALUE)
2936 #define STACK(SUBOP, COUNT) STACK_##SUBOP (COUNT)
2938 #define STACK_POP(COUNT) java_stack_pop (COUNT)
2940 #define STACK_SWAP(COUNT) java_stack_swap()
2942 #define STACK_DUP(COUNT) java_stack_dup (COUNT, 0)
2943 #define STACK_DUPx1(COUNT) java_stack_dup (COUNT, 1)
2944 #define STACK_DUPx2(COUNT) java_stack_dup (COUNT, 2)
2946 #define SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
2947 PC = (PC + 3) / 4 * 4; TABLE_OR_LOOKUP##_SWITCH
2949 #define LOOKUP_SWITCH \
2950 { jint default_offset = IMMEDIATE_s4; jint npairs = IMMEDIATE_s4; \
2951 tree selector = pop_value (INT_type_node); \
2952 tree duplicate, label; \
2953 tree type = TREE_TYPE (selector); \
2954 flush_quick_stack (); \
2955 expand_start_case (0, selector, type, "switch statement");\
2956 while (--npairs >= 0) \
2958 jint match = IMMEDIATE_s4; jint offset = IMMEDIATE_s4; \
2959 tree value = build_int_2 (match, match < 0 ? -1 : 0); \
2960 TREE_TYPE (value) = type; \
2961 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2962 pushcase (value, convert, label, &duplicate); \
2963 expand_java_goto (oldpc + offset); \
2965 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2966 pushcase (NULL_TREE, 0, label, &duplicate); \
2967 expand_java_goto (oldpc + default_offset); \
2968 expand_end_case (selector); \
2971 #define TABLE_SWITCH \
2972 { jint default_offset = IMMEDIATE_s4; \
2973 jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
2974 tree selector = pop_value (INT_type_node); \
2975 tree duplicate, label; \
2976 tree type = TREE_TYPE (selector); \
2977 flush_quick_stack (); \
2978 expand_start_case (0, selector, type, "switch statement");\
2979 for (; low <= high; low++) \
2981 jint offset = IMMEDIATE_s4; \
2982 tree value = build_int_2 (low, low < 0 ? -1 : 0); \
2983 TREE_TYPE (value) = type; \
2984 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2985 pushcase (value, convert, label, &duplicate); \
2986 expand_java_goto (oldpc + offset); \
2988 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2989 pushcase (NULL_TREE, 0, label, &duplicate); \
2990 expand_java_goto (oldpc + default_offset); \
2991 expand_end_case (selector); \
2994 #define INVOKE(MAYBE_STATIC, IS_INTERFACE) \
2995 { int opcode = byte_ops[PC-1]; \
2996 int method_ref_index = IMMEDIATE_u2; \
2998 if (IS_INTERFACE) { nargs = IMMEDIATE_u1; (void) IMMEDIATE_u1; } \
3000 expand_invoke (opcode, method_ref_index, nargs); \
3003 /* Handle new, checkcast, instanceof */
3004 #define OBJECT(TYPE, OP) \
3005 expand_java_##OP (get_class_constant (current_jcf, IMMEDIATE_u2))
3007 #define ARRAY(OPERAND_TYPE, SUBOP) ARRAY_##SUBOP(OPERAND_TYPE)
3009 #define ARRAY_LOAD(OPERAND_TYPE) \
3011 expand_java_arrayload( OPERAND_TYPE##_type_node ); \
3014 #define ARRAY_STORE(OPERAND_TYPE) \
3016 expand_java_arraystore( OPERAND_TYPE##_type_node ); \
3019 #define ARRAY_LENGTH(OPERAND_TYPE) expand_java_array_length();
3020 #define ARRAY_NEW(OPERAND_TYPE) ARRAY_NEW_##OPERAND_TYPE()
3021 #define ARRAY_NEW_PTR() \
3022 push_value (build_anewarray (get_class_constant (current_jcf, \
3024 pop_value (int_type_node)));
3025 #define ARRAY_NEW_NUM() \
3027 int atype = IMMEDIATE_u1; \
3028 push_value (build_newarray (atype, pop_value (int_type_node)));\
3030 #define ARRAY_NEW_MULTI() \
3032 tree class = get_class_constant (current_jcf, IMMEDIATE_u2 ); \
3033 int ndims = IMMEDIATE_u1; \
3034 expand_java_multianewarray( class, ndims ); \
3037 #define UNOP(OPERAND_TYPE, OPERAND_VALUE) \
3038 push_value (fold (build1 (NEGATE_EXPR, OPERAND_TYPE##_type_node, \
3039 pop_value (OPERAND_TYPE##_type_node))));
3041 #define CONVERT2(FROM_TYPE, TO_TYPE) \
3043 push_value (build1 (NOP_EXPR, int_type_node, \
3044 (convert (TO_TYPE##_type_node, \
3045 pop_value (FROM_TYPE##_type_node))))); \
3048 #define CONVERT(FROM_TYPE, TO_TYPE) \
3050 push_value (convert (TO_TYPE##_type_node, \
3051 pop_value (FROM_TYPE##_type_node))); \
3054 /* internal macro added for use by the WIDE case
3055 Added TREE_TYPE (decl) assignment, apbianco */
3056 #define STORE_INTERNAL(OPTYPE, OPVALUE) \
3059 int var = OPVALUE; \
3060 tree type = OPTYPE; \
3061 value = pop_value (type); \
3062 type = TREE_TYPE (value); \
3063 decl = find_local_variable (var, type, oldpc); \
3064 set_local_type (var, type ); \
3065 expand_assignment (decl, value, 0, 0); \
3068 #define STORE(OPERAND_TYPE, OPERAND_VALUE) \
3070 /* have to do this since OPERAND_VALUE may have side-effects */ \
3071 int opvalue = OPERAND_VALUE; \
3072 STORE_INTERNAL(OPERAND_TYPE##_type_node, opvalue); \
3075 #define SPECIAL(OPERAND_TYPE, INSTRUCTION) \
3076 SPECIAL_##INSTRUCTION(OPERAND_TYPE)
3078 #define SPECIAL_ENTER(IGNORED) MONITOR_OPERATION (soft_monitorenter_node)
3079 #define SPECIAL_EXIT(IGNORED) MONITOR_OPERATION (soft_monitorexit_node)
3081 #define MONITOR_OPERATION(call) \
3083 tree o = pop_value (ptr_type_node); \
3085 flush_quick_stack (); \
3086 c = build_java_monitor (call, o); \
3087 TREE_SIDE_EFFECTS (c) = 1; \
3088 expand_expr_stmt (c); \
3091 #define SPECIAL_IINC(IGNORED) \
3093 unsigned int local_var_index = IMMEDIATE_u1; \
3094 int ival = IMMEDIATE_s1; \
3095 expand_iinc(local_var_index, ival, oldpc); \
3098 #define SPECIAL_WIDE(IGNORED) \
3100 int modified_opcode = IMMEDIATE_u1; \
3101 unsigned int local_var_index = IMMEDIATE_u2; \
3102 switch (modified_opcode) \
3106 int ival = IMMEDIATE_s2; \
3107 expand_iinc (local_var_index, ival, oldpc); \
3110 case OPCODE_iload: \
3111 case OPCODE_lload: \
3112 case OPCODE_fload: \
3113 case OPCODE_dload: \
3114 case OPCODE_aload: \
3116 /* duplicate code from LOAD macro */ \
3117 LOAD_INTERNAL(operand_type[modified_opcode], local_var_index); \
3120 case OPCODE_istore: \
3121 case OPCODE_lstore: \
3122 case OPCODE_fstore: \
3123 case OPCODE_dstore: \
3124 case OPCODE_astore: \
3126 STORE_INTERNAL(operand_type[modified_opcode], local_var_index); \
3130 error ("unrecogized wide sub-instruction"); \
3134 #define SPECIAL_THROW(IGNORED) \
3135 build_java_athrow (pop_value (throwable_type_node))
3137 #define SPECIAL_BREAK NOT_IMPL1
3138 #define IMPL NOT_IMPL
3140 #include "javaop.def"
3143 fprintf (stderr, "%3d: unknown(%3d)\n", oldpc, byte_ops[PC]);
3148 /* Return the opcode at PC in the code section pointed to by
3151 static unsigned char
3152 peek_opcode_at_pc (JCF *jcf, int code_offset, int pc)
3154 unsigned char opcode;
3155 long absolute_offset = (long)JCF_TELL (jcf);
3157 JCF_SEEK (jcf, code_offset);
3158 opcode = jcf->read_ptr [pc];
3159 JCF_SEEK (jcf, absolute_offset);
3163 /* Some bytecode compilers are emitting accurate LocalVariableTable
3164 attributes. Here's an example:
3169 Attribute "LocalVariableTable"
3170 slot #<n>: ... (PC: PC+1 length: L)
3172 This is accurate because the local in slot <n> really exists after
3173 the opcode at PC is executed, hence from PC+1 to PC+1+L.
3175 This procedure recognizes this situation and extends the live range
3176 of the local in SLOT to START_PC-1 or START_PC-2 (depending on the
3177 length of the store instruction.)
3179 This function is used by `give_name_to_locals' so that a local's
3180 DECL features a DECL_LOCAL_START_PC such that the first related
3181 store operation will use DECL as a destination, not a unrelated
3182 temporary created for the occasion.
3184 This function uses a global (instruction_bits) `note_instructions' should
3185 have allocated and filled properly. */
3188 maybe_adjust_start_pc (struct JCF *jcf, int code_offset,
3189 int start_pc, int slot)
3191 int first, index, opcode;
3200 /* Find last previous instruction and remember it */
3201 for (pc = start_pc-1; pc; pc--)
3202 if (instruction_bits [pc] & BCODE_INSTRUCTION_START)
3206 /* Retrieve the instruction, handle `wide'. */
3207 opcode = (int) peek_opcode_at_pc (jcf, code_offset, pc++);
3208 if (opcode == OPCODE_wide)
3211 opcode = (int) peek_opcode_at_pc (jcf, code_offset, pc++);
3216 case OPCODE_astore_0:
3217 case OPCODE_astore_1:
3218 case OPCODE_astore_2:
3219 case OPCODE_astore_3:
3220 first = OPCODE_astore_0;
3223 case OPCODE_istore_0:
3224 case OPCODE_istore_1:
3225 case OPCODE_istore_2:
3226 case OPCODE_istore_3:
3227 first = OPCODE_istore_0;
3230 case OPCODE_lstore_0:
3231 case OPCODE_lstore_1:
3232 case OPCODE_lstore_2:
3233 case OPCODE_lstore_3:
3234 first = OPCODE_lstore_0;
3237 case OPCODE_fstore_0:
3238 case OPCODE_fstore_1:
3239 case OPCODE_fstore_2:
3240 case OPCODE_fstore_3:
3241 first = OPCODE_fstore_0;
3244 case OPCODE_dstore_0:
3245 case OPCODE_dstore_1:
3246 case OPCODE_dstore_2:
3247 case OPCODE_dstore_3:
3248 first = OPCODE_dstore_0;
3256 index = peek_opcode_at_pc (jcf, code_offset, pc);
3259 int other = peek_opcode_at_pc (jcf, code_offset, ++pc);
3260 index = (other << 8) + index;
3265 /* Now we decide: first >0 means we have a <t>store_<n>, index >0
3266 means we have a <t>store. */
3267 if ((first > 0 && opcode - first == slot) || (index > 0 && index == slot))
3273 /* Force the (direct) sub-operands of NODE to be evaluated in left-to-right
3274 order, as specified by Java Language Specification.
3276 The problem is that while expand_expr will evaluate its sub-operands in
3277 left-to-right order, for variables it will just return an rtx (i.e.
3278 an lvalue) for the variable (rather than an rvalue). So it is possible
3279 that a later sub-operand will change the register, and when the
3280 actual operation is done, it will use the new value, when it should
3281 have used the original value.
3283 We fix this by using save_expr. This forces the sub-operand to be
3284 copied into a fresh virtual register,
3286 For method invocation, we modify the arguments so that a
3287 left-to-right order evaluation is performed. Saved expressions
3288 will, in CALL_EXPR order, be reused when the call will be expanded.
3292 force_evaluation_order (tree node)
3294 if (flag_syntax_only)
3296 if (TREE_CODE_CLASS (TREE_CODE (node)) == '2')
3298 if (TREE_SIDE_EFFECTS (TREE_OPERAND (node, 1)))
3299 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
3301 else if (TREE_CODE (node) == CALL_EXPR
3302 || TREE_CODE (node) == NEW_CLASS_EXPR
3303 || (TREE_CODE (node) == COMPOUND_EXPR
3304 && TREE_CODE (TREE_OPERAND (node, 0)) == CALL_EXPR
3305 && TREE_CODE (TREE_OPERAND (node, 1)) == SAVE_EXPR))
3309 if (!TREE_OPERAND (node, 1))
3314 /* Position arg properly, account for wrapped around ctors. */
3315 if (TREE_CODE (node) == COMPOUND_EXPR)
3316 arg = TREE_OPERAND (node, 0);
3318 arg = TREE_OPERAND (arg, 1);
3320 /* Not having a list of argument here is an error. */
3321 if (TREE_CODE (arg) != TREE_LIST)
3324 /* This reverses the evaluation order. This is a desired effect. */
3325 for (cmp = NULL_TREE; arg; arg = TREE_CHAIN (arg))
3327 tree saved = save_expr (force_evaluation_order (TREE_VALUE (arg)));
3328 cmp = (cmp == NULL_TREE ? saved :
3329 build (COMPOUND_EXPR, void_type_node, cmp, saved));
3330 TREE_VALUE (arg) = saved;
3333 if (cmp && TREE_CODE (cmp) == COMPOUND_EXPR)
3334 TREE_SIDE_EFFECTS (cmp) = 1;
3338 cmp = save_expr (build (COMPOUND_EXPR, TREE_TYPE (node), cmp, node));
3339 CAN_COMPLETE_NORMALLY (cmp) = CAN_COMPLETE_NORMALLY (node);
3340 TREE_SIDE_EFFECTS (cmp) = 1;
3347 /* Called for every element in DECL_FUNCTION_INIT_TEST_TABLE of a
3348 method in order to emit initialization code for each test flag. */
3351 emit_init_test_initialization (void **entry, void *x ATTRIBUTE_UNUSED)
3353 struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
3354 tree klass = build_class_ref (ite->key);
3357 /* If the DECL_INITIAL of the test flag is set to true, it
3358 means that the class is already initialized the time it
3360 if (DECL_INITIAL (ite->value) == boolean_true_node)
3361 rhs = boolean_true_node;
3362 /* Otherwise, we initialize the class init check variable by looking
3363 at the `state' field of the class to see if it is already
3364 initialized. This makes things a bit faster if the class is
3365 already initialized, which should be the common case. */
3367 rhs = build (GE_EXPR, boolean_type_node,
3368 build (COMPONENT_REF, byte_type_node,
3369 build1 (INDIRECT_REF, class_type_node, klass),
3370 lookup_field (&class_type_node,
3371 get_identifier ("state"))),
3372 build_int_2 (JV_STATE_DONE, 0));
3374 expand_expr_stmt (build (MODIFY_EXPR, boolean_type_node,
3379 #include "gt-java-expr.h"