OSDN Git Service

2006-06-08 Andrew Haley <aph@redhat.com>
[pf3gnuchains/gcc-fork.git] / gcc / java / expr.c
1 /* Process expressions for the GNU compiler for the Java(TM) language.
2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3    Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
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)
10 any later version.
11
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.
16
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, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA.  
21
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.  */
25
26 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
27
28 #include "config.h"
29 #include "system.h"
30 #include "coretypes.h"
31 #include "tm.h"
32 #include "tree.h"
33 #include "real.h"
34 #include "rtl.h"
35 #include "flags.h"
36 #include "expr.h"
37 #include "java-tree.h"
38 #include "javaop.h"
39 #include "java-opcodes.h"
40 #include "jcf.h"
41 #include "java-except.h"
42 #include "parse.h"
43 #include "toplev.h"
44 #include "except.h"
45 #include "ggc.h"
46 #include "tree-gimple.h"
47 #include "target.h"
48
49 static void flush_quick_stack (void);
50 static void push_value (tree);
51 static tree pop_value (tree);
52 static void java_stack_swap (void);
53 static void java_stack_dup (int, int);
54 static void build_java_athrow (tree);
55 static void build_java_jsr (int, int);
56 static void build_java_ret (tree);
57 static void expand_java_multianewarray (tree, int);
58 static void expand_java_arraystore (tree);
59 static void expand_java_arrayload (tree);
60 static void expand_java_array_length (void);
61 static tree build_java_monitor (tree, tree);
62 static void expand_java_pushc (int, tree);
63 static void expand_java_return (tree);
64 static void expand_load_internal (int, tree, int);
65 static void expand_java_NEW (tree);
66 static void expand_java_INSTANCEOF (tree);
67 static void expand_java_CHECKCAST (tree);
68 static void expand_iinc (unsigned int, int, int);
69 static void expand_java_binop (tree, enum tree_code);
70 static void note_label (int, int);
71 static void expand_compare (enum tree_code, tree, tree, int);
72 static void expand_test (enum tree_code, tree, int);
73 static void expand_cond (enum tree_code, tree, int);
74 static void expand_java_goto (int);
75 static tree expand_java_switch (tree, int);
76 static void expand_java_add_case (tree, int, int);
77 #if 0
78 static void expand_java_call (int, int);
79 static void expand_java_ret (tree); 
80 #endif
81 static tree pop_arguments (tree); 
82 static void expand_invoke (int, int, int); 
83 static void expand_java_field_op (int, int, int); 
84 static void java_push_constant_from_pool (struct JCF *, int); 
85 static void java_stack_pop (int); 
86 static tree build_java_throw_out_of_bounds_exception (tree); 
87 static tree build_java_check_indexed_type (tree, tree); 
88 static unsigned char peek_opcode_at_pc (struct JCF *, int, int);
89 static void promote_arguments (void);
90
91 static GTY(()) tree operand_type[59];
92
93 static GTY(()) tree methods_ident;
94 static GTY(()) tree ncode_ident;
95 tree dtable_ident = NULL_TREE;
96
97 /* Set to nonzero value in order to emit class initialization code
98    before static field references.  */
99 int always_initialize_class_p = 0;
100
101 /* We store the stack state in two places:
102    Within a basic block, we use the quick_stack, which is a
103    pushdown list (TREE_LISTs) of expression nodes.
104    This is the top part of the stack;  below that we use find_stack_slot.
105    At the end of a basic block, the quick_stack must be flushed
106    to the stack slot array (as handled by find_stack_slot).
107    Using quick_stack generates better code (especially when
108    compiled without optimization), because we do not have to
109    explicitly store and load trees to temporary variables.
110
111    If a variable is on the quick stack, it means the value of variable
112    when the quick stack was last flushed.  Conceptually, flush_quick_stack
113    saves all the quick_stack elements in parallel.  However, that is
114    complicated, so it actually saves them (i.e. copies each stack value
115    to is home virtual register) from low indexes.  This allows a quick_stack
116    element at index i (counting from the bottom of stack the) to references
117    slot virtuals for register that are >= i, but not those that are deeper.
118    This convention makes most operations easier.  For example iadd works
119    even when the stack contains (reg[0], reg[1]):  It results in the
120    stack containing (reg[0]+reg[1]), which is OK.  However, some stack
121    operations are more complicated.  For example dup given a stack
122    containing (reg[0]) would yield (reg[0], reg[0]), which would violate
123    the convention, since stack value 1 would refer to a register with
124    lower index (reg[0]), which flush_quick_stack does not safely handle.
125    So dup cannot just add an extra element to the quick_stack, but iadd can.
126 */
127
128 static GTY(()) tree quick_stack;
129
130 /* A free-list of unused permanent TREE_LIST nodes.  */
131 static GTY((deletable)) tree tree_list_free_list;
132
133 /* The physical memory page size used in this computer.  See
134    build_field_ref().  */
135 static GTY(()) tree page_size;
136
137 /* The stack pointer of the Java virtual machine.
138    This does include the size of the quick_stack. */
139
140 int stack_pointer;
141
142 const unsigned char *linenumber_table;
143 int linenumber_count;
144
145 /* Largest pc so far in this method that has been passed to lookup_label. */
146 int highest_label_pc_this_method = -1;
147
148 /* Base value for this method to add to pc to get generated label. */
149 int start_label_pc_this_method = 0;
150
151 void
152 init_expr_processing (void)
153 {
154   operand_type[21] = operand_type[54] = int_type_node;
155   operand_type[22] = operand_type[55] = long_type_node;
156   operand_type[23] = operand_type[56] = float_type_node;
157   operand_type[24] = operand_type[57] = double_type_node;
158   operand_type[25] = operand_type[58] = ptr_type_node;
159 }
160
161 tree
162 java_truthvalue_conversion (tree expr)
163 {
164   /* It is simpler and generates better code to have only TRUTH_*_EXPR
165      or comparison expressions as truth values at this level.
166
167      This function should normally be identity for Java.  */
168
169   switch (TREE_CODE (expr))
170     {
171     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
172     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
173     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
174     case ORDERED_EXPR: case UNORDERED_EXPR:
175     case TRUTH_ANDIF_EXPR:
176     case TRUTH_ORIF_EXPR:
177     case TRUTH_AND_EXPR:
178     case TRUTH_OR_EXPR:
179     case TRUTH_XOR_EXPR:
180     case TRUTH_NOT_EXPR:
181     case ERROR_MARK:
182       return expr;
183
184     case INTEGER_CST:
185       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
186
187     case REAL_CST:
188       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
189
190     /* are these legal? XXX JH */
191     case NEGATE_EXPR:
192     case ABS_EXPR:
193     case FLOAT_EXPR:
194       /* These don't change whether an object is nonzero or zero.  */
195       return java_truthvalue_conversion (TREE_OPERAND (expr, 0));
196
197     case COND_EXPR:
198       /* Distribute the conversion into the arms of a COND_EXPR.  */
199       return fold_build3 (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
200                           java_truthvalue_conversion (TREE_OPERAND (expr, 1)),
201                           java_truthvalue_conversion (TREE_OPERAND (expr, 2)));
202
203     case NOP_EXPR:
204       /* If this is widening the argument, we can ignore it.  */
205       if (TYPE_PRECISION (TREE_TYPE (expr))
206           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
207         return java_truthvalue_conversion (TREE_OPERAND (expr, 0));
208       /* fall through to default */
209
210     default:
211       return fold_build2 (NE_EXPR, boolean_type_node,
212                           expr, boolean_false_node);
213     }
214 }
215
216 /* Save any stack slots that happen to be in the quick_stack into their
217    home virtual register slots.
218
219    The copy order is from low stack index to high, to support the invariant
220    that the expression for a slot may contain decls for stack slots with
221    higher (or the same) index, but not lower. */
222
223 static void
224 flush_quick_stack (void)
225 {
226   int stack_index = stack_pointer;
227   tree prev, cur, next;
228
229   /* First reverse the quick_stack, and count the number of slots it has. */
230   for (cur = quick_stack, prev = NULL_TREE; cur != NULL_TREE; cur = next)
231     {
232       next = TREE_CHAIN (cur);
233       TREE_CHAIN (cur) = prev;
234       prev = cur;
235       stack_index -= 1 + TYPE_IS_WIDE (TREE_TYPE (TREE_VALUE (cur)));
236     }
237   quick_stack = prev;
238
239   while (quick_stack != NULL_TREE)
240     {
241       tree decl;
242       tree node = quick_stack, type;
243       quick_stack = TREE_CHAIN (node);
244       TREE_CHAIN (node) = tree_list_free_list;
245       tree_list_free_list = node;
246       node = TREE_VALUE (node);
247       type = TREE_TYPE (node);
248
249       decl = find_stack_slot (stack_index, type);
250       if (decl != node)
251         java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (node), decl, node));
252       stack_index += 1 + TYPE_IS_WIDE (type);
253     }
254 }
255
256 /* Push TYPE on the type stack.
257    Return true on success, 0 on overflow. */
258
259 int
260 push_type_0 (tree type)
261 {
262   int n_words;
263   type = promote_type (type);
264   n_words = 1 + TYPE_IS_WIDE (type);
265   if (stack_pointer + n_words > DECL_MAX_STACK (current_function_decl))
266     return 0;
267   /* Allocate decl for this variable now, so we get a temporary that
268      survives the whole method. */
269   find_stack_slot (stack_pointer, type);
270   stack_type_map[stack_pointer++] = type;
271   n_words--;
272   while (--n_words >= 0)
273     stack_type_map[stack_pointer++] = TYPE_SECOND;
274   return 1;
275 }
276
277 void
278 push_type (tree type)
279 {
280   int r = push_type_0 (type);
281   gcc_assert (r);
282 }
283
284 static void
285 push_value (tree value)
286 {
287   tree type = TREE_TYPE (value);
288   if (TYPE_PRECISION (type) < 32 && INTEGRAL_TYPE_P (type))
289     {
290       type = promote_type (type);
291       value = convert (type, value);
292     }
293   push_type (type);
294   if (tree_list_free_list == NULL_TREE)
295     quick_stack = tree_cons (NULL_TREE, value, quick_stack);
296   else
297     {
298       tree node = tree_list_free_list;
299       tree_list_free_list = TREE_CHAIN (tree_list_free_list);
300       TREE_VALUE (node) = value;
301       TREE_CHAIN (node) = quick_stack;
302       quick_stack = node;
303     }
304 }
305
306 /* Pop a type from the type stack.
307    TYPE is the expected type.   Return the actual type, which must be
308    convertible to TYPE.
309    On an error, *MESSAGEP is set to a freshly malloc'd error message. */
310
311 tree
312 pop_type_0 (tree type, char **messagep)
313 {
314   int n_words;
315   tree t;
316   *messagep = NULL;
317   if (TREE_CODE (type) == RECORD_TYPE)
318     type = promote_type (type);
319   n_words = 1 + TYPE_IS_WIDE (type);
320   if (stack_pointer < n_words)
321     {
322       *messagep = xstrdup ("stack underflow");
323       return type;
324     }
325   while (--n_words > 0)
326     {
327       if (stack_type_map[--stack_pointer] != void_type_node)
328         {
329           *messagep = xstrdup ("Invalid multi-word value on type stack");
330           return type;
331         }
332     }
333   t = stack_type_map[--stack_pointer];
334   if (type == NULL_TREE || t == type)
335     return t;
336   if (TREE_CODE (t) == TREE_LIST)
337     {      
338       do
339         {
340           tree tt = TREE_PURPOSE (t);
341           if (! can_widen_reference_to (tt, type))
342             {
343               t = tt;
344               goto fail;
345             }
346           t = TREE_CHAIN (t);
347         }
348       while (t);
349       return t;
350     }
351   if (INTEGRAL_TYPE_P (type) && INTEGRAL_TYPE_P (t)
352       && TYPE_PRECISION (type) <= 32 && TYPE_PRECISION (t) <= 32)
353     return t;
354   if (TREE_CODE (type) == POINTER_TYPE && TREE_CODE (t) == POINTER_TYPE)
355     {
356       /* If the expected type we've been passed is object or ptr
357          (i.e. void*), the caller needs to know the real type.  */
358       if (type == ptr_type_node || type == object_ptr_type_node)
359         return t;
360
361       /* Since the verifier has already run, we know that any
362          types we see will be compatible.  In BC mode, this fact
363          may be checked at runtime, but if that is so then we can
364          assume its truth here as well.  So, we always succeed
365          here, with the expected type.  */
366       return type;
367     }
368
369   if (! flag_verify_invocations && flag_indirect_dispatch
370       && t == object_ptr_type_node)
371     {
372       if (type != ptr_type_node)
373         warning (0, "need to insert runtime check for %s", 
374                  xstrdup (lang_printable_name (type, 0)));
375       return type;
376     }
377
378   /* lang_printable_name uses a static buffer, so we must save the result
379      from calling it the first time.  */
380  fail:
381   {
382     char *temp = xstrdup (lang_printable_name (type, 0));
383     /* If the stack contains a multi-word type, keep popping the stack until 
384        the real type is found.  */
385     while (t == void_type_node)
386       t = stack_type_map[--stack_pointer];
387     *messagep = concat ("expected type '", temp,
388                         "' but stack contains '", lang_printable_name (t, 0),
389                         "'", NULL);
390     free (temp);
391   }
392   return type;
393 }
394
395 /* Pop a type from the type stack.
396    TYPE is the expected type.  Return the actual type, which must be
397    convertible to TYPE, otherwise call error. */
398
399 tree
400 pop_type (tree type)
401 {
402   char *message = NULL;
403   type = pop_type_0 (type, &message);
404   if (message != NULL)
405     {
406       error ("%s", message);
407       free (message);
408     }
409   return type;
410 }
411
412 \f
413 /* Return true if two type assertions are equal.  */
414
415 static int
416 type_assertion_eq (const void * k1_p, const void * k2_p)
417 {
418   type_assertion k1 = *(type_assertion *)k1_p;
419   type_assertion k2 = *(type_assertion *)k2_p;
420   return (k1.assertion_code == k2.assertion_code
421           && k1.op1 == k2.op1
422           && k1.op2 == k2.op2);
423 }
424
425 /* Hash a type assertion.  */
426
427 static hashval_t
428 type_assertion_hash (const void *p)
429 {
430   const type_assertion *k_p = p;
431   hashval_t hash = iterative_hash (&k_p->assertion_code, sizeof
432                                    k_p->assertion_code, 0);
433   hash = iterative_hash (&k_p->op1, sizeof k_p->op1, hash);
434   return iterative_hash (&k_p->op2, sizeof k_p->op2, hash);
435 }
436
437 /* Add an entry to the type assertion table for the given class.  
438    CLASS is the class for which this assertion will be evaluated by the 
439    runtime during loading/initialization.
440    ASSERTION_CODE is the 'opcode' or type of this assertion: see java-tree.h.
441    OP1 and OP2 are the operands. The tree type of these arguments may be
442    specific to each assertion_code. */
443
444 void
445 add_type_assertion (tree class, int assertion_code, tree op1, tree op2)
446 {
447   htab_t assertions_htab;
448   type_assertion as;
449   void **as_pp;
450
451   assertions_htab = TYPE_ASSERTIONS (class);
452   if (assertions_htab == NULL)
453     {
454       assertions_htab = htab_create_ggc (7, type_assertion_hash, 
455                                          type_assertion_eq, NULL);
456       TYPE_ASSERTIONS (current_class) = assertions_htab;
457     }
458
459   as.assertion_code = assertion_code;
460   as.op1 = op1;
461   as.op2 = op2;
462
463   as_pp = htab_find_slot (assertions_htab, &as, INSERT);
464
465   /* Don't add the same assertion twice.  */
466   if (*as_pp)
467     return;
468
469   *as_pp = ggc_alloc (sizeof (type_assertion));
470   **(type_assertion **)as_pp = as;
471 }
472
473 \f
474 /* Return 1 if SOURCE_TYPE can be safely widened to TARGET_TYPE.
475    Handles array types and interfaces.  */
476
477 int
478 can_widen_reference_to (tree source_type, tree target_type)
479 {
480   if (source_type == ptr_type_node || target_type == object_ptr_type_node)
481     return 1;
482
483   /* Get rid of pointers  */
484   if (TREE_CODE (source_type) == POINTER_TYPE)
485     source_type = TREE_TYPE (source_type);
486   if (TREE_CODE (target_type) == POINTER_TYPE)
487     target_type = TREE_TYPE (target_type);
488
489   if (source_type == target_type)
490     return 1;
491
492   /* FIXME: This is very pessimistic, in that it checks everything,
493      even if we already know that the types are compatible.  If we're
494      to support full Java class loader semantics, we need this.
495      However, we could do something more optimal.  */
496   if (! flag_verify_invocations)
497     {
498       add_type_assertion (current_class, JV_ASSERT_TYPES_COMPATIBLE, 
499                           source_type, target_type);
500
501       if (!quiet_flag)
502        warning (0, "assert: %s is assign compatible with %s", 
503                 xstrdup (lang_printable_name (target_type, 0)),
504                 xstrdup (lang_printable_name (source_type, 0)));
505       /* Punt everything to runtime.  */
506       return 1;
507     }
508
509   if (TYPE_DUMMY (source_type) || TYPE_DUMMY (target_type))
510     {
511       return 1;
512     }
513   else
514     {
515       if (TYPE_ARRAY_P (source_type) || TYPE_ARRAY_P (target_type))
516         {
517           HOST_WIDE_INT source_length, target_length;
518           if (TYPE_ARRAY_P (source_type) != TYPE_ARRAY_P (target_type))
519             {
520               /* An array implements Cloneable and Serializable.  */
521               tree name = DECL_NAME (TYPE_NAME (target_type));
522               return (name == java_lang_cloneable_identifier_node
523                       || name == java_io_serializable_identifier_node);
524             }
525           target_length = java_array_type_length (target_type);
526           if (target_length >= 0)
527             {
528               source_length = java_array_type_length (source_type);
529               if (source_length != target_length)
530                 return 0;
531             }
532           source_type = TYPE_ARRAY_ELEMENT (source_type);
533           target_type = TYPE_ARRAY_ELEMENT (target_type);
534           if (source_type == target_type)
535             return 1;
536           if (TREE_CODE (source_type) != POINTER_TYPE
537               || TREE_CODE (target_type) != POINTER_TYPE)
538             return 0;
539           return can_widen_reference_to (source_type, target_type);
540         }
541       else
542         {
543           int source_depth = class_depth (source_type);
544           int target_depth = class_depth (target_type);
545
546           if (TYPE_DUMMY (source_type) || TYPE_DUMMY (target_type))
547             {
548               if (! quiet_flag)
549                 warning (0, "assert: %s is assign compatible with %s", 
550                          xstrdup (lang_printable_name (target_type, 0)),
551                          xstrdup (lang_printable_name (source_type, 0)));
552               return 1;
553             }
554
555           /* class_depth can return a negative depth if an error occurred */
556           if (source_depth < 0 || target_depth < 0)
557             return 0;
558
559           if (CLASS_INTERFACE (TYPE_NAME (target_type)))
560             {
561               /* target_type is OK if source_type or source_type ancestors
562                  implement target_type. We handle multiple sub-interfaces  */
563               tree binfo, base_binfo;
564               int i;
565
566               for (binfo = TYPE_BINFO (source_type), i = 0;
567                    BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
568                 if (can_widen_reference_to
569                     (BINFO_TYPE (base_binfo), target_type))
570                   return 1;
571               
572               if (!i)
573                 return 0;
574             }
575
576           for ( ; source_depth > target_depth;  source_depth--) 
577             {
578               source_type
579                 = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (source_type), 0));
580             }
581           return source_type == target_type;
582         }
583     }
584 }
585
586 static tree
587 pop_value (tree type)
588 {
589   type = pop_type (type);
590   if (quick_stack)
591     {
592       tree node = quick_stack;
593       quick_stack = TREE_CHAIN (quick_stack);
594       TREE_CHAIN (node) = tree_list_free_list;
595       tree_list_free_list = node;
596       node = TREE_VALUE (node);
597       return node;
598     }
599   else
600     return find_stack_slot (stack_pointer, promote_type (type));
601 }
602
603
604 /* Pop and discard the top COUNT stack slots. */
605
606 static void
607 java_stack_pop (int count)
608 {
609   while (count > 0)
610     {
611       tree type, val;
612
613       gcc_assert (stack_pointer != 0);
614
615       type = stack_type_map[stack_pointer - 1];
616       if (type == TYPE_SECOND)
617         {
618           count--;
619           gcc_assert (stack_pointer != 1 && count > 0);
620
621           type = stack_type_map[stack_pointer - 2];
622         }
623       val = pop_value (type);
624       count--;
625     }
626 }
627
628 /* Implement the 'swap' operator (to swap two top stack slots). */
629
630 static void
631 java_stack_swap (void)
632 {
633   tree type1, type2;
634   tree temp;
635   tree decl1, decl2;
636
637   if (stack_pointer < 2
638       || (type1 = stack_type_map[stack_pointer - 1]) == TYPE_UNKNOWN
639       || (type2 = stack_type_map[stack_pointer - 2]) == TYPE_UNKNOWN
640       || type1 == TYPE_SECOND || type2 == TYPE_SECOND
641       || TYPE_IS_WIDE (type1) || TYPE_IS_WIDE (type2))
642     /* Bad stack swap.  */
643     abort ();
644   /* Bad stack swap.  */
645
646   flush_quick_stack ();
647   decl1 = find_stack_slot (stack_pointer - 1, type1);
648   decl2 = find_stack_slot (stack_pointer - 2, type2);
649   temp = build_decl (VAR_DECL, NULL_TREE, type1);
650   java_add_local_var (temp);
651   java_add_stmt (build2 (MODIFY_EXPR, type1, temp, decl1));
652   java_add_stmt (build2 (MODIFY_EXPR, type2, 
653                          find_stack_slot (stack_pointer - 1, type2),
654                          decl2));
655   java_add_stmt (build2 (MODIFY_EXPR, type1, 
656                          find_stack_slot (stack_pointer - 2, type1),
657                          temp));
658   stack_type_map[stack_pointer - 1] = type2;
659   stack_type_map[stack_pointer - 2] = type1;
660 }
661
662 static void
663 java_stack_dup (int size, int offset)
664 {
665   int low_index = stack_pointer - size - offset;
666   int dst_index;
667   if (low_index < 0)
668     error ("stack underflow - dup* operation");
669
670   flush_quick_stack ();
671
672   stack_pointer += size;
673   dst_index = stack_pointer;
674
675   for (dst_index = stack_pointer;  --dst_index >= low_index; )
676     {
677       tree type;
678       int src_index = dst_index - size;
679       if (src_index < low_index)
680         src_index = dst_index + size + offset;
681       type = stack_type_map [src_index];
682       if (type == TYPE_SECOND)
683         {
684           /* Dup operation splits 64-bit number.  */
685           gcc_assert (src_index > low_index);
686
687           stack_type_map[dst_index] = type;
688           src_index--;  dst_index--;
689           type = stack_type_map[src_index];
690           gcc_assert (TYPE_IS_WIDE (type));
691         }
692       else
693         gcc_assert (! TYPE_IS_WIDE (type));
694
695       if (src_index != dst_index)
696         {
697           tree src_decl = find_stack_slot (src_index, type);
698           tree dst_decl = find_stack_slot (dst_index, type);
699
700           java_add_stmt 
701             (build2 (MODIFY_EXPR, TREE_TYPE (dst_decl), dst_decl, src_decl));
702           stack_type_map[dst_index] = type;
703         }
704     }
705 }
706
707 /* Calls _Jv_Throw or _Jv_Sjlj_Throw.  Discard the contents of the
708    value stack. */
709
710 static void
711 build_java_athrow (tree node)
712 {
713   tree call;
714
715   call = build3 (CALL_EXPR,
716                  void_type_node,
717                  build_address_of (throw_node),
718                  build_tree_list (NULL_TREE, node),
719                  NULL_TREE);
720   TREE_SIDE_EFFECTS (call) = 1;
721   java_add_stmt (call);
722   java_stack_pop (stack_pointer);
723 }
724
725 /* Implementation for jsr/ret */
726
727 static void
728 build_java_jsr (int target_pc, int return_pc)
729 {
730   tree where =  lookup_label (target_pc);
731   tree ret = lookup_label (return_pc);
732   tree ret_label = fold_build1 (ADDR_EXPR, return_address_type_node, ret);
733   push_value (ret_label);
734   flush_quick_stack ();
735   java_add_stmt (build1 (GOTO_EXPR, void_type_node, where));
736
737   /* Do not need to emit the label here.  We noted the existence of the
738      label as a jump target in note_instructions; we'll emit the label
739      for real at the beginning of the expand_byte_code loop.  */
740 }
741
742 static void
743 build_java_ret (tree location)
744 {
745   java_add_stmt (build1 (GOTO_EXPR, void_type_node, location));
746 }
747  
748 /* Implementation of operations on array: new, load, store, length */
749
750 tree
751 decode_newarray_type (int atype)
752 {
753   switch (atype)
754     {
755     case 4:  return boolean_type_node;
756     case 5:  return char_type_node;
757     case 6:  return float_type_node;
758     case 7:  return double_type_node;
759     case 8:  return byte_type_node;
760     case 9:  return short_type_node;
761     case 10: return int_type_node;
762     case 11: return long_type_node;
763     default: return NULL_TREE;
764     }
765 }
766
767 /* Map primitive type to the code used by OPCODE_newarray. */
768
769 int
770 encode_newarray_type (tree type)
771 {
772   if (type == boolean_type_node)
773     return 4;
774   else if (type == char_type_node)
775     return 5;
776   else if (type == float_type_node)
777     return 6;
778   else if (type == double_type_node)
779     return 7;
780   else if (type == byte_type_node)
781     return 8;
782   else if (type == short_type_node)
783     return 9;
784   else if (type == int_type_node)
785     return 10;
786   else if (type == long_type_node)
787     return 11;
788   else
789     gcc_unreachable ();
790 }
791
792 /* Build a call to _Jv_ThrowBadArrayIndex(), the
793    ArrayIndexOfBoundsException exception handler.  */
794
795 static tree
796 build_java_throw_out_of_bounds_exception (tree index)
797 {
798   tree node = build3 (CALL_EXPR, int_type_node,
799                       build_address_of (soft_badarrayindex_node), 
800                       build_tree_list (NULL_TREE, index), NULL_TREE);
801   TREE_SIDE_EFFECTS (node) = 1; /* Allows expansion within ANDIF */
802   return (node);
803 }
804
805 /* Return the length of an array. Doesn't perform any checking on the nature
806    or value of the array NODE. May be used to implement some bytecodes.  */
807
808 tree
809 build_java_array_length_access (tree node)
810 {
811   tree type = TREE_TYPE (node);
812   tree array_type = TREE_TYPE (type);
813   HOST_WIDE_INT length;
814
815   if (!is_array_type_p (type))
816     {
817       /* With the new verifier, we will see an ordinary pointer type
818          here.  In this case, we just use an arbitrary array type.  */
819       array_type = build_java_array_type (object_ptr_type_node, -1);
820       type = promote_type (array_type);
821     }
822
823   length = java_array_type_length (type);
824   if (length >= 0)
825     return build_int_cst (NULL_TREE, length);
826
827   node = build3 (COMPONENT_REF, int_type_node,
828                  build_java_indirect_ref (array_type, node,
829                                           flag_check_references),
830                  lookup_field (&array_type, get_identifier ("length")),
831                  NULL_TREE);
832   IS_ARRAY_LENGTH_ACCESS (node) = 1;
833   return node;
834 }
835
836 /* Optionally checks a reference against the NULL pointer.  ARG1: the
837    expr, ARG2: we should check the reference.  Don't generate extra
838    checks if we're not generating code.  */
839
840 tree 
841 java_check_reference (tree expr, int check)
842 {
843   if (!flag_syntax_only && check)
844     {
845       expr = save_expr (expr);
846       expr = build3 (COND_EXPR, TREE_TYPE (expr),
847                      build2 (EQ_EXPR, boolean_type_node,
848                              expr, null_pointer_node),
849                      build3 (CALL_EXPR, void_type_node, 
850                              build_address_of (soft_nullpointer_node),
851                              NULL_TREE, NULL_TREE),
852                      expr);
853     }
854
855   return expr;
856 }
857
858 /* Reference an object: just like an INDIRECT_REF, but with checking.  */
859
860 tree
861 build_java_indirect_ref (tree type, tree expr, int check)
862 {
863   tree t;
864   t = java_check_reference (expr, check);
865   t = convert (build_pointer_type (type), t);
866   return build1 (INDIRECT_REF, type, t);
867 }
868
869 /* Implement array indexing (either as l-value or r-value).
870    Returns a tree for ARRAY[INDEX], assume TYPE is the element type.
871    Optionally performs bounds checking and/or test to NULL.
872    At this point, ARRAY should have been verified as an array.  */
873
874 tree
875 build_java_arrayaccess (tree array, tree type, tree index)
876 {
877   tree node, throw = NULL_TREE;
878   tree data_field;
879   tree ref;
880   tree array_type = TREE_TYPE (TREE_TYPE (array));
881
882   if (!is_array_type_p (TREE_TYPE (array)))
883     {
884       /* With the new verifier, we will see an ordinary pointer type
885          here.  In this case, we just use the correct array type.  */
886       array_type = build_java_array_type (type, -1);
887     }
888
889   if (flag_bounds_check)
890     {
891       /* Generate:
892        * (unsigned jint) INDEX >= (unsigned jint) LEN
893        *    && throw ArrayIndexOutOfBoundsException.
894        * Note this is equivalent to and more efficient than:
895        * INDEX < 0 || INDEX >= LEN && throw ... */
896       tree test;
897       tree len = convert (unsigned_int_type_node,
898                           build_java_array_length_access (array));
899       test = fold_build2 (GE_EXPR, boolean_type_node, 
900                           convert (unsigned_int_type_node, index),
901                           len);
902       if (! integer_zerop (test))
903         {
904           throw = build2 (TRUTH_ANDIF_EXPR, int_type_node, test,
905                           build_java_throw_out_of_bounds_exception (index));
906           /* allows expansion within COMPOUND */
907           TREE_SIDE_EFFECTS( throw ) = 1;
908         }
909     }
910
911   /* If checking bounds, wrap the index expr with a COMPOUND_EXPR in order
912      to have the bounds check evaluated first. */
913   if (throw != NULL_TREE)
914     index = build2 (COMPOUND_EXPR, int_type_node, throw, index);
915  
916   data_field = lookup_field (&array_type, get_identifier ("data"));
917
918   ref = build3 (COMPONENT_REF, TREE_TYPE (data_field),    
919                 build_java_indirect_ref (array_type, array, 
920                                          flag_check_references),
921                 data_field, NULL_TREE);
922   
923   node = build4 (ARRAY_REF, type, ref, index, NULL_TREE, NULL_TREE);
924   return node;
925 }
926
927 /* Generate code to throw an ArrayStoreException if OBJECT is not assignable
928    (at runtime) to an element of ARRAY.  A NOP_EXPR is returned if it can
929    determine that no check is required. */
930
931 tree
932 build_java_arraystore_check (tree array, tree object)
933 {
934   tree check, element_type, source;
935   tree array_type_p = TREE_TYPE (array);
936   tree object_type = TYPE_NAME (TREE_TYPE (TREE_TYPE (object)));
937
938   if (! flag_verify_invocations)
939     {
940       /* With the new verifier, we don't track precise types.  FIXME:
941          performance regression here.  */
942       element_type = TYPE_NAME (object_type_node);
943     }
944   else
945     {
946       gcc_assert (is_array_type_p (array_type_p));
947
948       /* Get the TYPE_DECL for ARRAY's element type. */
949       element_type
950         = TYPE_NAME (TREE_TYPE (TREE_TYPE (TREE_TYPE (array_type_p))));
951     }
952
953   gcc_assert (TREE_CODE (element_type) == TYPE_DECL
954               && TREE_CODE (object_type) == TYPE_DECL);
955
956   if (!flag_store_check)
957     return build1 (NOP_EXPR, array_type_p, array);
958
959   /* No check is needed if the element type is final.  Also check that
960      element_type matches object_type, since in the bytecode
961      compilation case element_type may be the actual element type of
962      the array rather than its declared type.  However, if we're doing
963      indirect dispatch, we can't do the `final' optimization.  */
964   if (element_type == object_type
965       && ! flag_indirect_dispatch
966       && CLASS_FINAL (element_type))
967     return build1 (NOP_EXPR, array_type_p, array);
968   
969   /* OBJECT might be wrapped by a SAVE_EXPR. */
970   if (TREE_CODE (object) == SAVE_EXPR)
971     source = TREE_OPERAND (object, 0);
972   else
973     source = object;
974   
975   /* Avoid the check if OBJECT was just loaded from the same array. */
976   if (TREE_CODE (source) == ARRAY_REF)
977     {
978       tree target;
979       source = TREE_OPERAND (source, 0); /* COMPONENT_REF. */
980       source = TREE_OPERAND (source, 0); /* INDIRECT_REF. */
981       source = TREE_OPERAND (source, 0); /* Source array's DECL or SAVE_EXPR. */
982       if (TREE_CODE (source) == SAVE_EXPR)
983         source = TREE_OPERAND (source, 0);
984       
985       target = array;
986       if (TREE_CODE (target) == SAVE_EXPR)
987         target = TREE_OPERAND (target, 0);
988       
989       if (source == target)
990         return build1 (NOP_EXPR, array_type_p, array);
991     }
992
993   /* Build an invocation of _Jv_CheckArrayStore */
994   check = build3 (CALL_EXPR, void_type_node,
995                   build_address_of (soft_checkarraystore_node),
996                   tree_cons (NULL_TREE, array,
997                              build_tree_list (NULL_TREE, object)),
998                   NULL_TREE);
999   TREE_SIDE_EFFECTS (check) = 1;
1000
1001   return check;
1002 }
1003
1004 /* Makes sure that INDEXED_TYPE is appropriate. If not, make it from
1005    ARRAY_NODE. This function is used to retrieve something less vague than
1006    a pointer type when indexing the first dimension of something like [[<t>.
1007    May return a corrected type, if necessary, otherwise INDEXED_TYPE is
1008    return unchanged.  */
1009
1010 static tree
1011 build_java_check_indexed_type (tree array_node ATTRIBUTE_UNUSED,
1012                                tree indexed_type)
1013 {
1014   /* We used to check to see if ARRAY_NODE really had array type.
1015      However, with the new verifier, this is not necessary, as we know
1016      that the object will be an array of the appropriate type.  */
1017
1018   return indexed_type;
1019 }
1020
1021 /* newarray triggers a call to _Jv_NewPrimArray. This function should be 
1022    called with an integer code (the type of array to create), and the length
1023    of the array to create.  */
1024
1025 tree
1026 build_newarray (int atype_value, tree length)
1027 {
1028   tree type_arg;
1029
1030   tree prim_type = decode_newarray_type (atype_value);
1031   tree type
1032     = build_java_array_type (prim_type,
1033                              host_integerp (length, 0) == INTEGER_CST
1034                              ? tree_low_cst (length, 0) : -1);
1035
1036   /* If compiling to native, pass a reference to the primitive type class 
1037      and save the runtime some work. However, the bytecode generator
1038      expects to find the type_code int here. */
1039   if (flag_emit_class_files)
1040     type_arg = build_int_cst (NULL_TREE, atype_value);
1041   else
1042     type_arg = build_class_ref (prim_type);
1043
1044   return build3 (CALL_EXPR, promote_type (type),
1045                  build_address_of (soft_newarray_node),
1046                  tree_cons (NULL_TREE, 
1047                             type_arg,
1048                             build_tree_list (NULL_TREE, length)),
1049                  NULL_TREE);
1050 }
1051
1052 /* Generates anewarray from a given CLASS_TYPE. Gets from the stack the size
1053    of the dimension. */
1054
1055 tree
1056 build_anewarray (tree class_type, tree length)
1057 {
1058   tree type
1059     = build_java_array_type (class_type,
1060                              host_integerp (length, 0)
1061                              ? tree_low_cst (length, 0) : -1);
1062
1063   return build3 (CALL_EXPR, promote_type (type),
1064                  build_address_of (soft_anewarray_node),
1065                  tree_cons (NULL_TREE, length,
1066                             tree_cons (NULL_TREE, build_class_ref (class_type),
1067                                        build_tree_list (NULL_TREE,
1068                                                         null_pointer_node))),
1069                  NULL_TREE);
1070 }
1071
1072 /* Return a node the evaluates 'new TYPE[LENGTH]'. */
1073
1074 tree
1075 build_new_array (tree type, tree length)
1076 {
1077   if (JPRIMITIVE_TYPE_P (type))
1078     return build_newarray (encode_newarray_type (type), length);
1079   else
1080     return build_anewarray (TREE_TYPE (type), length);
1081 }
1082
1083 /* Generates a call to _Jv_NewMultiArray. multianewarray expects a
1084    class pointer, a number of dimensions and the matching number of
1085    dimensions. The argument list is NULL terminated.  */
1086
1087 static void
1088 expand_java_multianewarray (tree class_type, int ndim)
1089 {
1090   int i;
1091   tree args = build_tree_list( NULL_TREE, null_pointer_node );
1092
1093   for( i = 0; i < ndim; i++ )
1094     args = tree_cons (NULL_TREE, pop_value (int_type_node), args);
1095
1096   push_value (build3 (CALL_EXPR,
1097                       promote_type (class_type),
1098                       build_address_of (soft_multianewarray_node),
1099                       tree_cons (NULL_TREE, build_class_ref (class_type),
1100                                  tree_cons (NULL_TREE, 
1101                                             build_int_cst (NULL_TREE, ndim),
1102                                             args)),
1103                       NULL_TREE));
1104 }
1105
1106 /*  ARRAY[INDEX] <- RHS. build_java_check_indexed_type makes sure that
1107     ARRAY is an array type. May expand some bound checking and NULL
1108     pointer checking. RHS_TYPE_NODE we are going to store. In the case
1109     of the CHAR/BYTE/BOOLEAN SHORT, the type popped of the stack is an
1110     INT. In those cases, we make the conversion.
1111
1112     if ARRAy is a reference type, the assignment is checked at run-time
1113     to make sure that the RHS can be assigned to the array element
1114     type. It is not necessary to generate this code if ARRAY is final.  */
1115
1116 static void
1117 expand_java_arraystore (tree rhs_type_node)
1118 {
1119   tree rhs_node    = pop_value ((INTEGRAL_TYPE_P (rhs_type_node) 
1120                                  && TYPE_PRECISION (rhs_type_node) <= 32) ? 
1121                                  int_type_node : rhs_type_node);
1122   tree index = pop_value (int_type_node);
1123   tree array_type, array;
1124
1125   /* If we're processing an `aaload' we might as well just pick
1126      `Object'.  */
1127   if (TREE_CODE (rhs_type_node) == POINTER_TYPE)
1128     {
1129       array_type = build_java_array_type (object_ptr_type_node, -1);
1130       rhs_type_node = object_ptr_type_node;
1131     }
1132   else
1133     array_type = build_java_array_type (rhs_type_node, -1);
1134
1135   array = pop_value (array_type);
1136   array = build1 (NOP_EXPR, promote_type (array_type), array);
1137
1138   rhs_type_node    = build_java_check_indexed_type (array, rhs_type_node);
1139
1140   flush_quick_stack ();
1141
1142   index = save_expr (index);
1143   array = save_expr (array);
1144
1145   if (TREE_CODE (rhs_type_node) == POINTER_TYPE)
1146     {
1147       tree check = build_java_arraystore_check (array, rhs_node);
1148       java_add_stmt (check);
1149     }
1150   
1151   array = build_java_arrayaccess (array, rhs_type_node, index);
1152   java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (array), array, rhs_node));  
1153 }
1154
1155 /* Expand the evaluation of ARRAY[INDEX]. build_java_check_indexed_type makes 
1156    sure that LHS is an array type. May expand some bound checking and NULL
1157    pointer checking.  
1158    LHS_TYPE_NODE is the type of ARRAY[INDEX]. But in the case of CHAR/BYTE/
1159    BOOLEAN/SHORT, we push a promoted type back to the stack.
1160 */
1161
1162 static void
1163 expand_java_arrayload (tree lhs_type_node)
1164 {
1165   tree load_node;
1166   tree index_node = pop_value (int_type_node);
1167   tree array_type;
1168   tree array_node;
1169
1170   /* If we're processing an `aaload' we might as well just pick
1171      `Object'.  */
1172   if (TREE_CODE (lhs_type_node) == POINTER_TYPE)
1173     {
1174       array_type = build_java_array_type (object_ptr_type_node, -1);
1175       lhs_type_node = object_ptr_type_node;
1176     }
1177   else
1178     array_type = build_java_array_type (lhs_type_node, -1);
1179   array_node = pop_value (array_type);
1180   array_node = build1 (NOP_EXPR, promote_type (array_type), array_node);
1181
1182   index_node = save_expr (index_node);
1183   array_node = save_expr (array_node);
1184
1185   lhs_type_node = build_java_check_indexed_type (array_node,
1186                                                  lhs_type_node);
1187   load_node = build_java_arrayaccess (array_node,
1188                                       lhs_type_node,
1189                                       index_node);
1190   if (INTEGRAL_TYPE_P (lhs_type_node) && TYPE_PRECISION (lhs_type_node) <= 32)
1191     load_node = fold_build1 (NOP_EXPR, int_type_node, load_node);
1192   push_value (load_node);
1193 }
1194
1195 /* Expands .length. Makes sure that we deal with and array and may expand
1196    a NULL check on the array object.  */
1197
1198 static void
1199 expand_java_array_length (void)
1200 {
1201   tree array  = pop_value (ptr_type_node);
1202   tree length = build_java_array_length_access (array);
1203
1204   push_value (length);
1205 }
1206
1207 /* Emit code for the call to _Jv_Monitor{Enter,Exit}. CALL can be
1208    either soft_monitorenter_node or soft_monitorexit_node.  */
1209
1210 static tree
1211 build_java_monitor (tree call, tree object)
1212 {
1213   return build3 (CALL_EXPR,
1214                  void_type_node,
1215                  build_address_of (call),
1216                  build_tree_list (NULL_TREE, object),
1217                  NULL_TREE);
1218 }
1219
1220 /* Emit code for one of the PUSHC instructions. */
1221
1222 static void
1223 expand_java_pushc (int ival, tree type)
1224 {
1225   tree value;
1226   if (type == ptr_type_node && ival == 0)
1227     value = null_pointer_node;
1228   else if (type == int_type_node || type == long_type_node)
1229     value = build_int_cst (type, ival);
1230   else if (type == float_type_node || type == double_type_node)
1231     {
1232       REAL_VALUE_TYPE x;
1233       REAL_VALUE_FROM_INT (x, ival, 0, TYPE_MODE (type));
1234       value = build_real (type, x);
1235     }
1236   else
1237     gcc_unreachable ();
1238
1239   push_value (value);
1240 }
1241
1242 static void
1243 expand_java_return (tree type)
1244 {
1245   if (type == void_type_node)
1246     java_add_stmt (build1 (RETURN_EXPR, void_type_node, NULL));   
1247   else
1248     {
1249       tree retval = pop_value (type);
1250       tree res = DECL_RESULT (current_function_decl);
1251       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, retval);
1252
1253       /* Handle the situation where the native integer type is smaller
1254          than the JVM integer. It can happen for many cross compilers.
1255          The whole if expression just goes away if INT_TYPE_SIZE < 32
1256          is false. */
1257       if (INT_TYPE_SIZE < 32
1258           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (res)))
1259               < GET_MODE_SIZE (TYPE_MODE (type))))
1260         retval = build1(NOP_EXPR, TREE_TYPE(res), retval);
1261       
1262       TREE_SIDE_EFFECTS (retval) = 1;
1263       java_add_stmt (build1 (RETURN_EXPR, TREE_TYPE (retval), retval));
1264     }
1265 }
1266
1267 static void
1268 expand_load_internal (int index, tree type, int pc)
1269 {
1270   tree copy;
1271   tree var = find_local_variable (index, type, pc);
1272
1273   /* Now VAR is the VAR_DECL (or PARM_DECL) that we are going to push
1274      on the stack.  If there is an assignment to this VAR_DECL between
1275      the stack push and the use, then the wrong code could be
1276      generated.  To avoid this we create a new local and copy our
1277      value into it.  Then we push this new local on the stack.
1278      Hopefully this all gets optimized out.  */
1279   copy = build_decl (VAR_DECL, NULL_TREE, type);
1280   if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
1281       && TREE_TYPE (copy) != TREE_TYPE (var))
1282     var = convert (type, var);
1283   java_add_local_var (copy);
1284   java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (var), copy, var));
1285   
1286   push_value (copy);
1287 }
1288
1289 tree
1290 build_address_of (tree value)
1291 {
1292   return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (value)), value);
1293 }
1294
1295 bool
1296 class_has_finalize_method (tree type)
1297 {
1298   tree super = CLASSTYPE_SUPER (type);
1299
1300   if (super == NULL_TREE)
1301     return false;       /* Every class with a real finalizer inherits   */
1302                         /* from java.lang.Object.                       */
1303   else
1304     return HAS_FINALIZER_P (type) || class_has_finalize_method (super);
1305 }
1306
1307 tree
1308 java_create_object (tree type)
1309 {
1310   tree alloc_node = (class_has_finalize_method (type) 
1311                      ? alloc_object_node
1312                      : alloc_no_finalizer_node);
1313   
1314   return build3 (CALL_EXPR, promote_type (type),
1315                  build_address_of (alloc_node),
1316                  build_tree_list (NULL_TREE, build_class_ref (type)),
1317                  NULL_TREE);
1318 }
1319
1320 static void
1321 expand_java_NEW (tree type)
1322 {
1323   tree alloc_node;
1324
1325   alloc_node = (class_has_finalize_method (type) ? alloc_object_node
1326                                                  : alloc_no_finalizer_node);
1327   if (! CLASS_LOADED_P (type))
1328     load_class (type, 1);
1329   safe_layout_class (type);
1330   push_value (build3 (CALL_EXPR, promote_type (type),
1331                       build_address_of (alloc_node),
1332                       build_tree_list (NULL_TREE, build_class_ref (type)),
1333                       NULL_TREE));
1334 }
1335
1336 /* This returns an expression which will extract the class of an
1337    object.  */
1338
1339 tree
1340 build_get_class (tree value)
1341 {
1342   tree class_field = lookup_field (&dtable_type, get_identifier ("class"));
1343   tree vtable_field = lookup_field (&object_type_node,
1344                                     get_identifier ("vtable"));
1345   tree tmp = build3 (COMPONENT_REF, dtable_ptr_type,
1346                      build_java_indirect_ref (object_type_node, value,
1347                                               flag_check_references),
1348                      vtable_field, NULL_TREE);
1349   return build3 (COMPONENT_REF, class_ptr_type,
1350                  build1 (INDIRECT_REF, dtable_type, tmp),
1351                  class_field, NULL_TREE);
1352 }
1353
1354 /* This builds the tree representation of the `instanceof' operator.
1355    It tries various tricks to optimize this in cases where types are
1356    known.  */
1357
1358 tree
1359 build_instanceof (tree value, tree type)
1360 {
1361   tree expr;
1362   tree itype = TREE_TYPE (TREE_TYPE (soft_instanceof_node));
1363   tree valtype = TREE_TYPE (TREE_TYPE (value));
1364   tree valclass = TYPE_NAME (valtype);
1365   tree klass;
1366
1367   /* When compiling from bytecode, we need to ensure that TYPE has
1368      been loaded.  */
1369   if (CLASS_P (type) && ! CLASS_LOADED_P (type))
1370     {
1371       load_class (type, 1);
1372       safe_layout_class (type);
1373       if (! TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) == ERROR_MARK)
1374         return error_mark_node;
1375     }
1376   klass = TYPE_NAME (type);
1377
1378   if (type == object_type_node || inherits_from_p (valtype, type))
1379     {
1380       /* Anything except `null' is an instance of Object.  Likewise,
1381          if the object is known to be an instance of the class, then
1382          we only need to check for `null'.  */
1383       expr = build2 (NE_EXPR, itype, value, null_pointer_node);
1384     }
1385   else if (flag_verify_invocations
1386            && ! TYPE_ARRAY_P (type)
1387            && ! TYPE_ARRAY_P (valtype)
1388            && DECL_P (klass) && DECL_P (valclass)
1389            && ! CLASS_INTERFACE (valclass)
1390            && ! CLASS_INTERFACE (klass)
1391            && ! inherits_from_p (type, valtype)
1392            && (CLASS_FINAL (klass)
1393                || ! inherits_from_p (valtype, type)))
1394     {
1395       /* The classes are from different branches of the derivation
1396          tree, so we immediately know the answer.  */
1397       expr = boolean_false_node;
1398     }
1399   else if (DECL_P (klass) && CLASS_FINAL (klass))
1400     {
1401       tree save = save_expr (value);
1402       expr = build3 (COND_EXPR, itype,
1403                      build2 (NE_EXPR, boolean_type_node,
1404                              save, null_pointer_node),
1405                      build2 (EQ_EXPR, itype,
1406                              build_get_class (save),
1407                              build_class_ref (type)),
1408                      boolean_false_node);
1409     }
1410   else
1411     {
1412       expr = build3 (CALL_EXPR, itype,
1413                      build_address_of (soft_instanceof_node),
1414                      tree_cons (NULL_TREE, value,
1415                                 build_tree_list (NULL_TREE,
1416                                                  build_class_ref (type))),
1417                      NULL_TREE);
1418     }
1419   TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (value);
1420   return expr;
1421 }
1422
1423 static void
1424 expand_java_INSTANCEOF (tree type)
1425 {
1426   tree value = pop_value (object_ptr_type_node);
1427   value = build_instanceof (value, type);
1428   push_value (value);
1429 }
1430
1431 static void
1432 expand_java_CHECKCAST (tree type)
1433 {
1434   tree value = pop_value (ptr_type_node);
1435   value = build3 (CALL_EXPR, promote_type (type),
1436                   build_address_of (soft_checkcast_node),
1437                   tree_cons (NULL_TREE, build_class_ref (type),
1438                              build_tree_list (NULL_TREE, value)),
1439                   NULL_TREE);
1440   push_value (value);
1441 }
1442
1443 static void
1444 expand_iinc (unsigned int local_var_index, int ival, int pc)
1445 {
1446   tree local_var, res;
1447   tree constant_value;
1448
1449   flush_quick_stack ();
1450   local_var = find_local_variable (local_var_index, int_type_node, pc);
1451   constant_value = build_int_cst (NULL_TREE, ival);
1452   res = fold_build2 (PLUS_EXPR, int_type_node, local_var, constant_value);
1453   java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (local_var), local_var, res));
1454   update_aliases (local_var, local_var_index, pc);
1455 }
1456
1457
1458 tree
1459 build_java_soft_divmod (enum tree_code op, tree type, tree op1, tree op2)
1460 {
1461   tree call = NULL;
1462   tree arg1 = convert (type, op1);
1463   tree arg2 = convert (type, op2);
1464
1465   if (type == int_type_node)
1466     {     
1467       switch (op)
1468         {
1469         case TRUNC_DIV_EXPR:
1470           call = soft_idiv_node;
1471           break;
1472         case TRUNC_MOD_EXPR:
1473           call = soft_irem_node;
1474           break;
1475         default:
1476           break;
1477         }
1478     }
1479   else if (type == long_type_node)
1480     {     
1481       switch (op)
1482         {
1483         case TRUNC_DIV_EXPR:
1484           call = soft_ldiv_node;
1485           break;
1486         case TRUNC_MOD_EXPR:
1487           call = soft_lrem_node;
1488           break;
1489         default:
1490           break;
1491         }
1492     }
1493
1494   gcc_assert (call);
1495   call = build3 (CALL_EXPR, type,
1496                  build_address_of (call),
1497                  tree_cons (NULL_TREE, arg1,
1498                             build_tree_list (NULL_TREE, arg2)),
1499                  NULL_TREE);
1500           
1501   return call;
1502 }
1503
1504 tree
1505 build_java_binop (enum tree_code op, tree type, tree arg1, tree arg2)
1506 {
1507   tree mask;
1508   switch (op)
1509     {
1510     case URSHIFT_EXPR:
1511       {
1512         tree u_type = java_unsigned_type (type);
1513         arg1 = convert (u_type, arg1);
1514         arg1 = build_java_binop (RSHIFT_EXPR, u_type, arg1, arg2);
1515         return convert (type, arg1);
1516       }
1517     case LSHIFT_EXPR:
1518     case RSHIFT_EXPR:
1519       mask = build_int_cst (NULL_TREE,
1520                             TYPE_PRECISION (TREE_TYPE (arg1)) - 1);
1521       arg2 = fold_build2 (BIT_AND_EXPR, int_type_node, arg2, mask);
1522       break;
1523
1524     case COMPARE_L_EXPR:  /* arg1 > arg2 ?  1 : arg1 == arg2 ? 0 : -1 */
1525     case COMPARE_G_EXPR:  /* arg1 < arg2 ? -1 : arg1 == arg2 ? 0 :  1 */
1526       arg1 = save_expr (arg1);  arg2 = save_expr (arg2);
1527       {
1528         tree ifexp1 = fold_build2 (op == COMPARE_L_EXPR ? GT_EXPR : LT_EXPR,
1529                                    boolean_type_node, arg1, arg2);
1530         tree ifexp2 = fold_build2 (EQ_EXPR, boolean_type_node, arg1, arg2);
1531         tree second_compare = fold_build3 (COND_EXPR, int_type_node,
1532                                            ifexp2, integer_zero_node,
1533                                            op == COMPARE_L_EXPR
1534                                            ? integer_minus_one_node
1535                                            : integer_one_node);
1536         return fold_build3 (COND_EXPR, int_type_node, ifexp1,
1537                             op == COMPARE_L_EXPR ? integer_one_node
1538                             : integer_minus_one_node,
1539                             second_compare);
1540       }
1541     case COMPARE_EXPR:
1542       arg1 = save_expr (arg1);  arg2 = save_expr (arg2);
1543       {
1544         tree ifexp1 = fold_build2 (LT_EXPR, boolean_type_node, arg1, arg2);
1545         tree ifexp2 = fold_build2 (GT_EXPR, boolean_type_node, arg1, arg2);
1546         tree second_compare = fold_build3 (COND_EXPR, int_type_node,
1547                                            ifexp2, integer_one_node,
1548                                            integer_zero_node);
1549         return fold_build3 (COND_EXPR, int_type_node,
1550                             ifexp1, integer_minus_one_node, second_compare);
1551       }      
1552     case TRUNC_DIV_EXPR:
1553     case TRUNC_MOD_EXPR:
1554       if (TREE_CODE (type) == REAL_TYPE
1555           && op == TRUNC_MOD_EXPR)
1556         {
1557           tree call;
1558           if (type != double_type_node)
1559             {
1560               arg1 = convert (double_type_node, arg1);
1561               arg2 = convert (double_type_node, arg2);
1562             }
1563           call = build3 (CALL_EXPR, double_type_node,
1564                          build_address_of (soft_fmod_node),
1565                          tree_cons (NULL_TREE, arg1,
1566                                     build_tree_list (NULL_TREE, arg2)),
1567                          NULL_TREE);
1568           if (type != double_type_node)
1569             call = convert (type, call);
1570           return call;
1571         }
1572       
1573       if (TREE_CODE (type) == INTEGER_TYPE
1574           && flag_use_divide_subroutine
1575           && ! flag_syntax_only)
1576         return build_java_soft_divmod (op, type, arg1, arg2);
1577       
1578       break;
1579     default:  ;
1580     }
1581   return fold_build2 (op, type, arg1, arg2);
1582 }
1583
1584 static void
1585 expand_java_binop (tree type, enum tree_code op)
1586 {
1587   tree larg, rarg;
1588   tree ltype = type;
1589   tree rtype = type;
1590   switch (op)
1591     {
1592     case LSHIFT_EXPR:
1593     case RSHIFT_EXPR:
1594     case URSHIFT_EXPR:
1595       rtype = int_type_node;
1596       rarg = pop_value (rtype);
1597       break;
1598     default:
1599       rarg = pop_value (rtype);
1600     }
1601   larg = pop_value (ltype);
1602   push_value (build_java_binop (op, type, larg, rarg));
1603 }
1604
1605 /* Lookup the field named NAME in *TYPEP or its super classes.
1606    If not found, return NULL_TREE.
1607    (If the *TYPEP is not found, or if the field reference is
1608    ambiguous, return error_mark_node.)
1609    If found, return the FIELD_DECL, and set *TYPEP to the
1610    class containing the field. */
1611
1612 tree
1613 lookup_field (tree *typep, tree name)
1614 {
1615   if (CLASS_P (*typep) && !CLASS_LOADED_P (*typep))
1616     {
1617       load_class (*typep, 1);
1618       safe_layout_class (*typep);
1619       if (!TYPE_SIZE (*typep) || TREE_CODE (TYPE_SIZE (*typep)) == ERROR_MARK)
1620         return error_mark_node;
1621     }
1622   do
1623     {
1624       tree field, binfo, base_binfo;
1625       tree save_field;
1626       int i;
1627
1628       for (field = TYPE_FIELDS (*typep); field; field = TREE_CHAIN (field))
1629         if (DECL_NAME (field) == name)
1630           return field;
1631
1632       /* Process implemented interfaces. */
1633       save_field = NULL_TREE;
1634       for (binfo = TYPE_BINFO (*typep), i = 0;
1635            BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
1636         {
1637           tree t = BINFO_TYPE (base_binfo);
1638           if ((field = lookup_field (&t, name)))
1639             {
1640               if (save_field == field)
1641                 continue;
1642               if (save_field == NULL_TREE)
1643                 save_field = field;
1644               else
1645                 {
1646                   tree i1 = DECL_CONTEXT (save_field);
1647                   tree i2 = DECL_CONTEXT (field);
1648                   error ("reference %qs is ambiguous: appears in interface %qs and interface %qs",
1649                          IDENTIFIER_POINTER (name),
1650                          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (i1))),
1651                          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (i2))));
1652                   return error_mark_node;
1653                 }
1654             }
1655         }
1656
1657       if (save_field != NULL_TREE)
1658         return save_field;
1659
1660       *typep = CLASSTYPE_SUPER (*typep);
1661     } while (*typep);
1662   return NULL_TREE;
1663 }
1664
1665 /* Look up the field named NAME in object SELF_VALUE,
1666    which has class SELF_CLASS (a non-handle RECORD_TYPE).
1667    SELF_VALUE is NULL_TREE if looking for a static field. */
1668
1669 tree
1670 build_field_ref (tree self_value, tree self_class, tree name)
1671 {
1672   tree base_class = self_class;
1673   tree field_decl = lookup_field (&base_class, name);
1674   if (field_decl == NULL_TREE)
1675     {
1676       error ("field %qs not found", IDENTIFIER_POINTER (name));
1677       return error_mark_node;
1678     }
1679   if (self_value == NULL_TREE)
1680     {
1681       return build_static_field_ref (field_decl);
1682     }
1683   else
1684     {
1685       tree base_type = promote_type (base_class);
1686
1687       /* CHECK is true if self_value is not the this pointer.  */
1688       int check = (! (DECL_P (self_value)
1689                       && DECL_NAME (self_value) == this_identifier_node));
1690
1691       /* Determine whether a field offset from NULL will lie within
1692          Page 0: this is necessary on those GNU/Linux/BSD systems that
1693          trap SEGV to generate NullPointerExceptions.  
1694
1695          We assume that Page 0 will be mapped with NOPERM, and that
1696          memory may be allocated from any other page, so only field
1697          offsets < pagesize are guaranteed to trap.  We also assume
1698          the smallest page size we'll encounter is 4k bytes.  */
1699       if (! flag_syntax_only && check && ! flag_check_references 
1700           && ! flag_indirect_dispatch)
1701         {
1702           tree field_offset = byte_position (field_decl);
1703           if (! page_size)
1704             page_size = size_int (4096);              
1705           check = ! INT_CST_LT_UNSIGNED (field_offset, page_size);
1706         }
1707
1708       if (base_type != TREE_TYPE (self_value))
1709         self_value = fold_build1 (NOP_EXPR, base_type, self_value);
1710       if (! flag_syntax_only && flag_indirect_dispatch)
1711         {
1712           tree otable_index
1713             = build_int_cst (NULL_TREE, get_symbol_table_index 
1714                              (field_decl, NULL_TREE, 
1715                               &TYPE_OTABLE_METHODS (output_class)));
1716           tree field_offset
1717             = build4 (ARRAY_REF, integer_type_node,
1718                       TYPE_OTABLE_DECL (output_class), otable_index,
1719                       NULL_TREE, NULL_TREE);
1720           tree address;
1721
1722           if (DECL_CONTEXT (field_decl) != output_class)
1723             field_offset
1724               = build3 (COND_EXPR, TREE_TYPE (field_offset),
1725                         build2 (EQ_EXPR, boolean_type_node,
1726                                 field_offset, integer_zero_node),
1727                         build3 (CALL_EXPR, void_type_node, 
1728                                 build_address_of (soft_nosuchfield_node),
1729                                 build_tree_list (NULL_TREE, otable_index), 
1730                                 NULL_TREE),
1731                         field_offset);
1732           
1733           field_offset = fold (convert (sizetype, field_offset));
1734           self_value = java_check_reference (self_value, check);
1735           address 
1736             = fold_build2 (PLUS_EXPR, 
1737                            build_pointer_type (TREE_TYPE (field_decl)),
1738                            self_value, field_offset);
1739           return fold_build1 (INDIRECT_REF, TREE_TYPE (field_decl), address);
1740         }
1741
1742       self_value = build_java_indirect_ref (TREE_TYPE (TREE_TYPE (self_value)),
1743                                             self_value, check);
1744       return fold_build3 (COMPONENT_REF, TREE_TYPE (field_decl),
1745                           self_value, field_decl, NULL_TREE);
1746     }
1747 }
1748
1749 tree
1750 lookup_label (int pc)
1751 {
1752   tree name;
1753   char buf[32];
1754   if (pc > highest_label_pc_this_method)
1755     highest_label_pc_this_method = pc;
1756   ASM_GENERATE_INTERNAL_LABEL(buf, "LJpc=", start_label_pc_this_method + pc);
1757   name = get_identifier (buf);
1758   if (IDENTIFIER_LOCAL_VALUE (name))
1759     return IDENTIFIER_LOCAL_VALUE (name);
1760   else
1761     {
1762       /* The type of the address of a label is return_address_type_node. */
1763       tree decl = create_label_decl (name);
1764       LABEL_PC (decl) = pc;
1765       return pushdecl (decl);
1766     }
1767 }
1768
1769 /* Generate a unique name for the purpose of loops and switches
1770    labels, and try-catch-finally blocks label or temporary variables.  */
1771
1772 tree
1773 generate_name (void)
1774 {
1775   static int l_number = 0;
1776   char buff [32];
1777   ASM_GENERATE_INTERNAL_LABEL(buff, "LJv", l_number);
1778   l_number++;
1779   return get_identifier (buff);
1780 }
1781
1782 tree
1783 create_label_decl (tree name)
1784 {
1785   tree decl;
1786   decl = build_decl (LABEL_DECL, name, 
1787                      TREE_TYPE (return_address_type_node));
1788   DECL_CONTEXT (decl) = current_function_decl;
1789   DECL_IGNORED_P (decl) = 1;
1790   return decl;
1791 }
1792
1793 /* This maps a bytecode offset (PC) to various flags. */
1794 char *instruction_bits;
1795
1796 static void
1797 note_label (int current_pc ATTRIBUTE_UNUSED, int target_pc)
1798 {
1799   lookup_label (target_pc);
1800   instruction_bits [target_pc] |= BCODE_JUMP_TARGET;
1801 }
1802
1803 /* Emit code to jump to TARGET_PC if VALUE1 CONDITION VALUE2,
1804    where CONDITION is one of one the compare operators. */
1805
1806 static void
1807 expand_compare (enum tree_code condition, tree value1, tree value2,
1808                 int target_pc)
1809 {
1810   tree target = lookup_label (target_pc);
1811   tree cond = fold_build2 (condition, boolean_type_node, value1, value2);
1812   java_add_stmt 
1813     (build3 (COND_EXPR, void_type_node, java_truthvalue_conversion (cond),
1814              build1 (GOTO_EXPR, void_type_node, target), 
1815              build_java_empty_stmt ()));
1816 }
1817
1818 /* Emit code for a TEST-type opcode. */
1819
1820 static void
1821 expand_test (enum tree_code condition, tree type, int target_pc)
1822 {
1823   tree value1, value2;
1824   flush_quick_stack ();
1825   value1 = pop_value (type);
1826   value2 = (type == ptr_type_node) ? null_pointer_node : integer_zero_node;
1827   expand_compare (condition, value1, value2, target_pc);
1828 }
1829
1830 /* Emit code for a COND-type opcode. */
1831
1832 static void
1833 expand_cond (enum tree_code condition, tree type, int target_pc)
1834 {
1835   tree value1, value2;
1836   flush_quick_stack ();
1837   /* note: pop values in opposite order */
1838   value2 = pop_value (type);
1839   value1 = pop_value (type);
1840   /* Maybe should check value1 and value2 for type compatibility ??? */
1841   expand_compare (condition, value1, value2, target_pc);
1842 }
1843
1844 static void
1845 expand_java_goto (int target_pc)
1846 {
1847   tree target_label = lookup_label (target_pc);
1848   flush_quick_stack ();
1849   java_add_stmt (build1 (GOTO_EXPR, void_type_node, target_label));
1850 }
1851
1852 static tree
1853 expand_java_switch (tree selector, int default_pc)
1854 {
1855   tree switch_expr, x;
1856
1857   flush_quick_stack ();
1858   switch_expr = build3 (SWITCH_EXPR, TREE_TYPE (selector), selector,
1859                         NULL_TREE, NULL_TREE);
1860   java_add_stmt (switch_expr);
1861
1862   x = build3 (CASE_LABEL_EXPR, void_type_node, NULL_TREE, NULL_TREE,
1863               create_artificial_label ());
1864   append_to_statement_list (x, &SWITCH_BODY (switch_expr));
1865
1866   x = build1 (GOTO_EXPR, void_type_node, lookup_label (default_pc));
1867   append_to_statement_list (x, &SWITCH_BODY (switch_expr));
1868
1869   return switch_expr;
1870 }
1871
1872 static void
1873 expand_java_add_case (tree switch_expr, int match, int target_pc)
1874 {
1875   tree value, x;
1876
1877   value = build_int_cst (TREE_TYPE (switch_expr), match);
1878   
1879   x = build3 (CASE_LABEL_EXPR, void_type_node, value, NULL_TREE,
1880               create_artificial_label ());
1881   append_to_statement_list (x, &SWITCH_BODY (switch_expr));
1882
1883   x = build1 (GOTO_EXPR, void_type_node, lookup_label (target_pc));
1884   append_to_statement_list (x, &SWITCH_BODY (switch_expr));
1885 }
1886
1887 static tree
1888 pop_arguments (tree arg_types)
1889 {
1890   if (arg_types == end_params_node)
1891     return NULL_TREE;
1892   if (TREE_CODE (arg_types) == TREE_LIST)
1893     {
1894       tree tail = pop_arguments (TREE_CHAIN (arg_types));
1895       tree type = TREE_VALUE (arg_types);
1896       tree arg = pop_value (type);
1897
1898       /* We simply cast each argument to its proper type.  This is
1899          needed since we lose type information coming out of the
1900          verifier.  We also have to do this when we pop an integer
1901          type that must be promoted for the function call.  */
1902       if (TREE_CODE (type) == POINTER_TYPE)
1903         arg = build1 (NOP_EXPR, type, arg);
1904       else if (targetm.calls.promote_prototypes (type)
1905                && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
1906                && INTEGRAL_TYPE_P (type))
1907         arg = convert (integer_type_node, arg);
1908       return tree_cons (NULL_TREE, arg, tail);
1909     }
1910   gcc_unreachable ();
1911 }
1912
1913 /* Attach to PTR (a block) the declaration found in ENTRY. */
1914
1915 int
1916 attach_init_test_initialization_flags (void **entry, void *ptr)
1917 {
1918   tree block = (tree)ptr;
1919   struct treetreehash_entry *ite = (struct treetreehash_entry *) *entry;
1920
1921   if (block != error_mark_node)
1922     {
1923       if (TREE_CODE (block) == BIND_EXPR)
1924         {
1925           tree body = BIND_EXPR_BODY (block);
1926           TREE_CHAIN (ite->value) = BIND_EXPR_VARS (block);
1927           BIND_EXPR_VARS (block) = ite->value;
1928           body = build2 (COMPOUND_EXPR, void_type_node,
1929                          build1 (DECL_EXPR, void_type_node, ite->value), body);
1930           BIND_EXPR_BODY (block) = body;
1931         }
1932       else
1933         {
1934           tree body = BLOCK_SUBBLOCKS (block);
1935           TREE_CHAIN (ite->value) = BLOCK_EXPR_DECLS (block);
1936           BLOCK_EXPR_DECLS (block) = ite->value;
1937           body = build2 (COMPOUND_EXPR, void_type_node,
1938                          build1 (DECL_EXPR, void_type_node, ite->value), body);
1939           BLOCK_SUBBLOCKS (block) = body;
1940         }
1941       
1942     }
1943   return true;
1944 }
1945
1946 /* Build an expression to initialize the class CLAS.
1947    if EXPR is non-NULL, returns an expression to first call the initializer
1948    (if it is needed) and then calls EXPR. */
1949
1950 tree
1951 build_class_init (tree clas, tree expr)
1952 {
1953   tree init;
1954
1955   /* An optimization: if CLAS is a superclass of the class we're
1956      compiling, we don't need to initialize it.  However, if CLAS is
1957      an interface, it won't necessarily be initialized, even if we
1958      implement it.  */
1959   if ((! CLASS_INTERFACE (TYPE_NAME (clas))
1960        && inherits_from_p (current_class, clas))
1961       || current_class == clas)
1962     return expr;
1963
1964   if (always_initialize_class_p)
1965     {
1966       init = build3 (CALL_EXPR, void_type_node,
1967                      build_address_of (soft_initclass_node),
1968                      build_tree_list (NULL_TREE, build_class_ref (clas)),
1969                      NULL_TREE);
1970       TREE_SIDE_EFFECTS (init) = 1;
1971     }
1972   else
1973     {
1974       tree *init_test_decl;
1975       tree decl;
1976       init_test_decl = java_treetreehash_new
1977         (DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl), clas);
1978
1979       if (*init_test_decl == NULL)
1980         {
1981           /* Build a declaration and mark it as a flag used to track
1982              static class initializations. */
1983           decl = build_decl (VAR_DECL, NULL_TREE,
1984                              boolean_type_node);
1985           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1986           LOCAL_CLASS_INITIALIZATION_FLAG (decl) = 1;
1987           DECL_CONTEXT (decl) = current_function_decl;
1988           DECL_FUNCTION_INIT_TEST_CLASS (decl) = clas;
1989           /* Tell the check-init code to ignore this decl when not
1990              optimizing class initialization. */
1991           if (!STATIC_CLASS_INIT_OPT_P ())
1992             DECL_BIT_INDEX (decl) = -1;
1993           DECL_INITIAL (decl) = boolean_false_node;
1994           /* Don't emit any symbolic debugging info for this decl.  */
1995           DECL_IGNORED_P (decl) = 1;      
1996           *init_test_decl = decl;
1997         }
1998
1999       init = build3 (CALL_EXPR, void_type_node,
2000                      build_address_of (soft_initclass_node),
2001                      build_tree_list (NULL_TREE, build_class_ref (clas)),
2002                      NULL_TREE);
2003       TREE_SIDE_EFFECTS (init) = 1;
2004       init = build3 (COND_EXPR, void_type_node,
2005                      build2 (EQ_EXPR, boolean_type_node, 
2006                              *init_test_decl, boolean_false_node),
2007                      init, integer_zero_node);
2008       TREE_SIDE_EFFECTS (init) = 1;
2009       init = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, 
2010                      build2 (MODIFY_EXPR, boolean_type_node,
2011                              *init_test_decl, boolean_true_node));
2012       TREE_SIDE_EFFECTS (init) = 1;
2013     }
2014
2015   if (expr != NULL_TREE)
2016     {
2017       expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
2018       TREE_SIDE_EFFECTS (expr) = 1;
2019       return expr;
2020     }
2021   return init;
2022 }
2023
2024 \f
2025
2026 /* Rewrite expensive calls that require stack unwinding at runtime to
2027    cheaper alternatives.  The logic here performs these
2028    transformations:
2029
2030    java.lang.Class.forName("foo") -> java.lang.Class.forName("foo", class$)
2031    java.lang.Class.getClassLoader() -> java.lang.Class.getClassLoader(class$)
2032
2033 */
2034
2035 typedef struct
2036 {
2037   const char *classname;
2038   const char *method;
2039   const char *signature;
2040   const char *new_signature;
2041   int flags;
2042   tree (*rewrite_arglist) (tree arglist);
2043 } rewrite_rule;
2044
2045 /* Add this.class to the end of an arglist.  */
2046
2047 static tree 
2048 rewrite_arglist_getclass (tree arglist)
2049 {
2050   return chainon (arglist, 
2051                   tree_cons (NULL_TREE, build_class_ref (output_class), NULL_TREE));
2052 }
2053
2054 static rewrite_rule rules[] =
2055   {{"java.lang.Class", "getClassLoader", "()Ljava/lang/ClassLoader;", 
2056     "(Ljava/lang/Class;)Ljava/lang/ClassLoader;", 
2057     ACC_FINAL|ACC_PRIVATE, rewrite_arglist_getclass},
2058    {"java.lang.Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;",
2059     "(Ljava/lang/String;Ljava/lang/Class;)Ljava/lang/Class;",
2060     ACC_FINAL|ACC_PRIVATE|ACC_STATIC, rewrite_arglist_getclass},
2061    {NULL, NULL, NULL, NULL, 0, NULL}};
2062
2063 /* Scan the rules list for replacements for *METHOD_P and replace the
2064    args accordingly.  If the rewrite results in an access to a private
2065    method, update SPECIAL.*/
2066
2067 void
2068 maybe_rewrite_invocation (tree *method_p, tree *arg_list_p, 
2069                           tree *method_signature_p, tree *special)
2070 {
2071   tree context = DECL_NAME (TYPE_NAME (DECL_CONTEXT (*method_p)));
2072   rewrite_rule *p;
2073   *special = NULL_TREE;
2074
2075   for (p = rules; p->classname; p++)
2076     {
2077       if (get_identifier (p->classname) == context)
2078         {
2079           tree method = DECL_NAME (*method_p);
2080           if (get_identifier (p->method) == method
2081               && get_identifier (p->signature) == *method_signature_p)
2082             {
2083               tree maybe_method
2084                 = lookup_java_method (DECL_CONTEXT (*method_p),
2085                                       method,
2086                                       get_identifier (p->new_signature));
2087               if (! maybe_method && ! flag_verify_invocations)
2088                 {
2089                   maybe_method
2090                     = add_method (DECL_CONTEXT (*method_p), p->flags, 
2091                                   method, get_identifier (p->new_signature));
2092                   DECL_EXTERNAL (maybe_method) = 1;
2093                 }
2094               *method_p = maybe_method;
2095               gcc_assert (*method_p);
2096               *arg_list_p = p->rewrite_arglist (*arg_list_p);
2097               *method_signature_p = get_identifier (p->new_signature);
2098               *special = integer_one_node;
2099
2100               break;
2101             }
2102         }
2103     }
2104 }
2105
2106 \f
2107
2108 tree
2109 build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED,
2110                         tree self_type, tree method_signature ATTRIBUTE_UNUSED,
2111                         tree arg_list ATTRIBUTE_UNUSED, tree special)
2112 {
2113   tree func;
2114   if (is_compiled_class (self_type))
2115     {
2116       /* With indirect dispatch we have to use indirect calls for all
2117          publicly visible methods or gcc will use PLT indirections
2118          to reach them.  We also have to use indirect dispatch for all
2119          external methods.  */
2120       if (! flag_indirect_dispatch 
2121           || (! DECL_EXTERNAL (method) && ! TREE_PUBLIC (method)))
2122         {
2123           func = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (method)),
2124                          method);
2125         }
2126       else
2127         {
2128           tree table_index
2129             = build_int_cst (NULL_TREE, 
2130                              (get_symbol_table_index 
2131                               (method, special,
2132                                &TYPE_ATABLE_METHODS (output_class))));
2133           func 
2134             = build4 (ARRAY_REF,  
2135                       TREE_TYPE (TREE_TYPE (TYPE_ATABLE_DECL (output_class))),
2136                       TYPE_ATABLE_DECL (output_class), table_index,
2137                       NULL_TREE, NULL_TREE);
2138         }
2139       func = convert (method_ptr_type_node, func);
2140     }
2141   else
2142     {
2143       /* We don't know whether the method has been (statically) compiled.
2144          Compile this code to get a reference to the method's code:
2145
2146          SELF_TYPE->methods[METHOD_INDEX].ncode
2147
2148       */
2149
2150       int method_index = 0;
2151       tree meth, ref;
2152
2153       /* The method might actually be declared in some superclass, so
2154          we have to use its class context, not the caller's notion of
2155          where the method is.  */
2156       self_type = DECL_CONTEXT (method);
2157       ref = build_class_ref (self_type);
2158       ref = build1 (INDIRECT_REF, class_type_node, ref);
2159       if (ncode_ident == NULL_TREE)
2160         ncode_ident = get_identifier ("ncode");
2161       if (methods_ident == NULL_TREE)
2162         methods_ident = get_identifier ("methods");
2163       ref = build3 (COMPONENT_REF, method_ptr_type_node, ref,
2164                     lookup_field (&class_type_node, methods_ident),
2165                     NULL_TREE);
2166       for (meth = TYPE_METHODS (self_type);
2167            ; meth = TREE_CHAIN (meth))
2168         {
2169           if (method == meth)
2170             break;
2171           if (meth == NULL_TREE)
2172             fatal_error ("method '%s' not found in class",
2173                          IDENTIFIER_POINTER (DECL_NAME (method)));
2174           method_index++;
2175         }
2176       method_index *= int_size_in_bytes (method_type_node);
2177       ref = fold_build2 (PLUS_EXPR, method_ptr_type_node,
2178                          ref, build_int_cst (NULL_TREE, method_index));
2179       ref = build1 (INDIRECT_REF, method_type_node, ref);
2180       func = build3 (COMPONENT_REF, nativecode_ptr_type_node,
2181                      ref, lookup_field (&method_type_node, ncode_ident),
2182                      NULL_TREE);
2183     }
2184   return func;
2185 }
2186
2187 tree
2188 invoke_build_dtable (int is_invoke_interface, tree arg_list)
2189 {
2190   tree dtable, objectref;
2191
2192   TREE_VALUE (arg_list) = save_expr (TREE_VALUE (arg_list));
2193
2194   /* If we're dealing with interfaces and if the objectref
2195      argument is an array then get the dispatch table of the class
2196      Object rather than the one from the objectref.  */
2197   objectref = (is_invoke_interface 
2198                && is_array_type_p (TREE_TYPE (TREE_VALUE (arg_list)))
2199                ? build_class_ref (object_type_node) : TREE_VALUE (arg_list));
2200
2201   if (dtable_ident == NULL_TREE)
2202     dtable_ident = get_identifier ("vtable");
2203   dtable = build_java_indirect_ref (object_type_node, objectref, 
2204                                     flag_check_references);
2205   dtable = build3 (COMPONENT_REF, dtable_ptr_type, dtable,
2206                    lookup_field (&object_type_node, dtable_ident), NULL_TREE);
2207
2208   return dtable;
2209 }
2210
2211 /* Determine the index in SYMBOL_TABLE for a reference to the decl
2212    T. If this decl has not been seen before, it will be added to the
2213    [oa]table_methods. If it has, the existing table slot will be
2214    reused.  */
2215
2216 int
2217 get_symbol_table_index (tree t, tree special, tree *symbol_table)
2218 {
2219   int i = 1;
2220   tree method_list;
2221
2222   if (*symbol_table == NULL_TREE)
2223     {
2224       *symbol_table = build_tree_list (special, t);
2225       return 1;
2226     }
2227   
2228   method_list = *symbol_table;
2229   
2230   while (1)
2231     {
2232       tree value = TREE_VALUE (method_list);
2233       tree purpose = TREE_PURPOSE (method_list);
2234       if (value == t && purpose == special)
2235         return i;
2236       i++;
2237       if (TREE_CHAIN (method_list) == NULL_TREE)
2238         break;
2239       else
2240         method_list = TREE_CHAIN (method_list);
2241     }
2242
2243   TREE_CHAIN (method_list) = build_tree_list (special, t);
2244   return i;
2245 }
2246
2247 tree 
2248 build_invokevirtual (tree dtable, tree method, tree special)
2249 {
2250   tree func;
2251   tree nativecode_ptr_ptr_type_node
2252     = build_pointer_type (nativecode_ptr_type_node);
2253   tree method_index;
2254   tree otable_index;
2255
2256   if (flag_indirect_dispatch)
2257     {
2258       gcc_assert (! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))));
2259
2260       otable_index 
2261         = build_int_cst (NULL_TREE, get_symbol_table_index 
2262                          (method, special,
2263                           &TYPE_OTABLE_METHODS (output_class)));
2264       method_index = build4 (ARRAY_REF, integer_type_node, 
2265                              TYPE_OTABLE_DECL (output_class), 
2266                              otable_index, NULL_TREE, NULL_TREE);
2267     }
2268   else
2269     {
2270       /* We fetch the DECL_VINDEX field directly here, rather than
2271          using get_method_index().  DECL_VINDEX is the true offset
2272          from the vtable base to a method, regrdless of any extra
2273          words inserted at the start of the vtable.  */
2274       method_index = DECL_VINDEX (method);
2275       method_index = size_binop (MULT_EXPR, method_index,
2276                                  TYPE_SIZE_UNIT (nativecode_ptr_ptr_type_node));
2277       if (TARGET_VTABLE_USES_DESCRIPTORS)
2278         method_index = size_binop (MULT_EXPR, method_index,
2279                                    size_int (TARGET_VTABLE_USES_DESCRIPTORS));
2280     }
2281
2282   func = fold_build2 (PLUS_EXPR, nativecode_ptr_ptr_type_node, dtable,
2283                       convert (nativecode_ptr_ptr_type_node, method_index));
2284
2285   if (TARGET_VTABLE_USES_DESCRIPTORS)
2286     func = build1 (NOP_EXPR, nativecode_ptr_type_node, func);
2287   else
2288     func = build1 (INDIRECT_REF, nativecode_ptr_type_node, func);
2289
2290   return func;
2291 }
2292
2293 static GTY(()) tree class_ident;
2294 tree
2295 build_invokeinterface (tree dtable, tree method)
2296 {
2297   tree lookup_arg;
2298   tree interface;
2299   tree idx;
2300
2301   /* We expand invokeinterface here.  */
2302             
2303   if (class_ident == NULL_TREE)
2304     class_ident = get_identifier ("class");
2305
2306   dtable = build_java_indirect_ref (dtable_type, dtable,
2307                                     flag_check_references);
2308   dtable = build3 (COMPONENT_REF, class_ptr_type, dtable,
2309                    lookup_field (&dtable_type, class_ident), NULL_TREE);
2310
2311   interface = DECL_CONTEXT (method);
2312   gcc_assert (CLASS_INTERFACE (TYPE_NAME (interface)));
2313   layout_class_methods (interface);
2314   
2315   if (flag_indirect_dispatch)
2316     {
2317       int itable_index 
2318         = 2 * (get_symbol_table_index 
2319                (method, NULL_TREE, &TYPE_ITABLE_METHODS (output_class)));
2320       interface 
2321         = build4 (ARRAY_REF, 
2322                  TREE_TYPE (TREE_TYPE (TYPE_ITABLE_DECL (output_class))),
2323                  TYPE_ITABLE_DECL (output_class), 
2324                   build_int_cst (NULL_TREE, itable_index-1),
2325                   NULL_TREE, NULL_TREE);
2326       idx 
2327         = build4 (ARRAY_REF, 
2328                  TREE_TYPE (TREE_TYPE (TYPE_ITABLE_DECL (output_class))),
2329                  TYPE_ITABLE_DECL (output_class), 
2330                   build_int_cst (NULL_TREE, itable_index),
2331                   NULL_TREE, NULL_TREE);
2332       interface = convert (class_ptr_type, interface);
2333       idx = convert (integer_type_node, idx);
2334     }
2335   else
2336     {
2337       idx = build_int_cst (NULL_TREE, 
2338                            get_interface_method_index (method, interface));
2339       interface = build_class_ref (interface);
2340     }
2341                                                           
2342   lookup_arg = tree_cons (NULL_TREE, dtable,
2343                           tree_cons (NULL_TREE, interface,
2344                                      build_tree_list (NULL_TREE, idx)));
2345
2346   return build3 (CALL_EXPR, ptr_type_node, 
2347                  build_address_of (soft_lookupinterfacemethod_node),
2348                  lookup_arg, NULL_TREE);
2349 }
2350   
2351 /* Expand one of the invoke_* opcodes.
2352    OPCODE is the specific opcode.
2353    METHOD_REF_INDEX is an index into the constant pool.
2354    NARGS is the number of arguments, or -1 if not specified. */
2355
2356 static void
2357 expand_invoke (int opcode, int method_ref_index, int nargs ATTRIBUTE_UNUSED)
2358 {
2359   tree method_signature
2360     = COMPONENT_REF_SIGNATURE(&current_jcf->cpool, method_ref_index);
2361   tree method_name = COMPONENT_REF_NAME (&current_jcf->cpool,
2362                                          method_ref_index);
2363   tree self_type
2364     = get_class_constant (current_jcf,
2365                           COMPONENT_REF_CLASS_INDEX(&current_jcf->cpool,
2366                           method_ref_index));
2367   const char *const self_name
2368     = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
2369   tree call, func, method, arg_list, method_type;
2370   tree check = NULL_TREE;
2371
2372   tree special = NULL_TREE;
2373
2374   if (! CLASS_LOADED_P (self_type))
2375     {
2376       load_class (self_type, 1);
2377       safe_layout_class (self_type);
2378       if (TREE_CODE (TYPE_SIZE (self_type)) == ERROR_MARK)
2379         fatal_error ("failed to find class '%s'", self_name);
2380     }
2381   layout_class_methods (self_type);
2382
2383   if (ID_INIT_P (method_name))
2384     method = lookup_java_constructor (self_type, method_signature);
2385   else
2386     method = lookup_java_method (self_type, method_name, method_signature);
2387
2388   /* We've found a method in a class other than the one in which it
2389      was wanted.  This can happen if, for instance, we're trying to
2390      compile invokespecial super.equals().  
2391      FIXME: This is a kludge.  Rather than nullifying the result, we
2392      should change lookup_java_method() so that it doesn't search the
2393      superclass chain when we're BC-compiling.  */
2394   if (! flag_verify_invocations
2395       && method
2396       && ! TYPE_ARRAY_P (self_type)
2397       && self_type != DECL_CONTEXT (method))
2398     method = NULL_TREE;
2399
2400   /* We've found a method in an interface, but this isn't an interface
2401      call.  */
2402   if (opcode != OPCODE_invokeinterface
2403       && method
2404       && (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method)))))
2405     method = NULL_TREE;
2406
2407   /* We've found a non-interface method but we are making an
2408      interface call.  This can happen if the interface overrides a
2409      method in Object.  */
2410   if (! flag_verify_invocations
2411       && opcode == OPCODE_invokeinterface
2412       && method
2413       && ! CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
2414     method = NULL_TREE;
2415
2416   if (method == NULL_TREE)
2417     {
2418       if (flag_verify_invocations || ! flag_indirect_dispatch)
2419         {
2420           error ("class '%s' has no method named '%s' matching signature '%s'",
2421                  self_name,
2422                  IDENTIFIER_POINTER (method_name),
2423                  IDENTIFIER_POINTER (method_signature));
2424         }
2425       else
2426         {
2427           int flags = ACC_PUBLIC;
2428           if (opcode == OPCODE_invokestatic)
2429             flags |= ACC_STATIC;
2430           if (opcode == OPCODE_invokeinterface)
2431             {
2432               flags |= ACC_INTERFACE | ACC_ABSTRACT;
2433               CLASS_INTERFACE (TYPE_NAME (self_type)) = 1;
2434             }
2435           method = add_method (self_type, flags, method_name,
2436                                method_signature);
2437           DECL_ARTIFICIAL (method) = 1;
2438           METHOD_DUMMY (method) = 1;
2439           layout_class_method (self_type, NULL,
2440                                method, NULL);
2441         }
2442     }
2443
2444   /* Invoke static can't invoke static/abstract method */
2445   if (method != NULL_TREE)
2446     {
2447       if (opcode == OPCODE_invokestatic)
2448         {
2449           if (!METHOD_STATIC (method))
2450             {
2451               error ("invokestatic on non static method");
2452               method = NULL_TREE;
2453             }
2454           else if (METHOD_ABSTRACT (method))
2455             {
2456               error ("invokestatic on abstract method");
2457               method = NULL_TREE;
2458             }
2459         }
2460       else
2461         {
2462           if (METHOD_STATIC (method))
2463             {
2464               error ("invoke[non-static] on static method");
2465               method = NULL_TREE;
2466             }
2467         }
2468     }
2469
2470   if (method == NULL_TREE)
2471     {
2472       /* If we got here, we emitted an error message above.  So we
2473          just pop the arguments, push a properly-typed zero, and
2474          continue.  */
2475       method_type = get_type_from_signature (method_signature);
2476       pop_arguments (TYPE_ARG_TYPES (method_type));
2477       if (opcode != OPCODE_invokestatic) 
2478         pop_type (self_type);
2479       method_type = promote_type (TREE_TYPE (method_type));
2480       push_value (convert (method_type, integer_zero_node));
2481       return;
2482     }
2483
2484   method_type = TREE_TYPE (method);
2485   arg_list = pop_arguments (TYPE_ARG_TYPES (method_type));
2486   flush_quick_stack ();
2487
2488   maybe_rewrite_invocation (&method, &arg_list, &method_signature,
2489                             &special);
2490
2491   func = NULL_TREE;
2492   if (opcode == OPCODE_invokestatic)
2493     func = build_known_method_ref (method, method_type, self_type,
2494                                    method_signature, arg_list, special);
2495   else if (opcode == OPCODE_invokespecial
2496            || (opcode == OPCODE_invokevirtual
2497                && (METHOD_PRIVATE (method)
2498                    || METHOD_FINAL (method) 
2499                    || CLASS_FINAL (TYPE_NAME (self_type)))))
2500     {
2501       /* If the object for the method call is null, we throw an
2502          exception.  We don't do this if the object is the current
2503          method's `this'.  In other cases we just rely on an
2504          optimization pass to eliminate redundant checks.  FIXME:
2505          Unfortunately there doesn't seem to be a way to determine
2506          what the current method is right now.
2507          We do omit the check if we're calling <init>.  */
2508       /* We use a SAVE_EXPR here to make sure we only evaluate
2509          the new `self' expression once.  */
2510       tree save_arg = save_expr (TREE_VALUE (arg_list));
2511       TREE_VALUE (arg_list) = save_arg;
2512       check = java_check_reference (save_arg, ! DECL_INIT_P (method));
2513       func = build_known_method_ref (method, method_type, self_type,
2514                                      method_signature, arg_list, special);
2515     }
2516   else
2517     {
2518       tree dtable = invoke_build_dtable (opcode == OPCODE_invokeinterface, 
2519                                          arg_list);
2520       if (opcode == OPCODE_invokevirtual)
2521         func = build_invokevirtual (dtable, method, special);
2522       else
2523         func = build_invokeinterface (dtable, method);
2524     }
2525       
2526   if (TREE_CODE (func) == ADDR_EXPR)
2527     TREE_TYPE (func) = build_pointer_type (method_type);
2528   else
2529     func = build1 (NOP_EXPR, build_pointer_type (method_type), func);
2530
2531   call = build3 (CALL_EXPR, TREE_TYPE (method_type),
2532                  func, arg_list, NULL_TREE);
2533   TREE_SIDE_EFFECTS (call) = 1;
2534   call = check_for_builtin (method, call);
2535
2536   if (check != NULL_TREE)
2537     {
2538       call = build2 (COMPOUND_EXPR, TREE_TYPE (call), check, call);
2539       TREE_SIDE_EFFECTS (call) = 1;
2540     }
2541
2542   if (TREE_CODE (TREE_TYPE (method_type)) == VOID_TYPE)
2543     java_add_stmt (call);
2544   else
2545     {
2546       push_value (call);
2547       flush_quick_stack ();
2548     }
2549 }
2550
2551 /* Create a stub which will be put into the vtable but which will call
2552    a JNI function.  */
2553
2554 tree
2555 build_jni_stub (tree method)
2556 {
2557   tree jnifunc, call, args, body, lookup_arg, method_sig, arg_types;
2558   tree jni_func_type, tem;
2559   tree env_var, res_var = NULL_TREE, block;
2560   tree method_args, res_type;
2561   tree meth_var;
2562   tree bind;
2563
2564   int args_size = 0;
2565
2566   tree klass = DECL_CONTEXT (method);
2567   int from_class = ! CLASS_FROM_SOURCE_P (klass);
2568   klass = build_class_ref (klass);
2569
2570   gcc_assert (METHOD_NATIVE (method) && flag_jni);
2571
2572   DECL_ARTIFICIAL (method) = 1;
2573   DECL_EXTERNAL (method) = 0;
2574
2575   env_var = build_decl (VAR_DECL, get_identifier ("env"), ptr_type_node);
2576   DECL_CONTEXT (env_var) = method;
2577
2578   if (TREE_TYPE (TREE_TYPE (method)) != void_type_node)
2579     {
2580       res_var = build_decl (VAR_DECL, get_identifier ("res"),
2581                             TREE_TYPE (TREE_TYPE (method)));
2582       DECL_CONTEXT (res_var) = method;
2583       TREE_CHAIN (env_var) = res_var;
2584     }
2585
2586   meth_var = build_decl (VAR_DECL, get_identifier ("meth"), ptr_type_node);
2587   TREE_STATIC (meth_var) = 1;
2588   TREE_PUBLIC (meth_var) = 0;
2589   DECL_EXTERNAL (meth_var) = 0;
2590   DECL_CONTEXT (meth_var) = method;
2591   DECL_ARTIFICIAL (meth_var) = 1;
2592   DECL_INITIAL (meth_var) = null_pointer_node;
2593   TREE_USED (meth_var) = 1;
2594   chainon (env_var, meth_var);
2595   build_result_decl (method);
2596
2597   /* One strange way that the front ends are different is that they
2598      store arguments differently.  */
2599   if (from_class)
2600     method_args = DECL_ARGUMENTS (method);
2601   else
2602     method_args = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (method));
2603   block = build_block (env_var, NULL_TREE, method_args, NULL_TREE);
2604   TREE_SIDE_EFFECTS (block) = 1;
2605   /* When compiling from source we don't set the type of the block,
2606      because that will prevent patch_return from ever being run.  */
2607   if (from_class)
2608     TREE_TYPE (block) = TREE_TYPE (TREE_TYPE (method));
2609
2610   /* Compute the local `env' by calling _Jv_GetJNIEnvNewFrame.  */
2611   body = build2 (MODIFY_EXPR, ptr_type_node, env_var,
2612                  build3 (CALL_EXPR, ptr_type_node,
2613                          build_address_of (soft_getjnienvnewframe_node),
2614                          build_tree_list (NULL_TREE, klass),
2615                          NULL_TREE));
2616   CAN_COMPLETE_NORMALLY (body) = 1;
2617
2618   /* All the arguments to this method become arguments to the
2619      underlying JNI function.  If we had to wrap object arguments in a
2620      special way, we would do that here.  */
2621   args = NULL_TREE;
2622   for (tem = method_args; tem != NULL_TREE; tem = TREE_CHAIN (tem))
2623     {
2624       int arg_bits = TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tem)));
2625 #ifdef PARM_BOUNDARY
2626       arg_bits = (((arg_bits + PARM_BOUNDARY - 1) / PARM_BOUNDARY)
2627                   * PARM_BOUNDARY);
2628 #endif
2629       args_size += (arg_bits / BITS_PER_UNIT);
2630
2631       args = tree_cons (NULL_TREE, tem, args);
2632     }
2633   args = nreverse (args);
2634   arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
2635
2636   /* For a static method the second argument is the class.  For a
2637      non-static method the second argument is `this'; that is already
2638      available in the argument list.  */
2639   if (METHOD_STATIC (method))
2640     {
2641       args_size += int_size_in_bytes (TREE_TYPE (klass));
2642       args = tree_cons (NULL_TREE, klass, args);
2643       arg_types = tree_cons (NULL_TREE, object_ptr_type_node, arg_types);
2644     }
2645
2646   /* The JNIEnv structure is the first argument to the JNI function.  */
2647   args_size += int_size_in_bytes (TREE_TYPE (env_var));
2648   args = tree_cons (NULL_TREE, env_var, args);
2649   arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
2650
2651   /* We call _Jv_LookupJNIMethod to find the actual underlying
2652      function pointer.  _Jv_LookupJNIMethod will throw the appropriate
2653      exception if this function is not found at runtime.  */
2654   tem = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, args_size));
2655   method_sig = build_java_signature (TREE_TYPE (method));
2656   lookup_arg = tree_cons (NULL_TREE,
2657                           build_utf8_ref (unmangle_classname
2658                                           (IDENTIFIER_POINTER (method_sig),
2659                                            IDENTIFIER_LENGTH (method_sig))), 
2660                           tem);
2661   tem = DECL_NAME (method);
2662   lookup_arg
2663     = tree_cons (NULL_TREE, klass,
2664                  tree_cons (NULL_TREE, build_utf8_ref (tem), lookup_arg));
2665   
2666   tem = build_function_type (TREE_TYPE (TREE_TYPE (method)), arg_types);
2667
2668 #ifdef MODIFY_JNI_METHOD_CALL
2669   tem = MODIFY_JNI_METHOD_CALL (tem);
2670 #endif
2671
2672   jni_func_type = build_pointer_type (tem);
2673
2674   jnifunc = build3 (COND_EXPR, ptr_type_node,
2675                     meth_var, meth_var,
2676                     build2 (MODIFY_EXPR, ptr_type_node, meth_var,
2677                             build3 (CALL_EXPR, ptr_type_node,
2678                                     build_address_of
2679                                       (soft_lookupjnimethod_node),
2680                                     lookup_arg, NULL_TREE)));
2681
2682   /* Now we make the actual JNI call via the resulting function
2683      pointer.    */
2684   call = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (method)),
2685                  build1 (NOP_EXPR, jni_func_type, jnifunc),
2686                  args, NULL_TREE);
2687
2688   /* If the JNI call returned a result, capture it here.  If we had to
2689      unwrap JNI object results, we would do that here.  */
2690   if (res_var != NULL_TREE)
2691     {
2692       /* If the call returns an object, it may return a JNI weak
2693          reference, in which case we must unwrap it.  */
2694       if (! JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_TYPE (method))))
2695         call = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (method)),
2696                        build_address_of (soft_unwrapjni_node),
2697                        build_tree_list (NULL_TREE, call),
2698                        NULL_TREE);
2699       call = build2 (MODIFY_EXPR, TREE_TYPE (TREE_TYPE (method)),
2700                      res_var, call);
2701     }
2702
2703   TREE_SIDE_EFFECTS (call) = 1;
2704   CAN_COMPLETE_NORMALLY (call) = 1;
2705
2706   body = build2 (COMPOUND_EXPR, void_type_node, body, call);
2707   TREE_SIDE_EFFECTS (body) = 1;
2708
2709   /* Now free the environment we allocated.  */
2710   call = build3 (CALL_EXPR, ptr_type_node,
2711                  build_address_of (soft_jnipopsystemframe_node),
2712                  build_tree_list (NULL_TREE, env_var),
2713                  NULL_TREE);
2714   TREE_SIDE_EFFECTS (call) = 1;
2715   CAN_COMPLETE_NORMALLY (call) = 1;
2716   body = build2 (COMPOUND_EXPR, void_type_node, body, call);
2717   TREE_SIDE_EFFECTS (body) = 1;
2718
2719   /* Finally, do the return.  */
2720   res_type = void_type_node;
2721   if (res_var != NULL_TREE)
2722     {
2723       tree drt;
2724       gcc_assert (DECL_RESULT (method));
2725       /* Make sure we copy the result variable to the actual
2726          result.  We use the type of the DECL_RESULT because it
2727          might be different from the return type of the function:
2728          it might be promoted.  */
2729       drt = TREE_TYPE (DECL_RESULT (method));
2730       if (drt != TREE_TYPE (res_var))
2731         res_var = build1 (CONVERT_EXPR, drt, res_var);
2732       res_var = build2 (MODIFY_EXPR, drt, DECL_RESULT (method), res_var);
2733       TREE_SIDE_EFFECTS (res_var) = 1;
2734     }
2735
2736   body = build2 (COMPOUND_EXPR, void_type_node, body,
2737                  build1 (RETURN_EXPR, res_type, res_var));
2738   TREE_SIDE_EFFECTS (body) = 1;
2739   
2740   bind = build3 (BIND_EXPR, void_type_node, BLOCK_VARS (block), 
2741                  body, block);
2742   return bind;
2743 }
2744
2745 /* Expand an operation to extract from or store into a field.
2746    IS_STATIC is 1 iff the field is static.
2747    IS_PUTTING is 1 for putting into a field;  0 for getting from the field.
2748    FIELD_REF_INDEX is an index into the constant pool.  */
2749
2750 static void
2751 expand_java_field_op (int is_static, int is_putting, int field_ref_index)
2752 {
2753   tree self_type
2754     = get_class_constant (current_jcf,
2755                           COMPONENT_REF_CLASS_INDEX (&current_jcf->cpool,
2756                           field_ref_index));
2757   const char *self_name
2758     = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
2759   tree field_name = COMPONENT_REF_NAME (&current_jcf->cpool, field_ref_index);
2760   tree field_signature = COMPONENT_REF_SIGNATURE (&current_jcf->cpool, 
2761                                                   field_ref_index);
2762   tree field_type = get_type_from_signature (field_signature);
2763   tree new_value = is_putting ? pop_value (field_type) : NULL_TREE;
2764   tree field_ref;
2765   int is_error = 0;
2766   tree original_self_type = self_type;
2767   tree field_decl;
2768   
2769   if (! CLASS_LOADED_P (self_type))
2770     load_class (self_type, 1);  
2771   field_decl = lookup_field (&self_type, field_name);
2772   if (field_decl == error_mark_node)
2773     {
2774       is_error = 1;
2775     }
2776   else if (field_decl == NULL_TREE)
2777     {
2778       if (! flag_verify_invocations)
2779         {
2780           int flags = ACC_PUBLIC;
2781           if (is_static)
2782             flags |= ACC_STATIC;
2783           self_type = original_self_type;
2784           field_decl = add_field (original_self_type, field_name,
2785                                   field_type, flags); 
2786           DECL_ARTIFICIAL (field_decl) = 1;
2787           DECL_IGNORED_P (field_decl) = 1;
2788         }
2789       else
2790         {      
2791           error ("missing field '%s' in '%s'",
2792                  IDENTIFIER_POINTER (field_name), self_name);
2793           is_error = 1;
2794       }
2795     }
2796   else if (build_java_signature (TREE_TYPE (field_decl)) != field_signature)
2797     {
2798       error ("mismatching signature for field '%s' in '%s'",
2799              IDENTIFIER_POINTER (field_name), self_name);
2800       is_error = 1;
2801     }
2802   field_ref = is_static ? NULL_TREE : pop_value (self_type);
2803   if (is_error)
2804     {
2805       if (! is_putting)
2806         push_value (convert (field_type, integer_zero_node));
2807       flush_quick_stack ();
2808       return;
2809     }
2810
2811   field_ref = build_field_ref (field_ref, self_type, field_name);
2812   if (is_static
2813       && ! flag_indirect_dispatch)
2814     field_ref = build_class_init (self_type, field_ref);
2815   if (is_putting)
2816     {
2817       flush_quick_stack ();
2818       if (FIELD_FINAL (field_decl))
2819         {
2820           if (DECL_CONTEXT (field_decl) != current_class)
2821             error ("assignment to final field %q+D not in field's class",
2822                    field_decl);
2823           else if (FIELD_STATIC (field_decl))
2824             {
2825               if (!DECL_CLINIT_P (current_function_decl))
2826                 warning (0, "assignment to final static field %q+D not in "
2827                          "class initializer",
2828                          field_decl);
2829             }
2830           else
2831             {
2832               tree cfndecl_name = DECL_NAME (current_function_decl);
2833               if (! DECL_CONSTRUCTOR_P (current_function_decl)
2834                   && !ID_FINIT_P (cfndecl_name))
2835                 warning (0, "assignment to final field %q+D not in constructor",
2836                          field_decl);
2837             }
2838         }
2839       java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (field_ref),
2840                              field_ref, new_value));
2841     }
2842   else
2843     push_value (field_ref);
2844 }
2845
2846 void
2847 load_type_state (tree label)
2848 {
2849   int i;
2850   tree vec = LABEL_TYPE_STATE (label);
2851   int cur_length = TREE_VEC_LENGTH (vec);
2852   stack_pointer = cur_length - DECL_MAX_LOCALS(current_function_decl);
2853   for (i = 0; i < cur_length; i++)
2854     type_map [i] = TREE_VEC_ELT (vec, i);
2855 }
2856
2857 /* Go over METHOD's bytecode and note instruction starts in
2858    instruction_bits[].  */
2859
2860 void
2861 note_instructions (JCF *jcf, tree method)
2862 {
2863   int PC; 
2864   unsigned char* byte_ops;
2865   long length = DECL_CODE_LENGTH (method);
2866
2867   int saw_index;
2868   jint INT_temp;
2869
2870 #undef RET /* Defined by config/i386/i386.h */
2871 #undef PTR
2872 #define BCODE byte_ops
2873 #define BYTE_type_node byte_type_node
2874 #define SHORT_type_node short_type_node
2875 #define INT_type_node int_type_node
2876 #define LONG_type_node long_type_node
2877 #define CHAR_type_node char_type_node
2878 #define PTR_type_node ptr_type_node
2879 #define FLOAT_type_node float_type_node
2880 #define DOUBLE_type_node double_type_node
2881 #define VOID_type_node void_type_node
2882 #define CONST_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
2883 #define CONST_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
2884 #define VAR_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
2885 #define VAR_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
2886
2887 #define CHECK_PC_IN_RANGE(PC) ((void)1) /* Already handled by verifier. */
2888
2889   JCF_SEEK (jcf, DECL_CODE_OFFSET (method));
2890   byte_ops = jcf->read_ptr;
2891   instruction_bits = xrealloc (instruction_bits, length + 1);
2892   memset (instruction_bits, 0, length + 1);
2893
2894   /* This pass figures out which PC can be the targets of jumps. */
2895   for (PC = 0; PC < length;)
2896     {
2897       int oldpc = PC; /* PC at instruction start. */
2898       instruction_bits [PC] |=  BCODE_INSTRUCTION_START;
2899       switch (byte_ops[PC++])
2900         {
2901 #define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
2902         case OPCODE: \
2903           PRE_##OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
2904           break;
2905
2906 #define NOTE_LABEL(PC) note_label(oldpc, PC)
2907
2908 #define PRE_PUSHC(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2909 #define PRE_LOAD(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2910 #define PRE_STORE(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2911 #define PRE_STACK(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2912 #define PRE_UNOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2913 #define PRE_BINOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2914 #define PRE_CONVERT(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2915 #define PRE_CONVERT2(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2916
2917 #define PRE_SPECIAL(OPERAND_TYPE, INSTRUCTION) \
2918   PRE_SPECIAL_##INSTRUCTION(OPERAND_TYPE)
2919 #define PRE_SPECIAL_IINC(OPERAND_TYPE) \
2920   ((void) IMMEDIATE_u1, (void) IMMEDIATE_s1)
2921 #define PRE_SPECIAL_ENTER(IGNORE) /* nothing */
2922 #define PRE_SPECIAL_EXIT(IGNORE) /* nothing */
2923 #define PRE_SPECIAL_THROW(IGNORE) /* nothing */
2924 #define PRE_SPECIAL_BREAK(IGNORE) /* nothing */
2925
2926 /* two forms of wide instructions */
2927 #define PRE_SPECIAL_WIDE(IGNORE) \
2928   { \
2929     int modified_opcode = IMMEDIATE_u1; \
2930     if (modified_opcode == OPCODE_iinc) \
2931       { \
2932         (void) IMMEDIATE_u2;    /* indexbyte1 and indexbyte2 */ \
2933         (void) IMMEDIATE_s2;    /* constbyte1 and constbyte2 */ \
2934       } \
2935     else \
2936       { \
2937         (void) IMMEDIATE_u2;    /* indexbyte1 and indexbyte2 */ \
2938       } \
2939   }
2940
2941 #define PRE_IMPL(IGNORE1, IGNORE2) /* nothing */
2942
2943 #define PRE_MONITOR(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2944
2945 #define PRE_RETURN(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2946 #define PRE_ARRAY(OPERAND_TYPE, SUBOP) \
2947           PRE_ARRAY_##SUBOP(OPERAND_TYPE)
2948 #define PRE_ARRAY_LOAD(TYPE) /* nothing */
2949 #define PRE_ARRAY_STORE(TYPE) /* nothing */
2950 #define PRE_ARRAY_LENGTH(TYPE) /* nothing */
2951 #define PRE_ARRAY_NEW(TYPE) PRE_ARRAY_NEW_##TYPE
2952 #define PRE_ARRAY_NEW_NUM ((void) IMMEDIATE_u1)
2953 #define PRE_ARRAY_NEW_PTR ((void) IMMEDIATE_u2)
2954 #define PRE_ARRAY_NEW_MULTI ((void) IMMEDIATE_u2, (void) IMMEDIATE_u1)
2955
2956 #define PRE_TEST(OPERAND_TYPE, OPERAND_VALUE) NOTE_LABEL (oldpc+IMMEDIATE_s2)
2957 #define PRE_COND(OPERAND_TYPE, OPERAND_VALUE) NOTE_LABEL (oldpc+IMMEDIATE_s2)
2958 #define PRE_BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
2959   saw_index = 0;  INT_temp = (OPERAND_VALUE); \
2960   if (!saw_index)  NOTE_LABEL(oldpc + INT_temp);
2961 #define PRE_JSR(OPERAND_TYPE, OPERAND_VALUE) \
2962   saw_index = 0;  INT_temp = (OPERAND_VALUE); \
2963   NOTE_LABEL (PC); \
2964   if (!saw_index)  NOTE_LABEL(oldpc + INT_temp);
2965
2966 #define PRE_RET(OPERAND_TYPE, OPERAND_VALUE)  (void)(OPERAND_VALUE)
2967
2968 #define PRE_SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
2969   PC = (PC + 3) / 4 * 4; PRE_##TABLE_OR_LOOKUP##_SWITCH
2970
2971 #define PRE_LOOKUP_SWITCH                                               \
2972   { jint default_offset = IMMEDIATE_s4;  jint npairs = IMMEDIATE_s4;    \
2973     NOTE_LABEL (default_offset+oldpc);                                  \
2974     if (npairs >= 0)                                                    \
2975       while (--npairs >= 0) {                                           \
2976        jint match ATTRIBUTE_UNUSED = IMMEDIATE_s4;                      \
2977        jint offset = IMMEDIATE_s4;                                      \
2978        NOTE_LABEL (offset+oldpc); }                                     \
2979   }
2980
2981 #define PRE_TABLE_SWITCH                                \
2982   { jint default_offset = IMMEDIATE_s4;                 \
2983     jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4;  \
2984     NOTE_LABEL (default_offset+oldpc);                  \
2985     if (low <= high)                                    \
2986      while (low++ <= high) {                            \
2987        jint offset = IMMEDIATE_s4;                      \
2988        NOTE_LABEL (offset+oldpc); }                     \
2989   }
2990
2991 #define PRE_FIELD(MAYBE_STATIC, PUT_OR_GET) (void)(IMMEDIATE_u2);
2992 #define PRE_OBJECT(MAYBE_STATIC, PUT_OR_GET) (void)(IMMEDIATE_u2);
2993 #define PRE_INVOKE(MAYBE_STATIC, IS_INTERFACE) \
2994   (void)(IMMEDIATE_u2); \
2995   PC += 2 * IS_INTERFACE /* for invokeinterface */;
2996
2997 #include "javaop.def"
2998 #undef JAVAOP
2999         }
3000     } /* for */
3001 }
3002
3003 void
3004 expand_byte_code (JCF *jcf, tree method)
3005 {
3006   int PC;
3007   int i;
3008   const unsigned char *linenumber_pointer;
3009   int dead_code_index = -1;
3010   unsigned char* byte_ops;
3011   long length = DECL_CODE_LENGTH (method);
3012
3013   stack_pointer = 0;
3014   JCF_SEEK (jcf, DECL_CODE_OFFSET (method));
3015   byte_ops = jcf->read_ptr;
3016
3017   /* We make an initial pass of the line number table, to note
3018      which instructions have associated line number entries. */
3019   linenumber_pointer = linenumber_table;
3020   for (i = 0; i < linenumber_count; i++)
3021     {
3022       int pc = GET_u2 (linenumber_pointer);
3023       linenumber_pointer += 4;
3024       if (pc >= length)
3025         warning (0, "invalid PC in line number table");
3026       else
3027         {
3028           if ((instruction_bits[pc] & BCODE_HAS_LINENUMBER) != 0)
3029             instruction_bits[pc] |= BCODE_HAS_MULTI_LINENUMBERS;
3030           instruction_bits[pc] |= BCODE_HAS_LINENUMBER;
3031         }
3032     }  
3033
3034   if (! verify_jvm_instructions_new (jcf, byte_ops, length))
3035     return;
3036
3037   promote_arguments ();
3038
3039   /* Translate bytecodes.  */
3040   linenumber_pointer = linenumber_table;
3041   for (PC = 0; PC < length;)
3042     {
3043       if ((instruction_bits [PC] & BCODE_TARGET) != 0 || PC == 0)
3044         {
3045           tree label = lookup_label (PC);
3046           flush_quick_stack ();
3047           if ((instruction_bits [PC] & BCODE_TARGET) != 0)
3048             java_add_stmt (build1 (LABEL_EXPR, void_type_node, label));
3049           if (LABEL_VERIFIED (label) || PC == 0)
3050             load_type_state (label);
3051         }
3052
3053       if (! (instruction_bits [PC] & BCODE_VERIFIED))
3054         {
3055           if (dead_code_index == -1)
3056             {
3057               /* This is the start of a region of unreachable bytecodes.
3058                  They still need to be processed in order for EH ranges
3059                  to get handled correctly.  However, we can simply
3060                  replace these bytecodes with nops.  */
3061               dead_code_index = PC;
3062             }
3063           
3064           /* Turn this bytecode into a nop.  */
3065           byte_ops[PC] = 0x0;
3066         }
3067        else
3068         {
3069           if (dead_code_index != -1)
3070             {
3071               /* We've just reached the end of a region of dead code.  */
3072               if (extra_warnings)
3073                 warning (0, "unreachable bytecode from %d to before %d",
3074                          dead_code_index, PC);
3075               dead_code_index = -1;
3076             }
3077         }
3078
3079       /* Handle possible line number entry for this PC.
3080
3081          This code handles out-of-order and multiple linenumbers per PC,
3082          but is optimized for the case of line numbers increasing
3083          monotonically with PC. */
3084       if ((instruction_bits[PC] & BCODE_HAS_LINENUMBER) != 0)
3085         {
3086           if ((instruction_bits[PC] & BCODE_HAS_MULTI_LINENUMBERS) != 0
3087               || GET_u2 (linenumber_pointer) != PC)
3088             linenumber_pointer = linenumber_table;
3089           while (linenumber_pointer < linenumber_table + linenumber_count * 4)
3090             {
3091               int pc = GET_u2 (linenumber_pointer);
3092               linenumber_pointer += 4;
3093               if (pc == PC)
3094                 {
3095                   int line = GET_u2 (linenumber_pointer - 2);
3096 #ifdef USE_MAPPED_LOCATION
3097                   input_location = linemap_line_start (&line_table, line, 1);
3098 #else
3099                   input_location.line = line;
3100 #endif
3101                   if (!(instruction_bits[PC] & BCODE_HAS_MULTI_LINENUMBERS))
3102                     break;
3103                 }
3104             }
3105         }
3106       maybe_pushlevels (PC);
3107       PC = process_jvm_instruction (PC, byte_ops, length);
3108       maybe_poplevels (PC);
3109     } /* for */
3110   
3111   if (dead_code_index != -1)
3112     {
3113       /* We've just reached the end of a region of dead code.  */
3114       if (extra_warnings)
3115         warning (0, "unreachable bytecode from %d to the end of the method", 
3116                  dead_code_index);
3117     }
3118 }
3119
3120 static void
3121 java_push_constant_from_pool (JCF *jcf, int index)
3122 {
3123   tree c;
3124   if (JPOOL_TAG (jcf, index) == CONSTANT_String)
3125     {
3126       tree name;
3127       name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index));
3128       index = alloc_name_constant (CONSTANT_String, name);
3129       c = build_ref_from_constant_pool (index);
3130       c = convert (promote_type (string_type_node), c);
3131     }
3132   else if (JPOOL_TAG (jcf, index) == CONSTANT_Class
3133            || JPOOL_TAG (jcf, index) == CONSTANT_ResolvedClass)
3134     {
3135       tree record = get_class_constant (jcf, index);
3136       c = build_class_ref (record);
3137     }
3138   else
3139     c = get_constant (jcf, index);
3140   push_value (c);
3141
3142
3143 int
3144 process_jvm_instruction (int PC, const unsigned char* byte_ops,
3145                          long length ATTRIBUTE_UNUSED)
3146
3147   const char *opname; /* Temporary ??? */
3148   int oldpc = PC; /* PC at instruction start. */
3149
3150   /* If the instruction is at the beginning of an exception handler,
3151      replace the top of the stack with the thrown object reference.  */
3152   if (instruction_bits [PC] & BCODE_EXCEPTION_TARGET)
3153     {
3154       /* Note that the verifier will not emit a type map at all for
3155          dead exception handlers.  In this case we just ignore the
3156          situation.  */
3157       if ((instruction_bits[PC] & BCODE_VERIFIED) != 0)
3158         {
3159           tree type = pop_type (promote_type (throwable_type_node));
3160           push_value (build_exception_object_ref (type));
3161         }
3162     }
3163
3164   switch (byte_ops[PC++])
3165     {
3166 #define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
3167     case OPCODE: \
3168       opname = #OPNAME; \
3169       OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
3170       break;
3171
3172 #define RET(OPERAND_TYPE, OPERAND_VALUE)                                \
3173   {                                                                     \
3174     int saw_index = 0;                                                  \
3175     int index     = OPERAND_VALUE;                                      \
3176     build_java_ret                                                      \
3177       (find_local_variable (index, return_address_type_node, oldpc));   \
3178   }
3179
3180 #define JSR(OPERAND_TYPE, OPERAND_VALUE) \
3181   {                                                 \
3182     /* OPERAND_VALUE may have side-effects on PC */ \
3183     int opvalue = OPERAND_VALUE;                    \
3184     build_java_jsr (oldpc + opvalue, PC);           \
3185   }
3186
3187 /* Push a constant onto the stack. */
3188 #define PUSHC(OPERAND_TYPE, OPERAND_VALUE) \
3189   { int saw_index = 0;  int ival = (OPERAND_VALUE); \
3190     if (saw_index) java_push_constant_from_pool (current_jcf, ival); \
3191     else expand_java_pushc (ival, OPERAND_TYPE##_type_node); }
3192
3193 /* internal macro added for use by the WIDE case */
3194 #define LOAD_INTERNAL(OPTYPE, OPVALUE) \
3195   expand_load_internal (OPVALUE, type_map[OPVALUE], oldpc);
3196
3197 /* Push local variable onto the opcode stack. */
3198 #define LOAD(OPERAND_TYPE, OPERAND_VALUE) \
3199   { \
3200     /* have to do this since OPERAND_VALUE may have side-effects */ \
3201     int opvalue = OPERAND_VALUE; \
3202     LOAD_INTERNAL(OPERAND_TYPE##_type_node, opvalue); \
3203   }
3204
3205 #define RETURN(OPERAND_TYPE, OPERAND_VALUE) \
3206   expand_java_return (OPERAND_TYPE##_type_node)
3207
3208 #define REM_EXPR TRUNC_MOD_EXPR
3209 #define BINOP(OPERAND_TYPE, OPERAND_VALUE) \
3210   expand_java_binop (OPERAND_TYPE##_type_node, OPERAND_VALUE##_EXPR)
3211
3212 #define FIELD(IS_STATIC, IS_PUT) \
3213   expand_java_field_op (IS_STATIC, IS_PUT, IMMEDIATE_u2)
3214
3215 #define TEST(OPERAND_TYPE, CONDITION) \
3216   expand_test (CONDITION##_EXPR, OPERAND_TYPE##_type_node, oldpc+IMMEDIATE_s2)
3217
3218 #define COND(OPERAND_TYPE, CONDITION) \
3219   expand_cond (CONDITION##_EXPR, OPERAND_TYPE##_type_node, oldpc+IMMEDIATE_s2)
3220
3221 #define BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
3222   BRANCH_##OPERAND_TYPE (OPERAND_VALUE)
3223
3224 #define BRANCH_GOTO(OPERAND_VALUE) \
3225   expand_java_goto (oldpc + OPERAND_VALUE)
3226
3227 #define BRANCH_CALL(OPERAND_VALUE) \
3228   expand_java_call (oldpc + OPERAND_VALUE, oldpc)
3229
3230 #if 0
3231 #define BRANCH_RETURN(OPERAND_VALUE) \
3232   { \
3233     tree type = OPERAND_TYPE##_type_node; \
3234     tree value = find_local_variable (OPERAND_VALUE, type, oldpc); \
3235     expand_java_ret (value); \
3236   }
3237 #endif
3238
3239 #define NOT_IMPL(OPERAND_TYPE, OPERAND_VALUE) \
3240           fprintf (stderr, "%3d: %s ", oldpc, opname); \
3241           fprintf (stderr, "(not implemented)\n")
3242 #define NOT_IMPL1(OPERAND_VALUE) \
3243           fprintf (stderr, "%3d: %s ", oldpc, opname); \
3244           fprintf (stderr, "(not implemented)\n")
3245
3246 #define BRANCH_RETURN(OPERAND_VALUE) NOT_IMPL1(OPERAND_VALUE)
3247
3248 #define STACK(SUBOP, COUNT) STACK_##SUBOP (COUNT)
3249
3250 #define STACK_POP(COUNT) java_stack_pop (COUNT)
3251
3252 #define STACK_SWAP(COUNT) java_stack_swap()
3253
3254 #define STACK_DUP(COUNT) java_stack_dup (COUNT, 0)
3255 #define STACK_DUPx1(COUNT) java_stack_dup (COUNT, 1)
3256 #define STACK_DUPx2(COUNT) java_stack_dup (COUNT, 2)
3257
3258 #define SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
3259   PC = (PC + 3) / 4 * 4; TABLE_OR_LOOKUP##_SWITCH
3260
3261 #define LOOKUP_SWITCH \
3262   { jint default_offset = IMMEDIATE_s4;  jint npairs = IMMEDIATE_s4; \
3263     tree selector = pop_value (INT_type_node); \
3264     tree switch_expr = expand_java_switch (selector, oldpc + default_offset); \
3265     while (--npairs >= 0) \
3266       { \
3267         jint match = IMMEDIATE_s4; jint offset = IMMEDIATE_s4; \
3268         expand_java_add_case (switch_expr, match, oldpc + offset); \
3269       } \
3270   }
3271
3272 #define TABLE_SWITCH \
3273   { jint default_offset = IMMEDIATE_s4; \
3274     jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
3275     tree selector = pop_value (INT_type_node); \
3276     tree switch_expr = expand_java_switch (selector, oldpc + default_offset); \
3277     for (; low <= high; low++) \
3278       { \
3279         jint offset = IMMEDIATE_s4; \
3280         expand_java_add_case (switch_expr, low, oldpc + offset); \
3281       } \
3282   }
3283
3284 #define INVOKE(MAYBE_STATIC, IS_INTERFACE) \
3285   { int opcode = byte_ops[PC-1]; \
3286     int method_ref_index = IMMEDIATE_u2; \
3287     int nargs; \
3288     if (IS_INTERFACE) { nargs = IMMEDIATE_u1;  (void) IMMEDIATE_u1; } \
3289     else nargs = -1; \
3290     expand_invoke (opcode, method_ref_index, nargs); \
3291   }
3292
3293 /* Handle new, checkcast, instanceof */
3294 #define OBJECT(TYPE, OP) \
3295   expand_java_##OP (get_class_constant (current_jcf, IMMEDIATE_u2))
3296
3297 #define ARRAY(OPERAND_TYPE, SUBOP) ARRAY_##SUBOP(OPERAND_TYPE)
3298
3299 #define ARRAY_LOAD(OPERAND_TYPE)                        \
3300   {                                                     \
3301     expand_java_arrayload( OPERAND_TYPE##_type_node );  \
3302   }
3303
3304 #define ARRAY_STORE(OPERAND_TYPE)                       \
3305   {                                                     \
3306     expand_java_arraystore( OPERAND_TYPE##_type_node ); \
3307   }
3308
3309 #define ARRAY_LENGTH(OPERAND_TYPE) expand_java_array_length();
3310 #define ARRAY_NEW(OPERAND_TYPE) ARRAY_NEW_##OPERAND_TYPE()
3311 #define ARRAY_NEW_PTR()                                                 \
3312     push_value (build_anewarray (get_class_constant (current_jcf,       \
3313                                                      IMMEDIATE_u2),     \
3314                                  pop_value (int_type_node)));
3315 #define ARRAY_NEW_NUM()                         \
3316   {                                             \
3317     int atype = IMMEDIATE_u1;                   \
3318     push_value (build_newarray (atype, pop_value (int_type_node)));\
3319   }
3320 #define ARRAY_NEW_MULTI()                                       \
3321   {                                                             \
3322     tree class = get_class_constant (current_jcf, IMMEDIATE_u2 );       \
3323     int  ndims = IMMEDIATE_u1;                                  \
3324     expand_java_multianewarray( class, ndims );                 \
3325   }
3326
3327 #define UNOP(OPERAND_TYPE, OPERAND_VALUE) \
3328   push_value (fold_build1 (NEGATE_EXPR, OPERAND_TYPE##_type_node, \
3329                            pop_value (OPERAND_TYPE##_type_node)));
3330
3331 #define CONVERT2(FROM_TYPE, TO_TYPE)                                     \
3332   {                                                                      \
3333     push_value (build1 (NOP_EXPR, int_type_node,                         \
3334                         (convert (TO_TYPE##_type_node,                   \
3335                                   pop_value (FROM_TYPE##_type_node))))); \
3336   }
3337
3338 #define CONVERT(FROM_TYPE, TO_TYPE)                             \
3339   {                                                             \
3340     push_value (convert (TO_TYPE##_type_node,                   \
3341                          pop_value (FROM_TYPE##_type_node)));   \
3342   }
3343
3344 /* internal macro added for use by the WIDE case 
3345    Added TREE_TYPE (decl) assignment, apbianco  */
3346 #define STORE_INTERNAL(OPTYPE, OPVALUE)                         \
3347   {                                                             \
3348     tree decl, value;                                           \
3349     int index = OPVALUE;                                        \
3350     tree type = OPTYPE;                                         \
3351     value = pop_value (type);                                   \
3352     type = TREE_TYPE (value);                                   \
3353     decl = find_local_variable (index, type, oldpc);            \
3354     set_local_type (index, type);                               \
3355     java_add_stmt (build2 (MODIFY_EXPR, type, decl, value));    \
3356     update_aliases (decl, index, PC);                           \
3357   }
3358
3359 #define STORE(OPERAND_TYPE, OPERAND_VALUE) \
3360   { \
3361     /* have to do this since OPERAND_VALUE may have side-effects */ \
3362     int opvalue = OPERAND_VALUE; \
3363     STORE_INTERNAL(OPERAND_TYPE##_type_node, opvalue); \
3364   }
3365
3366 #define SPECIAL(OPERAND_TYPE, INSTRUCTION) \
3367   SPECIAL_##INSTRUCTION(OPERAND_TYPE)
3368
3369 #define SPECIAL_ENTER(IGNORED) MONITOR_OPERATION (soft_monitorenter_node)
3370 #define SPECIAL_EXIT(IGNORED)  MONITOR_OPERATION (soft_monitorexit_node)
3371
3372 #define MONITOR_OPERATION(call)                 \
3373   {                                             \
3374     tree o = pop_value (ptr_type_node);         \
3375     tree c;                                     \
3376     flush_quick_stack ();                       \
3377     c = build_java_monitor (call, o);           \
3378     TREE_SIDE_EFFECTS (c) = 1;                  \
3379     java_add_stmt (c);                          \
3380   }
3381
3382 #define SPECIAL_IINC(IGNORED) \
3383   { \
3384     unsigned int local_var_index = IMMEDIATE_u1; \
3385     int ival = IMMEDIATE_s1; \
3386     expand_iinc(local_var_index, ival, oldpc); \
3387   }
3388
3389 #define SPECIAL_WIDE(IGNORED) \
3390   { \
3391     int modified_opcode = IMMEDIATE_u1; \
3392     unsigned int local_var_index = IMMEDIATE_u2; \
3393     switch (modified_opcode) \
3394       { \
3395       case OPCODE_iinc: \
3396         { \
3397           int ival = IMMEDIATE_s2; \
3398           expand_iinc (local_var_index, ival, oldpc); \
3399           break; \
3400         } \
3401       case OPCODE_iload: \
3402       case OPCODE_lload: \
3403       case OPCODE_fload: \
3404       case OPCODE_dload: \
3405       case OPCODE_aload: \
3406         { \
3407           /* duplicate code from LOAD macro */ \
3408           LOAD_INTERNAL(operand_type[modified_opcode], local_var_index); \
3409           break; \
3410         } \
3411       case OPCODE_istore: \
3412       case OPCODE_lstore: \
3413       case OPCODE_fstore: \
3414       case OPCODE_dstore: \
3415       case OPCODE_astore: \
3416         { \
3417           STORE_INTERNAL(operand_type[modified_opcode], local_var_index); \
3418           break; \
3419         } \
3420       default: \
3421         error ("unrecogized wide sub-instruction"); \
3422       } \
3423   }
3424
3425 #define SPECIAL_THROW(IGNORED) \
3426   build_java_athrow (pop_value (throwable_type_node))
3427
3428 #define SPECIAL_BREAK NOT_IMPL1
3429 #define IMPL          NOT_IMPL
3430
3431 #include "javaop.def"
3432 #undef JAVAOP
3433    default:
3434     fprintf (stderr, "%3d: unknown(%3d)\n", oldpc, byte_ops[PC]);
3435   }
3436   return PC;
3437 }
3438
3439 /* Return the opcode at PC in the code section pointed to by
3440    CODE_OFFSET.  */
3441
3442 static unsigned char
3443 peek_opcode_at_pc (JCF *jcf, int code_offset, int pc)
3444 {
3445   unsigned char opcode;
3446   long absolute_offset = (long)JCF_TELL (jcf);
3447
3448   JCF_SEEK (jcf, code_offset);
3449   opcode = jcf->read_ptr [pc];
3450   JCF_SEEK (jcf, absolute_offset);
3451   return opcode;
3452 }
3453
3454 /* Some bytecode compilers are emitting accurate LocalVariableTable
3455    attributes. Here's an example:
3456    
3457      PC   <t>store_<n>
3458      PC+1 ...
3459      
3460      Attribute "LocalVariableTable"
3461      slot #<n>: ... (PC: PC+1 length: L)
3462    
3463    This is accurate because the local in slot <n> really exists after
3464    the opcode at PC is executed, hence from PC+1 to PC+1+L.
3465
3466    This procedure recognizes this situation and extends the live range
3467    of the local in SLOT to START_PC-1 or START_PC-2 (depending on the
3468    length of the store instruction.)
3469
3470    This function is used by `give_name_to_locals' so that a local's
3471    DECL features a DECL_LOCAL_START_PC such that the first related
3472    store operation will use DECL as a destination, not an unrelated
3473    temporary created for the occasion.
3474
3475    This function uses a global (instruction_bits) `note_instructions' should
3476    have allocated and filled properly.  */
3477
3478 int
3479 maybe_adjust_start_pc (struct JCF *jcf, int code_offset,
3480                        int start_pc, int slot)
3481 {
3482   int first, index, opcode;
3483   int pc, insn_pc;
3484   int wide_found = 0;
3485
3486   if (!start_pc)
3487     return start_pc;
3488
3489   first = index = -1;
3490
3491   /* Find last previous instruction and remember it */
3492   for (pc = start_pc-1; pc; pc--) 
3493     if (instruction_bits [pc] & BCODE_INSTRUCTION_START)
3494       break;
3495   insn_pc = pc;
3496
3497   /* Retrieve the instruction, handle `wide'. */  
3498   opcode = (int) peek_opcode_at_pc (jcf, code_offset, pc++);
3499   if (opcode == OPCODE_wide)
3500     {
3501       wide_found = 1;
3502       opcode = (int) peek_opcode_at_pc (jcf, code_offset, pc++);
3503     }
3504
3505   switch (opcode)
3506     {
3507     case OPCODE_astore_0:
3508     case OPCODE_astore_1:
3509     case OPCODE_astore_2:
3510     case OPCODE_astore_3: