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 initialization 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 permanent 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 array
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 conversion.
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
1753 int method_index = 0;
1756 /* The method might actually be declared in some superclass, so
1757 we have to use its class context, not the caller's notion of
1758 where the method is. */
1759 self_type = DECL_CONTEXT (method);
1760 ref = build_class_ref (self_type);
1761 ref = build1 (INDIRECT_REF, class_type_node, ref);
1762 if (ncode_ident == NULL_TREE)
1763 ncode_ident = get_identifier ("ncode");
1764 if (methods_ident == NULL_TREE)
1765 methods_ident = get_identifier ("methods");
1766 ref = build (COMPONENT_REF, method_ptr_type_node, ref,
1767 lookup_field (&class_type_node, methods_ident));
1768 for (meth = TYPE_METHODS (self_type);
1769 ; meth = TREE_CHAIN (meth))
1773 if (meth == NULL_TREE)
1774 fatal_error ("method '%s' not found in class",
1775 IDENTIFIER_POINTER (DECL_NAME (method)));
1778 method_index *= int_size_in_bytes (method_type_node);
1779 ref = fold (build (PLUS_EXPR, method_ptr_type_node,
1780 ref, build_int_2 (method_index, 0)));
1781 ref = build1 (INDIRECT_REF, method_type_node, ref);
1782 func = build (COMPONENT_REF, nativecode_ptr_type_node,
1784 lookup_field (&method_type_node, ncode_ident));
1790 invoke_build_dtable (int is_invoke_interface, tree arg_list)
1792 tree dtable, objectref;
1794 TREE_VALUE (arg_list) = save_expr (TREE_VALUE (arg_list));
1796 /* If we're dealing with interfaces and if the objectref
1797 argument is an array then get the dispatch table of the class
1798 Object rather than the one from the objectref. */
1799 objectref = (is_invoke_interface
1800 && is_array_type_p (TREE_TYPE (TREE_VALUE (arg_list))) ?
1801 object_type_node : TREE_VALUE (arg_list));
1803 if (dtable_ident == NULL_TREE)
1804 dtable_ident = get_identifier ("vtable");
1805 dtable = build_java_indirect_ref (object_type_node, objectref,
1806 flag_check_references);
1807 dtable = build (COMPONENT_REF, dtable_ptr_type, dtable,
1808 lookup_field (&object_type_node, dtable_ident));
1813 /* Determine the index in the virtual offset table (otable) for a call to
1814 METHOD. If this method has not been seen before, it will be added to the
1815 otable_methods. If it has, the existing otable slot will be reused. */
1818 get_offset_table_index (tree method)
1823 if (otable_methods == NULL_TREE)
1825 otable_methods = build_tree_list (method, method);
1829 method_list = otable_methods;
1833 if (TREE_VALUE (method_list) == method)
1836 if (TREE_CHAIN (method_list) == NULL_TREE)
1839 method_list = TREE_CHAIN (method_list);
1842 TREE_CHAIN (method_list) = build_tree_list (method, method);
1847 build_invokevirtual (tree dtable, tree method)
1850 tree nativecode_ptr_ptr_type_node
1851 = build_pointer_type (nativecode_ptr_type_node);
1855 if (flag_indirect_dispatch)
1857 otable_index = build_int_2 (get_offset_table_index (method), 0);
1858 method_index = build (ARRAY_REF, integer_type_node, otable_decl,
1863 method_index = convert (sizetype, DECL_VINDEX (method));
1865 if (TARGET_VTABLE_USES_DESCRIPTORS)
1866 /* Add one to skip bogus descriptor for class and GC descriptor. */
1867 method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
1869 /* Add 1 to skip "class" field of dtable, and 1 to skip GC descriptor. */
1870 method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1872 method_index = size_binop (MULT_EXPR, method_index,
1873 TYPE_SIZE_UNIT (nativecode_ptr_ptr_type_node));
1875 if (TARGET_VTABLE_USES_DESCRIPTORS)
1876 method_index = size_binop (MULT_EXPR, method_index,
1877 size_int (TARGET_VTABLE_USES_DESCRIPTORS));
1880 func = fold (build (PLUS_EXPR, nativecode_ptr_ptr_type_node, dtable,
1881 convert (nativecode_ptr_ptr_type_node, method_index)));
1883 if (TARGET_VTABLE_USES_DESCRIPTORS)
1884 func = build1 (NOP_EXPR, nativecode_ptr_type_node, func);
1886 func = build1 (INDIRECT_REF, nativecode_ptr_type_node, func);
1891 static GTY(()) tree class_ident;
1893 build_invokeinterface (tree dtable, tree method)
1902 /* We expand invokeinterface here. _Jv_LookupInterfaceMethod() will
1903 ensure that the selected method exists, is public and not
1904 abstract nor static. */
1906 if (class_ident == NULL_TREE)
1907 class_ident = get_identifier ("class");
1909 dtable = build_java_indirect_ref (dtable_type, dtable,
1910 flag_check_references);
1911 dtable = build (COMPONENT_REF, class_ptr_type, dtable,
1912 lookup_field (&dtable_type, class_ident));
1914 interface = DECL_CONTEXT (method);
1915 if (! CLASS_INTERFACE (TYPE_NAME (interface)))
1917 layout_class_methods (interface);
1919 if (flag_indirect_dispatch)
1921 otable_index = build_int_2 (get_offset_table_index (method), 0);
1922 idx = build (ARRAY_REF, integer_type_node, otable_decl, otable_index);
1927 for (meth = TYPE_METHODS (interface); ; meth = TREE_CHAIN (meth), i++)
1931 idx = build_int_2 (i, 0);
1934 if (meth == NULL_TREE)
1939 lookup_arg = tree_cons (NULL_TREE, dtable,
1940 tree_cons (NULL_TREE, build_class_ref (interface),
1941 build_tree_list (NULL_TREE, idx)));
1943 return build (CALL_EXPR, ptr_type_node,
1944 build_address_of (soft_lookupinterfacemethod_node),
1945 lookup_arg, NULL_TREE);
1948 /* Expand one of the invoke_* opcodes.
1949 OCPODE is the specific opcode.
1950 METHOD_REF_INDEX is an index into the constant pool.
1951 NARGS is the number of arguments, or -1 if not specified. */
1954 expand_invoke (int opcode, int method_ref_index, int nargs ATTRIBUTE_UNUSED)
1956 tree method_signature = COMPONENT_REF_SIGNATURE(¤t_jcf->cpool, method_ref_index);
1957 tree method_name = COMPONENT_REF_NAME (¤t_jcf->cpool, method_ref_index);
1958 tree self_type = get_class_constant
1959 (current_jcf, COMPONENT_REF_CLASS_INDEX(¤t_jcf->cpool, method_ref_index));
1960 const char *const self_name
1961 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
1962 tree call, func, method, arg_list, method_type;
1963 tree check = NULL_TREE;
1965 if (! CLASS_LOADED_P (self_type))
1967 load_class (self_type, 1);
1968 safe_layout_class (self_type);
1969 if (TREE_CODE (TYPE_SIZE (self_type)) == ERROR_MARK)
1970 fatal_error ("failed to find class '%s'", self_name);
1972 layout_class_methods (self_type);
1974 if (ID_INIT_P (method_name))
1975 method = lookup_java_constructor (self_type, method_signature);
1977 method = lookup_java_method (self_type, method_name, method_signature);
1978 if (method == NULL_TREE)
1980 error ("class '%s' has no method named '%s' matching signature '%s'",
1982 IDENTIFIER_POINTER (method_name),
1983 IDENTIFIER_POINTER (method_signature));
1985 /* Invoke static can't invoke static/abstract method */
1986 else if (opcode == OPCODE_invokestatic)
1988 if (!METHOD_STATIC (method))
1990 error ("invokestatic on non static method");
1993 else if (METHOD_ABSTRACT (method))
1995 error ("invokestatic on abstract method");
2001 if (METHOD_STATIC (method))
2003 error ("invoke[non-static] on static method");
2008 if (method == NULL_TREE)
2010 method_type = get_type_from_signature (method_signature);
2011 pop_arguments (TYPE_ARG_TYPES (method_type));
2012 if (opcode != OPCODE_invokestatic)
2013 pop_type (self_type);
2014 method_type = promote_type (TREE_TYPE (method_type));
2015 push_value (convert (method_type, integer_zero_node));
2019 method_type = TREE_TYPE (method);
2020 arg_list = pop_arguments (TYPE_ARG_TYPES (method_type));
2021 flush_quick_stack ();
2024 if (opcode == OPCODE_invokestatic)
2025 func = build_known_method_ref (method, method_type, self_type,
2026 method_signature, arg_list);
2027 else if (opcode == OPCODE_invokespecial
2028 || (opcode == OPCODE_invokevirtual
2029 && (METHOD_PRIVATE (method)
2030 || METHOD_FINAL (method)
2031 || CLASS_FINAL (TYPE_NAME (self_type)))))
2033 /* If the object for the method call is null, we throw an
2034 exception. We don't do this if the object is the current
2035 method's `this'. In other cases we just rely on an
2036 optimization pass to eliminate redundant checks. FIXME:
2037 Unfortunately there doesn't seem to be a way to determine
2038 what the current method is right now.
2039 We do omit the check if we're calling <init>. */
2040 /* We use a SAVE_EXPR here to make sure we only evaluate
2041 the new `self' expression once. */
2042 tree save_arg = save_expr (TREE_VALUE (arg_list));
2043 TREE_VALUE (arg_list) = save_arg;
2044 check = java_check_reference (save_arg, ! DECL_INIT_P (method));
2045 func = build_known_method_ref (method, method_type, self_type,
2046 method_signature, arg_list);
2050 tree dtable = invoke_build_dtable (opcode == OPCODE_invokeinterface,
2052 if (opcode == OPCODE_invokevirtual)
2053 func = build_invokevirtual (dtable, method);
2055 func = build_invokeinterface (dtable, method);
2057 func = build1 (NOP_EXPR, build_pointer_type (method_type), func);
2059 call = build (CALL_EXPR, TREE_TYPE (method_type), func, arg_list, NULL_TREE);
2060 TREE_SIDE_EFFECTS (call) = 1;
2061 call = check_for_builtin (method, call);
2063 if (check != NULL_TREE)
2065 call = build (COMPOUND_EXPR, TREE_TYPE (call), check, call);
2066 TREE_SIDE_EFFECTS (call) = 1;
2069 if (TREE_CODE (TREE_TYPE (method_type)) == VOID_TYPE)
2070 expand_expr_stmt (call);
2074 flush_quick_stack ();
2078 /* Create a stub which will be put into the vtable but which will call
2082 build_jni_stub (tree method)
2084 tree jnifunc, call, args, body, lookup_arg, method_sig, arg_types;
2085 tree jni_func_type, tem;
2086 tree env_var, res_var = NULL_TREE, block;
2087 tree method_args, res_type;
2090 tree klass = DECL_CONTEXT (method);
2091 int from_class = ! CLASS_FROM_SOURCE_P (klass);
2092 klass = build_class_ref (klass);
2094 if (! METHOD_NATIVE (method) || ! flag_jni)
2097 DECL_ARTIFICIAL (method) = 1;
2098 DECL_EXTERNAL (method) = 0;
2100 env_var = build_decl (VAR_DECL, get_identifier ("env"), ptr_type_node);
2101 DECL_CONTEXT (env_var) = method;
2103 if (TREE_TYPE (TREE_TYPE (method)) != void_type_node)
2105 res_var = build_decl (VAR_DECL, get_identifier ("res"),
2106 TREE_TYPE (TREE_TYPE (method)));
2107 DECL_CONTEXT (res_var) = method;
2108 TREE_CHAIN (env_var) = res_var;
2111 meth_var = build_decl (VAR_DECL, get_identifier ("meth"), ptr_type_node);
2112 TREE_STATIC (meth_var) = 1;
2113 TREE_PUBLIC (meth_var) = 0;
2114 DECL_EXTERNAL (meth_var) = 0;
2115 DECL_CONTEXT (meth_var) = method;
2116 DECL_ARTIFICIAL (meth_var) = 1;
2117 DECL_INITIAL (meth_var) = null_pointer_node;
2118 TREE_USED (meth_var) = 1;
2119 chainon (env_var, meth_var);
2120 layout_decl (meth_var, 0);
2121 make_decl_rtl (meth_var, NULL);
2122 rest_of_decl_compilation (meth_var, NULL, 0, 0);
2124 /* One strange way that the front ends are different is that they
2125 store arguments differently. */
2127 method_args = DECL_ARGUMENTS (method);
2129 method_args = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (method));
2130 block = build_block (env_var, NULL_TREE, NULL_TREE,
2131 method_args, NULL_TREE);
2132 TREE_SIDE_EFFECTS (block) = 1;
2133 /* When compiling from source we don't set the type of the block,
2134 because that will prevent patch_return from ever being run. */
2136 TREE_TYPE (block) = TREE_TYPE (TREE_TYPE (method));
2138 /* Compute the local `env' by calling _Jv_GetJNIEnvNewFrame. */
2139 body = build (MODIFY_EXPR, ptr_type_node, env_var,
2140 build (CALL_EXPR, ptr_type_node,
2141 build_address_of (soft_getjnienvnewframe_node),
2142 build_tree_list (NULL_TREE, klass),
2144 CAN_COMPLETE_NORMALLY (body) = 1;
2146 /* All the arguments to this method become arguments to the
2147 underlying JNI function. If we had to wrap object arguments in a
2148 special way, we would do that here. */
2150 for (tem = method_args; tem != NULL_TREE; tem = TREE_CHAIN (tem))
2151 args = tree_cons (NULL_TREE, tem, args);
2152 args = nreverse (args);
2153 arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
2155 /* For a static method the second argument is the class. For a
2156 non-static method the second argument is `this'; that is already
2157 available in the argument list. */
2158 if (METHOD_STATIC (method))
2160 args = tree_cons (NULL_TREE, klass, args);
2161 arg_types = tree_cons (NULL_TREE, object_ptr_type_node, arg_types);
2164 /* The JNIEnv structure is the first argument to the JNI function. */
2165 args = tree_cons (NULL_TREE, env_var, args);
2166 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
2168 /* We call _Jv_LookupJNIMethod to find the actual underlying
2169 function pointer. _Jv_LookupJNIMethod will throw the appropriate
2170 exception if this function is not found at runtime. */
2171 method_sig = build_java_signature (TREE_TYPE (method));
2173 build_tree_list (NULL_TREE,
2174 build_utf8_ref (unmangle_classname
2175 (IDENTIFIER_POINTER (method_sig),
2176 IDENTIFIER_LENGTH (method_sig))));
2177 tem = DECL_NAME (method);
2179 = tree_cons (NULL_TREE, klass,
2180 tree_cons (NULL_TREE, build_utf8_ref (tem), lookup_arg));
2183 = build_pointer_type (build_function_type (TREE_TYPE (TREE_TYPE (method)),
2186 jnifunc = build (COND_EXPR, ptr_type_node,
2188 build (MODIFY_EXPR, ptr_type_node,
2190 build (CALL_EXPR, ptr_type_node,
2191 build_address_of (soft_lookupjnimethod_node),
2192 lookup_arg, NULL_TREE)));
2194 /* Now we make the actual JNI call via the resulting function
2196 call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (method)),
2197 build1 (NOP_EXPR, jni_func_type, jnifunc),
2200 /* If the JNI call returned a result, capture it here. If we had to
2201 unwrap JNI object results, we would do that here. */
2202 if (res_var != NULL_TREE)
2203 call = build (MODIFY_EXPR, TREE_TYPE (TREE_TYPE (method)),
2206 TREE_SIDE_EFFECTS (call) = 1;
2207 CAN_COMPLETE_NORMALLY (call) = 1;
2209 body = build (COMPOUND_EXPR, void_type_node, body, call);
2210 TREE_SIDE_EFFECTS (body) = 1;
2212 /* Now free the environment we allocated. */
2213 call = build (CALL_EXPR, ptr_type_node,
2214 build_address_of (soft_jnipopsystemframe_node),
2215 build_tree_list (NULL_TREE, env_var),
2217 TREE_SIDE_EFFECTS (call) = 1;
2218 CAN_COMPLETE_NORMALLY (call) = 1;
2219 body = build (COMPOUND_EXPR, void_type_node, body, call);
2220 TREE_SIDE_EFFECTS (body) = 1;
2222 /* Finally, do the return. When compiling from source we rely on
2223 patch_return to patch the return value -- because DECL_RESULT is
2224 not set at the time this function is called. */
2227 res_type = void_type_node;
2228 if (res_var != NULL_TREE)
2231 if (! DECL_RESULT (method))
2233 /* Make sure we copy the result variable to the actual
2234 result. We use the type of the DECL_RESULT because it
2235 might be different from the return type of the function:
2236 it might be promoted. */
2237 drt = TREE_TYPE (DECL_RESULT (method));
2238 if (drt != TREE_TYPE (res_var))
2239 res_var = build1 (CONVERT_EXPR, drt, res_var);
2240 res_var = build (MODIFY_EXPR, drt, DECL_RESULT (method), res_var);
2241 TREE_SIDE_EFFECTS (res_var) = 1;
2246 /* This is necessary to get patch_return to run. */
2247 res_type = NULL_TREE;
2249 body = build (COMPOUND_EXPR, void_type_node, body,
2250 build1 (RETURN_EXPR, res_type, res_var));
2251 TREE_SIDE_EFFECTS (body) = 1;
2253 BLOCK_EXPR_BODY (block) = body;
2257 /* Expand an operation to extract from or store into a field.
2258 IS_STATIC is 1 iff the field is static.
2259 IS_PUTTING is 1 for putting into a field; 0 for getting from the field.
2260 FIELD_REF_INDEX is an index into the constant pool. */
2263 expand_java_field_op (int is_static, int is_putting, int field_ref_index)
2266 get_class_constant (current_jcf,
2267 COMPONENT_REF_CLASS_INDEX (¤t_jcf->cpool,
2269 const char *self_name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
2270 tree field_name = COMPONENT_REF_NAME (¤t_jcf->cpool, field_ref_index);
2271 tree field_signature = COMPONENT_REF_SIGNATURE (¤t_jcf->cpool,
2273 tree field_type = get_type_from_signature (field_signature);
2274 tree new_value = is_putting ? pop_value (field_type) : NULL_TREE;
2277 tree field_decl = lookup_field (&self_type, field_name);
2278 if (field_decl == error_mark_node)
2282 else if (field_decl == NULL_TREE)
2284 error ("missing field '%s' in '%s'",
2285 IDENTIFIER_POINTER (field_name), self_name);
2288 else if (build_java_signature (TREE_TYPE (field_decl)) != field_signature)
2290 error ("mismatching signature for field '%s' in '%s'",
2291 IDENTIFIER_POINTER (field_name), self_name);
2294 field_ref = is_static ? NULL_TREE : pop_value (self_type);
2298 push_value (convert (field_type, integer_zero_node));
2299 flush_quick_stack ();
2303 field_ref = build_field_ref (field_ref, self_type, field_name);
2305 field_ref = build_class_init (self_type, field_ref);
2308 flush_quick_stack ();
2309 if (FIELD_FINAL (field_decl))
2311 if (DECL_CONTEXT (field_decl) != current_class)
2312 error_with_decl (field_decl,
2313 "assignment to final field `%s' not in field's class");
2314 else if (FIELD_STATIC (field_decl))
2316 if (!DECL_CLINIT_P (current_function_decl))
2317 warning_with_decl (field_decl,
2318 "assignment to final static field `%s' not in class initializer");
2322 tree cfndecl_name = DECL_NAME (current_function_decl);
2323 if (! DECL_CONSTRUCTOR_P (current_function_decl)
2324 && !ID_FINIT_P (cfndecl_name))
2325 warning_with_decl (field_decl, "assignment to final field `%s' not in constructor");
2328 expand_assignment (field_ref, new_value, 0, 0);
2331 push_value (field_ref);
2335 load_type_state (tree label)
2338 tree vec = LABEL_TYPE_STATE (label);
2339 int cur_length = TREE_VEC_LENGTH (vec);
2340 stack_pointer = cur_length - DECL_MAX_LOCALS(current_function_decl);
2341 for (i = 0; i < cur_length; i++)
2342 type_map [i] = TREE_VEC_ELT (vec, i);
2345 /* Do the expansion of a Java switch. With Gcc, switches are front-end
2346 dependent things, but they rely on gcc routines. This function is
2347 placed here because it uses things defined locally in parse.y. */
2350 case_identity (tree t __attribute__ ((__unused__)), tree v)
2355 /* Return the name of the vtable for an array of a given primitive
2358 get_primitive_array_vtable (tree elt)
2361 if (elt == boolean_type_node)
2362 r = boolean_array_vtable;
2363 else if (elt == byte_type_node)
2364 r = byte_array_vtable;
2365 else if (elt == char_type_node)
2366 r = char_array_vtable;
2367 else if (elt == short_type_node)
2368 r = short_array_vtable;
2369 else if (elt == int_type_node)
2370 r = int_array_vtable;
2371 else if (elt == long_type_node)
2372 r = long_array_vtable;
2373 else if (elt == float_type_node)
2374 r = float_array_vtable;
2375 else if (elt == double_type_node)
2376 r = double_array_vtable;
2379 return build_address_of (r);
2383 java_expand_expr (tree exp, rtx target, enum machine_mode tmode,
2384 int modifier /* Actually an enum expand_modifier. */)
2388 switch (TREE_CODE (exp))
2390 case NEW_ARRAY_INIT:
2393 tree array_type = TREE_TYPE (TREE_TYPE (exp));
2394 tree element_type = TYPE_ARRAY_ELEMENT (array_type);
2395 tree data_fld = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type)));
2396 HOST_WIDE_INT ilength = java_array_type_length (array_type);
2397 tree length = build_int_2 (ilength, 0);
2398 tree init = TREE_OPERAND (exp, 0);
2401 /* See if we can generate the array statically. */
2402 if (TREE_CONSTANT (init) && TREE_STATIC (exp)
2403 && JPRIMITIVE_TYPE_P (element_type))
2405 tree temp, value, init_decl;
2407 START_RECORD_CONSTRUCTOR (temp, object_type_node);
2408 PUSH_FIELD_VALUE (temp, "vtable",
2409 get_primitive_array_vtable (element_type));
2410 if (! flag_hash_synchronization)
2411 PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
2412 FINISH_RECORD_CONSTRUCTOR (temp);
2413 START_RECORD_CONSTRUCTOR (value, array_type);
2414 PUSH_SUPER_VALUE (value, temp);
2415 PUSH_FIELD_VALUE (value, "length", length);
2416 PUSH_FIELD_VALUE (value, "data", init);
2417 FINISH_RECORD_CONSTRUCTOR (value);
2419 init_decl = build_decl (VAR_DECL, generate_name (), array_type);
2420 pushdecl_top_level (init_decl);
2421 TREE_STATIC (init_decl) = 1;
2422 DECL_INITIAL (init_decl) = value;
2423 DECL_IGNORED_P (init_decl) = 1;
2424 TREE_READONLY (init_decl) = 1;
2425 /* Hash synchronization requires at least 64-bit alignment. */
2426 if (flag_hash_synchronization && POINTER_SIZE < 64)
2427 DECL_ALIGN (init_decl) = 64;
2428 rest_of_decl_compilation (init_decl, NULL, 1, 0);
2429 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (init_decl)) = 1;
2430 init = build1 (ADDR_EXPR, TREE_TYPE (exp), init_decl);
2431 r = expand_expr (init, target, tmode, modifier);
2435 array_decl = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (exp));
2436 expand_decl (array_decl);
2437 tmp = expand_assignment (array_decl,
2438 build_new_array (element_type, length),
2440 if (TREE_CONSTANT (init)
2441 && ilength >= 10 && JPRIMITIVE_TYPE_P (element_type))
2444 init_decl = build_decl (VAR_DECL, generate_name (),
2446 pushdecl_top_level (init_decl);
2447 TREE_STATIC (init_decl) = 1;
2448 DECL_INITIAL (init_decl) = init;
2449 DECL_IGNORED_P (init_decl) = 1;
2450 TREE_READONLY (init_decl) = 1;
2451 rest_of_decl_compilation (init_decl, NULL, 1, 0);
2452 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (init_decl)) = 1;
2455 expand_assignment (build (COMPONENT_REF, TREE_TYPE (data_fld),
2456 build_java_indirect_ref (array_type,
2457 array_decl, flag_check_references),
2458 data_fld), init, 0, 0);
2462 if (BLOCK_EXPR_BODY (exp))
2466 tree body = BLOCK_EXPR_BODY (exp);
2467 /* Set to 1 or more when we found a static class
2468 initialization flag. */
2469 int found_class_initialization_flag = 0;
2471 pushlevel (2); /* 2 and above */
2472 expand_start_bindings (0);
2473 local = BLOCK_EXPR_DECLS (exp);
2476 tree next = TREE_CHAIN (local);
2477 found_class_initialization_flag +=
2478 LOCAL_CLASS_INITIALIZATION_FLAG_P (local);
2479 layout_decl (local, 0);
2480 expand_decl (pushdecl (local));
2484 /* Emit initialization code for test flags if we saw one. */
2485 if (! always_initialize_class_p
2486 && current_function_decl
2487 && found_class_initialization_flag)
2489 (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl),
2490 emit_init_test_initialization, NULL);
2492 /* Avoid deep recursion for long block. */
2493 while (TREE_CODE (body) == COMPOUND_EXPR)
2495 expand_expr (TREE_OPERAND (body, 0), const0_rtx, VOIDmode, 0);
2497 body = TREE_OPERAND (body, 1);
2499 last = expand_expr (body, NULL_RTX, VOIDmode, 0);
2501 expand_end_bindings (getdecls (), 1, 0);
2510 if (pushcase (TREE_OPERAND (exp, 0), case_identity,
2511 build_decl (LABEL_DECL, NULL_TREE, NULL_TREE),
2514 EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (exp);
2516 (wfl_operator, "Duplicate case label: `%s'",
2517 print_int_node (TREE_OPERAND (exp, 0)));
2523 pushcase (NULL_TREE, 0,
2524 build_decl (LABEL_DECL, NULL_TREE, NULL_TREE), NULL);
2528 expand_start_case (0, TREE_OPERAND (exp, 0), int_type_node, "switch");
2529 expand_expr_stmt (TREE_OPERAND (exp, 1));
2530 expand_end_case (TREE_OPERAND (exp, 0));
2534 /* We expand a try[-catch] block */
2536 /* Expand the try block */
2537 expand_eh_region_start ();
2538 expand_expr_stmt (TREE_OPERAND (exp, 0));
2539 expand_start_all_catch ();
2541 /* Expand all catch clauses (EH handlers) */
2542 for (current = TREE_OPERAND (exp, 1); current;
2543 current = TREE_CHAIN (current))
2545 tree catch = TREE_OPERAND (current, 0);
2546 tree decl = BLOCK_EXPR_DECLS (catch);
2547 tree type = (decl ? TREE_TYPE (TREE_TYPE (decl)) : NULL_TREE);
2549 expand_start_catch (type);
2550 expand_expr_stmt (TREE_OPERAND (current, 0));
2551 expand_end_catch ();
2553 expand_end_all_catch ();
2556 case JAVA_EXC_OBJ_EXPR:
2557 return expand_expr (build_exception_object_ref (TREE_TYPE (exp)),
2558 target, tmode, modifier);
2561 /* Used only by expanded inline functions. */
2562 expand_label (TREE_OPERAND (exp, 0));
2566 internal_error ("can't expand %s", tree_code_name [TREE_CODE (exp)]);
2570 /* Go over METHOD's bytecode and note instruction starts in
2571 instruction_bits[]. */
2574 note_instructions (JCF *jcf, tree method)
2577 unsigned char* byte_ops;
2578 long length = DECL_CODE_LENGTH (method);
2583 #undef RET /* Defined by config/i386/i386.h */
2585 #define BCODE byte_ops
2586 #define BYTE_type_node byte_type_node
2587 #define SHORT_type_node short_type_node
2588 #define INT_type_node int_type_node
2589 #define LONG_type_node long_type_node
2590 #define CHAR_type_node char_type_node
2591 #define PTR_type_node ptr_type_node
2592 #define FLOAT_type_node float_type_node
2593 #define DOUBLE_type_node double_type_node
2594 #define VOID_type_node void_type_node
2595 #define CONST_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
2596 #define CONST_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
2597 #define VAR_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
2598 #define VAR_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
2600 #define CHECK_PC_IN_RANGE(PC) ((void)1) /* Already handled by verifier. */
2602 JCF_SEEK (jcf, DECL_CODE_OFFSET (method));
2603 byte_ops = jcf->read_ptr;
2604 instruction_bits = xrealloc (instruction_bits, length + 1);
2605 memset (instruction_bits, 0, length + 1);
2607 /* This pass figures out which PC can be the targets of jumps. */
2608 for (PC = 0; PC < length;)
2610 int oldpc = PC; /* PC at instruction start. */
2611 instruction_bits [PC] |= BCODE_INSTRUCTION_START;
2612 switch (byte_ops[PC++])
2614 #define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
2616 PRE_##OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
2619 #define NOTE_LABEL(PC) note_label(oldpc, PC)
2621 #define PRE_PUSHC(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2622 #define PRE_LOAD(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2623 #define PRE_STORE(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2624 #define PRE_STACK(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2625 #define PRE_UNOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2626 #define PRE_BINOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2627 #define PRE_CONVERT(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2628 #define PRE_CONVERT2(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2630 #define PRE_SPECIAL(OPERAND_TYPE, INSTRUCTION) \
2631 PRE_SPECIAL_##INSTRUCTION(OPERAND_TYPE)
2632 #define PRE_SPECIAL_IINC(OPERAND_TYPE) \
2633 ((void) IMMEDIATE_u1, (void) IMMEDIATE_s1)
2634 #define PRE_SPECIAL_ENTER(IGNORE) /* nothing */
2635 #define PRE_SPECIAL_EXIT(IGNORE) /* nothing */
2636 #define PRE_SPECIAL_THROW(IGNORE) /* nothing */
2637 #define PRE_SPECIAL_BREAK(IGNORE) /* nothing */
2639 /* two forms of wide instructions */
2640 #define PRE_SPECIAL_WIDE(IGNORE) \
2642 int modified_opcode = IMMEDIATE_u1; \
2643 if (modified_opcode == OPCODE_iinc) \
2645 (void) IMMEDIATE_u2; /* indexbyte1 and indexbyte2 */ \
2646 (void) IMMEDIATE_s2; /* constbyte1 and constbyte2 */ \
2650 (void) IMMEDIATE_u2; /* indexbyte1 and indexbyte2 */ \
2654 #define PRE_IMPL(IGNORE1, IGNORE2) /* nothing */
2656 #define PRE_MONITOR(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2658 #define PRE_RETURN(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2659 #define PRE_ARRAY(OPERAND_TYPE, SUBOP) \
2660 PRE_ARRAY_##SUBOP(OPERAND_TYPE)
2661 #define PRE_ARRAY_LOAD(TYPE) /* nothing */
2662 #define PRE_ARRAY_STORE(TYPE) /* nothing */
2663 #define PRE_ARRAY_LENGTH(TYPE) /* nothing */
2664 #define PRE_ARRAY_NEW(TYPE) PRE_ARRAY_NEW_##TYPE
2665 #define PRE_ARRAY_NEW_NUM ((void) IMMEDIATE_u1)
2666 #define PRE_ARRAY_NEW_PTR ((void) IMMEDIATE_u2)
2667 #define PRE_ARRAY_NEW_MULTI ((void) IMMEDIATE_u2, (void) IMMEDIATE_u1)
2669 #define PRE_TEST(OPERAND_TYPE, OPERAND_VALUE) NOTE_LABEL (oldpc+IMMEDIATE_s2)
2670 #define PRE_COND(OPERAND_TYPE, OPERAND_VALUE) NOTE_LABEL (oldpc+IMMEDIATE_s2)
2671 #define PRE_BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
2672 saw_index = 0; INT_temp = (OPERAND_VALUE); \
2673 if (!saw_index) NOTE_LABEL(oldpc + INT_temp);
2674 #define PRE_JSR(OPERAND_TYPE, OPERAND_VALUE) \
2675 saw_index = 0; INT_temp = (OPERAND_VALUE); \
2677 if (!saw_index) NOTE_LABEL(oldpc + INT_temp);
2679 #define PRE_RET(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE)
2681 #define PRE_SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
2682 PC = (PC + 3) / 4 * 4; PRE_##TABLE_OR_LOOKUP##_SWITCH
2684 #define PRE_LOOKUP_SWITCH \
2685 { jint default_offset = IMMEDIATE_s4; jint npairs = IMMEDIATE_s4; \
2686 NOTE_LABEL (default_offset+oldpc); \
2688 while (--npairs >= 0) { \
2689 jint match ATTRIBUTE_UNUSED = IMMEDIATE_s4; \
2690 jint offset = IMMEDIATE_s4; \
2691 NOTE_LABEL (offset+oldpc); } \
2694 #define PRE_TABLE_SWITCH \
2695 { jint default_offset = IMMEDIATE_s4; \
2696 jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
2697 NOTE_LABEL (default_offset+oldpc); \
2699 while (low++ <= high) { \
2700 jint offset = IMMEDIATE_s4; \
2701 NOTE_LABEL (offset+oldpc); } \
2704 #define PRE_FIELD(MAYBE_STATIC, PUT_OR_GET) (void)(IMMEDIATE_u2);
2705 #define PRE_OBJECT(MAYBE_STATIC, PUT_OR_GET) (void)(IMMEDIATE_u2);
2706 #define PRE_INVOKE(MAYBE_STATIC, IS_INTERFACE) \
2707 (void)(IMMEDIATE_u2); \
2708 PC += 2 * IS_INTERFACE /* for invokeinterface */;
2710 #include "javaop.def"
2717 expand_byte_code (JCF *jcf, tree method)
2721 const unsigned char *linenumber_pointer;
2722 int dead_code_index = -1;
2723 unsigned char* byte_ops;
2724 long length = DECL_CODE_LENGTH (method);
2727 JCF_SEEK (jcf, DECL_CODE_OFFSET (method));
2728 byte_ops = jcf->read_ptr;
2730 /* We make an initial pass of the line number table, to note
2731 which instructions have associated line number entries. */
2732 linenumber_pointer = linenumber_table;
2733 for (i = 0; i < linenumber_count; i++)
2735 int pc = GET_u2 (linenumber_pointer);
2736 linenumber_pointer += 4;
2738 warning ("invalid PC in line number table");
2741 if ((instruction_bits[pc] & BCODE_HAS_LINENUMBER) != 0)
2742 instruction_bits[pc] |= BCODE_HAS_MULTI_LINENUMBERS;
2743 instruction_bits[pc] |= BCODE_HAS_LINENUMBER;
2747 if (! verify_jvm_instructions (jcf, byte_ops, length))
2750 /* Translate bytecodes to rtl instructions. */
2751 linenumber_pointer = linenumber_table;
2752 for (PC = 0; PC < length;)
2754 if ((instruction_bits [PC] & BCODE_TARGET) != 0 || PC == 0)
2756 tree label = lookup_label (PC);
2757 flush_quick_stack ();
2758 if ((instruction_bits [PC] & BCODE_TARGET) != 0)
2759 expand_label (label);
2760 if (LABEL_VERIFIED (label) || PC == 0)
2761 load_type_state (label);
2764 if (! (instruction_bits [PC] & BCODE_VERIFIED))
2766 if (dead_code_index == -1)
2768 /* This is the start of a region of unreachable bytecodes.
2769 They still need to be processed in order for EH ranges
2770 to get handled correctly. However, we can simply
2771 replace these bytecodes with nops. */
2772 dead_code_index = PC;
2775 /* Turn this bytecode into a nop. */
2780 if (dead_code_index != -1)
2782 /* We've just reached the end of a region of dead code. */
2783 warning ("unreachable bytecode from %d to before %d",
2784 dead_code_index, PC);
2785 dead_code_index = -1;
2789 /* Handle possible line number entry for this PC.
2791 This code handles out-of-order and multiple linenumbers per PC,
2792 but is optimized for the case of line numbers increasing
2793 monotonically with PC. */
2794 if ((instruction_bits[PC] & BCODE_HAS_LINENUMBER) != 0)
2796 if ((instruction_bits[PC] & BCODE_HAS_MULTI_LINENUMBERS) != 0
2797 || GET_u2 (linenumber_pointer) != PC)
2798 linenumber_pointer = linenumber_table;
2799 while (linenumber_pointer < linenumber_table + linenumber_count * 4)
2801 int pc = GET_u2 (linenumber_pointer);
2802 linenumber_pointer += 4;
2805 lineno = GET_u2 (linenumber_pointer - 2);
2806 emit_line_note (input_filename, lineno);
2807 if (!(instruction_bits[PC] & BCODE_HAS_MULTI_LINENUMBERS))
2812 maybe_pushlevels (PC);
2813 PC = process_jvm_instruction (PC, byte_ops, length);
2814 maybe_poplevels (PC);
2817 if (dead_code_index != -1)
2819 /* We've just reached the end of a region of dead code. */
2820 warning ("unreachable bytecode from %d to the end of the method",
2826 java_push_constant_from_pool (JCF *jcf, int index)
2829 if (JPOOL_TAG (jcf, index) == CONSTANT_String)
2832 name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index));
2833 index = alloc_name_constant (CONSTANT_String, name);
2834 c = build_ref_from_constant_pool (index);
2835 TREE_TYPE (c) = promote_type (string_type_node);
2838 c = get_constant (jcf, index);
2843 process_jvm_instruction (int PC, const unsigned char* byte_ops,
2844 long length ATTRIBUTE_UNUSED)
2846 const char *opname; /* Temporary ??? */
2847 int oldpc = PC; /* PC at instruction start. */
2849 /* If the instruction is at the beginning of a exception handler,
2850 replace the top of the stack with the thrown object reference */
2851 if (instruction_bits [PC] & BCODE_EXCEPTION_TARGET)
2853 tree type = pop_type (ptr_type_node);
2854 push_value (build (JAVA_EXC_OBJ_EXPR, type));
2857 switch (byte_ops[PC++])
2859 #define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
2862 OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
2865 #define RET(OPERAND_TYPE, OPERAND_VALUE) \
2867 int saw_index = 0; \
2868 int index = OPERAND_VALUE; \
2869 build_java_ret (find_local_variable (index, ptr_type_node, oldpc)); \
2872 #define JSR(OPERAND_TYPE, OPERAND_VALUE) \
2874 /* OPERAND_VALUE may have side-effects on PC */ \
2875 int opvalue = OPERAND_VALUE; \
2876 build_java_jsr (oldpc + opvalue, PC); \
2879 /* Push a constant onto the stack. */
2880 #define PUSHC(OPERAND_TYPE, OPERAND_VALUE) \
2881 { int saw_index = 0; int ival = (OPERAND_VALUE); \
2882 if (saw_index) java_push_constant_from_pool (current_jcf, ival); \
2883 else expand_java_pushc (ival, OPERAND_TYPE##_type_node); }
2885 /* internal macro added for use by the WIDE case */
2886 #define LOAD_INTERNAL(OPTYPE, OPVALUE) \
2887 expand_load_internal (OPVALUE, type_map[OPVALUE], oldpc);
2889 /* Push local variable onto the opcode stack. */
2890 #define LOAD(OPERAND_TYPE, OPERAND_VALUE) \
2892 /* have to do this since OPERAND_VALUE may have side-effects */ \
2893 int opvalue = OPERAND_VALUE; \
2894 LOAD_INTERNAL(OPERAND_TYPE##_type_node, opvalue); \
2897 #define RETURN(OPERAND_TYPE, OPERAND_VALUE) \
2898 expand_java_return (OPERAND_TYPE##_type_node)
2900 #define REM_EXPR TRUNC_MOD_EXPR
2901 #define BINOP(OPERAND_TYPE, OPERAND_VALUE) \
2902 expand_java_binop (OPERAND_TYPE##_type_node, OPERAND_VALUE##_EXPR)
2904 #define FIELD(IS_STATIC, IS_PUT) \
2905 expand_java_field_op (IS_STATIC, IS_PUT, IMMEDIATE_u2)
2907 #define TEST(OPERAND_TYPE, CONDITION) \
2908 expand_test (CONDITION##_EXPR, OPERAND_TYPE##_type_node, oldpc+IMMEDIATE_s2)
2910 #define COND(OPERAND_TYPE, CONDITION) \
2911 expand_cond (CONDITION##_EXPR, OPERAND_TYPE##_type_node, oldpc+IMMEDIATE_s2)
2913 #define BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
2914 BRANCH_##OPERAND_TYPE (OPERAND_VALUE)
2916 #define BRANCH_GOTO(OPERAND_VALUE) \
2917 expand_java_goto (oldpc + OPERAND_VALUE)
2919 #define BRANCH_CALL(OPERAND_VALUE) \
2920 expand_java_call (oldpc + OPERAND_VALUE, oldpc)
2923 #define BRANCH_RETURN(OPERAND_VALUE) \
2925 tree type = OPERAND_TYPE##_type_node; \
2926 tree value = find_local_variable (OPERAND_VALUE, type, oldpc); \
2927 expand_java_ret (value); \
2931 #define NOT_IMPL(OPERAND_TYPE, OPERAND_VALUE) \
2932 fprintf (stderr, "%3d: %s ", oldpc, opname); \
2933 fprintf (stderr, "(not implemented)\n")
2934 #define NOT_IMPL1(OPERAND_VALUE) \
2935 fprintf (stderr, "%3d: %s ", oldpc, opname); \
2936 fprintf (stderr, "(not implemented)\n")
2938 #define BRANCH_RETURN(OPERAND_VALUE) NOT_IMPL1(OPERAND_VALUE)
2940 #define STACK(SUBOP, COUNT) STACK_##SUBOP (COUNT)
2942 #define STACK_POP(COUNT) java_stack_pop (COUNT)
2944 #define STACK_SWAP(COUNT) java_stack_swap()
2946 #define STACK_DUP(COUNT) java_stack_dup (COUNT, 0)
2947 #define STACK_DUPx1(COUNT) java_stack_dup (COUNT, 1)
2948 #define STACK_DUPx2(COUNT) java_stack_dup (COUNT, 2)
2950 #define SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
2951 PC = (PC + 3) / 4 * 4; TABLE_OR_LOOKUP##_SWITCH
2953 #define LOOKUP_SWITCH \
2954 { jint default_offset = IMMEDIATE_s4; jint npairs = IMMEDIATE_s4; \
2955 tree selector = pop_value (INT_type_node); \
2956 tree duplicate, label; \
2957 tree type = TREE_TYPE (selector); \
2958 flush_quick_stack (); \
2959 expand_start_case (0, selector, type, "switch statement");\
2960 while (--npairs >= 0) \
2962 jint match = IMMEDIATE_s4; jint offset = IMMEDIATE_s4; \
2963 tree value = build_int_2 (match, match < 0 ? -1 : 0); \
2964 TREE_TYPE (value) = type; \
2965 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2966 pushcase (value, convert, label, &duplicate); \
2967 expand_java_goto (oldpc + offset); \
2969 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2970 pushcase (NULL_TREE, 0, label, &duplicate); \
2971 expand_java_goto (oldpc + default_offset); \
2972 expand_end_case (selector); \
2975 #define TABLE_SWITCH \
2976 { jint default_offset = IMMEDIATE_s4; \
2977 jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
2978 tree selector = pop_value (INT_type_node); \
2979 tree duplicate, label; \
2980 tree type = TREE_TYPE (selector); \
2981 flush_quick_stack (); \
2982 expand_start_case (0, selector, type, "switch statement");\
2983 for (; low <= high; low++) \
2985 jint offset = IMMEDIATE_s4; \
2986 tree value = build_int_2 (low, low < 0 ? -1 : 0); \
2987 TREE_TYPE (value) = type; \
2988 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2989 pushcase (value, convert, label, &duplicate); \
2990 expand_java_goto (oldpc + offset); \
2992 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2993 pushcase (NULL_TREE, 0, label, &duplicate); \
2994 expand_java_goto (oldpc + default_offset); \
2995 expand_end_case (selector); \
2998 #define INVOKE(MAYBE_STATIC, IS_INTERFACE) \
2999 { int opcode = byte_ops[PC-1]; \
3000 int method_ref_index = IMMEDIATE_u2; \
3002 if (IS_INTERFACE) { nargs = IMMEDIATE_u1; (void) IMMEDIATE_u1; } \
3004 expand_invoke (opcode, method_ref_index, nargs); \
3007 /* Handle new, checkcast, instanceof */
3008 #define OBJECT(TYPE, OP) \
3009 expand_java_##OP (get_class_constant (current_jcf, IMMEDIATE_u2))
3011 #define ARRAY(OPERAND_TYPE, SUBOP) ARRAY_##SUBOP(OPERAND_TYPE)
3013 #define ARRAY_LOAD(OPERAND_TYPE) \
3015 expand_java_arrayload( OPERAND_TYPE##_type_node ); \
3018 #define ARRAY_STORE(OPERAND_TYPE) \
3020 expand_java_arraystore( OPERAND_TYPE##_type_node ); \
3023 #define ARRAY_LENGTH(OPERAND_TYPE) expand_java_array_length();
3024 #define ARRAY_NEW(OPERAND_TYPE) ARRAY_NEW_##OPERAND_TYPE()
3025 #define ARRAY_NEW_PTR() \
3026 push_value (build_anewarray (get_class_constant (current_jcf, \
3028 pop_value (int_type_node)));
3029 #define ARRAY_NEW_NUM() \
3031 int atype = IMMEDIATE_u1; \
3032 push_value (build_newarray (atype, pop_value (int_type_node)));\
3034 #define ARRAY_NEW_MULTI() \
3036 tree class = get_class_constant (current_jcf, IMMEDIATE_u2 ); \
3037 int ndims = IMMEDIATE_u1; \
3038 expand_java_multianewarray( class, ndims ); \
3041 #define UNOP(OPERAND_TYPE, OPERAND_VALUE) \
3042 push_value (fold (build1 (NEGATE_EXPR, OPERAND_TYPE##_type_node, \
3043 pop_value (OPERAND_TYPE##_type_node))));
3045 #define CONVERT2(FROM_TYPE, TO_TYPE) \
3047 push_value (build1 (NOP_EXPR, int_type_node, \
3048 (convert (TO_TYPE##_type_node, \
3049 pop_value (FROM_TYPE##_type_node))))); \
3052 #define CONVERT(FROM_TYPE, TO_TYPE) \
3054 push_value (convert (TO_TYPE##_type_node, \
3055 pop_value (FROM_TYPE##_type_node))); \
3058 /* internal macro added for use by the WIDE case
3059 Added TREE_TYPE (decl) assignment, apbianco */
3060 #define STORE_INTERNAL(OPTYPE, OPVALUE) \
3063 int var = OPVALUE; \
3064 tree type = OPTYPE; \
3065 value = pop_value (type); \
3066 type = TREE_TYPE (value); \
3067 decl = find_local_variable (var, type, oldpc); \
3068 set_local_type (var, type ); \
3069 expand_assignment (decl, value, 0, 0); \
3072 #define STORE(OPERAND_TYPE, OPERAND_VALUE) \
3074 /* have to do this since OPERAND_VALUE may have side-effects */ \
3075 int opvalue = OPERAND_VALUE; \
3076 STORE_INTERNAL(OPERAND_TYPE##_type_node, opvalue); \
3079 #define SPECIAL(OPERAND_TYPE, INSTRUCTION) \
3080 SPECIAL_##INSTRUCTION(OPERAND_TYPE)
3082 #define SPECIAL_ENTER(IGNORED) MONITOR_OPERATION (soft_monitorenter_node)
3083 #define SPECIAL_EXIT(IGNORED) MONITOR_OPERATION (soft_monitorexit_node)
3085 #define MONITOR_OPERATION(call) \
3087 tree o = pop_value (ptr_type_node); \
3089 flush_quick_stack (); \
3090 c = build_java_monitor (call, o); \
3091 TREE_SIDE_EFFECTS (c) = 1; \
3092 expand_expr_stmt (c); \
3095 #define SPECIAL_IINC(IGNORED) \
3097 unsigned int local_var_index = IMMEDIATE_u1; \
3098 int ival = IMMEDIATE_s1; \
3099 expand_iinc(local_var_index, ival, oldpc); \
3102 #define SPECIAL_WIDE(IGNORED) \
3104 int modified_opcode = IMMEDIATE_u1; \
3105 unsigned int local_var_index = IMMEDIATE_u2; \
3106 switch (modified_opcode) \
3110 int ival = IMMEDIATE_s2; \
3111 expand_iinc (local_var_index, ival, oldpc); \
3114 case OPCODE_iload: \
3115 case OPCODE_lload: \
3116 case OPCODE_fload: \
3117 case OPCODE_dload: \
3118 case OPCODE_aload: \
3120 /* duplicate code from LOAD macro */ \
3121 LOAD_INTERNAL(operand_type[modified_opcode], local_var_index); \
3124 case OPCODE_istore: \
3125 case OPCODE_lstore: \
3126 case OPCODE_fstore: \
3127 case OPCODE_dstore: \
3128 case OPCODE_astore: \
3130 STORE_INTERNAL(operand_type[modified_opcode], local_var_index); \
3134 error ("unrecogized wide sub-instruction"); \
3138 #define SPECIAL_THROW(IGNORED) \
3139 build_java_athrow (pop_value (throwable_type_node))
3141 #define SPECIAL_BREAK NOT_IMPL1
3142 #define IMPL NOT_IMPL
3144 #include "javaop.def"
3147 fprintf (stderr, "%3d: unknown(%3d)\n", oldpc, byte_ops[PC]);
3152 /* Return the opcode at PC in the code section pointed to by
3155 static unsigned char
3156 peek_opcode_at_pc (JCF *jcf, int code_offset, int pc)
3158 unsigned char opcode;
3159 long absolute_offset = (long)JCF_TELL (jcf);
3161 JCF_SEEK (jcf, code_offset);
3162 opcode = jcf->read_ptr [pc];
3163 JCF_SEEK (jcf, absolute_offset);
3167 /* Some bytecode compilers are emitting accurate LocalVariableTable
3168 attributes. Here's an example:
3173 Attribute "LocalVariableTable"
3174 slot #<n>: ... (PC: PC+1 length: L)
3176 This is accurate because the local in slot <n> really exists after
3177 the opcode at PC is executed, hence from PC+1 to PC+1+L.
3179 This procedure recognizes this situation and extends the live range
3180 of the local in SLOT to START_PC-1 or START_PC-2 (depending on the
3181 length of the store instruction.)
3183 This function is used by `give_name_to_locals' so that a local's
3184 DECL features a DECL_LOCAL_START_PC such that the first related
3185 store operation will use DECL as a destination, not a unrelated
3186 temporary created for the occasion.
3188 This function uses a global (instruction_bits) `note_instructions' should
3189 have allocated and filled properly. */
3192 maybe_adjust_start_pc (struct JCF *jcf, int code_offset,
3193 int start_pc, int slot)
3195 int first, index, opcode;
3204 /* Find last previous instruction and remember it */
3205 for (pc = start_pc-1; pc; pc--)
3206 if (instruction_bits [pc] & BCODE_INSTRUCTION_START)
3210 /* Retrieve the instruction, handle `wide'. */
3211 opcode = (int) peek_opcode_at_pc (jcf, code_offset, pc++);
3212 if (opcode == OPCODE_wide)
3215 opcode = (int) peek_opcode_at_pc (jcf, code_offset, pc++);
3220 case OPCODE_astore_0:
3221 case OPCODE_astore_1:
3222 case OPCODE_astore_2:
3223 case OPCODE_astore_3:
3224 first = OPCODE_astore_0;
3227 case OPCODE_istore_0:
3228 case OPCODE_istore_1:
3229 case OPCODE_istore_2:
3230 case OPCODE_istore_3:
3231 first = OPCODE_istore_0;
3234 case OPCODE_lstore_0:
3235 case OPCODE_lstore_1:
3236 case OPCODE_lstore_2:
3237 case OPCODE_lstore_3:
3238 first = OPCODE_lstore_0;
3241 case OPCODE_fstore_0:
3242 case OPCODE_fstore_1:
3243 case OPCODE_fstore_2:
3244 case OPCODE_fstore_3:
3245 first = OPCODE_fstore_0;
3248 case OPCODE_dstore_0:
3249 case OPCODE_dstore_1:
3250 case OPCODE_dstore_2:
3251 case OPCODE_dstore_3:
3252 first = OPCODE_dstore_0;
3260 index = peek_opcode_at_pc (jcf, code_offset, pc);
3263 int other = peek_opcode_at_pc (jcf, code_offset, ++pc);
3264 index = (other << 8) + index;
3269 /* Now we decide: first >0 means we have a <t>store_<n>, index >0
3270 means we have a <t>store. */
3271 if ((first > 0 && opcode - first == slot) || (index > 0 && index == slot))
3277 /* Force the (direct) sub-operands of NODE to be evaluated in left-to-right
3278 order, as specified by Java Language Specification.
3280 The problem is that while expand_expr will evaluate its sub-operands in
3281 left-to-right order, for variables it will just return an rtx (i.e.
3282 an lvalue) for the variable (rather than an rvalue). So it is possible
3283 that a later sub-operand will change the register, and when the
3284 actual operation is done, it will use the new value, when it should
3285 have used the original value.
3287 We fix this by using save_expr. This forces the sub-operand to be
3288 copied into a fresh virtual register,
3290 For method invocation, we modify the arguments so that a
3291 left-to-right order evaluation is performed. Saved expressions
3292 will, in CALL_EXPR order, be reused when the call will be expanded.
3296 force_evaluation_order (tree node)
3298 if (flag_syntax_only)
3300 if (TREE_CODE_CLASS (TREE_CODE (node)) == '2')
3302 if (TREE_SIDE_EFFECTS (TREE_OPERAND (node, 1)))
3303 TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
3305 else if (TREE_CODE (node) == CALL_EXPR
3306 || TREE_CODE (node) == NEW_CLASS_EXPR
3307 || (TREE_CODE (node) == COMPOUND_EXPR
3308 && TREE_CODE (TREE_OPERAND (node, 0)) == CALL_EXPR
3309 && TREE_CODE (TREE_OPERAND (node, 1)) == SAVE_EXPR))
3313 if (!TREE_OPERAND (node, 1))
3318 /* Position arg properly, account for wrapped around ctors. */
3319 if (TREE_CODE (node) == COMPOUND_EXPR)
3320 arg = TREE_OPERAND (node, 0);
3322 arg = TREE_OPERAND (arg, 1);
3324 /* Not having a list of argument here is an error. */
3325 if (TREE_CODE (arg) != TREE_LIST)
3328 /* This reverses the evaluation order. This is a desired effect. */
3329 for (cmp = NULL_TREE; arg; arg = TREE_CHAIN (arg))
3331 tree saved = save_expr (force_evaluation_order (TREE_VALUE (arg)));
3332 cmp = (cmp == NULL_TREE ? saved :
3333 build (COMPOUND_EXPR, void_type_node, cmp, saved));
3334 TREE_VALUE (arg) = saved;
3337 if (cmp && TREE_CODE (cmp) == COMPOUND_EXPR)
3338 TREE_SIDE_EFFECTS (cmp) = 1;
3342 cmp = save_expr (build (COMPOUND_EXPR, TREE_TYPE (node), cmp, node));
3343 CAN_COMPLETE_NORMALLY (cmp) = CAN_COMPLETE_NORMALLY (node);
3344 TREE_SIDE_EFFECTS (cmp) = 1;
3351 /* Called for every element in DECL_FUNCTION_INIT_TEST_TABLE of a
3352 method in order to emit initialization code for each test flag. */
3355 emit_init_test_initialization (void **entry, void *x ATTRIBUTE_UNUSED)
3357 struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
3358 tree klass = build_class_ref (ite->key);
3361 /* If the DECL_INITIAL of the test flag is set to true, it
3362 means that the class is already initialized the time it
3364 if (DECL_INITIAL (ite->value) == boolean_true_node)
3365 rhs = boolean_true_node;
3366 /* Otherwise, we initialize the class init check variable by looking
3367 at the `state' field of the class to see if it is already
3368 initialized. This makes things a bit faster if the class is
3369 already initialized, which should be the common case. */
3371 rhs = build (GE_EXPR, boolean_type_node,
3372 build (COMPONENT_REF, byte_type_node,
3373 build1 (INDIRECT_REF, class_type_node, klass),
3374 lookup_field (&class_type_node,
3375 get_identifier ("state"))),
3376 build_int_2 (JV_STATE_DONE, 0));
3378 expand_expr_stmt (build (MODIFY_EXPR, boolean_type_node,
3383 #include "gt-java-expr.h"