home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / kaffe-0.5p4-src.tgz / tar.out / contrib / kaffe / kaffevm / kaffe.def < prev    next >
Text File  |  1996-09-28  |  48KB  |  3,033 lines
  1. /*
  2.  * kaffe.def
  3.  * Kaffe instruction definitions.
  4.  *
  5.  * Copyright (c) 1996 Systems Architecture Research Centre,
  6.  *                 City University, London, UK.
  7.  *
  8.  * See the file "license.terms" for information on usage and redistribution
  9.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  10.  *
  11.  * Written by Tim Wilkinson <tim@sarc.city.ac.uk>, May 1996.
  12.  */
  13.  
  14. define_insn(NOP)
  15. {
  16.         /*
  17.          * No operation.
  18.          */
  19. }
  20.  
  21. define_insn(ACONST_NULL)
  22. {
  23.     /*
  24.      * ... -> ..., 0 
  25.      */
  26.     push(1);
  27.     move_ref_const(stack(0), 0);
  28. }
  29.  
  30. define_insn(ICONST_M1)
  31. {
  32.     /*
  33.      * ... -> ..., -1 
  34.      */
  35.     push(1);
  36.     move_int_const(stack(0), -1);
  37. }
  38.  
  39. define_insn(ICONST_0)
  40. {
  41.     /*
  42.      * ... -> ..., 0
  43.      */
  44.     push(1);
  45.     move_int_const(stack(0), 0);
  46. }
  47.  
  48. define_insn(ICONST_1)
  49. {
  50.     /*
  51.      * ... -> ..., 1
  52.      */
  53.     push(1);
  54.     move_int_const(stack(0), 1);
  55. }
  56.  
  57. define_insn(ICONST_2)
  58. {
  59.     /*
  60.      * ... -> ..., 2
  61.      */
  62.     push(1);
  63.     move_int_const(stack(0), 2);
  64. }
  65.  
  66. define_insn(ICONST_3)
  67. {
  68.     /*
  69.      * ... -> ..., 3
  70.      */
  71.     push(1);
  72.     move_int_const(stack(0), 3);
  73. }
  74.  
  75. define_insn(ICONST_4)
  76. {
  77.     /*
  78.      * ... -> ..., 4
  79.      */
  80.     push(1);
  81.     move_int_const(stack(0), 4);
  82. }
  83.  
  84. define_insn(ICONST_5)
  85. {
  86.     /*
  87.      * ... -> ..., 5
  88.      */
  89.     push(1);
  90.     move_int_const(stack(0), 5);
  91. }
  92.  
  93. define_insn(LCONST_0)
  94. {
  95.     /*
  96.      * ... -> ..., 0, 0
  97.      */
  98.     push(2);
  99.     move_long_const(stack(0), 0);
  100. }
  101.  
  102. define_insn(LCONST_1)
  103. {
  104.     /*
  105.      * ... -> ..., 0, 1
  106.      */
  107.     push(2);
  108.     move_long_const(stack(0), 1);
  109. }
  110.  
  111. define_insn(FCONST_0)
  112. {
  113.     /*
  114.      * ... -> ..., 0.0
  115.      */
  116.     push(1);
  117.     move_float_const(stack(0), 0.0);
  118. }
  119.  
  120. define_insn(FCONST_1)
  121. {
  122.     /*
  123.      * ... -> ..., 1.0
  124.      */
  125.     push(1);
  126.     move_float_const(stack(0), 1.0);
  127. }
  128.  
  129. define_insn(FCONST_2)
  130. {
  131.     /*
  132.      * ... -> ..., 2.0
  133.      */
  134.     push(1);
  135.     move_float_const(stack(0), 2.0);
  136. }
  137.  
  138. define_insn(DCONST_0)
  139. {
  140.     /*
  141.      * ... -> ..., 0.0
  142.      */
  143.     push(2);
  144.     move_double_const(stack(0), 0.0);
  145. }
  146.  
  147. define_insn(DCONST_1)
  148. {
  149.     /*
  150.      * ... -> ..., 1.0
  151.      */
  152.     push(2);
  153.     move_double_const(stack(0), 1.0);
  154. }
  155.  
  156. define_insn(BIPUSH)
  157. {
  158.     /*
  159.      * ... -> ..., val
  160.      */
  161.     low = (int8)getpc(0);
  162.     push(1);
  163.     move_int_const(stack(0), low);
  164. }
  165.  
  166. define_insn(SIPUSH)
  167. {
  168.     /*
  169.      * ... -> ..., val
  170.      */
  171.     low = (int16)((getpc(0) << 8) | getpc(1));
  172.     push(1);
  173.     move_int_const(stack(0), low);
  174. }
  175.  
  176. define_insn(LDC1)
  177. {
  178.     /*
  179.      * ... -> ..., const
  180.      */
  181.     idx = (uint8)getpc(0);
  182.     cnst = constant(idx);
  183.     push(1);
  184.     move_any(stack(0), cnst);
  185. }
  186.  
  187. define_insn(LDC2)
  188. {
  189.     /*
  190.      * ... -> ..., const
  191.      */
  192.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  193.     cnst = constant(idx);
  194.     push(1);
  195.     move_any(stack(0), cnst);
  196. }
  197.  
  198. define_insn(LDC2W)
  199. {
  200.     /*
  201.      * ... -> ..., long const
  202.      */
  203.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  204.     cnst = constant_long(idx);
  205.     push(2);
  206.     move_anylong(stack(0), cnst);
  207. }
  208.  
  209. define_insn(ILOAD)
  210. {
  211.     /*
  212.      * ..., -> ..., local variable
  213.      */
  214.     idx = wide + (uint8)getpc(0);
  215.  
  216.     check_local_int(idx);
  217.  
  218.     push(1);
  219.     move_int(stack(0), local(idx));
  220.     wide = 0;
  221. }
  222.  
  223. define_insn(LLOAD)
  224. {
  225.     /*
  226.      * ..., -> ..., long local variable
  227.      */
  228.     idx = wide + (uint8)getpc(0);
  229.  
  230.     check_local_long(idx+1);
  231.  
  232.     push(2);
  233.     move_long(stack(0), local_long(idx));
  234.     wide = 0;
  235. }
  236.  
  237. define_insn(FLOAD)
  238. {
  239.     /*
  240.      * ..., -> ..., local variable
  241.      */
  242.     idx = wide + (uint8)getpc(0);
  243.  
  244.     check_local_float(idx);
  245.  
  246.     push(1);
  247.     move_float(stack(0), local_float(idx));
  248.     wide = 0;
  249. }
  250.  
  251. define_insn(DLOAD)
  252. {
  253.     /*
  254.      * ..., -> ..., long local variable
  255.      */
  256.     idx = wide + (uint8)getpc(0);
  257.  
  258.     check_local_double(idx+1);
  259.  
  260.     push(2);
  261.     move_double(stack(0), local_double(idx));
  262.     wide = 0;
  263. }
  264.  
  265. define_insn(ALOAD)
  266. {
  267.     /*
  268.      * ..., -> ..., local variable
  269.      */
  270.     idx = wide + (uint8)getpc(0);
  271.  
  272.     check_local_ref(idx);
  273.  
  274.     push(1);
  275.     move_ref(stack(0), local(idx));
  276.     wide = 0;
  277. }
  278.  
  279. define_insn(ILOAD_0)
  280. {
  281.     /*
  282.      * ..., -> ..., local variable
  283.      */
  284.     check_local_int(0);
  285.  
  286.     push(1);
  287.     move_int(stack(0), local(0));
  288. }
  289.  
  290. define_insn(ILOAD_1)
  291. {
  292.     /*
  293.      * ..., -> ..., local variable
  294.      */
  295.     check_local_int(1);
  296.  
  297.     push(1);
  298.     move_int(stack(0), local(1));
  299. }
  300.  
  301. define_insn(ILOAD_2)
  302. {
  303.     /*
  304.      * ..., -> ..., local variable
  305.      */
  306.     check_local_int(2);
  307.  
  308.     push(1);
  309.     move_int(stack(0), local(2));
  310. }
  311.  
  312. define_insn(ILOAD_3)
  313. {
  314.     /*
  315.      * ..., -> ..., local variable
  316.      */
  317.     check_local_int(3);
  318.  
  319.     push(1);
  320.     move_int(stack(0), local(3));
  321. }
  322.  
  323. define_insn(LLOAD_0)
  324. {
  325.     /*
  326.      * ..., -> ..., local variable
  327.      */
  328.     check_local_long(0+1);
  329.  
  330.     push(2);
  331.     move_long(stack(0), local_long(0));
  332. }
  333.  
  334. define_insn(LLOAD_1)
  335. {
  336.     /*
  337.      * ..., -> ..., local variable
  338.      */
  339.     check_local_long(1+1);
  340.  
  341.     push(2);
  342.     move_long(stack(0), local_long(1));
  343. }
  344.  
  345. define_insn(LLOAD_2)
  346. {
  347.     /*
  348.      * ..., -> ..., local variable
  349.      */
  350.     check_local_long(2+1);
  351.  
  352.     push(2);
  353.     move_long(stack(0), local_long(2));
  354. }
  355.  
  356. define_insn(LLOAD_3)
  357. {
  358.     /*
  359.      * ..., -> ..., local variable
  360.      */
  361.     check_local_long(3+1);
  362.  
  363.     push(2);
  364.     move_long(stack(0), local_long(3));
  365. }
  366.  
  367. define_insn(FLOAD_0)
  368. {
  369.     /*
  370.      * ..., -> ..., local variable
  371.      */
  372.     check_local_float(0);
  373.  
  374.     push(1);
  375.     move_float(stack(0), local_float(0));
  376. }
  377.  
  378. define_insn(FLOAD_1)
  379. {
  380.     /*
  381.      * ..., -> ..., local variable
  382.      */
  383.     check_local_float(1);
  384.  
  385.     push(1);
  386.     move_float(stack(0), local_float(1));
  387. }
  388.  
  389. define_insn(FLOAD_2)
  390. {
  391.     /*
  392.      * ..., -> ..., local variable
  393.      */
  394.     check_local_float(2);
  395.  
  396.     push(1);
  397.     move_float(stack(0), local_float(2));
  398. }
  399.  
  400. define_insn(FLOAD_3)
  401. {
  402.     /*
  403.      * ..., -> ..., local variable
  404.      */
  405.     check_local_float(3);
  406.  
  407.     push(1);
  408.     move_float(stack(0), local_float(3));
  409. }
  410.  
  411. define_insn(DLOAD_0)
  412. {
  413.     /*
  414.      * ..., -> ..., local variable
  415.      */
  416.     check_local_double(0+1);
  417.  
  418.     push(2);
  419.     move_double(stack(0), local_double(0));
  420. }
  421.  
  422. define_insn(DLOAD_1)
  423. {
  424.     /*
  425.      * ..., -> ..., local variable
  426.      */
  427.     check_local_double(1+1);
  428.  
  429.     push(2);
  430.     move_double(stack(0), local_double(1));
  431. }
  432.  
  433. define_insn(DLOAD_2)
  434. {
  435.     /*
  436.      * ..., -> ..., local variable
  437.      */
  438.     check_local_double(2+1);
  439.  
  440.     push(2);
  441.     move_double(stack(0), local_double(2));
  442. }
  443.  
  444. define_insn(DLOAD_3)
  445. {
  446.     /*
  447.      * ..., -> ..., local variable
  448.      */
  449.     check_local_double(3+1);
  450.  
  451.     push(2);
  452.     move_double(stack(0), local_double(3));
  453. }
  454.  
  455. define_insn(ALOAD_0)
  456. {
  457.     /*
  458.      * ..., -> ..., local variable
  459.      */
  460.     check_local_ref(0);
  461.  
  462.     push(1);
  463.     move_ref(stack(0), local(0));
  464. }
  465.  
  466. define_insn(ALOAD_1)
  467. {
  468.     /*
  469.      * ..., -> ..., local variable
  470.      */
  471.     check_local_ref(1);
  472.  
  473.     push(1);
  474.     move_ref(stack(0), local(1));
  475. }
  476.  
  477. define_insn(ALOAD_2)
  478. {
  479.     /*
  480.      * ..., -> ..., local variable
  481.      */
  482.     check_local_ref(2);
  483.  
  484.     push(1);
  485.     move_ref(stack(0), local(2));
  486. }
  487.  
  488. define_insn(ALOAD_3)
  489. {
  490.     /*
  491.      * ..., -> ..., local variable
  492.      */
  493.     check_local_ref(3);
  494.  
  495.     push(1);
  496.     move_ref(stack(0), local(3));
  497. }
  498.  
  499. define_insn(IALOAD)
  500. {
  501.     /*
  502.      * ..., array ref, index -> ..., value
  503.      */
  504.     check_stack_int(0);
  505.     check_stack_intarray(1);
  506.  
  507.     slot_alloctmp(tmp);
  508.  
  509.     /* Check we are within the array bounds */
  510.     move_ref(tmp, stack(1));
  511.     if (object_array_length != 0) {
  512.         add_ref_const(tmp, tmp, object_array_length);
  513.     }
  514.     load_int(tmp, tmp);
  515.     cmp_int(0, stack(0), tmp);
  516.  
  517.     branch_lt(reference_label(10));
  518.     softcall_badarrayindex();
  519.     set_label(10);
  520.  
  521.     lshl_int_const(tmp, stack(0), SHIFT_jint);
  522.     if (object_array_offset != 0) {
  523.         add_int_const(tmp, tmp, object_array_offset);
  524.     }
  525.     add_ref(tmp, tmp, stack(1));
  526.     load_int(stack(1), tmp);
  527.  
  528.     pop(1);
  529. }
  530.  
  531. define_insn(LALOAD)
  532. {
  533.     /*
  534.      * ..., array ref, index -> ..., long value
  535.      */
  536.     check_stack_int(0);
  537.     check_stack_longarray(1);
  538.  
  539.     slot_alloctmp(tmp);
  540.  
  541.     /* Check we are within the array bounds */
  542.     move_ref(tmp, stack(1));
  543.     if (object_array_length != 0) {
  544.         add_ref_const(tmp, tmp, object_array_length);
  545.     }
  546.     load_int(tmp, tmp);
  547.     cmp_int(0, stack(0), tmp);
  548.  
  549.     branch_lt(reference_label(11));
  550.     softcall_badarrayindex();
  551.     set_label(11);
  552.  
  553.     lshl_int_const(tmp, stack(0), SHIFT_jlong);
  554.     if (object_array_offset != 0) {
  555.         add_int_const(tmp, tmp, object_array_offset);
  556.     }
  557.     add_ref(tmp, tmp, stack(1));
  558.     load_long(stack(0), tmp);
  559. }
  560.  
  561. define_insn(FALOAD)
  562. {
  563.     /*
  564.      * ..., array ref, index -> ..., float value
  565.      */
  566.     check_stack_int(0);
  567.     check_stack_floatarray(1);
  568.  
  569.     slot_alloctmp(tmp);
  570.  
  571.     /* Check we are within the array bounds */
  572.     move_ref(tmp, stack(1));
  573.     if (object_array_length != 0) {
  574.         add_ref_const(tmp, tmp, object_array_length);
  575.     }
  576.     load_int(tmp, tmp);
  577.     cmp_int(0, stack(0), tmp);
  578.  
  579.     branch_lt(reference_label(12));
  580.     softcall_badarrayindex();
  581.     set_label(12);
  582.  
  583.     lshl_int_const(tmp, stack(0), SHIFT_jfloat);
  584.     if (object_array_offset != 0) {
  585.         add_int_const(tmp, tmp, object_array_offset);
  586.     }
  587.     add_ref(tmp, tmp, stack(1));
  588.     load_float(stack(1), tmp);
  589.  
  590.     pop(1);
  591. }
  592.  
  593. define_insn(DALOAD)
  594. {
  595.     /*
  596.      * ..., array ref, index -> ..., double value
  597.      */
  598.     check_stack_int(0);
  599.     check_stack_doublearray(1);
  600.  
  601.     slot_alloctmp(tmp);
  602.  
  603.     /* Check we are within the array bounds */
  604.     move_ref(tmp, stack(1));
  605.     if (object_array_length != 0) {
  606.         add_ref_const(tmp, tmp, object_array_length);
  607.     }
  608.     load_int(tmp, tmp);
  609.     cmp_int(0, stack(0), tmp);
  610.  
  611.     branch_lt(reference_label(13));
  612.     softcall_badarrayindex();
  613.     set_label(13);
  614.  
  615.     lshl_int_const(tmp, stack(0), SHIFT_jdouble);
  616.     if (object_array_offset != 0) {
  617.         add_int_const(tmp, tmp, object_array_offset);
  618.     }
  619.     add_ref(tmp, tmp, stack(1));
  620.     load_double(stack(0), tmp);
  621. }
  622.  
  623. define_insn(AALOAD)
  624. {
  625.     /*
  626.      * ..., array ref, index -> ..., ref value
  627.      */
  628.     check_stack_int(0);
  629.     check_stack_refarray(1);
  630.  
  631.     slot_alloctmp(tmp);
  632.  
  633.     /* Check we are within the array bounds */
  634.     move_ref(tmp, stack(1));
  635.     if (object_array_length != 0) {
  636.         add_ref_const(tmp, tmp, object_array_length);
  637.     }
  638.     load_int(tmp, tmp);
  639.     cmp_int(0, stack(0), tmp);
  640.  
  641.     branch_lt(reference_label(14));
  642.     softcall_badarrayindex();
  643.     set_label(14);
  644.  
  645.     lshl_int_const(tmp, stack(0), SHIFT_jref);
  646.     if (object_array_offset != 0) {
  647.         add_int_const(tmp, tmp, object_array_offset);
  648.     }
  649.     add_ref(tmp, tmp, stack(1));
  650.     load_ref(stack(1), tmp);
  651.  
  652.     pop(1);
  653. }
  654.  
  655. define_insn(BALOAD)
  656. {
  657.     /*
  658.      * ..., array ref, index -> ..., byte value
  659.      */
  660.     check_stack_int(0);
  661.     check_stack_bytearray(1);
  662.  
  663.     slot_alloctmp(tmp);
  664.  
  665.     /* Check we are within the array bounds */
  666.     move_ref(tmp, stack(1));
  667.     if (object_array_length != 0) {
  668.         add_ref_const(tmp, tmp, object_array_length);
  669.     }
  670.     load_int(tmp, tmp);
  671.     cmp_int(0, stack(0), tmp);
  672.  
  673.     branch_lt(reference_label(15));
  674.     softcall_badarrayindex();
  675.     set_label(15);
  676.  
  677.     if (SHIFT_jbyte > 0) {
  678.         lshl_int_const(tmp, stack(0), SHIFT_jbyte);
  679.     }
  680.     else {
  681.         move_int(tmp, stack(0));
  682.     }
  683.     if (object_array_offset != 0) {
  684.         add_int_const(tmp, tmp, object_array_offset);
  685.     }
  686.     add_ref(tmp, tmp, stack(1));
  687.     load_byte(stack(1), tmp);
  688.  
  689.     pop(1);
  690. }
  691.  
  692. define_insn(CALOAD)
  693. {
  694.     /*
  695.      * ..., array ref, index -> ..., char value
  696.      */
  697.     check_stack_int(0);
  698.     check_stack_chararray(1);
  699.  
  700.     slot_alloctmp(tmp);
  701.  
  702.     /* Check we are within the array bounds */
  703.     move_ref(tmp, stack(1));
  704.     if (object_array_length != 0) {
  705.         add_ref_const(tmp, tmp, object_array_length);
  706.     }
  707.     load_int(tmp, tmp);
  708.     cmp_int(0, stack(0), tmp);
  709.  
  710.     branch_lt(reference_label(16));
  711.     softcall_badarrayindex();
  712.     set_label(16);
  713.  
  714.     if (SHIFT_jchar > 0) {
  715.         lshl_int_const(tmp, stack(0), SHIFT_jchar);
  716.     }
  717.     else {
  718.         move_int(tmp, stack(0));
  719.     }
  720.     if (object_array_offset != 0) {
  721.         add_int_const(tmp, tmp, object_array_offset);
  722.     }
  723.     add_ref(tmp, tmp, stack(1));
  724.     load_char(stack(1), tmp);
  725.  
  726.     pop(1);
  727. }
  728.  
  729. define_insn(SALOAD)
  730. {
  731.     /*
  732.      * ..., array ref, index -> ..., short value
  733.      */
  734.     check_stack_int(0);
  735.     check_stack_shortarray(1);
  736.  
  737.     slot_alloctmp(tmp);
  738.  
  739.     /* Check we are within the array bounds */
  740.     move_ref(tmp, stack(1));
  741.     if (object_array_length != 0) {
  742.         add_ref_const(tmp, tmp, object_array_length);
  743.     }
  744.     load_int(tmp, tmp);
  745.     cmp_int(0, stack(0), tmp);
  746.  
  747.     branch_lt(reference_label(17));
  748.     softcall_badarrayindex();
  749.     set_label(17);
  750.  
  751.     lshl_int_const(tmp, stack(0), SHIFT_jshort);
  752.     if (object_array_offset != 0) {
  753.         add_int_const(tmp, tmp, object_array_offset);
  754.     }
  755.     add_ref(tmp, tmp, stack(1));
  756.     load_short(stack(1), tmp);
  757.  
  758.     pop(1);
  759. }
  760.  
  761. define_insn(ISTORE)
  762. {
  763.     /*
  764.      * ..., var -> ...
  765.      */
  766.     check_stack_int(0);
  767.  
  768.     idx = wide + (uint8)getpc(0);
  769.  
  770.     move_int(local(idx), stack(0));
  771.     pop(1);
  772.     wide = 0;
  773. }
  774.  
  775. define_insn(LSTORE)
  776. {
  777.     /*
  778.      * ..., long var -> ...
  779.      */
  780.     check_stack_long(0);
  781.  
  782.     idx = wide + (uint8)getpc(0);
  783.  
  784.     move_long(local_long(idx), stack(0));
  785.     pop(2);
  786.     wide = 0;
  787. }
  788.  
  789. define_insn(FSTORE)
  790. {
  791.     /*
  792.      * ..., var -> ...
  793.      */
  794.     check_stack_float(0);
  795.  
  796.     idx = wide + (uint8)getpc(0);
  797.  
  798.     move_float(local_float(idx), stack(0));
  799.     pop(1);
  800.     wide = 0;
  801. }
  802.  
  803. define_insn(DSTORE)
  804. {
  805.     /*
  806.      * ..., var -> ...
  807.      */
  808.     check_stack_double(0);
  809.  
  810.     idx = wide + (uint8)getpc(0);
  811.  
  812.     move_double(local_double(idx), stack(0));
  813.     pop(2);
  814.     wide = 0;
  815. }
  816.  
  817. define_insn(ASTORE)
  818. {
  819.     /*
  820.      * ..., var -> ...
  821.      */
  822.     check_stack_ref(0);
  823.  
  824.     idx = wide + (uint8)getpc(0);
  825.  
  826.     move_ref(local(idx), stack(0));
  827.     pop(1);
  828.     wide = 0;
  829. }
  830.  
  831. define_insn(ISTORE_0)
  832. {
  833.     /*
  834.      * ..., val -> ...
  835.      */
  836.     check_stack_int(0);
  837.  
  838.     move_int(local(0), stack(0));
  839.     pop(1);
  840. }
  841.  
  842. define_insn(ISTORE_1)
  843. {
  844.     /*
  845.      * ..., val -> ...
  846.      */
  847.     check_stack_int(0);
  848.  
  849.     move_int(local(1), stack(0));
  850.     pop(1);
  851. }
  852.  
  853. define_insn(ISTORE_2)
  854. {
  855.     /*
  856.      * ..., val -> ...
  857.      */
  858.     check_stack_int(0);
  859.  
  860.     move_int(local(2), stack(0));
  861.     pop(1);
  862. }
  863.  
  864. define_insn(ISTORE_3)
  865. {
  866.     /*
  867.      * ..., val -> ...
  868.      */
  869.     check_stack_int(0);
  870.  
  871.     move_int(local(3), stack(0));
  872.     pop(1);
  873. }
  874.  
  875. define_insn(LSTORE_0)
  876. {
  877.     /*
  878.      * ..., long val -> ...
  879.      */
  880.     check_stack_long(0);
  881.  
  882.     move_long(local_long(0), stack(0));
  883.     pop(2);
  884. }
  885.  
  886. define_insn(LSTORE_1)
  887. {
  888.     /*
  889.      * ..., long val -> ...
  890.      */
  891.     check_stack_long(0);
  892.  
  893.     move_long(local_long(1), stack(0));
  894.     pop(2);
  895. }
  896.  
  897. define_insn(LSTORE_2)
  898. {
  899.     /*
  900.      * ..., long val -> ...
  901.      */
  902.     check_stack_long(0);
  903.  
  904.     move_long(local_long(2), stack(0));
  905.     pop(2);
  906. }
  907.  
  908. define_insn(LSTORE_3)
  909. {
  910.     /*
  911.      * ..., long val -> ...
  912.      */
  913.     check_stack_long(0);
  914.  
  915.     move_long(local_long(3), stack(0));
  916.     pop(2);
  917. }
  918.  
  919. define_insn(FSTORE_0)
  920. {
  921.     /*
  922.      * ..., val -> ...
  923.      */
  924.     check_stack_float(0);
  925.  
  926.     move_float(local_float(0), stack(0));
  927.     pop(1);
  928. }
  929.  
  930. define_insn(FSTORE_1)
  931. {
  932.     /*
  933.      * ..., val -> ...
  934.      */
  935.     check_stack_float(0);
  936.  
  937.     move_float(local_float(1), stack(0));
  938.     pop(1);
  939. }
  940.  
  941. define_insn(FSTORE_2)
  942. {
  943.     /*
  944.      * ..., val -> ...
  945.      */
  946.     check_stack_float(0);
  947.  
  948.     move_float(local_float(2), stack(0));
  949.     pop(1);
  950. }
  951.  
  952. define_insn(FSTORE_3)
  953. {
  954.     /*
  955.      * ..., val -> ...
  956.      */
  957.     check_stack_float(0);
  958.  
  959.     move_float(local_float(3), stack(0));
  960.     pop(1);
  961. }
  962.  
  963. define_insn(DSTORE_0)
  964. {
  965.     /*
  966.      * ..., long val -> ...
  967.      */
  968.     check_stack_double(0);
  969.  
  970.     move_double(local_double(0), stack(0));
  971.     pop(2);
  972. }
  973.  
  974. define_insn(DSTORE_1)
  975. {
  976.     /*
  977.      * ..., long val -> ...
  978.      */
  979.     check_stack_double(0);
  980.  
  981.     move_double(local_double(1), stack(0));
  982.     pop(2);
  983. }
  984.  
  985. define_insn(DSTORE_2)
  986. {
  987.     /*
  988.      * ..., long val -> ...
  989.      */
  990.     check_stack_double(0);
  991.  
  992.     move_double(local_double(2), stack(0));
  993.     pop(2);
  994. }
  995.  
  996. define_insn(DSTORE_3)
  997. {
  998.     /*
  999.      * ..., long val -> ...
  1000.      */
  1001.     check_stack_double(0);
  1002.  
  1003.     move_double(local_double(3), stack(0));
  1004.     pop(2);
  1005. }
  1006.  
  1007. define_insn(ASTORE_0)
  1008. {
  1009.     /*
  1010.      * ..., val -> ...
  1011.      */
  1012.     check_stack_ref(0);
  1013.  
  1014.     move_ref(local(0), stack(0));
  1015.     pop(1);
  1016. }
  1017.  
  1018. define_insn(ASTORE_1)
  1019. {
  1020.     /*
  1021.      * ..., val -> ...
  1022.      */
  1023.     check_stack_ref(0);
  1024.  
  1025.     move_ref(local(1), stack(0));
  1026.     pop(1);
  1027. }
  1028.  
  1029. define_insn(ASTORE_2)
  1030. {
  1031.     /*
  1032.      * ..., val -> ...
  1033.      */
  1034.     check_stack_ref(0);
  1035.  
  1036.     move_ref(local(2), stack(0));
  1037.     pop(1);
  1038. }
  1039.  
  1040. define_insn(ASTORE_3)
  1041. {
  1042.     /*
  1043.      * ..., val -> ...
  1044.      */
  1045.     check_stack_ref(0);
  1046.  
  1047.     move_ref(local(3), stack(0));
  1048.     pop(1);
  1049. }
  1050.  
  1051. define_insn(IASTORE)
  1052. {
  1053.     /*
  1054.      * ..., array ref, index, val -> ...
  1055.      */
  1056.     check_stack_int(0);
  1057.     check_stack_int(1);
  1058.     check_stack_intarray(2);
  1059.  
  1060.     slot_alloctmp(tmp);
  1061.  
  1062.     /* Check we are within the array bounds */
  1063.     move_ref(tmp, stack(2));
  1064.     if (object_array_length != 0) {
  1065.         add_ref_const(tmp, tmp, object_array_length);
  1066.     }
  1067.     load_int(tmp, tmp);
  1068.     cmp_int(0, stack(1), tmp);
  1069.  
  1070.     branch_lt(reference_label(18));
  1071.     softcall_badarrayindex();
  1072.     set_label(18);
  1073.  
  1074.     lshl_int_const(tmp, stack(1), SHIFT_jint);
  1075.     if (object_array_offset != 0) {
  1076.         add_int_const(tmp, tmp, object_array_offset);
  1077.     }
  1078.     add_ref(tmp, tmp, stack(2));
  1079.     store_int(tmp, stack(0));
  1080.  
  1081.     pop(3);
  1082. }
  1083.  
  1084. define_insn(LASTORE)
  1085. {
  1086.     /*
  1087.      * ..., array ref, index, long val -> ...
  1088.      */
  1089.     check_stack_int(0);
  1090.     check_stack_int(1);
  1091.     check_stack_longarray(2);
  1092.  
  1093.     slot_alloctmp(tmp);
  1094.  
  1095.     /* Check we are within the array bounds */
  1096.     move_ref(tmp, stack(3));
  1097.     if (object_array_length != 0) {
  1098.         add_ref_const(tmp, tmp, object_array_length);
  1099.     }
  1100.     load_int(tmp, tmp);
  1101.     cmp_int(0, stack(2), tmp);
  1102.  
  1103.     branch_lt(reference_label(19));
  1104.     softcall_badarrayindex();
  1105.     set_label(19);
  1106.  
  1107.     lshl_int_const(tmp, stack(2), SHIFT_jlong);
  1108.     if (object_array_offset != 0) {
  1109.         add_int_const(tmp, tmp, object_array_offset);
  1110.     }
  1111.     add_ref(tmp, tmp, stack(3));
  1112.     store_long(tmp, stack(0));
  1113.  
  1114.     pop(4);
  1115. }
  1116.  
  1117. define_insn(FASTORE)
  1118. {
  1119.     /*
  1120.      * ..., array ref, index, float val -> ...
  1121.      */
  1122.     check_stack_int(0);
  1123.     check_stack_int(1);
  1124.     check_stack_floatarray(2);
  1125.  
  1126.     slot_alloctmp(tmp);
  1127.  
  1128.     /* Check we are within the array bounds */
  1129.     move_ref(tmp, stack(2));
  1130.     if (object_array_length != 0) {
  1131.         add_ref_const(tmp, tmp, object_array_length);
  1132.     }
  1133.     load_int(tmp, tmp);
  1134.     cmp_int(0, stack(1), tmp);
  1135.  
  1136.     branch_lt(reference_label(20));
  1137.     softcall_badarrayindex();
  1138.     set_label(20);
  1139.  
  1140.     lshl_int_const(tmp, stack(1), SHIFT_jfloat);
  1141.     if (object_array_offset != 0) {
  1142.         add_int_const(tmp, tmp, object_array_offset);
  1143.     }
  1144.     add_ref(tmp, tmp, stack(2));
  1145.     store_float(tmp, stack(0));
  1146.  
  1147.     pop(3);
  1148. }
  1149.  
  1150. define_insn(DASTORE)
  1151. {
  1152.     /*
  1153.      * ..., array ref, index, double val -> ...
  1154.      */
  1155.     check_stack_int(0);
  1156.     check_stack_int(1);
  1157.     check_stack_doublearray(2);
  1158.  
  1159.     slot_alloctmp(tmp);
  1160.  
  1161.     /* Check we are within the array bounds */
  1162.     move_ref(tmp, stack(3));
  1163.     if (object_array_length != 0) {
  1164.         add_ref_const(tmp, tmp, object_array_length);
  1165.     }
  1166.     load_int(tmp, tmp);
  1167.     cmp_int(0, stack(2), tmp);
  1168.  
  1169.     branch_lt(reference_label(21));
  1170.     softcall_badarrayindex();
  1171.     set_label(21);
  1172.  
  1173.     lshl_int_const(tmp, stack(2), SHIFT_jdouble);
  1174.     if (object_array_offset != 0) {
  1175.         add_int_const(tmp, tmp, object_array_offset);
  1176.     }
  1177.     add_ref(tmp, tmp, stack(3));
  1178.     store_double(tmp, stack(0));
  1179.  
  1180.     pop(4);
  1181. }
  1182.  
  1183. define_insn(AASTORE)
  1184. {
  1185.     /*
  1186.      * ..., array ref, index, val -> ...
  1187.      */
  1188.     check_stack_int(0);
  1189.     check_stack_int(1);
  1190.     check_stack_refarray(2);
  1191.  
  1192.     slot_alloctmp(tmp);
  1193.  
  1194.     /* Check we are within the array bounds */
  1195.     move_ref(tmp, stack(2));
  1196.     if (object_array_length != 0) {
  1197.         add_ref_const(tmp, tmp, object_array_length);
  1198.     }
  1199.     load_int(tmp, tmp);
  1200.     cmp_int(0, stack(1), tmp);
  1201.  
  1202.     branch_lt(reference_label(22));
  1203.     softcall_badarrayindex();
  1204.     set_label(22);
  1205.  
  1206.     lshl_int_const(tmp, stack(1), SHIFT_jref);
  1207.     if (object_array_offset != 0) {
  1208.         add_int_const(tmp, tmp, object_array_offset);
  1209.     }
  1210.     add_ref(tmp, tmp, stack(2));
  1211.     store_ref(tmp, stack(0));
  1212.  
  1213.     pop(3);
  1214. }
  1215.  
  1216. define_insn(BASTORE)
  1217. {
  1218.     /*
  1219.      * ..., array ref, index, byte value  -> ...
  1220.      */
  1221.     check_stack_int(0);
  1222.     check_stack_int(1);
  1223.     check_stack_bytearray(2);
  1224.  
  1225.     slot_alloctmp(tmp);
  1226.  
  1227.     /* Check we are within the array bounds */
  1228.     move_ref(tmp, stack(2));
  1229.     if (object_array_length != 0) {
  1230.         add_ref_const(tmp, tmp, object_array_length);
  1231.     }
  1232.     load_int(tmp, tmp);
  1233.     cmp_int(0, stack(1), tmp);
  1234.  
  1235.     branch_lt(reference_label(23));
  1236.     softcall_badarrayindex();
  1237.     set_label(23);
  1238.  
  1239.     if (SHIFT_jbyte > 0) {
  1240.         lshl_int_const(tmp, stack(1), SHIFT_jbyte);
  1241.     }
  1242.     else {
  1243.         move_int(tmp, stack(1));
  1244.     }
  1245.     if (object_array_offset != 0) {
  1246.         add_int_const(tmp, tmp, object_array_offset);
  1247.     }
  1248.     add_ref(tmp, tmp, stack(2));
  1249.     store_byte(tmp, stack(0));
  1250.  
  1251.     pop(3);
  1252. }
  1253.  
  1254. define_insn(CASTORE)
  1255. {
  1256.     /*
  1257.      * ..., array ref, index, char value  -> ...
  1258.      */
  1259.     check_stack_int(0);
  1260.     check_stack_int(1);
  1261.     check_stack_chararray(2);
  1262.  
  1263.     slot_alloctmp(tmp);
  1264.  
  1265.     /* Check we are within the array bounds */
  1266.     move_ref(tmp, stack(2));
  1267.     if (object_array_length != 0) {
  1268.         add_ref_const(tmp, tmp, object_array_length);
  1269.     }
  1270.     load_int(tmp, tmp);
  1271.     cmp_int(0, stack(1), tmp);
  1272.  
  1273.     branch_lt(reference_label(24));
  1274.     softcall_badarrayindex();
  1275.     set_label(24);
  1276.  
  1277.     if (SHIFT_jchar > 0) {
  1278.         lshl_int_const(tmp, stack(1), SHIFT_jchar);
  1279.     }
  1280.     else {
  1281.         move_int(tmp, stack(1));
  1282.     }
  1283.     if (object_array_offset != 0) {
  1284.         add_int_const(tmp, tmp, object_array_offset);
  1285.     }
  1286.     add_ref(tmp, tmp, stack(2));
  1287.     store_char(tmp, stack(0));
  1288.  
  1289.     pop(3);
  1290. }
  1291.  
  1292. define_insn(SASTORE)
  1293. {
  1294.     /*
  1295.      * ..., array ref, index, short value  -> ...
  1296.      */
  1297.     check_stack_int(0);
  1298.     check_stack_int(1);
  1299.     check_stack_shortarray(2);
  1300.  
  1301.     slot_alloctmp(tmp);
  1302.     
  1303.     /* Check we are within the array bounds */
  1304.     move_ref(tmp, stack(2));
  1305.     if (object_array_length != 0) {
  1306.         add_ref_const(tmp, tmp, object_array_length);
  1307.     }
  1308.     load_int(tmp, tmp);
  1309.     cmp_int(0, stack(1), tmp);
  1310.  
  1311.     branch_lt(reference_label(25));
  1312.     softcall_badarrayindex();
  1313.     set_label(25);
  1314.  
  1315.     if (SHIFT_jshort > 0) {
  1316.         lshl_int_const(tmp, stack(1), SHIFT_jshort);
  1317.     }
  1318.     else {
  1319.         move_int(tmp, stack(1));
  1320.     }
  1321.     if (object_array_offset != 0) {
  1322.         add_int_const(tmp, tmp, object_array_offset);
  1323.     }
  1324.     add_ref(tmp, tmp, stack(2));
  1325.     store_short(tmp, stack(0));
  1326.  
  1327.     pop(3);
  1328. }
  1329.  
  1330. define_insn(POP)
  1331. {
  1332.     pop(1);
  1333. }
  1334.  
  1335. define_insn(POP2)
  1336. {
  1337.     pop(2);
  1338. }
  1339.  
  1340. define_insn(DUP)
  1341. {
  1342.     push(1);
  1343.     move_any(stack(0), stack(1));
  1344. }
  1345.  
  1346. define_insn(DUP_X1)
  1347. {
  1348.     push(1);
  1349.     move_any(stack(0), stack(1));
  1350.     move_any(stack(1), stack(2));
  1351.     move_any(stack(2), stack(0));
  1352. }
  1353.  
  1354. define_insn(DUP_X2)
  1355. {
  1356.     push(1);
  1357.     move_any(stack(0), stack(1));
  1358.     move_any(stack(1), stack(2));
  1359.     move_any(stack(2), stack(3));
  1360.     move_any(stack(3), stack(0));
  1361. }
  1362.  
  1363. define_insn(DUP2)
  1364. {
  1365.     push(2);
  1366.     move_any(stack(0), stack(2));
  1367.     move_any(stack(1), stack(3));
  1368. }
  1369.  
  1370. define_insn(DUP2_X1)
  1371. {
  1372.     push(2);
  1373.     move_any(stack(0), stack(2));
  1374.     move_any(stack(1), stack(3));
  1375.     move_any(stack(2), stack(4));
  1376.     move_any(stack(3), stack(0));
  1377.     move_any(stack(4), stack(1));
  1378. }
  1379.  
  1380. define_insn(DUP2_X2)
  1381. {
  1382.     push(2);
  1383.     move_any(stack(0), stack(2));
  1384.     move_any(stack(1), stack(3));
  1385.     move_any(stack(2), stack(4));
  1386.     move_any(stack(3), stack(5));
  1387.     move_any(stack(4), stack(0));
  1388.     move_any(stack(5), stack(1));
  1389. }
  1390.  
  1391. define_insn(SWAP)
  1392. {
  1393.         /*
  1394.          * ..., val1, val2 -> ..., val2, val1
  1395.          */
  1396.     swap_int(stack(0), stack(1));
  1397. }
  1398.  
  1399. define_insn(IADD)
  1400. {
  1401.         /*
  1402.          * ..., val1, val2 -> ..., val1+val2
  1403.          */
  1404.     check_stack_int(0);
  1405.     check_stack_int(1);
  1406.  
  1407.     add_int(stack(1), stack(1), stack(0));
  1408.     pop(1);
  1409. }
  1410.  
  1411. define_insn(LADD)
  1412. {
  1413.         /*
  1414.          * ..., long val1, long val2 -> ..., long val1+val2
  1415.          */
  1416.     check_stack_long(0);
  1417.     check_stack_long(2);
  1418.  
  1419.     add_long(stack(2), stack(2), stack(0));
  1420.     pop(2);
  1421. }
  1422.  
  1423. define_insn(FADD)
  1424. {
  1425.         /*
  1426.          * ..., val1, val2 -> ..., val1+val2
  1427.          */
  1428.     check_stack_float(0);
  1429.     check_stack_float(1);
  1430.  
  1431.     add_float(stack(1), stack(1), stack(0));
  1432.     pop(1);
  1433. }
  1434.  
  1435. define_insn(DADD)
  1436. {
  1437.         /*
  1438.          * ..., double val1, long val2 -> ..., double val1+val2
  1439.          */
  1440.     check_stack_double(0);
  1441.     check_stack_double(2);
  1442.  
  1443.     add_double(stack(2), stack(2), stack(0));
  1444.     pop(2);
  1445. }
  1446.  
  1447. define_insn(ISUB)
  1448. {
  1449.         /*
  1450.          * ..., val1, val2 -> ..., val1-val2
  1451.          */
  1452.     check_stack_int(0);
  1453.     check_stack_int(1);
  1454.  
  1455.     sub_int(stack(1), stack(1), stack(0));
  1456.     pop(1);
  1457. }
  1458.  
  1459. define_insn(LSUB)
  1460. {
  1461.         /*
  1462.          * ..., long val1, long val2 -> ..., long val1-val2
  1463.          */
  1464.     check_stack_long(0);
  1465.     check_stack_long(2);
  1466.  
  1467.     sub_long(stack(2), stack(2), stack(0));
  1468.     pop(2);
  1469. }
  1470.  
  1471. define_insn(FSUB)
  1472. {
  1473.         /*
  1474.          * ..., val1, val2 -> ..., val1-val2
  1475.          */
  1476.     check_stack_float(0);
  1477.     check_stack_float(1);
  1478.  
  1479.     sub_float(stack(1), stack(1), stack(0));
  1480.     pop(1);
  1481. }
  1482.  
  1483. define_insn(DSUB)
  1484. {
  1485.         /*
  1486.          * ..., double val1, long val2 -> ..., double val1-val2
  1487.          */
  1488.     check_stack_double(0);
  1489.     check_stack_double(2);
  1490.  
  1491.     sub_double(stack(2), stack(2), stack(0));
  1492.     pop(2);
  1493. }
  1494.  
  1495. define_insn(IMUL)
  1496. {
  1497.         /*
  1498.          * ..., val1, val2 -> ..., val1*val2
  1499.          */
  1500.     check_stack_int(0);
  1501.     check_stack_int(1);
  1502.  
  1503.     mul_int(stack(1), stack(1), stack(0));
  1504.     pop(1);
  1505. }
  1506.  
  1507. define_insn(LMUL)
  1508. {
  1509.         /*
  1510.          * ..., long val1, long val2 -> ..., long val1*val2
  1511.          */
  1512.     check_stack_long(0);
  1513.     check_stack_long(2);
  1514.  
  1515.     mul_long(stack(2), stack(2), stack(0));
  1516.     pop(2);
  1517. }
  1518.  
  1519. define_insn(FMUL)
  1520. {
  1521.         /*
  1522.          * ..., val1, val2 -> ..., val1*val2
  1523.          */
  1524.     check_stack_float(0);
  1525.     check_stack_float(1);
  1526.  
  1527.     mul_float(stack(1), stack(1), stack(0));
  1528.     pop(1);
  1529. }
  1530.  
  1531. define_insn(DMUL)
  1532. {
  1533.         /*
  1534.          * ..., double val1, long val2 -> ..., double val1*val2
  1535.          */
  1536.     check_stack_double(0);
  1537.     check_stack_double(2);
  1538.  
  1539.     mul_double(stack(2), stack(2), stack(0));
  1540.     pop(2);
  1541. }
  1542.  
  1543. define_insn(IDIV)
  1544. {
  1545.         /*
  1546.          * ..., val1, val2 -> ..., val1/val2
  1547.          */
  1548.     check_stack_int(0);
  1549.     check_stack_int(1);
  1550.  
  1551.     div_int(stack(1), stack(1), stack(0));
  1552.     pop(1);
  1553. }
  1554.  
  1555. define_insn(LDIV)
  1556. {
  1557.         /*
  1558.          * ..., long val1, long val2 -> ..., long val1/val2
  1559.          */
  1560.     check_stack_long(0);
  1561.     check_stack_long(2);
  1562.  
  1563.     div_long(stack(2), stack(2), stack(0));
  1564.     pop(2);
  1565. }
  1566.  
  1567. define_insn(FDIV)
  1568. {
  1569.         /*
  1570.          * ..., val1, val2 -> ..., val1/val2
  1571.          */
  1572.     check_stack_float(0);
  1573.     check_stack_float(1);
  1574.  
  1575.     div_float(stack(1), stack(1), stack(0));
  1576.     pop(1);
  1577. }
  1578.  
  1579. define_insn(DDIV)
  1580. {
  1581.         /*
  1582.          * ..., val1, val2 -> ..., val1/val2
  1583.          */
  1584.     check_stack_double(0);
  1585.     check_stack_double(2);
  1586.  
  1587.     div_double(stack(2), stack(2), stack(0));
  1588.     pop(2);
  1589. }
  1590.  
  1591. define_insn(IREM)
  1592. {
  1593.         /*
  1594.          * ..., val1, val2 -> ..., val1%val2
  1595.          */
  1596.     check_stack_int(0);
  1597.     check_stack_int(1);
  1598.  
  1599.     rem_int(stack(1), stack(1), stack(0));
  1600.     pop(1);
  1601. }
  1602.  
  1603. define_insn(LREM)
  1604. {
  1605.         /*
  1606.          * ..., long val1, long val2 -> ..., long val1%val2
  1607.          */
  1608.     check_stack_long(0);
  1609.     check_stack_long(2);
  1610.  
  1611.     rem_long(stack(2), stack(2), stack(0));
  1612.     pop(2);
  1613. }
  1614.  
  1615. define_insn(FREM)
  1616. {
  1617.         /*
  1618.          * ..., val1, val2 -> ..., val1%val2
  1619.          */
  1620.     check_stack_float(0);
  1621.     check_stack_float(1);
  1622.  
  1623.     rem_float(stack(1), stack(1), stack(0));
  1624.     pop(1);
  1625. }
  1626.  
  1627. define_insn(DREM)
  1628. {
  1629.         /*
  1630.          * ..., val1, val2 -> ..., val1%val2
  1631.          */
  1632.     check_stack_double(0);
  1633.     check_stack_double(2);
  1634.  
  1635.     rem_double(stack(2), stack(2), stack(0));
  1636.     pop(2);
  1637. }
  1638.  
  1639. define_insn(INEG)
  1640. {
  1641.     check_stack_int(0);
  1642.  
  1643.     neg_int(stack(0), stack(0));
  1644. }
  1645.  
  1646. define_insn(LNEG)
  1647. {
  1648.     check_stack_long(0);
  1649.  
  1650.     neg_long(stack(0), stack(0));
  1651. }
  1652.  
  1653. define_insn(FNEG)
  1654. {
  1655.     check_stack_float(0);
  1656.  
  1657.     neg_float(stack(0), stack(0));
  1658. }
  1659.  
  1660. define_insn(DNEG)
  1661. {
  1662.     check_stack_double(0);
  1663.  
  1664.     neg_double(stack(0), stack(0));
  1665. }
  1666.  
  1667. define_insn(ISHL)
  1668. {
  1669.     /*
  1670.      * ..., val1, val2 -> ... val1 << val2
  1671.      */
  1672.     check_stack_int(0);
  1673.     check_stack_int(1);
  1674.  
  1675.     lshl_int(stack(1), stack(1), stack(0));
  1676.     pop(1);
  1677. }
  1678.  
  1679. define_insn(LSHL)
  1680. {
  1681.     /*
  1682.      * ..., long val1, val2 -> ... long val1 << val2
  1683.      */
  1684.     check_stack_int(0);
  1685.     check_stack_long(1);
  1686.  
  1687.     lshl_long(stack(1), stack(1), stack(0));
  1688.     pop(1);
  1689. }
  1690.  
  1691. define_insn(ISHR)
  1692. {
  1693.     /*
  1694.      * ..., val1, val2 -> ... val1 >> val2
  1695.      */
  1696.     check_stack_int(0);
  1697.     check_stack_int(1);
  1698.  
  1699.     ashr_int(stack(1), stack(1), stack(0));
  1700.     pop(1);
  1701. }
  1702.  
  1703. define_insn(LSHR)
  1704. {
  1705.     /*
  1706.      * ..., long val1, val2 -> ... long val1 >> val2
  1707.      */
  1708.     check_stack_int(0);
  1709.     check_stack_long(1);
  1710.  
  1711.     ashr_long(stack(1), stack(1), stack(0));
  1712.     pop(1);
  1713. }
  1714.  
  1715. define_insn(IUSHR)
  1716. {
  1717.     /*
  1718.      * ..., val1, val2 -> ... val1 >> val2
  1719.      */
  1720.     check_stack_int(0);
  1721.     check_stack_int(1);
  1722.  
  1723.     lshr_int(stack(1), stack(1), stack(0));
  1724.     pop(1);
  1725. }
  1726.  
  1727. define_insn(LUSHR)
  1728. {
  1729.     /*
  1730.      * ..., long val1, val2 -> ... long val1 >> val2
  1731.      */
  1732.     check_stack_int(0);
  1733.     check_stack_long(1);
  1734.  
  1735.     lshr_long(stack(1), stack(1), stack(0));
  1736.     pop(1);
  1737. }
  1738.  
  1739. define_insn(IAND)
  1740. {
  1741.         /*
  1742.          * ..., val1, val2 -> ..., val1 & val2
  1743.          */
  1744.     check_stack_int(0);
  1745.     check_stack_int(1);
  1746.  
  1747.     and_int(stack(1), stack(1), stack(0));
  1748.     pop(1);
  1749. }
  1750.  
  1751. define_insn(LAND)
  1752. {
  1753.         /*
  1754.          * ..., long val1, long val2 -> ..., long val1 & val2
  1755.          */
  1756.     check_stack_long(0);
  1757.     check_stack_long(2);
  1758.  
  1759.     and_long(stack(2), stack(2), stack(0));
  1760.     pop(2);
  1761. }
  1762.  
  1763. define_insn(IOR)
  1764. {
  1765.         /*
  1766.          * ..., val1, val2 -> ..., val1 | val2
  1767.          */
  1768.     check_stack_int(0);
  1769.     check_stack_int(1);
  1770.  
  1771.     or_int(stack(1), stack(1), stack(0));
  1772.     pop(1);
  1773. }
  1774.  
  1775. define_insn(LOR)
  1776. {
  1777.         /*
  1778.          * ..., long val1, long val2 -> ..., long val1 | val2
  1779.          */
  1780.     check_stack_long(0);
  1781.     check_stack_long(2);
  1782.  
  1783.     or_long(stack(2), stack(2), stack(0));
  1784.     pop(2);
  1785. }
  1786.  
  1787. define_insn(IXOR)
  1788. {
  1789.         /*
  1790.          * ..., val1, val2 -> ..., val1 ^ val2
  1791.          */
  1792.     check_stack_int(0);
  1793.     check_stack_int(1);
  1794.  
  1795.     xor_int(stack(1), stack(1), stack(0));
  1796.     pop(1);
  1797. }
  1798.  
  1799. define_insn(LXOR)
  1800. {
  1801.         /*
  1802.          * ..., long val1, long val2 -> ..., long val1 ^ val2
  1803.          */
  1804.     check_stack_long(0);
  1805.     check_stack_long(2);
  1806.  
  1807.     xor_long(stack(2), stack(2), stack(0));
  1808.     pop(2);
  1809. }
  1810.  
  1811. define_insn(IINC)
  1812. {
  1813.     idx = wide + (uint8)getpc(0);
  1814.     low = (int8)getpc(1);
  1815.  
  1816.     check_local_int(idx);
  1817.  
  1818.     add_int_const(local(idx), local(idx), low);
  1819.     wide = 0;
  1820. }
  1821.  
  1822. define_insn(I2L)
  1823. {
  1824.     check_stack_int(0);
  1825.  
  1826.     push(1);
  1827.     cvt_int_long(stack(0), stack(1));
  1828. }
  1829.  
  1830. define_insn(I2F)
  1831. {
  1832.     check_stack_int(0);
  1833.  
  1834.     cvt_int_float(stack(0), stack(0));
  1835. }
  1836.  
  1837. define_insn(I2D)
  1838. {
  1839.     check_stack_int(0);
  1840.  
  1841.     push(1);
  1842.     cvt_int_double(stack(0), stack(1));
  1843. }
  1844.  
  1845. define_insn(L2I)
  1846. {
  1847.     check_stack_long(0);
  1848.  
  1849.     cvt_long_int(stack(1), stack(0));
  1850.     pop(1);
  1851. }
  1852.  
  1853. define_insn(L2F)
  1854. {
  1855.     check_stack_long(0);
  1856.  
  1857.     cvt_long_float(stack(1), stack(0));
  1858.     pop(1);
  1859. }
  1860.  
  1861. define_insn(L2D)
  1862. {
  1863.     check_stack_long(0);
  1864.  
  1865.     cvt_long_double(stack(0), stack(0));
  1866. }
  1867.  
  1868. define_insn(F2I)
  1869. {
  1870.     check_stack_float(0);
  1871.  
  1872.     cvt_float_int(stack(0), stack(0));
  1873. }
  1874.  
  1875. define_insn(F2L)
  1876. {
  1877.     check_stack_float(0);
  1878.  
  1879.     push(1);
  1880.     cvt_float_long(stack(0), stack(1));
  1881. }
  1882.  
  1883. define_insn(F2D)
  1884. {
  1885.     check_stack_float(0);
  1886.  
  1887.     push(1);
  1888.     cvt_float_double(stack(0), stack(1));
  1889. }
  1890.  
  1891. define_insn(D2I)
  1892. {
  1893.     check_stack_double(0);
  1894.  
  1895.     cvt_double_int(stack(1), stack(0));
  1896.     pop(1);
  1897. }
  1898.  
  1899. define_insn(D2L)
  1900. {
  1901.     check_stack_double(0);
  1902.  
  1903.     cvt_double_long(stack(0), stack(0));
  1904. }
  1905.  
  1906. define_insn(D2F)
  1907. {
  1908.     check_stack_double(0);
  1909.  
  1910.     cvt_double_float(stack(1), stack(0));
  1911.     pop(1);
  1912. }
  1913.  
  1914. define_insn(INT2BYTE)
  1915. {
  1916.     check_stack_int(0);
  1917.  
  1918.     cvt_int_byte(stack(0), stack(0));
  1919. }
  1920.  
  1921. define_insn(INT2CHAR)
  1922. {
  1923.     check_stack_int(0);
  1924.  
  1925.     cvt_int_char(stack(0), stack(0));
  1926. }
  1927.  
  1928. define_insn(INT2SHORT)
  1929. {
  1930.     check_stack_int(0);
  1931.  
  1932.     cvt_int_short(stack(0), stack(0));
  1933. }
  1934.  
  1935. define_insn(LCMP)
  1936. {
  1937.     /*
  1938.      * ..., long val1, long val2 -> ..., result
  1939.      */
  1940.     check_stack_long(0);
  1941.     check_stack_long(2);
  1942.  
  1943.     cmp_long(stack(3), stack(0), stack(2));
  1944.     pop(3);
  1945. }
  1946.  
  1947. define_insn(FCMPL)
  1948. {
  1949.     /*
  1950.      * ..., float val1, float val2 -> ..., result
  1951.      */
  1952.     check_stack_float(0);
  1953.     check_stack_float(1);
  1954.  
  1955.     cmpl_float(stack(1), stack(1), stack(0));
  1956.     pop(1);
  1957. }
  1958.  
  1959. define_insn(FCMPG)
  1960. {
  1961.     /*
  1962.      * ..., float val1, float val2 -> ..., result
  1963.      */
  1964.     check_stack_float(0);
  1965.     check_stack_float(1);
  1966.  
  1967.     cmpg_float(stack(1), stack(1), stack(0));
  1968.     pop(1);
  1969. }
  1970.  
  1971. define_insn(DCMPL)
  1972. {
  1973.     /*
  1974.      * ..., double val1, double val2 -> ..., result
  1975.      */
  1976.     check_stack_double(0);
  1977.     check_stack_double(2);
  1978.  
  1979.     cmpl_double(stack(3), stack(2), stack(0));
  1980.     pop(3);
  1981. }
  1982.  
  1983. define_insn(DCMPG)
  1984. {
  1985.     /*
  1986.      * ..., double val1, double val2 -> ..., result
  1987.      */
  1988.     check_stack_double(0);
  1989.     check_stack_double(2);
  1990.  
  1991.     cmpg_double(stack(3), stack(2), stack(0));
  1992.     pop(3);
  1993. }
  1994.  
  1995. define_insn(IFEQ)
  1996. {
  1997.     check_stack_int(0);
  1998.  
  1999.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2000.  
  2001.     end_basic_block();
  2002.  
  2003.     cmp_int_const(0, stack(0), 0);
  2004.     branch_eq(reference_code_label(pc+idx));
  2005.  
  2006.     pop(1);
  2007. }
  2008.  
  2009. define_insn(IFNE)
  2010. {
  2011.     check_stack_int(0);
  2012.  
  2013.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2014.  
  2015.     end_basic_block();
  2016.  
  2017.     cmp_int_const(0, stack(0), 0);
  2018.     branch_ne(reference_code_label(pc+idx));
  2019.  
  2020.     pop(1);
  2021. }
  2022.  
  2023. define_insn(IFLT)
  2024. {
  2025.     check_stack_int(0);
  2026.  
  2027.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2028.  
  2029.     end_basic_block();
  2030.  
  2031.     cmp_int_const(0, stack(0), 0);
  2032.     branch_lt(reference_code_label(pc+idx));
  2033.  
  2034.     pop(1);
  2035. }
  2036.  
  2037. define_insn(IFGE)
  2038. {
  2039.     check_stack_int(0);
  2040.  
  2041.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2042.  
  2043.     end_basic_block();
  2044.  
  2045.     cmp_int_const(0, stack(0), 0);
  2046.     branch_ge(reference_code_label(pc+idx));
  2047.  
  2048.     pop(1);
  2049. }
  2050.  
  2051. define_insn(IFGT)
  2052. {
  2053.     check_stack_int(0);
  2054.  
  2055.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2056.  
  2057.     end_basic_block();
  2058.  
  2059.     cmp_int_const(0, stack(0), 0);
  2060.     branch_gt(reference_code_label(pc+idx));
  2061.  
  2062.     pop(1);
  2063. }
  2064.  
  2065. define_insn(IFLE)
  2066. {
  2067.     check_stack_int(0);
  2068.  
  2069.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2070.  
  2071.     end_basic_block();
  2072.  
  2073.     cmp_int_const(0, stack(0), 0);
  2074.     branch_le(reference_code_label(pc+idx));
  2075.  
  2076.     pop(1);
  2077. }
  2078.  
  2079. define_insn(IF_ICMPEQ)
  2080. {
  2081.     check_stack_int(0);
  2082.     check_stack_int(1);
  2083.  
  2084.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2085.  
  2086.     end_basic_block();
  2087.  
  2088.     cmp_int(0, stack(1), stack(0));
  2089.     branch_eq(reference_code_label(pc+idx));
  2090.  
  2091.     pop(2);
  2092. }
  2093.  
  2094. define_insn(IF_ICMPNE)
  2095. {
  2096.     check_stack_int(0);
  2097.     check_stack_int(1);
  2098.  
  2099.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2100.  
  2101.     end_basic_block();
  2102.  
  2103.     cmp_int(0, stack(1), stack(0));
  2104.     branch_ne(reference_code_label(pc+idx));
  2105.  
  2106.     pop(2);
  2107. }
  2108.  
  2109. define_insn(IF_ICMPLT)
  2110. {
  2111.     check_stack_int(0);
  2112.     check_stack_int(1);
  2113.  
  2114.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2115.  
  2116.     end_basic_block();
  2117.  
  2118.     cmp_int(0, stack(1), stack(0));
  2119.     branch_lt(reference_code_label(pc+idx));
  2120.  
  2121.     pop(2);
  2122. }
  2123.  
  2124. define_insn(IF_ICMPGE)
  2125. {
  2126.     check_stack_int(0);
  2127.     check_stack_int(1);
  2128.  
  2129.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2130.  
  2131.     end_basic_block();
  2132.  
  2133.     cmp_int(0, stack(1), stack(0));
  2134.     branch_ge(reference_code_label(pc+idx));
  2135.  
  2136.     pop(2);
  2137. }
  2138.  
  2139. define_insn(IF_ICMPGT)
  2140. {
  2141.     check_stack_int(0);
  2142.     check_stack_int(1);
  2143.  
  2144.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2145.  
  2146.     end_basic_block();
  2147.  
  2148.     cmp_int(0, stack(1), stack(0));
  2149.     branch_gt(reference_code_label(pc+idx));
  2150.  
  2151.     pop(2);
  2152. }
  2153.  
  2154. define_insn(IF_ICMPLE)
  2155. {
  2156.     check_stack_int(0);
  2157.     check_stack_int(1);
  2158.  
  2159.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2160.  
  2161.     end_basic_block();
  2162.  
  2163.     cmp_int(0, stack(1), stack(0));
  2164.     branch_le(reference_code_label(pc+idx));
  2165.  
  2166.     pop(2);
  2167. }
  2168.  
  2169. define_insn(IF_ACMPEQ)
  2170. {
  2171.     check_stack_ref(0);
  2172.     check_stack_ref(1);
  2173.  
  2174.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2175.  
  2176.     end_basic_block();
  2177.  
  2178.     cmp_ref(0, stack(1), stack(0));
  2179.     branch_eq(reference_code_label(pc+idx));
  2180.  
  2181.     pop(2);
  2182. }
  2183.  
  2184. define_insn(IF_ACMPNE)
  2185. {
  2186.     check_stack_ref(0);
  2187.     check_stack_ref(1);
  2188.  
  2189.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2190.  
  2191.     end_basic_block();
  2192.  
  2193.     cmp_ref(0, stack(1), stack(0));
  2194.     branch_ne(reference_code_label(pc+idx));
  2195.  
  2196.     pop(2);
  2197. }
  2198.  
  2199. define_insn(GOTO)
  2200. {
  2201.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2202.  
  2203.     end_basic_block();
  2204.     branch_a(reference_code_label(pc+idx));
  2205. }
  2206.  
  2207. define_insn(JSR)
  2208. {
  2209.     /*
  2210.      * ... -> ..., ret-addr
  2211.      */
  2212.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2213.  
  2214.     push(1);
  2215.     move_label_const(stack(0), reference_code_label(npc));
  2216.     end_basic_block();
  2217.     branch_a(reference_code_label(pc+idx));
  2218. }
  2219.  
  2220. define_insn(RET)
  2221. {
  2222.     idx = (uint8)getpc(0);
  2223.  
  2224.     check_local_ref(idx);
  2225.  
  2226.     end_basic_block();
  2227.     branch_indirect(stored_code_label(local(idx)));
  2228. }
  2229.  
  2230. define_insn(TABLESWITCH)
  2231. {
  2232.     /*
  2233.      * ..., index -> ...
  2234.      */
  2235.     check_stack_int(0);
  2236.  
  2237.     slot_alloctmp(tmp2);
  2238.  
  2239.     npc = (pc + 1 + 3) & -4;
  2240.     low = (int32)((getcode(npc+4) << 24) | (getcode(npc+5) << 16) |
  2241.                 (getcode(npc+6) << 8) | getcode(npc+7));
  2242.     high = (int32)((getcode(npc+8) << 24) | (getcode(npc+9) << 16) |
  2243.                 (getcode(npc+10) << 8) | getcode(npc+11));
  2244.     npc = npc + 12;
  2245.  
  2246.     end_basic_block();
  2247.     cmp_int_const(0, stack(0), low);
  2248.     branch_lt(reference_label(8));
  2249.     if (low != 0) {
  2250.         start_basic_block();
  2251.         sub_int_const(stack(0), stack(0), low);
  2252.         end_basic_block();
  2253.     }
  2254.     cmp_int_const(0, stack(0), high-low);
  2255.     branch_le(reference_label(7));
  2256.  
  2257.     start_basic_block();
  2258.     set_label(8);
  2259.     move_int_const(stack(0), -3); /* Position at default entry */
  2260.     end_basic_block();
  2261.  
  2262.     start_basic_block();
  2263.     set_label(7);
  2264.     lshl_int_const(stack(0), stack(0), switchtable_shift);
  2265.     move_label_const(tmp2, reference_table_label(9));
  2266.     add_ref(stack(0), stack(0), tmp2);
  2267.     load_code_ref(stack(0), stack(0));
  2268.     end_basic_block();
  2269.     branch_indirect(table_code_label(stack(0)));
  2270.     pop(1);
  2271.  
  2272. #if defined(TRANSLATOR)
  2273.     {
  2274.         build_code_ref(&getcode(npc-12), pc);    /* Default entry */
  2275.         build_code_ref(&getcode(npc-12), pc);    /* Dummy */
  2276.         build_code_ref(&getcode(npc-12), pc);    /* Dummy */
  2277.         set_label(9);
  2278.         for (idx = 0; idx < high-low+1; idx++) {
  2279.             build_code_ref(&getcode(npc + (idx << switchtable_shift)), pc);
  2280.         }
  2281.     }
  2282. #endif
  2283.     adjustpc((4 - (pc % 4)) + 12 + (high - low + 1) * 4);
  2284. }
  2285.  
  2286. define_insn(LOOKUPSWITCH)
  2287. {
  2288.     /*
  2289.      * ..., key -> ...
  2290.      */
  2291.     check_stack_int(0);
  2292.  
  2293.     npc = (pc + 1 + 3) & -4;
  2294.     idx = (int32)((getcode(npc+4) << 24) | (getcode(npc+5) << 16) |
  2295.                 (getcode(npc+6) << 8) | getcode(npc+7));
  2296.  
  2297.     slot_alloctmp(mtable);
  2298.     slot_alloctmp(tmp);
  2299.     slot_alloctmp(tmp2);
  2300.  
  2301.     move_label_const(tmp2, reference_table_label(7));
  2302.     move_ref(tmp, tmp2);
  2303.     add_int_const(tmp, tmp, idx * switchpair_size);
  2304.  
  2305.     end_basic_block();
  2306.     set_label(5);
  2307.     start_basic_block();
  2308.     load_key(mtable, tmp);
  2309.     end_basic_block();
  2310.     cmp_int(0, mtable, stack(0));
  2311.     branch_eq(reference_label(6));
  2312.  
  2313.     start_basic_block();
  2314.     sub_int_const(tmp, tmp, switchpair_size);
  2315.     end_basic_block();
  2316.     cmp_int(0, tmp, tmp2);
  2317.     branch_ne(reference_label(5));
  2318.  
  2319.     start_basic_block();
  2320.     sub_int_const(tmp, tmp, switchpair_addr);
  2321.     end_basic_block();
  2322.  
  2323.     set_label(6);
  2324.     start_basic_block();
  2325.     add_int_const(tmp, tmp, switchpair_addr);
  2326.     load_code_ref(tmp, tmp);
  2327.     end_basic_block();
  2328.     branch_indirect(table_code_label(tmp));
  2329.     pop(1);
  2330.  
  2331. #if defined(TRANSLATOR)
  2332.     {
  2333.         set_label(7);
  2334.         build_code_ref(&getcode(npc), pc);
  2335.         build_key(&getcode(npc)); /* Dummy key */
  2336.         for (low = 1; low <= idx; low++) {
  2337.             build_key(&getcode(npc + (low * switchpair_size)));
  2338.             build_code_ref(&getcode(npc + (low * switchpair_size) + switchpair_addr), pc);
  2339.         }
  2340.     }
  2341. #endif
  2342.     adjustpc((4 - (pc % 4)) + (idx + 1) * 8);
  2343. }
  2344.  
  2345. define_insn(IRETURN)
  2346. {
  2347.     check_stack_int(0);
  2348.  
  2349.     monitor_exit();
  2350.     move_int(returnarg_int(), stack(0));
  2351.     end_function();
  2352.     ret();
  2353. }
  2354.  
  2355. define_insn(LRETURN)
  2356. {
  2357.     check_stack_long(0);
  2358.  
  2359.     monitor_exit();
  2360.     move_long(returnarg_long(), stack(0));
  2361.     end_function();
  2362.     ret();
  2363. }
  2364.  
  2365. define_insn(FRETURN)
  2366. {
  2367.     check_stack_float(0);
  2368.  
  2369.     monitor_exit();
  2370.     move_float(returnarg_float(), stack(0));
  2371.     end_function();
  2372.     ret();
  2373. }
  2374.  
  2375. define_insn(DRETURN)
  2376. {
  2377.     check_stack_double(0);
  2378.  
  2379.     monitor_exit();
  2380.     move_double(returnarg_double(), stack(0));
  2381.     end_function();
  2382.     ret();
  2383. }
  2384.  
  2385. define_insn(ARETURN)
  2386. {
  2387.     check_stack_ref(0);
  2388.  
  2389.     monitor_exit();
  2390.     move_ref(returnarg_ref(), stack(0));
  2391.     end_function();
  2392.     ret();
  2393. }
  2394.  
  2395. define_insn(RETURN)
  2396. {
  2397.     monitor_exit();
  2398.     end_function();
  2399.     ret();
  2400. }
  2401.  
  2402. define_insn(GETSTATIC)
  2403. {
  2404.     /*
  2405.      * ... -> ..., value
  2406.      */
  2407.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2408.  
  2409.     slot_alloctmp(tmp);
  2410.  
  2411.     get_static_field_info(constants(), idx);
  2412.     move_ref_const(tmp, field_statics() + field_offset());
  2413.  
  2414.     if (field_size() == 1) {
  2415.         push(1);
  2416.         load_any(stack(0), tmp);
  2417.     }
  2418.     else {
  2419.         push(2);
  2420.         load_anylong(stack(0), tmp);
  2421.     }
  2422. }
  2423.  
  2424. define_insn(PUTSTATIC)
  2425. {
  2426.     /*
  2427.      * ..., value  -> ...
  2428.      */
  2429.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2430.     slot_alloctmp(tmp);
  2431.  
  2432.     get_static_field_info(constants(), idx);
  2433.     move_ref_const(tmp, field_statics() + field_offset());
  2434.  
  2435.     if (field_size() == 1) {
  2436.  
  2437. #if defined(GC_INCREMENTAL)
  2438.         /* If colour of referenced object is white, add it
  2439.          * to the garbage collector.
  2440.          */
  2441.         if (field_isref()) {
  2442.  
  2443.             end_basic_block();
  2444.             cmp_int_const(0, stack(0), 0);
  2445.             branch_eq(reference_label(27));
  2446.  
  2447.             slot_alloctmp(tmp2);
  2448.  
  2449.             if (object_colour() == 0) {
  2450.                 move_ref(tmp2, stack(0));
  2451.             }
  2452.             else {
  2453.                 add_ref_const(tmp2, stack(0), object_colour());
  2454.             }
  2455.             load_int(tmp2, tmp2);
  2456.             end_basic_block();
  2457.             cmp_int_const(0, tmp2, object_white());
  2458.             branch_ne(reference_label(26));
  2459.             softcall_addtogc(stack(0));
  2460.             set_label(27);
  2461.             set_label(26);
  2462.         }
  2463. #endif
  2464.  
  2465.         store_any(tmp, stack(0));
  2466.         pop(1);
  2467.     }
  2468.     else {
  2469.         store_anylong(tmp, stack(0));
  2470.         pop(2);
  2471.     }
  2472. }
  2473.  
  2474. define_insn(GETFIELD)
  2475. {
  2476.     /*
  2477.      * ..., obj-ref -> ..., value
  2478.      */
  2479.     check_stack_ref(0);
  2480.  
  2481.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2482.  
  2483.     get_field_info(constants(), idx);
  2484.     add_ref_const(stack(0), stack(0), field_data() + field_offset());
  2485.     if (field_size() == 1) {
  2486.         load_any(stack(0), stack(0));
  2487.     }
  2488.     else {
  2489.         push(1);
  2490.         load_anylong(stack(0), stack(1));
  2491.     }
  2492. }
  2493.  
  2494. define_insn(PUTFIELD)
  2495. {
  2496.     /*
  2497.      * ..., obj-ref, value  -> ...
  2498.      */
  2499.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2500.  
  2501.     get_field_info(constants(), idx);
  2502.     if (field_size() == 1) {
  2503.         check_stack_ref(1);
  2504.  
  2505. #if defined(GC_INCREMENTAL)
  2506.         /* If colour of referenced object is white, add it
  2507.          * to the garbage collector.
  2508.          */
  2509.         if (field_isref()) {
  2510.  
  2511.             end_basic_block();
  2512.             cmp_int_const(0, stack(0), 0);
  2513.             branch_eq(reference_label(28));
  2514.  
  2515.             slot_alloctmp(tmp2);
  2516.  
  2517.             if (object_colour() == 0) {
  2518.                 move_ref(tmp2, stack(0));
  2519.             }
  2520.             else {
  2521.                 add_ref_const(tmp2, stack(0), object_colour());
  2522.             }
  2523.             load_int(tmp2, tmp2);
  2524.             end_basic_block();
  2525.             cmp_int_const(0, tmp2, object_white());
  2526.             branch_ne(reference_label(29));
  2527.             softcall_addtogc(stack(0));
  2528.             set_label(28);
  2529.             set_label(29);
  2530.         }
  2531. #endif
  2532.  
  2533.         add_ref_const(stack(1), stack(1), field_data()+field_offset());
  2534.         store_any(stack(1), stack(0));
  2535.  
  2536.         pop(2);
  2537.     }
  2538.     else {
  2539.         check_stack_ref(2);
  2540.  
  2541.         add_ref_const(stack(2), stack(2), field_data() + field_offset());
  2542.         store_anylong(stack(2), stack(0));
  2543.         pop(3);
  2544.     }
  2545. }
  2546.  
  2547. #define    METHOD_PUSHARGS()                    \
  2548.     for (low = 0; low < idx; low++) {            \
  2549.         switch (method_arg(idx-low-1)) {        \
  2550.         case 'L':                    \
  2551.         case '[':                    \
  2552.         case 'I':                    \
  2553.         case 'Z':                    \
  2554.         case 'S':                    \
  2555.         case 'B':                    \
  2556.         case 'C':                    \
  2557.         case 'F':                    \
  2558.             pusharg_any(stack(low));        \
  2559.             break;                    \
  2560.         case 'J':                    \
  2561.         case 'D':                    \
  2562.             pusharg_anylong(stack(low));        \
  2563.             low++;                    \
  2564.             break;                    \
  2565.         case 'V':                    \
  2566.         default:                    \
  2567.             abort();                \
  2568.         }                        \
  2569.     }
  2570.  
  2571. #define    METHOD_RETURN_VALUE()                    \
  2572.     /* Store the return type (if necessary) */        \
  2573.     switch (low) {                        \
  2574.     case 'V':                        \
  2575.         pop(idx);                    \
  2576.         break;                        \
  2577.     case 'L':                        \
  2578.     case '[':                        \
  2579.         pop(idx - 1);                    \
  2580.         return_ref(stack(0));                \
  2581.         break;                        \
  2582.     case 'I':                        \
  2583.     case 'Z':                        \
  2584.     case 'S':                        \
  2585.     case 'B':                        \
  2586.     case 'C':                        \
  2587.         pop(idx - 1);                    \
  2588.         return_int(stack(0));                \
  2589.         break;                        \
  2590.     case 'F':                        \
  2591.         pop(idx - 1);                    \
  2592.         return_float(stack(0));                \
  2593.         break;                        \
  2594.     case 'J':                        \
  2595.         pop(idx - 2);                    \
  2596.         return_long(stack(0));                \
  2597.         break;                        \
  2598.     case 'D':                        \
  2599.         pop(idx - 2);                    \
  2600.         return_double(stack(0));            \
  2601.         break;                        \
  2602.     default:                        \
  2603.         abort();                    \
  2604.     }
  2605.  
  2606. define_insn(INVOKEVIRTUAL)
  2607. {
  2608.     /*
  2609.      * (*soft_lookupmethod(obj->methodtable, msig))(...);
  2610.      *
  2611.      * ..., obj, ..args.., -> ...
  2612.      */
  2613.  
  2614.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2615.  
  2616.     slot_alloctmp(tmp);
  2617.     slot_alloctmp(mtable);
  2618.  
  2619.     get_method_info(constants(), idx);
  2620.     idx = method_nargs();
  2621.  
  2622.     check_stack_ref(idx);
  2623.  
  2624.     /* Find dispatch table in object */
  2625.     if (method_dtable_offset != 0) {
  2626.         add_ref_const(mtable, stack(idx), method_dtable_offset);
  2627.         load_ref(mtable, mtable);
  2628.     }
  2629.     else {
  2630.         load_ref(mtable, stack(idx));
  2631.     }
  2632.  
  2633.     /* Check method table for cached entry */
  2634.     add_ref_const(tmp, mtable, DTABLE_METHODOFFSET + method_idx() * DTABLE_METHODSIZE);
  2635.     load_ref(tmp, tmp);
  2636.     end_basic_block();
  2637.     cmp_ref_const(0, tmp, 0);
  2638.     branch_ne(reference_label(31));
  2639.     softcall_lookupmethod(tmp, method_name(), mtable);
  2640.     slot_nowriteback(mtable);
  2641.  
  2642.     end_basic_block();
  2643.     set_label(31);
  2644.     start_basic_block();
  2645.     /* Push arguments */
  2646.     METHOD_PUSHARGS();
  2647.     /* Push object */
  2648.     pusharg_ref(stack(idx));
  2649.  
  2650.     end_basic_block();
  2651.  
  2652.     /* Call it */
  2653.     low = method_returntype();
  2654.     call(tmp);
  2655.  
  2656.     /* Pop args */
  2657.     idx++;
  2658.     popargs(idx);
  2659.  
  2660.     start_basic_block();
  2661.     METHOD_RETURN_VALUE();
  2662. }
  2663.  
  2664. define_insn(INVOKENONVIRTUAL)
  2665. {
  2666.     /*
  2667.      * (*soft_lookupmethod(class->methodtable, msig))(...);
  2668.      *
  2669.      * ..., obj, ..args.., -> ...
  2670.      */
  2671.  
  2672.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2673.  
  2674.     slot_alloctmp(tmp);
  2675.     slot_alloctmp(mtable);
  2676.  
  2677.     get_method_info(constants(), idx);
  2678.     idx = method_nargs();
  2679.  
  2680.     check_stack_ref(idx);
  2681.  
  2682.     get_dispatch_table(mtable);
  2683.  
  2684.     /* Check dispatch table for entry */
  2685.     add_ref_const(tmp, mtable, DTABLE_METHODOFFSET + method_idx() * DTABLE_METHODSIZE);
  2686.     load_ref(tmp, tmp);
  2687.     end_basic_block();
  2688.     cmp_ref_const(0, tmp, 0);
  2689.     branch_ne(reference_label(33));
  2690.     softcall_lookupmethod(tmp, method_name(), mtable);
  2691.     slot_nowriteback(mtable);
  2692.  
  2693.     end_basic_block();
  2694.     set_label(33);
  2695.     start_basic_block();
  2696.     /* Push arguments */
  2697.     METHOD_PUSHARGS();
  2698.     /* Push object */
  2699.     pusharg_ref(stack(idx));
  2700.  
  2701.     end_basic_block();
  2702.  
  2703.     /* Call it */
  2704.     low = method_returntype();
  2705.     call(tmp);
  2706.  
  2707.     /* Pop args */
  2708.     idx++;
  2709.     popargs(idx);
  2710.  
  2711.     start_basic_block();
  2712.     METHOD_RETURN_VALUE();
  2713. }
  2714.  
  2715. define_insn(INVOKESTATIC)
  2716. {
  2717.     /*
  2718.      * (*soft_lookupmethod(class->methodtable, msig))(...);
  2719.      *
  2720.      * ..., ..args.., -> ...
  2721.      */
  2722.  
  2723.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2724.  
  2725.     slot_alloctmp(tmp);
  2726.     slot_alloctmp(mtable);
  2727.  
  2728.     get_method_info(constants(), idx);
  2729.     idx = method_nargs();
  2730.  
  2731.     get_dispatch_table(mtable);
  2732.  
  2733.     /* Check method table for cached entry */
  2734.     add_ref_const(tmp, mtable, DTABLE_METHODOFFSET + method_idx() * DTABLE_METHODSIZE);
  2735.     load_ref(tmp, tmp);
  2736.     end_basic_block();
  2737.     cmp_ref_const(0, tmp, 0);
  2738.     branch_ne(reference_label(35));
  2739.     softcall_lookupmethod(tmp, method_name(), mtable);
  2740.     slot_nowriteback(mtable);
  2741.  
  2742.     end_basic_block();
  2743.     set_label(35);
  2744.     start_basic_block();
  2745.     /* Push arguments */
  2746.     METHOD_PUSHARGS();
  2747.  
  2748.     /* Push dummy object */
  2749.     pusharg_ref_const(0);
  2750.  
  2751.     end_basic_block();
  2752.  
  2753.     /* Call it */
  2754.     low = method_returntype();
  2755.     call(tmp);
  2756.  
  2757.     /* Pop args */
  2758.     popargs(idx+1);
  2759.  
  2760.     start_basic_block();
  2761.     METHOD_RETURN_VALUE();
  2762. }
  2763.  
  2764. define_insn(INVOKEINTERFACE)
  2765. {
  2766.     /*
  2767.      * (*soft_lookupmethod(class->methodtable, msig))(...);
  2768.      *
  2769.      * ..., obj, ..args.., -> ...
  2770.      */
  2771.  
  2772.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2773.  
  2774.     slot_alloctmp(tmp);
  2775.     slot_alloctmp(mtable);
  2776.  
  2777.     get_method_info(constants(), idx);
  2778.     idx = (uint8)getpc(2) - 1;
  2779.  
  2780.     check_stack_ref(idx);
  2781.  
  2782.     /* Find dispatch table in object */
  2783.     if (method_dtable_offset != 0) {
  2784.         add_ref_const(mtable, stack(idx), method_dtable_offset);
  2785.         load_ref(mtable, mtable);
  2786.     }
  2787.     else {
  2788.         load_ref(mtable, stack(idx));
  2789.     }
  2790.  
  2791.     /* Find method table in dispatch table */
  2792.     if (method_mtable_offset != 0) {
  2793.         add_ref_const(mtable, mtable, method_mtable_offset);
  2794.     }
  2795.     load_ref(mtable, mtable);
  2796.  
  2797.     /* Check method table for cached entry */
  2798.     low = method_hash() % MAXMETHOD;
  2799.     add_ref_const(tmp, mtable, MTABLE_TAG + MTABLE_METHODOFFSET + low * MTABLE_METHODSIZE);
  2800.     load_ref(tmp, tmp);
  2801.     slot_nowriteback(tmp);
  2802.     end_basic_block();
  2803.     cmp_ref_const(0, tmp, method_tag());
  2804.     branch_ne(reference_label(36));
  2805.     add_ref_const(tmp, mtable, MTABLE_METHOD + MTABLE_METHODOFFSET + low * MTABLE_METHODSIZE);
  2806.     slot_nowriteback(mtable);
  2807.     load_ref(tmp, tmp);
  2808.     end_basic_block();
  2809.     branch_a(reference_label(37));
  2810.  
  2811.     set_label(36);
  2812.     start_basic_block();
  2813.     softcall_lookupmethod(tmp, method_name(), mtable);
  2814.     slot_nowriteback(mtable);
  2815.  
  2816.     end_basic_block();
  2817.     set_label(37);
  2818.     start_basic_block();
  2819.     /* Push arguments */
  2820.     METHOD_PUSHARGS();
  2821.     /* Push object */
  2822.     pusharg_ref(stack(idx));
  2823.  
  2824.     end_basic_block();
  2825.  
  2826.     /* Call it */
  2827.     low = method_returntype();
  2828.     call(tmp);
  2829.  
  2830.     /* Pop args */
  2831.     idx++;
  2832.     popargs(idx);
  2833.  
  2834.     start_basic_block();
  2835.     METHOD_RETURN_VALUE();
  2836. }
  2837.  
  2838. define_insn(NEW)
  2839. {
  2840.     /*
  2841.      * ... ->  ..., object ref
  2842.      */
  2843.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2844.  
  2845.     get_class_info(constants(), idx);
  2846.     push(1);
  2847.     softcall_new(stack(0), class_object());
  2848. }
  2849.  
  2850. define_insn(NEWARRAY)
  2851. {
  2852.     /*
  2853.      * ... size ->  ..., object ref
  2854.      */
  2855.     check_stack_int(0);
  2856.  
  2857.     low = (uint8)getpc(0);
  2858.     softcall_newarray(stack(0), stack(0), low);
  2859. }
  2860.  
  2861. define_insn(ANEWARRAY)
  2862. {
  2863.     /*
  2864.      * ... size ->  ..., object ref
  2865.      */
  2866.     check_stack_int(0);
  2867.  
  2868.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2869.  
  2870.     get_class_info(constants(), idx);
  2871.     softcall_anewarray(stack(0), stack(0), class_object());
  2872. }
  2873.  
  2874. define_insn(ARRAYLENGTH)
  2875. {
  2876.     /*
  2877.      * ..., obj -> ..., length
  2878.      */
  2879.     check_stack_array(0);
  2880.  
  2881.     if (object_array_length != 0) {
  2882.         add_ref_const(stack(0), stack(0), object_array_length);
  2883.     }
  2884.     load_int(stack(0), stack(0));
  2885. }
  2886.  
  2887. define_insn(ATHROW)
  2888. {
  2889.     /*
  2890.      * ..., obj -> undefined
  2891.      */
  2892.     check_stack_ref(0);
  2893.  
  2894.     softcall_athrow(stack(0));
  2895. }
  2896.  
  2897. define_insn(CHECKCAST)
  2898. {
  2899.     /*
  2900.      * ..., obj -> ..., obj
  2901.      */
  2902.     check_stack_ref(0);
  2903.  
  2904.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2905.  
  2906.     get_class_info(constants(), idx);
  2907.     softcall_checkcast(stack(0), class_object());
  2908. }
  2909.  
  2910. define_insn(INSTANCEOF)
  2911. {
  2912.     /*
  2913.      * ..., obj -> ..., result
  2914.      */
  2915.     check_stack_ref(0);
  2916.  
  2917.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2918.  
  2919.     get_class_info(constants(), idx);
  2920.     softcall_instanceof(stack(0), stack(0), class_object());
  2921. }
  2922.  
  2923. define_insn(MONITORENTER)
  2924. {
  2925.     /*
  2926.      * ... obj -> ...
  2927.      */
  2928.     check_stack_ref(0);
  2929.  
  2930.     softcall_monitorenter(stack(0));
  2931.     pop(1);
  2932. }
  2933.  
  2934. define_insn(MONITOREXIT)
  2935. {
  2936.     /*
  2937.      * ... obj -> ...
  2938.      */
  2939.     check_stack_ref(0);
  2940.  
  2941.     softcall_monitorexit(stack(0));
  2942.     pop(1);
  2943. }
  2944.  
  2945. define_insn(WIDE)
  2946. {
  2947.     wide = (uint16)(getpc(0) << 8);
  2948. }
  2949.  
  2950. define_insn(MULTIANEWARRAY)
  2951. {
  2952.     /*
  2953.      * ... size1, size2, ... sizen ->  ..., object ref
  2954.      */
  2955.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  2956.     low = (uint8)getpc(2);
  2957.  
  2958.     for (high = 0; high < low; high++) {
  2959.         check_stack_int(high);
  2960.     }
  2961.  
  2962.     get_class_info(constants(), idx);
  2963.     softcall_multianewarray(stack(low-1), low, stack(0), class_object());
  2964.  
  2965.     pop(low-1);
  2966. }
  2967.  
  2968. define_insn(IFNULL)
  2969. {
  2970.     check_stack_ref(0);
  2971.  
  2972.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2973.  
  2974.     end_basic_block();
  2975.  
  2976.     cmp_ref_const(0, stack(0), 0);
  2977.     branch_eq(reference_code_label(pc+idx));
  2978.  
  2979.     pop(1);
  2980. }
  2981.  
  2982. define_insn(IFNONNULL)
  2983. {
  2984.     check_stack_ref(0);
  2985.  
  2986.     idx = (int16)((getpc(0) << 8) | getpc(1));
  2987.  
  2988.     end_basic_block();
  2989.  
  2990.     cmp_ref_const(0, stack(0), 0);
  2991.     branch_ne(reference_code_label(pc+idx));
  2992.  
  2993.     pop(1);
  2994. }
  2995.  
  2996. define_insn(GOTO_W)
  2997. {
  2998.     idx = (int32)((getpc(0) << 24) | (getpc(1) << 16) |
  2999.                 (getpc(2) << 8) | getpc(3));
  3000.  
  3001.     end_basic_block();
  3002.     branch_eq(reference_code_label(pc+idx));
  3003. }
  3004.  
  3005. define_insn(JSR_W)
  3006. {
  3007.     /*
  3008.      * ... -> ..., ret-addr
  3009.      */
  3010.     idx = (int32)((getpc(0) << 24) | (getpc(1) << 16) |
  3011.                 (getpc(2) << 8) | getpc(3));
  3012.  
  3013.     push(1);
  3014.     move_label_const(stack(0), reference_code_label(npc));
  3015.     end_basic_block();
  3016.     branch_a(reference_code_label(pc+idx));
  3017. }
  3018.  
  3019. define_insn(BREAKPOINT)
  3020. {
  3021.     breakpoint();
  3022. }
  3023.  
  3024. define_insn(RET_W)
  3025. {
  3026.     idx = (uint16)((getpc(0) << 8) | getpc(1));
  3027.  
  3028.     check_local_ref(idx);
  3029.  
  3030.     end_basic_block();
  3031.     branch_indirect(stored_code_label(local(idx)));
  3032. }
  3033.