gcc/java/expr.c

   1 /* Process expressions for the GNU compiler for the Java(TM) language.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.
  20
  21 Java and all Java-based marks are trademarks or registered trademarks
  22 of Sun Microsystems, Inc. in the United States and other countries.
  23 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  24
  25 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "tree.h"
  30 #include "real.h"
  31 #include "rtl.h"
  32 #include "flags.h"
  33 #include "expr.h"
  34 #include "java-tree.h"
  35 #include "javaop.h"
  36 #include "java-opcodes.h"
  37 #include "jcf.h"
  38 #include "java-except.h"
  39 #include "parse.h"
  40 #include "toplev.h"
  41 #include "except.h"
  42 #include "defaults.h"
  43
  44 static void flush_quick_stack PARAMS ((void));
  45 static void push_value PARAMS ((tree));
  46 static tree pop_value PARAMS ((tree));
  47 static void java_stack_swap PARAMS ((void));
  48 static void java_stack_dup PARAMS ((int, int));
  49 static void build_java_athrow PARAMS ((tree));
  50 static void build_java_jsr PARAMS ((tree, tree));
  51 static void build_java_ret PARAMS ((tree));
  52 static void expand_java_multianewarray PARAMS ((tree, int));
  53 static void expand_java_arraystore PARAMS ((tree));
  54 static void expand_java_arrayload PARAMS ((tree));
  55 static void expand_java_array_length PARAMS ((void));
  56 static tree build_java_monitor PARAMS ((tree, tree));
  57 static void expand_java_pushc PARAMS ((int, tree));
  58 static void expand_java_return PARAMS ((tree));
  59 static void expand_java_NEW PARAMS ((tree));
  60 static void expand_java_INSTANCEOF PARAMS ((tree));
  61 static void expand_java_CHECKCAST PARAMS ((tree));
  62 static void expand_iinc PARAMS ((unsigned int, int, int));
  63 static void expand_java_binop PARAMS ((tree, enum tree_code));
  64 static void note_label PARAMS ((int, int));
  65 static void expand_compare PARAMS ((enum tree_code, tree, tree, int));
  66 static void expand_test PARAMS ((enum tree_code, tree, int));
  67 static void expand_cond PARAMS ((enum tree_code, tree, int));
  68 static void expand_java_goto PARAMS ((int));
  69 #if 0
  70 static void expand_java_call PARAMS ((int, int));
  71 static void expand_java_ret PARAMS ((tree));
  72 #endif
  73 static tree pop_arguments PARAMS ((tree));
  74 static void expand_invoke PARAMS ((int, int, int));
  75 static void expand_java_field_op PARAMS ((int, int, int));
  76 static void java_push_constant_from_pool PARAMS ((struct JCF *, int));
  77 static void java_stack_pop PARAMS ((int));
  78 static tree build_java_throw_out_of_bounds_exception PARAMS ((tree));
  79 static tree build_java_check_indexed_type PARAMS ((tree, tree));
  80 static tree java_array_data_offset PARAMS ((tree));
  81 static tree case_identity PARAMS ((tree, tree));
  82
  83 static tree operand_type[59];
  84 extern struct obstack permanent_obstack;
  85
  86 /* Set to non-zero value in order to emit class initilization code
  87    before static field references.  */
  88 int always_initialize_class_p;
  89
  90 void
  91 init_expr_processing()
  92 {
  93   operand_type[21] = operand_type[54] = int_type_node;
  94   operand_type[22] = operand_type[55] = long_type_node;
  95   operand_type[23] = operand_type[56] = float_type_node;
  96   operand_type[24] = operand_type[57] = double_type_node;
  97   operand_type[25] = operand_type[58] = ptr_type_node;
  98 }
  99
 100 /* We store the stack state in two places:
 101    Within a basic block, we use the quick_stack, which is a
 102    pushdown list (TREE_LISTs) of expression nodes.
 103    This is the top part of the stack;  below that we use find_stack_slot.
 104    At the end of a basic block, the quick_stack must be flushed
 105    to the stack slot array (as handled by find_stack_slot).
 106    Using quick_stack generates better code (especially when
 107    compiled without optimization), because we do not have to
 108    explicitly store and load trees to temporary variables.
 109
 110    If a variable is on the quick stack, it means the value of variable
 111    when the quick stack was last flushed.  Conceptually, flush_quick_stack
 112    saves all the the quick_stack elements in parellel.  However, that is
 113    complicated, so it actually saves them (i.e. copies each stack value
 114    to is home virtual register) from low indexes.  This allows a quick_stack
 115    element at index i (counting from the bottom of stack the) to references
 116    slot virtuals for register that are >= i, but not those that are deeper.
 117    This convention makes most operations easier.  For example iadd works
 118    even when the stack contains (reg[0], reg[1]):  It results in the
 119    stack containing (reg[0]+reg[1]), which is OK.  However, some stack
 120    operations are more complicated.  For example dup given a stack
 121    containing (reg[0]) would yield (reg[0], reg[0]), which would violate
 122    the convention, since stack value 1 would refer to a register with
 123    lower index (reg[0]), which flush_quick_stack does not safely handle.
 124    So dup cannot just add an extra element to the quick_stack, but iadd can.
 125 */
 126
 127 tree quick_stack = NULL_TREE;
 128
 129 /* A free-list of unused permamnet TREE_LIST nodes. */
 130 tree tree_list_free_list = NULL_TREE;
 131
 132 /* The stack pointer of the Java virtual machine.
 133    This does include the size of the quick_stack. */
 134
 135 int stack_pointer;
 136
 137 const unsigned char *linenumber_table;
 138 int linenumber_count;
 139
 140 tree
 141 truthvalue_conversion (expr)
 142      tree expr;
 143 {
 144   /* It is simpler and generates better code to have only TRUTH_*_EXPR
 145      or comparison expressions as truth values at this level.
 146
 147      This function should normally be identity for Java.  */
 148
 149   switch (TREE_CODE (expr))
 150     {
 151     case EQ_EXPR:
 152     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
 153     case TRUTH_ANDIF_EXPR:
 154     case TRUTH_ORIF_EXPR:
 155     case TRUTH_AND_EXPR:
 156     case TRUTH_OR_EXPR:
 157     case ERROR_MARK:
 158       return expr;
 159
 160     case INTEGER_CST:
 161       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
 162
 163     case REAL_CST:
 164       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
 165
 166     /* are these legal? XXX JH */
 167     case NEGATE_EXPR:
 168     case ABS_EXPR:
 169     case FLOAT_EXPR:
 170     case FFS_EXPR:
 171       /* These don't change whether an object is non-zero or zero.  */
 172       return truthvalue_conversion (TREE_OPERAND (expr, 0));
 173
 174     case COND_EXPR:
 175       /* Distribute the conversion into the arms of a COND_EXPR.  */
 176       return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
 177                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
 178                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
 179
 180     case NOP_EXPR:
 181       /* If this is widening the argument, we can ignore it.  */
 182       if (TYPE_PRECISION (TREE_TYPE (expr))
 183           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
 184         return truthvalue_conversion (TREE_OPERAND (expr, 0));
 185       /* fall through to default */
 186
 187     default:
 188       return fold (build (NE_EXPR, boolean_type_node, expr, boolean_false_node));
 189     }
 190 }
 191
 192 #ifdef JAVA_USE_HANDLES
 193 /* Given a pointer to a handle, get a pointer to an object. */
 194
 195 tree
 196 unhand_expr (expr)
 197      tree expr;
 198 {
 199   tree field, handle_type;
 200   expr = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (expr)), expr);
 201   handle_type = TREE_TYPE (expr);
 202   field = TYPE_FIELDS (handle_type);
 203   expr = build (COMPONENT_REF, TREE_TYPE (field), expr, field);
 204   return expr;
 205 }
 206 #endif
 207
 208 /* Save any stack slots that happen to be in the quick_stack into their
 209    home virtual register slots.
 210
 211    The copy order is from low stack index to high, to support the invariant
 212    that the expression for a slot may contain decls for stack slots with
 213    higher (or the same) index, but not lower. */
 214
 215 static void
 216 flush_quick_stack ()
 217 {
 218   int stack_index = stack_pointer;
 219   register tree prev, cur, next;
 220
 221   /* First reverse the quick_stack, and count the number of slots it has. */
 222   for (cur = quick_stack, prev = NULL_TREE; cur != NULL_TREE; cur = next)
 223     {
 224       next = TREE_CHAIN (cur);
 225       TREE_CHAIN (cur) = prev;
 226       prev = cur;
 227       stack_index -= 1 + TYPE_IS_WIDE (TREE_TYPE (TREE_VALUE (cur)));
 228     }
 229   quick_stack = prev;
 230
 231   while (quick_stack != NULL_TREE)
 232     {
 233       tree decl;
 234       tree node = quick_stack, type;
 235       quick_stack = TREE_CHAIN (node);
 236       TREE_CHAIN (node) = tree_list_free_list;
 237       tree_list_free_list = node;
 238       node = TREE_VALUE (node);
 239       type = TREE_TYPE (node);
 240
 241       decl = find_stack_slot (stack_index, type);
 242       if (decl != node)
 243           expand_assignment (decl, node, 0, 0);
 244       stack_index += 1 + TYPE_IS_WIDE (type);
 245     }
 246 }
 247
 248 void
 249 push_type (type)
 250      tree type;
 251 {
 252   int n_words;
 253   type = promote_type (type);
 254   n_words = 1 + TYPE_IS_WIDE (type);
 255   if (stack_pointer + n_words > DECL_MAX_STACK (current_function_decl))
 256     fatal ("stack overflow");
 257   stack_type_map[stack_pointer++] = type;
 258   n_words--;
 259   while (--n_words >= 0)
 260     stack_type_map[stack_pointer++] = TYPE_SECOND;
 261 }
 262
 263 static void
 264 push_value (value)
 265      tree value;
 266 {
 267   tree type = TREE_TYPE (value);
 268   if (TYPE_PRECISION (type) < 32 && INTEGRAL_TYPE_P (type))
 269     {
 270       type = promote_type (type);
 271       value = convert (type, value);
 272     }
 273   push_type (type);
 274   if (tree_list_free_list == NULL_TREE)
 275     quick_stack = perm_tree_cons (NULL_TREE, value, quick_stack);
 276   else
 277     {
 278       tree node = tree_list_free_list;
 279       tree_list_free_list = TREE_CHAIN (tree_list_free_list);
 280       TREE_VALUE (node) = value;
 281       TREE_CHAIN (node) = quick_stack;
 282       quick_stack = node;
 283     }
 284 }
 285
 286 /* Pop a type from the type stack.
 287    TYPE is the expected type.   Return the actual type, which must be
 288    convertible to TYPE, otherwise NULL_TREE is returned. */
 289
 290 tree
 291 pop_type_0 (type)
 292      tree type;
 293 {
 294   int n_words;
 295   tree t;
 296   if (TREE_CODE (type) == RECORD_TYPE)
 297     type = promote_type (type);
 298   n_words = 1 + TYPE_IS_WIDE (type);
 299   if (stack_pointer < n_words)
 300     fatal ("stack underflow");
 301   while (--n_words > 0)
 302     {
 303       if (stack_type_map[--stack_pointer] != void_type_node)
 304         fatal ("Invalid multi-word value on type stack");
 305     }
 306   t = stack_type_map[--stack_pointer];
 307   if (type == NULL_TREE || t == type)
 308     return t;
 309   if (INTEGRAL_TYPE_P (type) && INTEGRAL_TYPE_P (t)
 310       && TYPE_PRECISION (type) <= 32 && TYPE_PRECISION (t) <= 32)
 311       return t;
 312   if (TREE_CODE (type) == POINTER_TYPE && TREE_CODE (t) == POINTER_TYPE)
 313     {
 314       if (type == ptr_type_node || type == object_ptr_type_node)
 315         return t;
 316       else if (t == ptr_type_node)  /* Special case for null reference. */
 317         return type;
 318       else if (can_widen_reference_to (t, type))
 319         return t;
 320       /* This is a kludge, but matches what Sun's verifier does.
 321          It can be tricked, but is safe as long as type errors
 322          (i.e. interface method calls) are caught at run-time. */
 323       else if (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (type)))
 324                && t == object_ptr_type_node)
 325         return t;
 326     }
 327   return NULL_TREE;
 328 }
 329
 330 /* Pop a type from the type stack.
 331    TYPE is the expected type.  Return the actual type, which must be
 332    convertible to TYPE, otherwise call error. */
 333
 334 tree
 335 pop_type (type)
 336      tree type;
 337 {
 338   tree t = pop_type_0 (type);
 339   if (t != NULL_TREE)
 340     return t;
 341   error ("unexpected type on stack");
 342   return type;
 343 }
 344
 345 /* Return 1f if SOURCE_TYPE can be safely widened to TARGET_TYPE.
 346    Handles array types and interfaces.  */
 347
 348 int
 349 can_widen_reference_to (source_type, target_type)
 350      tree source_type, target_type;
 351 {
 352   if (source_type == ptr_type_node || target_type == object_ptr_type_node)
 353     return 1;
 354
 355   /* Get rid of pointers  */
 356   if (TREE_CODE (source_type) == POINTER_TYPE)
 357     source_type = TREE_TYPE (source_type);
 358   if (TREE_CODE (target_type) == POINTER_TYPE)
 359     target_type = TREE_TYPE (target_type);
 360
 361   if (source_type == target_type)
 362     return 1;
 363   else
 364     {
 365       source_type = HANDLE_TO_CLASS_TYPE (source_type);
 366       target_type = HANDLE_TO_CLASS_TYPE (target_type);
 367       if (TYPE_ARRAY_P (source_type) || TYPE_ARRAY_P (target_type))
 368         {
 369           HOST_WIDE_INT source_length, target_length;
 370           if (TYPE_ARRAY_P (source_type) != TYPE_ARRAY_P (target_type))
 371             return 0;
 372           target_length = java_array_type_length (target_type);
 373           if (target_length >= 0)
 374             {
 375               source_length = java_array_type_length (source_type);
 376               if (source_length != target_length)
 377                 return 0;
 378             }
 379           source_type = TYPE_ARRAY_ELEMENT (source_type);
 380           target_type = TYPE_ARRAY_ELEMENT (target_type);
 381           if (source_type == target_type)
 382             return 1;
 383           if (TREE_CODE (source_type) != POINTER_TYPE
 384               || TREE_CODE (target_type) != POINTER_TYPE)
 385             return 0;
 386           return can_widen_reference_to (source_type, target_type);
 387         }
 388       else
 389         {
 390           int source_depth = class_depth (source_type);
 391           int target_depth = class_depth (target_type);
 392
 393           /* class_depth can return a negative depth if an error occurred */
 394           if (source_depth < 0 || target_depth < 0)
 395             return 0;
 396
 397           if (CLASS_INTERFACE (TYPE_NAME (target_type)))
 398             {
 399               /* target_type is OK if source_type or source_type ancestors
 400                  implement target_type. We handle multiple sub-interfaces  */
 401
 402               tree basetype_vec = TYPE_BINFO_BASETYPES (source_type);
 403               int n = TREE_VEC_LENGTH (basetype_vec), i;
 404               for (i=0 ; i < n; i++)
 405                 if (can_widen_reference_to
 406                     (TREE_TYPE (TREE_VEC_ELT (basetype_vec, i)),
 407                      target_type))
 408                   return 1;
 409               if (n == 0)
 410                 return 0;
 411             }
 412
 413           for ( ; source_depth > target_depth;  source_depth--)
 414             {
 415               source_type = TYPE_BINFO_BASETYPE (source_type, 0);
 416             }
 417           return source_type == target_type;
 418         }
 419     }
 420 }
 421
 422 static tree
 423 pop_value (type)
 424      tree type;
 425 {
 426   type = pop_type (type);
 427   if (quick_stack)
 428     {
 429       tree node = quick_stack;
 430       quick_stack = TREE_CHAIN (quick_stack);
 431       TREE_CHAIN (node) = tree_list_free_list;
 432       tree_list_free_list = node;
 433       node = TREE_VALUE (node);
 434       return node;
 435     }
 436   else
 437     return find_stack_slot (stack_pointer, promote_type (type));
 438 }
 439
 440
 441 /* Pop and discrad the top COUNT stack slots. */
 442
 443 static void
 444 java_stack_pop (count)
 445      int count;
 446 {
 447   while (count > 0)
 448     {
 449       tree type, val;
 450       if (stack_pointer == 0)
 451         fatal ("stack underflow");
 452       type = stack_type_map[stack_pointer - 1];
 453       if (type == TYPE_SECOND)
 454         {
 455           count--;
 456           if (stack_pointer == 1 || count <= 0)
 457             fatal ("stack underflow");
 458           type = stack_type_map[stack_pointer - 2];
 459         }
 460       val = pop_value (type);
 461       count--;
 462     }
 463 }
 464
 465 /* Implement the 'swap' operator (to swap two top stack slots). */
 466
 467 static void
 468 java_stack_swap ()
 469 {
 470   tree type1, type2;
 471   rtx temp;
 472   tree decl1, decl2;
 473
 474   if (stack_pointer < 2
 475       || (type1 = stack_type_map[stack_pointer - 1]) == TYPE_UNKNOWN
 476       || (type2 = stack_type_map[stack_pointer - 2]) == TYPE_UNKNOWN
 477       || type1 == TYPE_SECOND || type2 == TYPE_SECOND
 478       || TYPE_IS_WIDE (type1) || TYPE_IS_WIDE (type2))
 479     fatal ("bad stack swap");
 480
 481   flush_quick_stack ();
 482   decl1 = find_stack_slot (stack_pointer - 1, type1);
 483   decl2 = find_stack_slot (stack_pointer - 2, type2);
 484   temp = copy_to_reg (DECL_RTL (decl1));
 485   emit_move_insn (DECL_RTL (decl1), DECL_RTL (decl2));
 486   emit_move_insn (DECL_RTL (decl2), temp);
 487   stack_type_map[stack_pointer - 1] = type2;
 488   stack_type_map[stack_pointer - 2] = type1;
 489 }
 490
 491 static void
 492 java_stack_dup (size, offset)
 493      int size, offset;
 494 {
 495   int low_index = stack_pointer - size - offset;
 496   int dst_index;
 497   if (low_index < 0)
 498     error ("stack underflow - dup* operation");
 499
 500   flush_quick_stack ();
 501
 502   stack_pointer += size;
 503   dst_index = stack_pointer;
 504
 505   for (dst_index = stack_pointer;  --dst_index >= low_index; )
 506     {
 507       tree type;
 508       int src_index = dst_index - size;
 509       if (src_index < low_index)
 510         src_index = dst_index + size + offset;
 511       type = stack_type_map [src_index];
 512       if (type == TYPE_SECOND)
 513         {
 514           if (src_index <= low_index)
 515             fatal ("dup operation splits 64-bit number");
 516           stack_type_map[dst_index] = type;
 517           src_index--;  dst_index--;
 518           type = stack_type_map[src_index];
 519           if (! TYPE_IS_WIDE (type))
 520             fatal ("internal error - dup operation");
 521         }
 522       else if (TYPE_IS_WIDE (type))
 523         fatal ("internal error - dup operation");
 524       if (src_index != dst_index)
 525         {
 526           tree src_decl = find_stack_slot (src_index, type);
 527           tree dst_decl = find_stack_slot (dst_index, type);
 528           emit_move_insn (DECL_RTL (dst_decl), DECL_RTL (src_decl));
 529           stack_type_map[dst_index] = type;
 530         }
 531     }
 532 }
 533
 534 /* Calls _Jv_Throw or _Jv_Sjlj_Throw.  Discard the contents of the
 535    value stack. */
 536
 537 static void
 538 build_java_athrow (node)
 539     tree node;
 540 {
 541   tree call;
 542
 543   call = build (CALL_EXPR,
 544                 void_type_node,
 545                 build_address_of (throw_node[exceptions_via_longjmp ? 1 : 0]),
 546                 build_tree_list (NULL_TREE, node),
 547                 NULL_TREE);
 548   TREE_SIDE_EFFECTS (call) = 1;
 549   expand_expr_stmt (call);
 550   java_stack_pop (stack_pointer);
 551 }
 552
 553 /* Implementation for jsr/ret */
 554
 555 static void
 556 build_java_jsr (where, ret)
 557     tree where;
 558     tree ret;
 559 {
 560   tree ret_label = fold (build1 (ADDR_EXPR, return_address_type_node, ret));
 561   push_value (ret_label);
 562   flush_quick_stack ();
 563   emit_jump (label_rtx (where));
 564   expand_label (ret);
 565 }
 566
 567 static void
 568 build_java_ret (location)
 569   tree location;
 570 {
 571   expand_computed_goto (location);
 572 }
 573
 574 /* Implementation of operations on array: new, load, store, length */
 575
 576 /* Array core info access macros */
 577
 578 #define JAVA_ARRAY_LENGTH_OFFSET(A) \
 579   byte_position (TREE_CHAIN (TYPE_FIELDS (TREE_TYPE (TREE_TYPE (A)))))
 580
 581 tree
 582 decode_newarray_type (atype)
 583   int atype;
 584 {
 585   switch (atype)
 586     {
 587     case 4:  return boolean_type_node;
 588     case 5:  return char_type_node;
 589     case 6:  return float_type_node;
 590     case 7:  return double_type_node;
 591     case 8:  return byte_type_node;
 592     case 9:  return short_type_node;
 593     case 10: return int_type_node;
 594     case 11: return long_type_node;
 595     default: return NULL_TREE;
 596     }
 597 }
 598
 599 /* Map primitive type to the code used by OPCODE_newarray. */
 600
 601 int
 602 encode_newarray_type (type)
 603      tree type;
 604 {
 605   if (type == boolean_type_node)
 606     return 4;
 607   else if (type == char_type_node)
 608     return 5;
 609   else if (type == float_type_node)
 610     return 6;
 611   else if (type == double_type_node)
 612     return 7;
 613   else if (type == byte_type_node)
 614     return 8;
 615   else if (type == short_type_node)
 616     return 9;
 617   else if (type == int_type_node)
 618     return 10;
 619   else if (type == long_type_node)
 620     return 11;
 621   else
 622     fatal ("Can't compute type code - patch_newarray");
 623 }
 624
 625 /* Build a call to _Jv_ThrowBadArrayIndex(), the
 626    ArrayIndexOfBoundsException exception handler.  */
 627
 628 static tree
 629 build_java_throw_out_of_bounds_exception (index)
 630     tree index;
 631 {
 632   tree node = build (CALL_EXPR, int_type_node,
 633                      build_address_of (soft_badarrayindex_node),
 634                      build_tree_list (NULL_TREE, index), NULL_TREE);
 635   TREE_SIDE_EFFECTS (node) = 1; /* Allows expansion within ANDIF */
 636   return (node);
 637 }
 638
 639 /* Return the length of an array. Doesn't perform any checking on the nature
 640    or value of the array NODE. May be used to implement some bytecodes.  */
 641
 642 tree
 643 build_java_array_length_access (node)
 644     tree node;
 645 {
 646   tree type = TREE_TYPE (node);
 647   HOST_WIDE_INT length;
 648   if (!is_array_type_p (type))
 649     fatal ("array length on a non-array reference");
 650   length = java_array_type_length (type);
 651   if (length >= 0)
 652     return build_int_2 (length, 0);
 653   return fold (build1 (INDIRECT_REF,
 654                        int_type_node,
 655                        fold (build (PLUS_EXPR, ptr_type_node,
 656                                     node,
 657                                     JAVA_ARRAY_LENGTH_OFFSET(node)))));
 658 }
 659
 660 /* Optionally checks an array against the NULL pointer, eventually throwing a
 661    NullPointerException. It could replace signal handling, but tied to NULL.
 662    ARG1: the pointer to check, ARG2: the expression to use if
 663    the pointer is non-null and ARG3 the type that should be returned.   */
 664
 665 tree
 666 build_java_arraynull_check (node, expr, type)
 667     tree node ATTRIBUTE_UNUSED;
 668     tree expr;
 669     tree type ATTRIBUTE_UNUSED;
 670 {
 671 #if 0
 672   static int java_array_access_throws_null_exception = 0;
 673   node = ???;
 674   if (java_array_access_throws_null_exception)
 675       return (build (COND_EXPR,
 676                      type,
 677                      build (EQ_EXPR, int_type_node, node, null_pointer_node),
 678                      build_java_athrow (node), expr ));
 679   else
 680 #endif
 681       return (expr);
 682 }
 683
 684 static tree
 685 java_array_data_offset (array)
 686      tree array;
 687 {
 688   tree array_type = TREE_TYPE (TREE_TYPE (array));
 689   tree data_fld = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type)));
 690
 691   if (data_fld == NULL_TREE)
 692     return size_in_bytes (array_type);
 693   else
 694     return byte_position (data_fld);
 695 }
 696
 697 /* Implement array indexing (either as l-value or r-value).
 698    Returns a tree for ARRAY[INDEX], assume TYPE is the element type.
 699    Optionally performs bounds checking and/or test to NULL.
 700    At this point, ARRAY should have been verified as an array.  */
 701
 702 tree
 703 build_java_arrayaccess (array, type, index)
 704     tree array, type, index;
 705 {
 706   tree arith, node, throw = NULL_TREE;
 707
 708   arith = fold (build (PLUS_EXPR, int_type_node,
 709                        java_array_data_offset (array),
 710                        fold (build (MULT_EXPR, int_type_node,
 711                                     index, size_in_bytes(type)))));
 712
 713   if (flag_bounds_check)
 714     {
 715       /* Generate:
 716        * (unsigned jint) INDEX >= (unsigned jint) LEN
 717        *    && throw ArrayIndexOutOfBoundsException.
 718        * Note this is equivalent to and more efficient than:
 719        * INDEX < 0 || INDEX >= LEN && throw ... */
 720       tree test;
 721       tree len = build_java_array_length_access (array);
 722       TREE_TYPE (len) = unsigned_int_type_node;
 723       test = fold (build (GE_EXPR, boolean_type_node,
 724                                convert (unsigned_int_type_node, index),
 725                                len));
 726       if (! integer_zerop (test))
 727         {
 728           throw = build (TRUTH_ANDIF_EXPR, int_type_node, test,
 729                          build_java_throw_out_of_bounds_exception (index));
 730           /* allows expansion within COMPOUND */
 731           TREE_SIDE_EFFECTS( throw ) = 1;
 732         }
 733     }
 734
 735   node = build1 (INDIRECT_REF, type,
 736                  fold (build (PLUS_EXPR, ptr_type_node,
 737                               array,
 738                               (throw ? build (COMPOUND_EXPR, int_type_node,
 739                                               throw, arith )
 740                                      : arith))));
 741
 742   return (fold (build_java_arraynull_check (array, node, type)));
 743 }
 744
 745 /* Makes sure that INDEXED_TYPE is appropriate. If not, make it from
 746    ARRAY_NODE. This function is used to retrieve something less vague than
 747    a pointer type when indexing the first dimension of something like [[<t>.
 748    May return a corrected type, if necessary, otherwise INDEXED_TYPE is
 749    return unchanged.
 750    As a side effect, it also makes sure that ARRAY_NODE is an array.  */
 751
 752 static tree
 753 build_java_check_indexed_type (array_node, indexed_type)
 754     tree array_node;
 755     tree indexed_type;
 756 {
 757   tree elt_type;
 758
 759   if (!is_array_type_p (TREE_TYPE (array_node)))
 760     fatal ("array indexing on a non-array reference");
 761
 762   elt_type = (TYPE_ARRAY_ELEMENT (TREE_TYPE (TREE_TYPE (array_node))));
 763
 764   if (indexed_type == ptr_type_node )
 765       return promote_type (elt_type);
 766
 767   /* BYTE/BOOLEAN store and load are used for both type */
 768   if (indexed_type == byte_type_node && elt_type == boolean_type_node )
 769     return boolean_type_node;
 770
 771   if (indexed_type != elt_type )
 772     fatal ("type array element mismatch");
 773   else
 774     return indexed_type;
 775 }
 776
 777 /* newarray triggers a call to _Jv_NewArray. This function should be called
 778    with an integer code (the type of array to create) and get from the stack
 779    the size of the dimmension.  */
 780
 781 tree
 782 build_newarray (atype_value, length)
 783      int atype_value;
 784      tree length;
 785 {
 786   tree type
 787     = build_java_array_type (decode_newarray_type (atype_value),
 788                              host_integerp (length, 0) == INTEGER_CST
 789                              ? tree_low_cst (length, 0) : -1);
 790
 791   return build (CALL_EXPR, promote_type (type),
 792                 build_address_of (soft_newarray_node),
 793                 tree_cons (NULL_TREE,
 794                            build_int_2 (atype_value, 0),
 795                            build_tree_list (NULL_TREE, length)),
 796                 NULL_TREE);
 797 }
 798
 799 /* Generates anewarray from a given CLASS_TYPE. Gets from the stack the size
 800    of the dimension. */
 801
 802 tree
 803 build_anewarray (class_type, length)
 804     tree class_type;
 805     tree length;
 806 {
 807   tree type
 808     = build_java_array_type (class_type,
 809                              host_integerp (length, 0)
 810                              ? tree_low_cst (length, 0) : -1);
 811
 812   return build (CALL_EXPR, promote_type (type),
 813                 build_address_of (soft_anewarray_node),
 814                 tree_cons (NULL_TREE, length,
 815                            tree_cons (NULL_TREE, build_class_ref (class_type),
 816                                       build_tree_list (NULL_TREE,
 817                                                        null_pointer_node))),
 818                 NULL_TREE);
 819 }
 820
 821 /* Return a node the evaluates 'new TYPE[LENGTH]'. */
 822
 823 tree
 824 build_new_array (type, length)
 825      tree type;
 826      tree length;
 827 {
 828   if (JPRIMITIVE_TYPE_P (type))
 829     return build_newarray (encode_newarray_type (type), length);
 830   else
 831     return build_anewarray (TREE_TYPE (type), length);
 832 }
 833
 834 /* Generates a call to _Jv_NewMultiArray. multianewarray expects a
 835    class pointer, a number of dimensions and the matching number of
 836    dimensions. The argument list is NULL terminated.  */
 837
 838 static void
 839 expand_java_multianewarray (class_type, ndim)
 840     tree class_type;
 841     int  ndim;
 842 {
 843   int i;
 844   tree args = build_tree_list( NULL_TREE, null_pointer_node );
 845
 846   for( i = 0; i < ndim; i++ )
 847     args = tree_cons (NULL_TREE, pop_value (int_type_node), args);
 848
 849   push_value (build (CALL_EXPR,
 850                      promote_type (class_type),
 851                      build_address_of (soft_multianewarray_node),
 852                      tree_cons (NULL_TREE, build_class_ref (class_type),
 853                                 tree_cons (NULL_TREE,
 854                                            build_int_2 (ndim, 0), args )),
 855                      NULL_TREE));
 856 }
 857
 858 /*  ARRAY[INDEX] <- RHS. build_java_check_indexed_type makes sure that
 859     ARRAY is an array type. May expand some bound checking and NULL
 860     pointer checking. RHS_TYPE_NODE we are going to store. In the case
 861     of the CHAR/BYTE/BOOLEAN SHORT, the type popped of the stack is an
 862     INT. In those cases, we make the convertion.
 863
 864     if ARRAy is a reference type, the assignment is checked at run-time
 865     to make sure that the RHS can be assigned to the array element
 866     type. It is not necessary to generate this code if ARRAY is final.  */
 867
 868 static void
 869 expand_java_arraystore (rhs_type_node)
 870      tree rhs_type_node;
 871 {
 872   tree rhs_node    = pop_value ((INTEGRAL_TYPE_P (rhs_type_node)
 873                                  && TYPE_PRECISION (rhs_type_node) <= 32) ?
 874                                  int_type_node : rhs_type_node);
 875   tree index = pop_value (int_type_node);
 876   tree array = pop_value (ptr_type_node);
 877
 878   rhs_type_node    = build_java_check_indexed_type (array, rhs_type_node);
 879
 880   flush_quick_stack ();
 881
 882   index = save_expr (index);
 883   array = save_expr (array);
 884
 885   if (TREE_CODE (rhs_type_node) == POINTER_TYPE)
 886     {
 887       tree check = build (CALL_EXPR, void_type_node,
 888                           build_address_of (soft_checkarraystore_node),
 889                           tree_cons (NULL_TREE, array,
 890                                      build_tree_list (NULL_TREE, rhs_node)),
 891                           NULL_TREE);
 892       TREE_SIDE_EFFECTS (check) = 1;
 893       expand_expr_stmt (check);
 894     }
 895
 896   expand_assignment (build_java_arrayaccess (array,
 897                                              rhs_type_node,
 898                                              index),
 899                      rhs_node, 0, 0);
 900 }
 901
 902 /* Expand the evaluation of ARRAY[INDEX]. build_java_check_indexed_type makes
 903    sure that LHS is an array type. May expand some bound checking and NULL
 904    pointer checking.
 905    LHS_TYPE_NODE is the type of ARRAY[INDEX]. But in the case of CHAR/BYTE/
 906    BOOLEAN/SHORT, we push a promoted type back to the stack.
 907 */
 908
 909 static void
 910 expand_java_arrayload (lhs_type_node )
 911     tree lhs_type_node;
 912 {
 913   tree load_node;
 914   tree index_node = pop_value (int_type_node);
 915   tree array_node = pop_value (ptr_type_node);
 916
 917   index_node = save_expr (index_node);
 918   array_node = save_expr (array_node);
 919   lhs_type_node   = build_java_check_indexed_type (array_node, lhs_type_node);
 920
 921   load_node = build_java_arrayaccess (array_node,
 922                                       lhs_type_node,
 923                                       index_node);
 924
 925   if (INTEGRAL_TYPE_P (lhs_type_node) && TYPE_PRECISION (lhs_type_node) <= 32)
 926     load_node = fold (build1 (NOP_EXPR, int_type_node, load_node));
 927   push_value (load_node);
 928 }
 929
 930 /* Expands .length. Makes sure that we deal with and array and may expand
 931    a NULL check on the array object.  */
 932
 933 static void
 934 expand_java_array_length ()
 935 {
 936   tree array  = pop_value (ptr_type_node);
 937   tree length = build_java_array_length_access (array);
 938
 939   push_value (build_java_arraynull_check (array, length, int_type_node));
 940 }
 941
 942 /* Emit code for the call to _Jv_Monitor{Enter,Exit}. CALL can be
 943    either soft_monitorenter_node or soft_monitorexit_node.  */
 944
 945 static tree
 946 build_java_monitor (call, object)
 947     tree call;
 948     tree object;
 949 {
 950   return (build (CALL_EXPR,
 951                  void_type_node,
 952                  build_address_of (call),
 953                  build_tree_list (NULL_TREE, object),
 954                  NULL_TREE));
 955 }
 956
 957 /* Emit code for one of the PUSHC instructions. */
 958
 959 static void
 960 expand_java_pushc (ival, type)
 961      int ival;
 962      tree type;
 963 {
 964   tree value;
 965   if (type == ptr_type_node && ival == 0)
 966     value = null_pointer_node;
 967   else if (type == int_type_node || type == long_type_node)
 968     {
 969       value = build_int_2 (ival, ival < 0 ? -1 : 0);
 970       TREE_TYPE (value) = type;
 971     }
 972   else if (type == float_type_node || type == double_type_node)
 973     {
 974       REAL_VALUE_TYPE x;
 975 #ifdef REAL_ARITHMETIC
 976       REAL_VALUE_FROM_INT (x, ival, 0, TYPE_MODE (type));
 977 #else
 978       x = ival;
 979 #endif
 980       value = build_real (type, x);
 981     }
 982   else
 983     fatal ("internal error in expand_java_pushc");
 984   push_value (value);
 985 }
 986
 987 #ifndef INT_TYPE_SIZE
 988 #define INT_TYPE_SIZE BITS_PER_WORD
 989 #endif
 990
 991 static void
 992 expand_java_return (type)
 993      tree type;
 994 {
 995   if (type == void_type_node)
 996     expand_null_return ();
 997   else
 998     {
 999       tree retval = pop_value (type);
1000       tree res = DECL_RESULT (current_function_decl);
1001       retval = build (MODIFY_EXPR, TREE_TYPE (res), res, retval);
1002
1003       /* Handle the situation where the native integer type is smaller
1004          than the JVM integer. It can happen for many cross compilers.
1005          The whole if expression just goes away if INT_TYPE_SIZE < 32
1006          is false. */
1007       if (INT_TYPE_SIZE < 32
1008           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (res)))
1009               < GET_MODE_SIZE (TYPE_MODE (type))))
1010         retval = build1(NOP_EXPR, TREE_TYPE(res), retval);
1011
1012       TREE_SIDE_EFFECTS (retval) = 1;
1013       expand_return (retval);
1014     }
1015 }
1016
1017 tree
1018 build_address_of (value)
1019      tree value;
1020 {
1021   return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (value)), value);
1022 }
1023
1024 static void
1025 expand_java_NEW (type)
1026      tree type;
1027 {
1028   if (! CLASS_LOADED_P (type))
1029     load_class (type, 1);
1030   safe_layout_class (type);
1031   push_value (build (CALL_EXPR, promote_type (type),
1032                      build_address_of (alloc_object_node),
1033                      tree_cons (NULL_TREE, build_class_ref (type),
1034                                 build_tree_list (NULL_TREE,
1035                                                  size_in_bytes (type))),
1036                      NULL_TREE));
1037 }
1038
1039 /* This returns an expression which will extract the class of an
1040    object.  */
1041
1042 tree
1043 build_get_class (value)
1044      tree value;
1045 {
1046   tree class_field = lookup_field (&dtable_type, get_identifier ("class"));
1047   tree vtable_field = lookup_field (&object_type_node,
1048                                     get_identifier ("vtable"));
1049   return build (COMPONENT_REF, class_ptr_type,
1050                 build1 (INDIRECT_REF, dtable_type,
1051                         build (COMPONENT_REF, dtable_ptr_type,
1052                                build1 (INDIRECT_REF, object_type_node, value),
1053                                vtable_field)),
1054                 class_field);
1055 }
1056
1057 /* This builds the tree representation of the `instanceof' operator.
1058    It tries various tricks to optimize this in cases where types are
1059    known.  */
1060
1061 tree
1062 build_instanceof (value, type)
1063      tree value, type;
1064 {
1065   tree expr;
1066   tree itype = TREE_TYPE (TREE_TYPE (soft_instanceof_node));
1067   tree valtype = TREE_TYPE (TREE_TYPE (value));
1068   tree valclass = TYPE_NAME (valtype);
1069   tree klass;
1070
1071   /* When compiling from bytecode, we need to ensure that TYPE has
1072      been loaded.  */
1073   if (CLASS_P (type) && ! CLASS_LOADED_P (type))
1074     {
1075       load_class (type, 1);
1076       safe_layout_class (type);
1077       if (! TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) == ERROR_MARK)
1078         return error_mark_node;
1079     }
1080   klass = TYPE_NAME (type);
1081
1082   if (type == object_type_node || inherits_from_p (valtype, type))
1083     {
1084       /* Anything except `null' is an instance of Object.  Likewise,
1085          if the object is known to be an instance of the class, then
1086          we only need to check for `null'.  */
1087       expr = build (COND_EXPR, itype,
1088                     value,
1089                     boolean_true_node, boolean_false_node);
1090     }
1091   else if (DECL_P (klass) && DECL_P (valclass)
1092            && ! CLASS_INTERFACE (valclass)
1093            && ! CLASS_INTERFACE (klass)
1094            && ! inherits_from_p (type, valtype)
1095            && (CLASS_FINAL (klass)
1096                || ! inherits_from_p (valtype, type)))
1097     {
1098       /* The classes are from different branches of the derivation
1099          tree, so we immediately know the answer.  */
1100       expr = boolean_false_node;
1101     }
1102   else if (DECL_P (klass) && CLASS_FINAL (klass))
1103     {
1104       tree save = save_expr (value);
1105       expr = build (COND_EXPR, itype,
1106                     save,
1107                     build (EQ_EXPR, itype,
1108                            build_get_class (save),
1109                            build_class_ref (type)),
1110                     boolean_false_node);
1111     }
1112   else
1113     {
1114       expr = build (CALL_EXPR, itype,
1115                     build_address_of (soft_instanceof_node),
1116                     tree_cons (NULL_TREE, value,
1117                                build_tree_list (NULL_TREE,
1118                                                 build_class_ref (type))),
1119                     NULL_TREE);
1120     }
1121   TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (value);
1122   return expr;
1123 }
1124
1125 static void
1126 expand_java_INSTANCEOF (type)
1127      tree type;
1128 {
1129   tree value = pop_value (object_ptr_type_node);
1130   value = build_instanceof (value, type);
1131   push_value (value);
1132 }
1133
1134 static void
1135 expand_java_CHECKCAST (type)
1136      tree type;
1137 {
1138   tree value = pop_value (ptr_type_node);
1139   value = build (CALL_EXPR, promote_type (type),
1140                  build_address_of (soft_checkcast_node),
1141                  tree_cons (NULL_TREE, build_class_ref (type),
1142                             build_tree_list (NULL_TREE, value)),
1143                  NULL_TREE);
1144   push_value (value);
1145 }
1146
1147 static void
1148 expand_iinc (local_var_index, ival, pc)
1149      unsigned int local_var_index;
1150      int ival;
1151      int pc;
1152 {
1153     tree local_var, res;
1154     tree constant_value;
1155
1156     flush_quick_stack ();
1157     local_var = find_local_variable (local_var_index, int_type_node, pc);
1158     constant_value = build_int_2 (ival, ival < 0 ? -1 : 0);
1159     res = fold (build (PLUS_EXPR, int_type_node, local_var, constant_value));
1160     expand_assignment (local_var, res, 0, 0);
1161 }
1162
1163
1164 tree
1165 build_java_soft_divmod (op, type, op1, op2)
1166     enum tree_code op;
1167     tree type, op1, op2;
1168 {
1169   tree call = NULL;
1170   tree arg1 = convert (type, op1);
1171   tree arg2 = convert (type, op2);
1172
1173   if (type == int_type_node)
1174     {
1175       switch (op)
1176         {
1177         case TRUNC_DIV_EXPR:
1178           call = soft_idiv_node;
1179           break;
1180         case TRUNC_MOD_EXPR:
1181           call = soft_irem_node;
1182           break;
1183         default:
1184           break;
1185         }
1186     }
1187   else if (type == long_type_node)
1188     {
1189       switch (op)
1190         {
1191         case TRUNC_DIV_EXPR:
1192           call = soft_ldiv_node;
1193           break;
1194         case TRUNC_MOD_EXPR:
1195           call = soft_lrem_node;
1196           break;
1197         default:
1198           break;
1199         }
1200     }
1201
1202   if (! call)
1203     fatal ("Internal compiler error in build_java_soft_divmod");
1204
1205   call = build (CALL_EXPR, type,
1206                 build_address_of (call),
1207                 tree_cons (NULL_TREE, arg1,
1208                            build_tree_list (NULL_TREE, arg2)),
1209                 NULL_TREE);
1210
1211   return call;
1212 }
1213
1214 tree
1215 build_java_binop (op, type, arg1, arg2)
1216      enum tree_code op;
1217      tree type, arg1, arg2;
1218 {
1219   tree mask;
1220   switch (op)
1221     {
1222     case URSHIFT_EXPR:
1223       {
1224         tree u_type = unsigned_type (type);
1225         arg1 = convert (u_type, arg1);
1226         arg1 = build_java_binop (RSHIFT_EXPR, u_type, arg1, arg2);
1227         return convert (type, arg1);
1228       }
1229     case LSHIFT_EXPR:
1230     case RSHIFT_EXPR:
1231       mask = build_int_2 (TYPE_PRECISION (TREE_TYPE (arg1)) - 1, 0);
1232       arg2 = fold (build (BIT_AND_EXPR, int_type_node, arg2, mask));
1233       break;
1234
1235     case COMPARE_L_EXPR:  /* arg1 > arg2 ?  1 : arg1 == arg2 ? 0 : -1 */
1236     case COMPARE_G_EXPR:  /* arg1 < arg2 ? -1 : arg1 == arg2 ? 0 :  1 */
1237       arg1 = save_expr (arg1);  arg2 = save_expr (arg2);
1238       {
1239         tree ifexp1 = fold ( build (op == COMPARE_L_EXPR ? GT_EXPR : LT_EXPR,
1240                                     boolean_type_node, arg1, arg2));
1241         tree ifexp2 = fold ( build (EQ_EXPR, boolean_type_node, arg1, arg2));
1242         tree second_compare = fold (build (COND_EXPR, int_type_node,
1243                                            ifexp2, integer_zero_node,
1244                                            op == COMPARE_L_EXPR
1245                                            ? integer_negative_one_node
1246                                            : integer_one_node));
1247         return fold (build (COND_EXPR, int_type_node, ifexp1,
1248                             op == COMPARE_L_EXPR ? integer_one_node
1249                             : integer_negative_one_node,
1250                             second_compare));
1251       }
1252     case COMPARE_EXPR:
1253       arg1 = save_expr (arg1);  arg2 = save_expr (arg2);
1254       {
1255         tree ifexp1 = fold ( build (LT_EXPR, boolean_type_node, arg1, arg2));
1256         tree ifexp2 = fold ( build (GT_EXPR, boolean_type_node, arg1, arg2));
1257         tree second_compare = fold ( build (COND_EXPR, int_type_node,
1258                                             ifexp2, integer_one_node,
1259                                             integer_zero_node));
1260         return fold (build (COND_EXPR, int_type_node,
1261                             ifexp1, integer_negative_one_node, second_compare));
1262       }
1263     case TRUNC_DIV_EXPR:
1264     case TRUNC_MOD_EXPR:
1265       if (TREE_CODE (type) == REAL_TYPE
1266           && op == TRUNC_MOD_EXPR)
1267         {
1268           tree call;
1269           if (type != double_type_node)
1270             {
1271               arg1 = convert (double_type_node, arg1);
1272               arg2 = convert (double_type_node, arg2);
1273             }
1274           call = build (CALL_EXPR, double_type_node,
1275                         build_address_of (soft_fmod_node),
1276                         tree_cons (NULL_TREE, arg1,
1277                                    build_tree_list (NULL_TREE, arg2)),
1278                         NULL_TREE);
1279           if (type != double_type_node)
1280             call = convert (type, call);
1281           return call;
1282         }
1283
1284       if (TREE_CODE (type) == INTEGER_TYPE
1285           && flag_use_divide_subroutine
1286           && ! flag_syntax_only)
1287         return build_java_soft_divmod (op, type, arg1, arg2);
1288
1289       break;
1290     default:  ;
1291     }
1292   return fold (build (op, type, arg1, arg2));
1293 }
1294
1295 static void
1296 expand_java_binop (type, op)
1297      tree type;  enum tree_code op;
1298 {
1299   tree larg, rarg;
1300   tree ltype = type;
1301   tree rtype = type;
1302   switch (op)
1303     {
1304     case LSHIFT_EXPR:
1305     case RSHIFT_EXPR:
1306     case URSHIFT_EXPR:
1307       rtype = int_type_node;
1308       rarg = pop_value (rtype);
1309       break;
1310     default:
1311       rarg = pop_value (rtype);
1312     }
1313   larg = pop_value (ltype);
1314   push_value (build_java_binop (op, type, larg, rarg));
1315 }
1316
1317 /* Lookup the field named NAME in *TYPEP or its super classes.
1318    If not found, return NULL_TREE.
1319    (If the *TYPEP is not found, or if the field reference is
1320    ambiguous, return error_mark_node.)
1321    If found, return the FIELD_DECL, and set *TYPEP to the
1322    class containing the field. */
1323
1324 tree
1325 lookup_field (typep, name)
1326      tree *typep;
1327      tree name;
1328 {
1329   if (CLASS_P (*typep) && !CLASS_LOADED_P (*typep))
1330     {
1331       load_class (*typep, 1);
1332       safe_layout_class (*typep);
1333       if (!TYPE_SIZE (*typep) || TREE_CODE (TYPE_SIZE (*typep)) == ERROR_MARK)
1334         return error_mark_node;
1335     }
1336   do
1337     {
1338       tree field, basetype_vec;
1339       tree save_field;
1340       int n, i;
1341
1342       for (field = TYPE_FIELDS (*typep); field; field = TREE_CHAIN (field))
1343         if (DECL_NAME (field) == name)
1344           return field;
1345
1346       /* If *typep is an innerclass, lookup the field in its enclosing
1347          contexts */
1348       if (INNER_CLASS_TYPE_P (*typep))
1349         {
1350           tree outer_type = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (*typep)));
1351
1352           if ((field = lookup_field (&outer_type, name)))
1353             return field;
1354         }
1355
1356       /* Process implemented interfaces. */
1357       basetype_vec = TYPE_BINFO_BASETYPES (*typep);
1358       n = TREE_VEC_LENGTH (basetype_vec);
1359       save_field = NULL_TREE;
1360       for (i = 0; i < n; i++)
1361         {
1362           tree t = BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i));
1363           if ((field = lookup_field (&t, name)))
1364             {
1365               if (save_field == field)
1366                 continue;
1367               if (save_field == NULL_TREE)
1368                 save_field = field;
1369               else
1370                 {
1371                   tree i1 = DECL_CONTEXT (save_field);
1372                   tree i2 = DECL_CONTEXT (field);
1373                   error ("reference `%s' is ambiguous: appears in interface `%s' and interface `%s'",
1374                          IDENTIFIER_POINTER (name),
1375                          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (i1))),
1376                          IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (i2))));
1377                   return error_mark_node;
1378                 }
1379             }
1380         }
1381
1382       if (save_field != NULL_TREE)
1383         return save_field;
1384
1385       *typep = CLASSTYPE_SUPER (*typep);
1386     } while (*typep);
1387   return NULL_TREE;
1388 }
1389
1390 /* Look up the field named NAME in object SELF_VALUE,
1391    which has class SELF_CLASS (a non-handle RECORD_TYPE).
1392    SELF_VALUE is NULL_TREE if looking for a static field. */
1393
1394 tree
1395 build_field_ref (self_value, self_class, name)
1396      tree self_value, self_class, name;
1397 {
1398   tree base_class = self_class;
1399   tree field_decl = lookup_field (&base_class, name);
1400   if (field_decl == NULL_TREE)
1401     {
1402       error ("field `%s' not found", IDENTIFIER_POINTER (name));
1403       return error_mark_node;
1404     }
1405   if (self_value == NULL_TREE)
1406     {
1407       return build_static_field_ref (field_decl);
1408     }
1409   else
1410     {
1411       tree base_handle_type = promote_type (base_class);
1412       if (base_handle_type != TREE_TYPE (self_value))
1413         self_value = fold (build1 (NOP_EXPR, base_handle_type, self_value));
1414 #ifdef JAVA_USE_HANDLES
1415       self_value = unhand_expr (self_value);
1416 #endif
1417       self_value = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (self_value)),
1418                            self_value);
1419       return fold (build (COMPONENT_REF, TREE_TYPE (field_decl),
1420                           self_value, field_decl));
1421     }
1422 }
1423
1424 tree
1425 lookup_label (pc)
1426      int pc;
1427 {
1428   tree name;
1429   char buf[32];
1430   ASM_GENERATE_INTERNAL_LABEL(buf, "LJpc=", pc);
1431   name = get_identifier (buf);
1432   if (IDENTIFIER_LOCAL_VALUE (name))
1433     return IDENTIFIER_LOCAL_VALUE (name);
1434   else
1435     {
1436       /* The type of the address of a label is return_address_type_node. */
1437       tree decl = create_label_decl (name);
1438       LABEL_PC (decl) = pc;
1439       label_rtx (decl);
1440       return pushdecl (decl);
1441     }
1442 }
1443
1444 /* Generate a unique name for the purpose of loops and switches
1445    labels, and try-catch-finally blocks label or temporary variables.  */
1446
1447 tree
1448 generate_name ()
1449 {
1450   static int l_number = 0;
1451   char buff [32];
1452   ASM_GENERATE_INTERNAL_LABEL(buff, "LJv", l_number);
1453   l_number++;
1454   return get_identifier (buff);
1455 }
1456
1457 tree
1458 create_label_decl (name)
1459      tree name;
1460 {
1461   tree decl;
1462   push_obstacks (&permanent_obstack, &permanent_obstack);
1463   decl = build_decl (LABEL_DECL, name,
1464                      TREE_TYPE (return_address_type_node));
1465   pop_obstacks ();
1466   DECL_CONTEXT (decl) = current_function_decl;
1467   DECL_IGNORED_P (decl) = 1;
1468   return decl;
1469 }
1470
1471 /* This maps a bytecode offset (PC) to various flags. */
1472 char *instruction_bits;
1473
1474 static void
1475 note_label (current_pc, target_pc)
1476      int current_pc ATTRIBUTE_UNUSED, target_pc;
1477 {
1478   lookup_label (target_pc);
1479   instruction_bits [target_pc] |= BCODE_JUMP_TARGET;
1480 }
1481
1482 /* Emit code to jump to TARGET_PC if VALUE1 CONDITION VALUE2,
1483    where CONDITION is one of one the compare operators. */
1484
1485 static void
1486 expand_compare (condition, value1, value2, target_pc)
1487      enum tree_code condition;
1488      tree value1, value2;
1489      int target_pc;
1490 {
1491   tree target = lookup_label (target_pc);
1492   tree cond = fold (build (condition, boolean_type_node, value1, value2));
1493   expand_start_cond (truthvalue_conversion (cond), 0);
1494   expand_goto (target);
1495   expand_end_cond ();
1496 }
1497
1498 /* Emit code for a TEST-type opcode. */
1499
1500 static void
1501 expand_test (condition, type, target_pc)
1502      enum tree_code condition;
1503      tree type;
1504      int target_pc;
1505 {
1506   tree value1, value2;
1507   flush_quick_stack ();
1508   value1 = pop_value (type);
1509   value2 = (type == ptr_type_node) ? null_pointer_node : integer_zero_node;
1510   expand_compare (condition, value1, value2, target_pc);
1511 }
1512
1513 /* Emit code for a COND-type opcode. */
1514
1515 static void
1516 expand_cond (condition, type, target_pc)
1517      enum tree_code condition;
1518      tree type;
1519      int target_pc;
1520 {
1521   tree value1, value2;
1522   flush_quick_stack ();
1523   /* note: pop values in opposite order */
1524   value2 = pop_value (type);
1525   value1 = pop_value (type);
1526   /* Maybe should check value1 and value2 for type compatibility ??? */
1527   expand_compare (condition, value1, value2, target_pc);
1528 }
1529
1530 static void
1531 expand_java_goto (target_pc)
1532      int target_pc;
1533 {
1534   tree target_label = lookup_label (target_pc);
1535   flush_quick_stack ();
1536   expand_goto (target_label);
1537 }
1538
1539 #if 0
1540 static void
1541 expand_java_call (target_pc, return_address)
1542      int target_pc, return_address;
1543 {
1544   tree target_label = lookup_label (target_pc);
1545   tree value = build_int_2 (return_address, return_address < 0 ? -1 : 0);
1546   push_value (value);
1547   flush_quick_stack ();
1548   expand_goto (target_label);
1549 }
1550
1551 static void
1552 expand_java_ret (return_address)
1553      tree return_address ATTRIBUTE_UNUSED;
1554 {
1555   warning ("ret instruction not implemented");
1556 #if 0
1557   tree target_label = lookup_label (target_pc);
1558   flush_quick_stack ();
1559   expand_goto (target_label);
1560 #endif
1561 }
1562 #endif
1563
1564 /* Recursive helper function to pop argument types during verifiation. */
1565
1566 void
1567 pop_argument_types (arg_types)
1568      tree arg_types;
1569 {
1570   if (arg_types == end_params_node)
1571     return;
1572   if (TREE_CODE (arg_types) == TREE_LIST)
1573     {
1574       pop_argument_types (TREE_CHAIN (arg_types));
1575       pop_type (TREE_VALUE (arg_types));
1576       return;
1577     }
1578   abort ();
1579 }
1580
1581 static tree
1582 pop_arguments (arg_types)
1583      tree arg_types;
1584 {
1585   if (arg_types == end_params_node)
1586     return NULL_TREE;
1587   if (TREE_CODE (arg_types) == TREE_LIST)
1588     {
1589       tree tail = pop_arguments (TREE_CHAIN (arg_types));
1590       tree type = TREE_VALUE (arg_types);
1591       tree arg = pop_value (type);
1592       if (PROMOTE_PROTOTYPES
1593           && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
1594           && INTEGRAL_TYPE_P (type))
1595         arg = convert (integer_type_node, arg);
1596       return tree_cons (NULL_TREE, arg, tail);
1597     }
1598   abort ();
1599 }
1600
1601 /* Build an expression to initialize the class CLAS.
1602    if EXPR is non-NULL, returns an expression to first call the initializer
1603    (if it is needed) and then calls EXPR. */
1604
1605 tree
1606 build_class_init (clas, expr)
1607      tree clas, expr;
1608 {
1609   tree init, call;
1610   struct init_test_hash_entry *ite;
1611   if (inherits_from_p (current_class, clas))
1612     return expr;
1613
1614   if (always_initialize_class_p)
1615     {
1616       init = build (CALL_EXPR, void_type_node,
1617                     build_address_of (soft_initclass_node),
1618                     build_tree_list (NULL_TREE, build_class_ref (clas)),
1619                     NULL_TREE);
1620       TREE_SIDE_EFFECTS (init) = 1;
1621     }
1622   else
1623     {
1624       ite = (struct init_test_hash_entry *)
1625         hash_lookup (&DECL_FUNCTION_INIT_TEST_TABLE (current_function_decl),
1626                      (const hash_table_key) clas,
1627                      TRUE, NULL);
1628
1629       if (ite->init_test_decl == 0)
1630         ite->init_test_decl = build_decl (VAR_DECL, NULL_TREE,
1631                                           boolean_type_node);
1632       /* Tell the check-init code to ignore this decl.  */
1633       DECL_BIT_INDEX(ite->init_test_decl) = -1;
1634
1635       init = build (CALL_EXPR, void_type_node,
1636                     build_address_of (soft_initclass_node),
1637                     build_tree_list (NULL_TREE, build_class_ref (clas)),
1638                     NULL_TREE);
1639       TREE_SIDE_EFFECTS (init) = 1;
1640       call = build (COMPOUND_EXPR, TREE_TYPE (expr), init,
1641                     build (MODIFY_EXPR, boolean_type_node,
1642                            ite->init_test_decl, boolean_true_node));
1643       TREE_SIDE_EFFECTS (call) = 1;
1644       init = build (COND_EXPR, void_type_node,
1645                     build (EQ_EXPR, boolean_type_node,
1646                            ite->init_test_decl, boolean_false_node),
1647                     call, integer_zero_node);
1648       TREE_SIDE_EFFECTS (init) = 1;
1649     }
1650
1651   if (expr != NULL_TREE)
1652     {
1653       expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
1654       TREE_SIDE_EFFECTS (expr) = 1;
1655       return expr;
1656     }
1657   return init;
1658 }
1659
1660 static tree methods_ident = NULL_TREE;
1661 static tree ncode_ident = NULL_TREE;
1662 tree dtable_ident = NULL_TREE;
1663
1664 tree
1665 build_known_method_ref (method, method_type, self_type, method_signature, arg_list)
1666      tree method, method_type ATTRIBUTE_UNUSED, self_type,
1667           method_signature ATTRIBUTE_UNUSED, arg_list ATTRIBUTE_UNUSED;
1668 {
1669   tree func;
1670   if (is_compiled_class (self_type))
1671     {
1672       make_decl_rtl (method, NULL, 1);
1673       func = build1 (ADDR_EXPR, method_ptr_type_node, method);
1674     }
1675   else
1676     {
1677       /* We don't know whether the method has been (statically) compiled.
1678          Compile this code to get a reference to the method's code:
1679
1680          SELF_TYPE->methods[METHOD_INDEX].ncode
1681
1682          This is guaranteed to work (assuming SELF_TYPE has
1683          been initialized), since if the method is not compiled yet,
1684          its ncode points to a trampoline that forces compilation. */
1685
1686       int method_index = 0;
1687       tree meth;
1688       tree ref = build_class_ref (self_type);
1689       ref = build1 (INDIRECT_REF, class_type_node, ref);
1690       if (ncode_ident == NULL_TREE)
1691         ncode_ident = get_identifier ("ncode");
1692       if (methods_ident == NULL_TREE)
1693         methods_ident = get_identifier ("methods");
1694       ref = build (COMPONENT_REF, method_ptr_type_node, ref,
1695                    lookup_field (&class_type_node, methods_ident));
1696       for (meth = TYPE_METHODS (CLASS_TO_HANDLE_TYPE (self_type));
1697            ; meth = TREE_CHAIN (meth))
1698         {
1699           if (method == meth)
1700             break;
1701           if (meth == NULL_TREE)
1702             fatal ("method '%s' not found in class",
1703                    IDENTIFIER_POINTER (DECL_NAME (method)));
1704           method_index++;
1705         }
1706       method_index *= int_size_in_bytes (method_type_node);
1707       ref = fold (build (PLUS_EXPR, method_ptr_type_node,
1708                          ref, build_int_2 (method_index, 0)));
1709       ref = build1 (INDIRECT_REF, method_type_node, ref);
1710       func = build (COMPONENT_REF, nativecode_ptr_type_node,
1711                     ref,
1712                     lookup_field (&method_type_node, ncode_ident));
1713     }
1714   return func;
1715 }
1716
1717 tree
1718 invoke_build_dtable (is_invoke_interface, arg_list)
1719      int is_invoke_interface;
1720      tree arg_list;
1721 {
1722   tree dtable, objectref;
1723
1724   TREE_VALUE (arg_list) = save_expr (TREE_VALUE (arg_list));
1725
1726   /* If we're dealing with interfaces and if the objectref
1727      argument is an array then get the dispatch table of the class
1728      Object rather than the one from the objectref.  */
1729   objectref = (is_invoke_interface
1730                && is_array_type_p (TREE_TYPE (TREE_VALUE (arg_list))) ?
1731                object_type_node : TREE_VALUE (arg_list));
1732
1733   if (dtable_ident == NULL_TREE)
1734     dtable_ident = get_identifier ("vtable");
1735   dtable = build1 (INDIRECT_REF, object_type_node, objectref );
1736   dtable = build (COMPONENT_REF, dtable_ptr_type, dtable,
1737                   lookup_field (&object_type_node, dtable_ident));
1738
1739   return dtable;
1740 }
1741
1742 tree
1743 build_invokevirtual (dtable, method)
1744      tree dtable, method;
1745 {
1746   tree func;
1747   tree nativecode_ptr_ptr_type_node
1748     = build_pointer_type (nativecode_ptr_type_node);
1749   tree method_index = convert (sizetype, DECL_VINDEX (method));
1750
1751   /* Add one to skip "class" field of dtable, and one to skip unused
1752      vtable entry (for C++ compatibility). */
1753   method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1754   method_index = size_binop (MULT_EXPR, method_index,
1755                              TYPE_SIZE_UNIT (nativecode_ptr_ptr_type_node));
1756   func = fold (build (PLUS_EXPR, nativecode_ptr_ptr_type_node, dtable,
1757                       convert (nativecode_ptr_ptr_type_node, method_index)));
1758   func = build1 (INDIRECT_REF, nativecode_ptr_type_node, func);
1759
1760   return func;
1761 }
1762
1763 tree
1764 build_invokeinterface (dtable, method)
1765      tree dtable, method;
1766 {
1767   static tree class_ident = NULL_TREE;
1768   tree lookup_arg;
1769   tree interface;
1770   tree idx;
1771   tree meth;
1772   int i;
1773
1774   /* We expand invokeinterface here.  _Jv_LookupInterfaceMethod() will
1775      ensure that the selected method exists, is public and not
1776      abstract nor static.  */
1777
1778   if (class_ident == NULL_TREE)
1779     class_ident = get_identifier ("class");
1780
1781   dtable = build1 (INDIRECT_REF, dtable_type, dtable);
1782   dtable = build (COMPONENT_REF, class_ptr_type, dtable,
1783                   lookup_field (&dtable_type, class_ident));
1784
1785   interface = DECL_CONTEXT (method);
1786   layout_class_methods (interface);
1787
1788   i = 1;
1789   for (meth = TYPE_METHODS (interface); ; meth = TREE_CHAIN (meth), i++)
1790     {
1791       if (meth == method)
1792         {
1793           idx = build_int_2 (i, 0);
1794           break;
1795         }
1796       if (meth == NULL_TREE)
1797         fatal ("internal error in build_invokeinterface");
1798     }
1799
1800   lookup_arg = tree_cons (NULL_TREE, dtable,
1801                           tree_cons (NULL_TREE, build_class_ref (interface),
1802                                      build_tree_list (NULL_TREE, idx)));
1803
1804   return build (CALL_EXPR, ptr_type_node,
1805                 build_address_of (soft_lookupinterfacemethod_node),
1806                 lookup_arg, NULL_TREE);
1807 }
1808
1809 /* Expand one of the invoke_* opcodes.
1810    OCPODE is the specific opcode.
1811    METHOD_REF_INDEX is an index into the constant pool.
1812    NARGS is the number of arguments, or -1 if not specified. */
1813
1814 static void
1815 expand_invoke (opcode, method_ref_index, nargs)
1816      int opcode;
1817      int method_ref_index;
1818      int nargs ATTRIBUTE_UNUSED;
1819 {
1820   tree method_signature = COMPONENT_REF_SIGNATURE(&current_jcf->cpool, method_ref_index);
1821   tree method_name = COMPONENT_REF_NAME (&current_jcf->cpool, method_ref_index);
1822   tree self_type = get_class_constant
1823     (current_jcf, COMPONENT_REF_CLASS_INDEX(&current_jcf->cpool, method_ref_index));
1824   const char *self_name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
1825   tree call, func, method, arg_list, method_type;
1826   tree cond = NULL_TREE;
1827
1828   if (! CLASS_LOADED_P (self_type))
1829     {
1830       load_class (self_type, 1);
1831       safe_layout_class (self_type);
1832       if (TREE_CODE (TYPE_SIZE (self_type)) == ERROR_MARK)
1833         fatal ("failed to find class '%s'", self_name);
1834     }
1835   layout_class_methods (self_type);
1836
1837   if (ID_INIT_P (method_name))
1838     method = lookup_java_constructor (CLASS_TO_HANDLE_TYPE (self_type),
1839                                       method_signature);
1840   else
1841     method = lookup_java_method (CLASS_TO_HANDLE_TYPE (self_type),
1842                                  method_name, method_signature);
1843   if (method == NULL_TREE)
1844     {
1845       error ("Class '%s' has no method named '%s' matching signature '%s'",
1846              self_name,
1847              IDENTIFIER_POINTER (method_name),
1848              IDENTIFIER_POINTER (method_signature));
1849     }
1850   /* Invoke static can't invoke static/abstract method */
1851   else if (opcode == OPCODE_invokestatic)
1852     {
1853       if (!METHOD_STATIC (method))
1854         {
1855           error ("invokestatic on non static method");
1856           method = NULL_TREE;
1857         }
1858       else if (METHOD_ABSTRACT (method))
1859         {
1860           error ("invokestatic on abstract method");
1861           method = NULL_TREE;
1862         }
1863     }
1864   else
1865     {
1866       if (METHOD_STATIC (method))
1867         {
1868           error ("invoke[non-static] on static method");
1869           method = NULL_TREE;
1870         }
1871     }
1872
1873   if (method == NULL_TREE)
1874     {
1875       method_type = get_type_from_signature (method_signature);
1876       pop_arguments (TYPE_ARG_TYPES (method_type));
1877       if (opcode != OPCODE_invokestatic)
1878         pop_type (self_type);
1879       method_type = promote_type (TREE_TYPE (method_type));
1880       push_value (convert (method_type, integer_zero_node));
1881       return;
1882     }
1883
1884   method_type = TREE_TYPE (method);
1885   arg_list = pop_arguments (TYPE_ARG_TYPES (method_type));
1886   flush_quick_stack ();
1887
1888   func = NULL_TREE;
1889   if (opcode == OPCODE_invokestatic)
1890     func = build_known_method_ref (method, method_type, self_type,
1891                                    method_signature, arg_list);
1892   else if (opcode == OPCODE_invokespecial
1893            || (opcode == OPCODE_invokevirtual
1894                && (METHOD_PRIVATE (method)
1895                    || METHOD_FINAL (method)
1896                    || CLASS_FINAL (TYPE_NAME (self_type)))))
1897     {
1898       /* If the object for the method call is null, we throw an
1899          exception.  We don't do this if the object is the current
1900          method's `this'.  In other cases we just rely on an
1901          optimization pass to eliminate redundant checks.  FIXME:
1902          Unfortunately there doesn't seem to be a way to determine
1903          what the current method is right now.  */
1904       /* We use a SAVE_EXPR here to make sure we only evaluate
1905          the new `self' expression once.  */
1906       tree save_arg = save_expr (TREE_VALUE (arg_list));
1907       TREE_VALUE (arg_list) = save_arg;
1908       cond = build (EQ_EXPR, boolean_type_node, save_arg, null_pointer_node);
1909       func = build_known_method_ref (method, method_type, self_type,
1910                                      method_signature, arg_list);
1911     }
1912   else
1913     {
1914       tree dtable = invoke_build_dtable (opcode == OPCODE_invokeinterface,
1915                                          arg_list);
1916       if (opcode == OPCODE_invokevirtual)
1917         func = build_invokevirtual (dtable, method);
1918       else
1919         func = build_invokeinterface (dtable, method);
1920     }
1921   func = build1 (NOP_EXPR, build_pointer_type (method_type), func);
1922   call = build (CALL_EXPR, TREE_TYPE (method_type), func, arg_list, NULL_TREE);
1923   TREE_SIDE_EFFECTS (call) = 1;
1924
1925   if (cond != NULL_TREE)
1926     {
1927       /* We have to make the `then' branch a compound expression to
1928          make the types turn out right.  This seems bizarre.  */
1929       call = build (COND_EXPR, TREE_TYPE (call), cond,
1930                     build (COMPOUND_EXPR, TREE_TYPE (call),
1931                            build (CALL_EXPR, void_type_node,
1932                                   build_address_of (soft_nullpointer_node),
1933                                   NULL_TREE, NULL_TREE),
1934                            (FLOAT_TYPE_P (TREE_TYPE (call))
1935                             ? build_real (TREE_TYPE (call), dconst0)
1936                             : build1 (CONVERT_EXPR, TREE_TYPE (call),
1937                                       integer_zero_node))),
1938                     call);
1939       TREE_SIDE_EFFECTS (call) = 1;
1940     }
1941
1942   if (TREE_CODE (TREE_TYPE (method_type)) == VOID_TYPE)
1943     expand_expr_stmt (call);
1944   else
1945     {
1946       push_value (call);
1947       flush_quick_stack ();
1948     }
1949 }
1950
1951 /* Create a stub which will be put into the vtable but which will call
1952    a JNI function.  */
1953
1954 tree
1955 build_jni_stub (method)
1956      tree method;
1957 {
1958   tree jnifunc, call, args, body, lookup_arg, method_sig, arg_types;
1959   tree jni_func_type, tem;
1960   tree env_var, res_var = NULL_TREE, block;
1961   tree method_args, res_type;
1962   tree meth_var;
1963
1964   tree klass = DECL_CONTEXT (method);
1965   int from_class = ! CLASS_FROM_SOURCE_P (klass);
1966   klass = build_class_ref (klass);
1967
1968   if (! METHOD_NATIVE (method) || ! flag_jni)
1969     abort ();
1970
1971   DECL_ARTIFICIAL (method) = 1;
1972   DECL_EXTERNAL (method) = 0;
1973
1974   env_var = build_decl (VAR_DECL, get_identifier ("env"), ptr_type_node);
1975   DECL_CONTEXT (env_var) = method;
1976
1977   if (TREE_TYPE (TREE_TYPE (method)) != void_type_node)
1978     {
1979       res_var = build_decl (VAR_DECL, get_identifier ("res"),
1980                             TREE_TYPE (TREE_TYPE (method)));
1981       DECL_CONTEXT (res_var) = method;
1982       TREE_CHAIN (env_var) = res_var;
1983     }
1984
1985   push_obstacks (&permanent_obstack, &permanent_obstack);
1986   meth_var = build_decl (VAR_DECL, get_identifier ("meth"), ptr_type_node);
1987   TREE_STATIC (meth_var) = 1;
1988   TREE_PUBLIC (meth_var) = 0;
1989   DECL_EXTERNAL (meth_var) = 0;
1990   make_decl_rtl (meth_var, NULL, 0);
1991   meth_var = pushdecl_top_level (meth_var);
1992   pop_obstacks ();
1993
1994   /* One strange way that the front ends are different is that they
1995      store arguments differently.  */
1996   if (from_class)
1997     method_args = DECL_ARGUMENTS (method);
1998   else
1999     method_args = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (method));
2000   block = build_block (env_var, NULL_TREE, NULL_TREE,
2001                        method_args, NULL_TREE);
2002   TREE_SIDE_EFFECTS (block) = 1;
2003   /* When compiling from source we don't set the type of the block,
2004      because that will prevent patch_return from ever being run.  */
2005   if (from_class)
2006     TREE_TYPE (block) = TREE_TYPE (TREE_TYPE (method));
2007
2008   /* Compute the local `env' by calling _Jv_GetJNIEnvNewFrame.  */
2009   body = build (MODIFY_EXPR, ptr_type_node, env_var,
2010                 build (CALL_EXPR, ptr_type_node,
2011                        build_address_of (soft_getjnienvnewframe_node),
2012                        build_tree_list (NULL_TREE, klass),
2013                        NULL_TREE));
2014   CAN_COMPLETE_NORMALLY (body) = 1;
2015
2016   /* All the arguments to this method become arguments to the
2017      underlying JNI function.  If we had to wrap object arguments in a
2018      special way, we would do that here.  */
2019   args = NULL_TREE;
2020   for (tem = method_args; tem != NULL_TREE; tem = TREE_CHAIN (tem))
2021     args = tree_cons (NULL_TREE, tem, args);
2022   args = nreverse (args);
2023   arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
2024
2025   /* For a static method the second argument is the class.  For a
2026      non-static method the second argument is `this'; that is already
2027      available in the argument list.  */
2028   if (METHOD_STATIC (method))
2029     {
2030       args = tree_cons (NULL_TREE, klass, args);
2031       arg_types = tree_cons (NULL_TREE, object_ptr_type_node, arg_types);
2032     }
2033
2034   /* The JNIEnv structure is the first argument to the JNI function.  */
2035   args = tree_cons (NULL_TREE, env_var, args);
2036   arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
2037
2038   /* We call _Jv_LookupJNIMethod to find the actual underlying
2039      function pointer.  _Jv_LookupJNIMethod will throw the appropriate
2040      exception if this function is not found at runtime.  */
2041   method_sig = build_java_signature (TREE_TYPE (method));
2042   lookup_arg =
2043     build_tree_list (NULL_TREE,
2044                      build_utf8_ref (unmangle_classname
2045                                      (IDENTIFIER_POINTER (method_sig),
2046                                       IDENTIFIER_LENGTH (method_sig))));
2047   tem = DECL_NAME (method);
2048   lookup_arg
2049     = tree_cons (NULL_TREE, klass,
2050                  tree_cons (NULL_TREE, build_utf8_ref (tem), lookup_arg));
2051
2052   jni_func_type
2053     = build_pointer_type (build_function_type (TREE_TYPE (TREE_TYPE (method)),
2054                                                arg_types));
2055
2056   jnifunc = build (COND_EXPR, ptr_type_node,
2057                    meth_var, meth_var,
2058                    build (MODIFY_EXPR, ptr_type_node,
2059                           meth_var,
2060                           build (CALL_EXPR, ptr_type_node,
2061                                  build_address_of (soft_lookupjnimethod_node),
2062                                  lookup_arg, NULL_TREE)));
2063
2064   /* Now we make the actual JNI call via the resulting function
2065      pointer.    */
2066   call = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (method)),
2067                 build1 (NOP_EXPR, jni_func_type, jnifunc),
2068                 args, NULL_TREE);
2069
2070   /* If the JNI call returned a result, capture it here.  If we had to
2071      unwrap JNI object results, we would do that here.  */
2072   if (res_var != NULL_TREE)
2073     call = build (MODIFY_EXPR, TREE_TYPE (TREE_TYPE (method)),
2074                   res_var, call);
2075
2076   TREE_SIDE_EFFECTS (call) = 1;
2077   CAN_COMPLETE_NORMALLY (call) = 1;
2078
2079   body = build (COMPOUND_EXPR, void_type_node, body, call);
2080   TREE_SIDE_EFFECTS (body) = 1;
2081
2082   /* Now free the environment we allocated.  */
2083   call = build (CALL_EXPR, ptr_type_node,
2084                 build_address_of (soft_jnipopsystemframe_node),
2085                 build_tree_list (NULL_TREE, env_var),
2086                 NULL_TREE);
2087   TREE_SIDE_EFFECTS (call) = 1;
2088   CAN_COMPLETE_NORMALLY (call) = 1;
2089   body = build (COMPOUND_EXPR, void_type_node, body, call);
2090   TREE_SIDE_EFFECTS (body) = 1;
2091
2092   /* Finally, do the return.  When compiling from source we rely on
2093      patch_return to patch the return value -- because DECL_RESULT is
2094      not set at the time this function is called.  */
2095   if (from_class)
2096     {
2097       res_type = void_type_node;
2098       if (res_var != NULL_TREE)
2099         {
2100           tree drt;
2101           if (! DECL_RESULT (method))
2102             abort ();
2103           /* Make sure we copy the result variable to the actual
2104              result.  We use the type of the DECL_RESULT because it
2105              might be different from the return type of the function:
2106              it might be promoted.  */
2107           drt = TREE_TYPE (DECL_RESULT (method));
2108           if (drt != TREE_TYPE (res_var))
2109             res_var = build1 (CONVERT_EXPR, drt, res_var);
2110           res_var = build (MODIFY_EXPR, drt, DECL_RESULT (method), res_var);
2111           TREE_SIDE_EFFECTS (res_var) = 1;
2112         }
2113     }
2114   else
2115     {
2116       /* This is necessary to get patch_return to run.  */
2117       res_type = NULL_TREE;
2118     }
2119   body = build (COMPOUND_EXPR, void_type_node, body,
2120                 build1 (RETURN_EXPR, res_type, res_var));
2121   TREE_SIDE_EFFECTS (body) = 1;
2122
2123   BLOCK_EXPR_BODY (block) = body;
2124   return block;
2125 }
2126
2127 /* Expand an operation to extract from or store into a field.
2128    IS_STATIC is 1 iff the field is static.
2129    IS_PUTTING is 1 for putting into a field;  0 for getting from the field.
2130    FIELD_REF_INDEX is an index into the constant pool.  */
2131
2132 static void
2133 expand_java_field_op (is_static, is_putting, field_ref_index)
2134      int is_static;
2135      int is_putting;
2136      int field_ref_index;
2137 {
2138   tree self_type =
2139       get_class_constant (current_jcf,
2140                           COMPONENT_REF_CLASS_INDEX (&current_jcf->cpool,
2141                                                      field_ref_index));
2142   const char *self_name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
2143   tree field_name = COMPONENT_REF_NAME (&current_jcf->cpool, field_ref_index);
2144   tree field_signature = COMPONENT_REF_SIGNATURE (&current_jcf->cpool,
2145                                                   field_ref_index);
2146   tree field_type = get_type_from_signature (field_signature);
2147   tree new_value = is_putting ? pop_value (field_type) : NULL_TREE;
2148   tree field_ref;
2149   int is_error = 0;
2150   tree field_decl = lookup_field (&self_type, field_name);
2151   if (field_decl == error_mark_node)
2152     {
2153       is_error = 1;
2154     }
2155   else if (field_decl == NULL_TREE)
2156     {
2157       error ("Missing field '%s' in '%s'",
2158              IDENTIFIER_POINTER (field_name), self_name);
2159       is_error = 1;
2160     }
2161   else if (build_java_signature (TREE_TYPE (field_decl)) != field_signature)
2162     {
2163       error ("Mismatching signature for field '%s' in '%s'",
2164              IDENTIFIER_POINTER (field_name), self_name);
2165       is_error = 1;
2166     }
2167   field_ref = is_static ? NULL_TREE : pop_value (self_type);
2168   if (is_error)
2169     {
2170       if (! is_putting)
2171         push_value (convert (field_type, integer_zero_node));
2172       flush_quick_stack ();
2173       return;
2174     }
2175
2176   /* Inline references to java.lang.PRIMTYPE.TYPE.
2177      In addition to being a useful (minor) optimization,
2178      this is also needed to avoid circularities in the implementation
2179      of these fields in libjava. */
2180   if (field_name == TYPE_identifier_node && ! is_putting
2181       && ! flag_emit_class_files && field_type == class_ptr_type
2182       && strncmp (self_name, "java.lang.", 10) == 0)
2183     {
2184       tree typ = build_primtype_type_ref (self_name);
2185       if (typ)
2186         {
2187           push_value (typ);
2188           return;
2189         }
2190     }
2191
2192   field_ref = build_field_ref (field_ref, self_type, field_name);
2193   if (is_static)
2194     field_ref = build_class_init (self_type, field_ref);
2195   if (is_putting)
2196     {
2197       flush_quick_stack ();
2198       if (FIELD_FINAL (field_decl))
2199         {
2200           if (DECL_CONTEXT (field_decl) != current_class)
2201             error_with_decl (field_decl,
2202                      "assignment to final field `%s' not in field's class");
2203           else if (FIELD_STATIC (field_decl))
2204             {
2205               if (!DECL_CLINIT_P (current_function_decl))
2206                 error_with_decl (field_decl,
2207              "assignment to final static field `%s' not in class initializer");
2208             }
2209           else
2210             {
2211               tree cfndecl_name = DECL_NAME (current_function_decl);
2212               if (! DECL_CONSTRUCTOR_P (current_function_decl)
2213                   && !ID_FINIT_P (cfndecl_name))
2214                 error_with_decl (field_decl, "assignment to final field `%s' not in constructor");
2215             }
2216         }
2217       expand_assignment (field_ref, new_value, 0, 0);
2218     }
2219   else
2220     push_value (field_ref);
2221 }
2222
2223 tree
2224 build_primtype_type_ref (self_name)
2225     const char *self_name;
2226 {
2227   const char *class_name = self_name+10;
2228   tree typ;
2229   if (strncmp(class_name, "Byte", 4) == 0)
2230     typ = byte_type_node;
2231   else if (strncmp(class_name, "Short", 5) == 0)
2232     typ = short_type_node;
2233   else if (strncmp(class_name, "Integer", 7) == 0)
2234     typ = int_type_node;
2235   else if (strncmp(class_name, "Long", 4) == 0)
2236     typ = long_type_node;
2237   else if (strncmp(class_name, "Float", 5) == 0)
2238     typ = float_type_node;
2239   else if (strncmp(class_name, "Double", 6) == 0)
2240     typ = double_type_node;
2241   else if (strncmp(class_name, "Boolean", 7) == 0)
2242     typ = boolean_type_node;
2243   else if (strncmp(class_name, "Char", 4) == 0)
2244     typ = char_type_node;
2245   else if (strncmp(class_name, "Void", 4) == 0)
2246     typ = void_type_node;
2247   else
2248     typ = NULL_TREE;
2249   if (typ != NULL_TREE)
2250     return build_class_ref (typ);
2251   else
2252     return NULL_TREE;
2253 }
2254
2255 void
2256 load_type_state (label)
2257      tree label;
2258 {
2259   int i;
2260   tree vec = LABEL_TYPE_STATE (label);
2261   int cur_length = TREE_VEC_LENGTH (vec);
2262   stack_pointer = cur_length - DECL_MAX_LOCALS(current_function_decl);
2263   for (i = 0; i < cur_length; i++)
2264     type_map [i] = TREE_VEC_ELT (vec, i);
2265 }
2266
2267 /* Do the expansion of a Java switch. With Gcc, switches are front-end
2268    dependant things, but they rely on gcc routines. This function is
2269    placed here because it uses things defined locally in parse.y. */
2270
2271 static tree
2272 case_identity (t, v)
2273      tree t __attribute__ ((__unused__));
2274      tree v;
2275 {
2276   return v;
2277 }
2278
2279 /* Return the name of the vtable for an array of a given primitive
2280    type.  */
2281 static tree
2282 get_primitive_array_vtable (tree elt)
2283 {
2284   tree r;
2285   if (elt == boolean_type_node)
2286     r = boolean_array_vtable;
2287   else if (elt == byte_type_node)
2288     r = byte_array_vtable;
2289   else if (elt == char_type_node)
2290     r = char_array_vtable;
2291   else if (elt == short_type_node)
2292     r = short_array_vtable;
2293   else if (elt == int_type_node)
2294     r = int_array_vtable;
2295   else if (elt == long_type_node)
2296     r = long_array_vtable;
2297   else if (elt == float_type_node)
2298     r = float_array_vtable;
2299   else if (elt == double_type_node)
2300     r = double_array_vtable;
2301   else
2302     abort ();
2303   return build_address_of (r);
2304 }
2305
2306 struct rtx_def *
2307 java_lang_expand_expr (exp, target, tmode, modifier)
2308      register tree exp;
2309      rtx target ATTRIBUTE_UNUSED;
2310      enum machine_mode tmode ATTRIBUTE_UNUSED;
2311      enum expand_modifier modifier ATTRIBUTE_UNUSED;
2312 {
2313   tree current;
2314
2315   switch (TREE_CODE (exp))
2316     {
2317     case NEW_ARRAY_INIT:
2318       {
2319         rtx tmp;
2320         tree array_type = TREE_TYPE (TREE_TYPE (exp));
2321         tree element_type = TYPE_ARRAY_ELEMENT (array_type);
2322         tree data_fld = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type)));
2323         HOST_WIDE_INT ilength = java_array_type_length (array_type);
2324         tree length = build_int_2 (ilength, 0);
2325         tree init = TREE_OPERAND (exp, 0);
2326         tree array_decl;
2327
2328         /* See if we can generate the array statically.  */
2329         if (TREE_CONSTANT (init) && TREE_STATIC (exp)
2330             && JPRIMITIVE_TYPE_P (element_type))
2331           {
2332             tree temp, value, init_decl;
2333             struct rtx_def *r;
2334             push_obstacks (&permanent_obstack, &permanent_obstack);
2335             START_RECORD_CONSTRUCTOR (temp, object_type_node);
2336             PUSH_FIELD_VALUE (temp, "vtable",
2337                               get_primitive_array_vtable (element_type));
2338             if (! flag_hash_synchronization)
2339               PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
2340             FINISH_RECORD_CONSTRUCTOR (temp);
2341             START_RECORD_CONSTRUCTOR (value, array_type);
2342             PUSH_SUPER_VALUE (value, temp);
2343             /* FIXME: build a new `length' here to get it on the right
2344                obstack.  */
2345             PUSH_FIELD_VALUE (value, "length", build_int_2 (ilength, 0));
2346             PUSH_FIELD_VALUE (value, "data", init);
2347             FINISH_RECORD_CONSTRUCTOR (value);
2348
2349             init_decl = build_decl (VAR_DECL, generate_name (), array_type);
2350             pushdecl_top_level (init_decl);
2351             TREE_STATIC (init_decl) = 1;
2352             DECL_INITIAL (init_decl) = value;
2353             DECL_IGNORED_P (init_decl) = 1;
2354             TREE_READONLY (init_decl) = 1;
2355             make_decl_rtl (init_decl, NULL, 1);
2356             init = build1 (ADDR_EXPR, TREE_TYPE (exp), init_decl);
2357             r = expand_expr (init, target, tmode, modifier);
2358             pop_obstacks ();
2359             return r;
2360           }
2361
2362         array_decl = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (exp));
2363         expand_decl (array_decl);
2364         tmp = expand_assignment (array_decl,
2365                                  build_new_array (element_type, length),
2366                                  1, 0);
2367         if (TREE_CONSTANT (init)
2368             && ilength >= 10 && JPRIMITIVE_TYPE_P (element_type))
2369           {
2370             tree init_decl;
2371             push_obstacks (&permanent_obstack, &permanent_obstack);
2372             init_decl = build_decl (VAR_DECL, generate_name (),
2373                                     TREE_TYPE (init));
2374             pushdecl_top_level (init_decl);
2375             TREE_STATIC (init_decl) = 1;
2376             DECL_INITIAL (init_decl) = init;
2377             DECL_IGNORED_P (init_decl) = 1;
2378             TREE_READONLY (init_decl) = 1;
2379             TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (init_decl)) = 1;
2380             make_decl_rtl (init_decl, NULL, 1);
2381             pop_obstacks ();
2382             init = init_decl;
2383           }
2384         expand_assignment (build (COMPONENT_REF, TREE_TYPE (data_fld),
2385                                   build1 (INDIRECT_REF, array_type,
2386                                           array_decl), data_fld), init, 0, 0);
2387         return tmp;
2388       }
2389     case BLOCK:
2390       if (BLOCK_EXPR_BODY (exp))
2391         {
2392           tree local;
2393           tree body = BLOCK_EXPR_BODY (exp);
2394           pushlevel (2);        /* 2 and above */
2395           expand_start_bindings (0);
2396           local = BLOCK_EXPR_DECLS (exp);
2397           while (local)
2398             {
2399               tree next = TREE_CHAIN (local);
2400               layout_decl (local, 0);
2401               expand_decl (pushdecl (local));
2402               local = next;
2403             }
2404           /* Avoid deep recursion for long block.  */
2405           while (TREE_CODE (body) == COMPOUND_EXPR)
2406             {
2407               expand_expr (TREE_OPERAND (body, 0), const0_rtx, VOIDmode, 0);
2408               emit_queue ();
2409               body = TREE_OPERAND (body, 1);
2410             }
2411           expand_expr (body, const0_rtx, VOIDmode, 0);
2412           emit_queue ();
2413           poplevel (1, 1, 0);
2414           expand_end_bindings (getdecls (), 1, 0);
2415           return const0_rtx;
2416         }
2417       return const0_rtx;
2418
2419     case CASE_EXPR:
2420       {
2421         tree duplicate;
2422         if (pushcase (TREE_OPERAND (exp, 0), case_identity,
2423                       build_decl (LABEL_DECL, NULL_TREE, NULL_TREE),
2424                       &duplicate) == 2)
2425           {
2426             EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (exp);
2427             parse_error_context
2428               (wfl_operator, "Duplicate case label: `%s'",
2429                print_int_node (TREE_OPERAND (exp, 0)));
2430           }
2431         return const0_rtx;
2432       }
2433
2434     case DEFAULT_EXPR:
2435       pushcase (NULL_TREE, 0,
2436                 build_decl (LABEL_DECL, NULL_TREE, NULL_TREE), NULL);
2437       return const0_rtx;
2438
2439     case SWITCH_EXPR:
2440       expand_start_case (0, TREE_OPERAND (exp, 0), int_type_node, "switch");
2441       expand_expr_stmt (TREE_OPERAND (exp, 1));
2442       expand_end_case (TREE_OPERAND (exp, 0));
2443       return const0_rtx;
2444
2445     case TRY_EXPR:
2446       /* We expand a try[-catch] block */
2447
2448       /* Expand the try block */
2449       push_obstacks (&permanent_obstack, &permanent_obstack);
2450       expand_eh_region_start ();
2451       pop_obstacks ();
2452       expand_expr_stmt (TREE_OPERAND (exp, 0));
2453       push_obstacks (&permanent_obstack, &permanent_obstack);
2454       expand_start_all_catch ();
2455       pop_obstacks ();
2456
2457       /* Expand all catch clauses (EH handlers) */
2458       for (current = TREE_OPERAND (exp, 1); current;
2459            current = TREE_CHAIN (current))
2460         {
2461           tree type;
2462           tree catch = TREE_OPERAND (current, 0);
2463           tree decl = BLOCK_EXPR_DECLS (catch);
2464           type = (decl ? TREE_TYPE (TREE_TYPE (decl)) : NULL_TREE);
2465           start_catch_handler (prepare_eh_table_type (type));
2466           expand_expr_stmt (TREE_OPERAND (current, 0));
2467
2468           expand_resume_after_catch ();
2469           end_catch_handler ();
2470         }
2471       expand_end_all_catch ();
2472       return const0_rtx;
2473
2474     default:
2475       fatal ("Can't expand '%s' tree - java_lang_expand_expr",
2476              tree_code_name [TREE_CODE (exp)]);
2477     }
2478 }
2479
2480 void
2481 expand_byte_code (jcf, method)
2482      JCF *jcf;
2483      tree method;
2484 {
2485   int PC;
2486   int i;
2487   int saw_index;
2488   const unsigned char *linenumber_pointer;
2489   int dead_code_index = -1;
2490
2491 #undef RET /* Defined by config/i386/i386.h */
2492 #undef AND /* Causes problems with opcodes for iand and land. */
2493 #undef PTR
2494 #define BCODE byte_ops
2495 #define BYTE_type_node byte_type_node
2496 #define SHORT_type_node short_type_node
2497 #define INT_type_node int_type_node
2498 #define LONG_type_node long_type_node
2499 #define CHAR_type_node char_type_node
2500 #define PTR_type_node ptr_type_node
2501 #define FLOAT_type_node float_type_node
2502 #define DOUBLE_type_node double_type_node
2503 #define VOID_type_node void_type_node
2504   jint INT_temp;
2505   unsigned char* byte_ops;
2506   long length = DECL_CODE_LENGTH (method);
2507
2508   stack_pointer = 0;
2509   JCF_SEEK (jcf, DECL_CODE_OFFSET (method));
2510   byte_ops = jcf->read_ptr;
2511
2512 #define CONST_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
2513 #define CONST_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
2514 #define VAR_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
2515 #define VAR_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
2516
2517 #define CHECK_PC_IN_RANGE(PC) ((void)1) /* Already handled by verifier. */
2518
2519   instruction_bits = oballoc (length + 1);
2520   bzero (instruction_bits, length + 1);
2521
2522   /* We make an initial pass of the line number table, to note
2523      which instructions have associated line number entries. */
2524   linenumber_pointer = linenumber_table;
2525   for (i = 0; i < linenumber_count; i++)
2526     {
2527       int pc = GET_u2 (linenumber_pointer);
2528       linenumber_pointer += 4;
2529       if (pc >= length)
2530         warning ("invalid PC in line number table");
2531       else
2532         {
2533           if ((instruction_bits[pc] & BCODE_HAS_LINENUMBER) != 0)
2534             instruction_bits[pc] |= BCODE_HAS_MULTI_LINENUMBERS;
2535           instruction_bits[pc] |= BCODE_HAS_LINENUMBER;
2536         }
2537     }
2538
2539   /* Do a preliminary pass.
2540    * This figures out which PC can be the targets of jumps. */
2541   for (PC = 0; PC < length;)
2542     {
2543       int oldpc = PC; /* PC at instruction start. */
2544       instruction_bits [PC] |=  BCODE_INSTRUCTION_START;
2545       switch (byte_ops[PC++])
2546         {
2547 #define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
2548         case OPCODE: \
2549           PRE_##OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
2550           break;
2551
2552 #define NOTE_LABEL(PC) note_label(oldpc, PC)
2553
2554 #define PRE_PUSHC(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2555 #define PRE_LOAD(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2556 #define PRE_STORE(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
2557 #define PRE_STACK(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2558 #define PRE_UNOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2559 #define PRE_BINOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2560 #define PRE_CONVERT(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2561 #define PRE_CONVERT2(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2562
2563 #define PRE_SPECIAL(OPERAND_TYPE, INSTRUCTION) \
2564   PRE_SPECIAL_##INSTRUCTION(OPERAND_TYPE)
2565 #define PRE_SPECIAL_IINC(OPERAND_TYPE) \
2566   ((void) IMMEDIATE_u1, (void) IMMEDIATE_s1)
2567 #define PRE_SPECIAL_ENTER(IGNORE) /* nothing */
2568 #define PRE_SPECIAL_EXIT(IGNORE) /* nothing */
2569 #define PRE_SPECIAL_THROW(IGNORE) /* nothing */
2570 #define PRE_SPECIAL_BREAK(IGNORE) /* nothing */
2571
2572 /* two forms of wide instructions */
2573 #define PRE_SPECIAL_WIDE(IGNORE) \
2574   { \
2575     int modified_opcode = IMMEDIATE_u1; \
2576     if (modified_opcode == OPCODE_iinc) \
2577       { \
2578         (void) IMMEDIATE_u2;    /* indexbyte1 and indexbyte2 */ \
2579         (void) IMMEDIATE_s2;    /* constbyte1 and constbyte2 */ \
2580       } \
2581     else \
2582       { \
2583         (void) IMMEDIATE_u2;    /* indexbyte1 and indexbyte2 */ \
2584       } \
2585   }
2586
2587 /* nothing */ /* XXX JH */
2588
2589 #define PRE_IMPL(IGNORE1, IGNORE2) /* nothing */
2590
2591 #define PRE_MONITOR(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2592
2593 #define PRE_RETURN(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
2594 #define PRE_ARRAY(OPERAND_TYPE, SUBOP) \
2595           PRE_ARRAY_##SUBOP(OPERAND_TYPE)
2596 #define PRE_ARRAY_LOAD(TYPE) /* nothing */
2597 #define PRE_ARRAY_STORE(TYPE) /* nothing */
2598 #define PRE_ARRAY_LENGTH(TYPE) /* nothing */
2599 #define PRE_ARRAY_NEW(TYPE) PRE_ARRAY_NEW_##TYPE
2600 #define PRE_ARRAY_NEW_NUM ((void) IMMEDIATE_u1)
2601 #define PRE_ARRAY_NEW_PTR ((void) IMMEDIATE_u2)
2602 #define PRE_ARRAY_NEW_MULTI ((void) IMMEDIATE_u2, (void) IMMEDIATE_u1)
2603
2604 #define PRE_TEST(OPERAND_TYPE, OPERAND_VALUE) NOTE_LABEL (oldpc+IMMEDIATE_s2)
2605 #define PRE_COND(OPERAND_TYPE, OPERAND_VALUE) NOTE_LABEL (oldpc+IMMEDIATE_s2)
2606 #define PRE_BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
2607   saw_index = 0;  INT_temp = (OPERAND_VALUE); \
2608   if (!saw_index)  NOTE_LABEL(oldpc + INT_temp);
2609 #define PRE_JSR(OPERAND_TYPE, OPERAND_VALUE) \
2610   saw_index = 0;  INT_temp = (OPERAND_VALUE); \
2611   if (!saw_index)  NOTE_LABEL(oldpc + INT_temp);
2612
2613 #define PRE_RET(OPERAND_TYPE, OPERAND_VALUE)  (void)(OPERAND_VALUE)
2614
2615 #define PRE_SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
2616   PC = (PC + 3) / 4 * 4; PRE_##TABLE_OR_LOOKUP##_SWITCH
2617
2618 #define PRE_LOOKUP_SWITCH                                               \
2619   { jint default_offset = IMMEDIATE_s4;  jint npairs = IMMEDIATE_s4;    \
2620     NOTE_LABEL (default_offset+oldpc);                                  \
2621     if (npairs >= 0)                                                    \
2622       while (--npairs >= 0) {                                           \
2623        jint match ATTRIBUTE_UNUSED = IMMEDIATE_s4;                      \
2624        jint offset = IMMEDIATE_s4;                                      \
2625        NOTE_LABEL (offset+oldpc); }                                     \
2626   }
2627
2628 #define PRE_TABLE_SWITCH                                \
2629   { jint default_offset = IMMEDIATE_s4;                 \
2630     jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4;  \
2631     NOTE_LABEL (default_offset+oldpc);                  \
2632     if (low <= high)                                    \
2633      while (low++ <= high) {                            \
2634        jint offset = IMMEDIATE_s4;                      \
2635        NOTE_LABEL (offset+oldpc); }                     \
2636   }
2637
2638 #define PRE_FIELD(MAYBE_STATIC, PUT_OR_GET) (void)(IMMEDIATE_u2);
2639 #define PRE_OBJECT(MAYBE_STATIC, PUT_OR_GET) (void)(IMMEDIATE_u2);
2640 #define PRE_INVOKE(MAYBE_STATIC, IS_INTERFACE) \
2641   (void)(IMMEDIATE_u2); \
2642   PC += 2 * IS_INTERFACE /* for invokeinterface */;
2643
2644 #include "javaop.def"
2645 #undef JAVAOP
2646         }
2647     } /* for */
2648
2649   if (! verify_jvm_instructions (jcf, byte_ops, length))
2650     return;
2651
2652   /* Translate bytecodes to rtl instructions. */
2653   linenumber_pointer = linenumber_table;
2654   for (PC = 0; PC < length;)
2655     {
2656       if ((instruction_bits [PC] & BCODE_TARGET) != 0 || PC == 0)
2657         {
2658           tree label = lookup_label (PC);
2659           flush_quick_stack ();
2660           if ((instruction_bits [PC] & BCODE_TARGET) != 0)
2661             expand_label (label);
2662           if (LABEL_VERIFIED (label) || PC == 0)
2663             load_type_state (label);
2664         }
2665
2666       if (! (instruction_bits [PC] & BCODE_VERIFIED))
2667         {
2668           if (dead_code_index == -1)
2669             {
2670               /* This is the start of a region of unreachable bytecodes.
2671                  They still need to be processed in order for EH ranges
2672                  to get handled correctly.  However, we can simply
2673                  replace these bytecodes with nops.  */
2674               dead_code_index = PC;
2675             }
2676
2677           /* Turn this bytecode into a nop.  */
2678           byte_ops[PC] = 0x0;
2679         }
2680        else
2681         {
2682           if (dead_code_index != -1)
2683             {
2684               /* We've just reached the end of a region of dead code.  */
2685               warning ("Unreachable bytecode from %d to before %d.",
2686                        dead_code_index, PC);
2687               dead_code_index = -1;
2688             }
2689         }
2690
2691       /* Handle possible line number entry for this PC.
2692
2693          This code handles out-of-order and multiple linenumbers per PC,
2694          but is optimized for the case of line numbers increasing
2695          monotonically with PC. */
2696       if ((instruction_bits[PC] & BCODE_HAS_LINENUMBER) != 0)
2697         {
2698           if ((instruction_bits[PC] & BCODE_HAS_MULTI_LINENUMBERS) != 0
2699               || GET_u2 (linenumber_pointer) != PC)
2700             linenumber_pointer = linenumber_table;
2701           while (linenumber_pointer < linenumber_table + linenumber_count * 4)
2702             {
2703               int pc = GET_u2 (linenumber_pointer);
2704               linenumber_pointer += 4;
2705               if (pc == PC)
2706                 {
2707                   lineno = GET_u2 (linenumber_pointer - 2);
2708                   emit_line_note (input_filename, lineno);
2709                   if (!(instruction_bits[PC] & BCODE_HAS_MULTI_LINENUMBERS))
2710                     break;
2711                 }
2712             }
2713         }
2714       maybe_pushlevels (PC);
2715       PC = process_jvm_instruction (PC, byte_ops, length);
2716       maybe_poplevels (PC);
2717     } /* for */
2718
2719   if (dead_code_index != -1)
2720     {
2721       /* We've just reached the end of a region of dead code.  */
2722       warning ("Unreachable bytecode from %d to the end of the method.",
2723               dead_code_index);
2724     }
2725 }
2726
2727 static void
2728 java_push_constant_from_pool (jcf, index)
2729      JCF *jcf;
2730      int index;
2731 {
2732   tree c;
2733   if (JPOOL_TAG (jcf, index) == CONSTANT_String)
2734     {
2735       tree name;
2736       push_obstacks (&permanent_obstack, &permanent_obstack);
2737       name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index));
2738       index = alloc_name_constant (CONSTANT_String, name);
2739       c = build_ref_from_constant_pool (index);
2740       TREE_TYPE (c) = promote_type (string_type_node);
2741       pop_obstacks ();
2742     }
2743   else
2744     c = get_constant (jcf, index);
2745   push_value (c);
2746 }
2747
2748 int
2749 process_jvm_instruction (PC, byte_ops, length)
2750      int PC;
2751      const unsigned char* byte_ops;
2752      long length ATTRIBUTE_UNUSED;
2753 {
2754   const char *opname; /* Temporary ??? */
2755   int oldpc = PC; /* PC at instruction start. */
2756
2757   /* If the instruction is at the beginning of a exception handler,
2758      replace the top of the stack with the thrown object reference */
2759   if (instruction_bits [PC] & BCODE_EXCEPTION_TARGET)
2760     {
2761       tree type = pop_type (ptr_type_node);
2762       push_value (build1 (NOP_EXPR, type, soft_exceptioninfo_call_node));
2763     }
2764
2765   switch (byte_ops[PC++])
2766     {
2767 #define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
2768     case OPCODE: \
2769       opname = #OPNAME; \
2770       OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
2771       break;
2772
2773 #define RET(OPERAND_TYPE, OPERAND_VALUE)                                \
2774   {                                                                     \
2775     int saw_index = 0;                                                  \
2776     int index     = OPERAND_VALUE;                                      \
2777     build_java_ret (find_local_variable (index, ptr_type_node, oldpc)); \
2778   }
2779
2780 #define JSR(OPERAND_TYPE, OPERAND_VALUE)                \
2781   {                                                     \
2782     tree where = lookup_label (oldpc+OPERAND_VALUE);    \
2783     tree ret   = lookup_label (PC);                     \
2784     build_java_jsr (where, ret);                        \
2785     load_type_state (ret);                              \
2786   }
2787
2788 /* Push a constant onto the stack. */
2789 #define PUSHC(OPERAND_TYPE, OPERAND_VALUE) \
2790   { int saw_index = 0;  int ival = (OPERAND_VALUE); \
2791     if (saw_index) java_push_constant_from_pool (current_jcf, ival); \
2792     else expand_java_pushc (ival, OPERAND_TYPE##_type_node); }
2793
2794 /* internal macro added for use by the WIDE case */
2795 #define LOAD_INTERNAL(OPTYPE, OPVALUE) \
2796   push_value (find_local_variable (OPVALUE, type_map[OPVALUE], oldpc));
2797
2798 /* Push local variable onto the opcode stack. */
2799 #define LOAD(OPERAND_TYPE, OPERAND_VALUE) \
2800   { \
2801     /* have to do this since OPERAND_VALUE may have side-effects */ \
2802     int opvalue = OPERAND_VALUE; \
2803     LOAD_INTERNAL(OPERAND_TYPE##_type_node, opvalue); \
2804   }
2805
2806 #define RETURN(OPERAND_TYPE, OPERAND_VALUE) \
2807   expand_java_return (OPERAND_TYPE##_type_node)
2808
2809 #define REM_EXPR TRUNC_MOD_EXPR
2810 #define BINOP(OPERAND_TYPE, OPERAND_VALUE) \
2811   expand_java_binop (OPERAND_TYPE##_type_node, OPERAND_VALUE##_EXPR)
2812
2813 #define FIELD(IS_STATIC, IS_PUT) \
2814   expand_java_field_op (IS_STATIC, IS_PUT, IMMEDIATE_u2)
2815
2816 #define TEST(OPERAND_TYPE, CONDITION) \
2817   expand_test (CONDITION##_EXPR, OPERAND_TYPE##_type_node, oldpc+IMMEDIATE_s2)
2818
2819 #define COND(OPERAND_TYPE, CONDITION) \
2820   expand_cond (CONDITION##_EXPR, OPERAND_TYPE##_type_node, oldpc+IMMEDIATE_s2)
2821
2822 #define BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
2823   BRANCH_##OPERAND_TYPE (OPERAND_VALUE)
2824
2825 #define BRANCH_GOTO(OPERAND_VALUE) \
2826   expand_java_goto (oldpc + OPERAND_VALUE)
2827
2828 #define BRANCH_CALL(OPERAND_VALUE) \
2829   expand_java_call (oldpc + OPERAND_VALUE, oldpc)
2830
2831 #if 0
2832 #define BRANCH_RETURN(OPERAND_VALUE) \
2833   { \
2834     tree type = OPERAND_TYPE##_type_node; \
2835     tree value = find_local_variable (OPERAND_VALUE, type, oldpc); \
2836     expand_java_ret (value); \
2837   }
2838 #endif
2839
2840 #define NOT_IMPL(OPERAND_TYPE, OPERAND_VALUE) \
2841           fprintf (stderr, "%3d: %s ", oldpc, opname); \
2842           fprintf (stderr, "(not implemented)\n")
2843 #define NOT_IMPL1(OPERAND_VALUE) \
2844           fprintf (stderr, "%3d: %s ", oldpc, opname); \
2845           fprintf (stderr, "(not implemented)\n")
2846
2847 #define BRANCH_RETURN(OPERAND_VALUE) NOT_IMPL1(OPERAND_VALUE)
2848
2849 #define STACK(SUBOP, COUNT) STACK_##SUBOP (COUNT)
2850
2851 #define STACK_POP(COUNT) java_stack_pop (COUNT)
2852
2853 #define STACK_SWAP(COUNT) java_stack_swap()
2854
2855 #define STACK_DUP(COUNT) java_stack_dup (COUNT, 0)
2856 #define STACK_DUPx1(COUNT) java_stack_dup (COUNT, 1)
2857 #define STACK_DUPx2(COUNT) java_stack_dup (COUNT, 2)
2858
2859 #define SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
2860   PC = (PC + 3) / 4 * 4; TABLE_OR_LOOKUP##_SWITCH
2861
2862 #define LOOKUP_SWITCH \
2863   { jint default_offset = IMMEDIATE_s4;  jint npairs = IMMEDIATE_s4; \
2864     tree selector = pop_value (INT_type_node); \
2865     tree duplicate, label; \
2866     tree type = TREE_TYPE (selector); \
2867     flush_quick_stack (); \
2868     expand_start_case (0, selector, type, "switch statement");\
2869     push_momentary (); \
2870     while (--npairs >= 0) \
2871       { \
2872         jint match = IMMEDIATE_s4; jint offset = IMMEDIATE_s4; \
2873         tree value = build_int_2 (match, match < 0 ? -1 : 0); \
2874         TREE_TYPE (value) = type; \
2875         label =  build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2876         pushcase (value, convert, label, &duplicate); \
2877         expand_java_goto (oldpc + offset); \
2878       } \
2879     label =  build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2880     pushcase (NULL_TREE, 0, label, &duplicate); \
2881     expand_java_goto (oldpc + default_offset); \
2882     pop_momentary (); \
2883     expand_end_case (selector); \
2884   }
2885
2886 #define TABLE_SWITCH \
2887   { jint default_offset = IMMEDIATE_s4; \
2888     jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
2889     tree selector = pop_value (INT_type_node); \
2890     tree duplicate, label; \
2891     tree type = TREE_TYPE (selector); \
2892     flush_quick_stack (); \
2893     expand_start_case (0, selector, type, "switch statement");\
2894     push_momentary (); \
2895     for (; low <= high; low++) \
2896       { \
2897         jint offset = IMMEDIATE_s4; \
2898         tree value = build_int_2 (low, low < 0 ? -1 : 0); \
2899         TREE_TYPE (value) = type; \
2900         label =  build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2901         pushcase (value, convert, label, &duplicate); \
2902         expand_java_goto (oldpc + offset); \
2903       } \
2904     label =  build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
2905     pushcase (NULL_TREE, 0, label, &duplicate); \
2906     expand_java_goto (oldpc + default_offset); \
2907     pop_momentary (); \
2908     expand_end_case (selector); \
2909   }
2910
2911 #define INVOKE(MAYBE_STATIC, IS_INTERFACE) \
2912   { int opcode = byte_ops[PC-1]; \
2913     int method_ref_index = IMMEDIATE_u2; \
2914     int nargs; \
2915     if (IS_INTERFACE) { nargs = IMMEDIATE_u1;  (void) IMMEDIATE_u1; } \
2916     else nargs = -1; \
2917     expand_invoke (opcode, method_ref_index, nargs); \
2918   }
2919
2920 /* Handle new, checkcast, instanceof */
2921 #define OBJECT(TYPE, OP) \
2922   expand_java_##OP (get_class_constant (current_jcf, IMMEDIATE_u2))
2923
2924 #define ARRAY(OPERAND_TYPE, SUBOP) ARRAY_##SUBOP(OPERAND_TYPE)
2925
2926 #define ARRAY_LOAD(OPERAND_TYPE)                        \
2927   {                                                     \
2928     expand_java_arrayload( OPERAND_TYPE##_type_node );  \
2929   }
2930
2931 #define ARRAY_STORE(OPERAND_TYPE)                       \
2932   {                                                     \
2933     expand_java_arraystore( OPERAND_TYPE##_type_node ); \
2934   }
2935
2936 #define ARRAY_LENGTH(OPERAND_TYPE) expand_java_array_length();
2937 #define ARRAY_NEW(OPERAND_TYPE) ARRAY_NEW_##OPERAND_TYPE()
2938 #define ARRAY_NEW_PTR()                                                 \
2939     push_value (build_anewarray (get_class_constant (current_jcf,       \
2940                                                      IMMEDIATE_u2),     \
2941                                  pop_value (int_type_node)));
2942 #define ARRAY_NEW_NUM()                         \
2943   {                                             \
2944     int atype = IMMEDIATE_u1;                   \
2945     push_value (build_newarray (atype, pop_value (int_type_node)));\
2946   }
2947 #define ARRAY_NEW_MULTI()                                       \
2948   {                                                             \
2949     tree class = get_class_constant (current_jcf, IMMEDIATE_u2 );       \
2950     int  ndims = IMMEDIATE_u1;                                  \
2951     expand_java_multianewarray( class, ndims );                 \
2952   }
2953
2954 #define UNOP(OPERAND_TYPE, OPERAND_VALUE) \
2955   push_value (fold (build1 (NEGATE_EXPR, OPERAND_TYPE##_type_node, \
2956                             pop_value (OPERAND_TYPE##_type_node))));
2957
2958 #define CONVERT2(FROM_TYPE, TO_TYPE)                                     \
2959   {                                                                      \
2960     push_value (build1 (NOP_EXPR, int_type_node,                         \
2961                         (convert (TO_TYPE##_type_node,                   \
2962                                   pop_value (FROM_TYPE##_type_node))))); \
2963   }
2964
2965 #define CONVERT(FROM_TYPE, TO_TYPE)                             \
2966   {                                                             \
2967     push_value (convert (TO_TYPE##_type_node,                   \
2968                          pop_value (FROM_TYPE##_type_node)));   \
2969   }
2970
2971 /* internal macro added for use by the WIDE case
2972    Added TREE_TYPE (decl) assignment, apbianco  */
2973 #define STORE_INTERNAL(OPTYPE, OPVALUE)                 \
2974   {                                                     \
2975     tree decl, value;                                   \
2976     int var = OPVALUE;                                  \
2977     tree type = OPTYPE;                                 \
2978     value = pop_value (type);                           \
2979     type = TREE_TYPE (value);                           \
2980     decl = find_local_variable (var, type, oldpc);      \
2981     set_local_type (var, type );                        \
2982     expand_assignment (decl, value, 0, 0);              \
2983   }
2984
2985 #define STORE(OPERAND_TYPE, OPERAND_VALUE) \
2986   { \
2987     /* have to do this since OPERAND_VALUE may have side-effects */ \
2988     int opvalue = OPERAND_VALUE; \
2989     STORE_INTERNAL(OPERAND_TYPE##_type_node, opvalue); \
2990   }
2991
2992 #define SPECIAL(OPERAND_TYPE, INSTRUCTION) \
2993   SPECIAL_##INSTRUCTION(OPERAND_TYPE)
2994
2995 #define SPECIAL_ENTER(IGNORED) MONITOR_OPERATION (soft_monitorenter_node)
2996 #define SPECIAL_EXIT(IGNORED)  MONITOR_OPERATION (soft_monitorexit_node)
2997
2998 #define MONITOR_OPERATION(call)                 \
2999   {                                             \
3000     tree o = pop_value (ptr_type_node);         \
3001     tree c;                                     \
3002     flush_quick_stack ();                       \
3003     c = build_java_monitor (call, o);           \
3004     TREE_SIDE_EFFECTS (c) = 1;                  \
3005     expand_expr_stmt (c);                       \
3006   }
3007
3008 #define SPECIAL_IINC(IGNORED) \
3009   { \
3010     unsigned int local_var_index = IMMEDIATE_u1; \
3011     int ival = IMMEDIATE_s1; \
3012     expand_iinc(local_var_index, ival, oldpc); \
3013   }
3014
3015 #define SPECIAL_WIDE(IGNORED) \
3016   { \
3017     int modified_opcode = IMMEDIATE_u1; \
3018     unsigned int local_var_index = IMMEDIATE_u2; \
3019     switch (modified_opcode) \
3020       { \
3021       case OPCODE_iinc: \
3022         { \
3023           int ival = IMMEDIATE_s2; \
3024           expand_iinc (local_var_index, ival, oldpc); \
3025           break; \
3026         } \
3027       case OPCODE_iload: \
3028       case OPCODE_lload: \
3029       case OPCODE_fload: \
3030       case OPCODE_dload: \
3031       case OPCODE_aload: \
3032         { \
3033           /* duplicate code from LOAD macro */ \
3034           LOAD_INTERNAL(operand_type[modified_opcode], local_var_index); \
3035           break; \
3036         } \
3037       case OPCODE_istore: \
3038       case OPCODE_lstore: \
3039       case OPCODE_fstore: \
3040       case OPCODE_dstore: \
3041       case OPCODE_astore: \
3042         { \
3043           STORE_INTERNAL(operand_type[modified_opcode], local_var_index); \
3044           break; \
3045         } \
3046       default: \
3047         error ("unrecogized wide sub-instruction"); \
3048       } \
3049   }
3050
3051 #define SPECIAL_THROW(IGNORED) \
3052   build_java_athrow (pop_value (throwable_type_node))
3053
3054 #define SPECIAL_BREAK NOT_IMPL1
3055 #define IMPL          NOT_IMPL
3056
3057 #include "javaop.def"
3058 #undef JAVAOP
3059    default:
3060     fprintf (stderr, "%3d: unknown(%3d)\n", oldpc, byte_ops[PC]);
3061   }
3062   return PC;
3063 }
3064
3065 /* Force the (direct) sub-operands of NODE to be evaluated in left-to-right
3066    order, as specified by Java Language Specification.
3067
3068    The problem is that while expand_expr will evaluate its sub-operands in
3069    left-to-right order, for variables it will just return an rtx (i.e.
3070    an lvalue) for the variable (rather than an rvalue).  So it is possible
3071    that a later sub-operand will change the register, and when the
3072    actual operation is done, it will use the new value, when it should
3073    have used the original value.
3074
3075    We fix this by using save_expr.  This forces the sub-operand to be
3076    copied into a fresh virtual register,
3077
3078    For method invocation, we modify the arguments so that a
3079    left-to-right order evaluation is performed. Saved expressions
3080    will, in CALL_EXPR order, be reused when the call will be expanded.
3081 */
3082
3083 tree
3084 force_evaluation_order (node)
3085      tree  node;
3086 {
3087   if (flag_syntax_only)
3088     return node;
3089   if (TREE_CODE_CLASS (TREE_CODE (node)) == '2')
3090     {
3091       if (TREE_SIDE_EFFECTS (TREE_OPERAND (node, 1)))
3092         TREE_OPERAND (node, 0) = save_expr (TREE_OPERAND (node, 0));
3093     }
3094   else if (TREE_CODE (node) == CALL_EXPR || TREE_CODE (node) == NEW_CLASS_EXPR)
3095     {
3096       tree arg, cmp;
3097
3098       if (!TREE_OPERAND (node, 1))
3099         return node;
3100
3101       /* This reverses the evaluation order. This is a desired effect. */
3102       for (cmp = NULL_TREE, arg = TREE_OPERAND (node, 1);
3103            arg; arg = TREE_CHAIN (arg))
3104         {
3105           tree saved = save_expr (force_evaluation_order (TREE_VALUE (arg)));
3106           cmp = (cmp == NULL_TREE ? saved :
3107                  build (COMPOUND_EXPR, void_type_node, cmp, saved));
3108           TREE_VALUE (arg) = saved;
3109         }
3110
3111       if (cmp && TREE_CODE (cmp) == COMPOUND_EXPR)
3112         TREE_SIDE_EFFECTS (cmp) = 1;
3113
3114       if (cmp)
3115         {
3116           cmp = save_expr (build (COMPOUND_EXPR, TREE_TYPE (node), cmp, node));
3117           CAN_COMPLETE_NORMALLY (cmp) = CAN_COMPLETE_NORMALLY (node);
3118           TREE_SIDE_EFFECTS (cmp) = 1;
3119           node = cmp;
3120         }
3121     }
3122   return node;
3123 }