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 / jit / icode.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  34KB  |  1,853 lines
  1. /* icode.c
  2.  * Define the instructions.
  3.  *
  4.  * Copyright (c) 1996 Systems Architecture Research Centre,
  5.  *           City University, London, UK.
  6.  *
  7.  * See the file "license.terms" for information on usage and redistribution
  8.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  9.  *
  10.  * Written by Tim Wilkinson <tim@sarc.city.ac.uk>, June 1996.
  11.  */
  12.  
  13. #include <assert.h>
  14. #include "gtypes.h"
  15. #include "slots.h"
  16. #include "seq.h"
  17. #include "registers.h"
  18. #include "basecode.h"
  19. #include "labels.h"
  20. #include "icode.h"
  21. #include "codeproto.h"
  22. #include "soft.h"
  23. #include "access.h"
  24. #include "object.h"
  25. #include "constants.h"
  26. #include "classMethod.h"
  27. #include "gc.h"
  28. #include "flags.h"
  29. #include "md.h"
  30.  
  31. void startBlock(sequence*);
  32. void endBlock(sequence*);
  33.  
  34. extern uint32 pc;
  35. extern uint32 npc;
  36.  
  37. #define    MAXLABTAB    64
  38. label* labtab[MAXLABTAB];
  39.  
  40. /* ----------------------------------------------------------------------- */
  41. /* Register loads and spills.                           */
  42. /*                                       */
  43.  
  44. #if defined(HAVE_spill_int)
  45. void
  46. spill_int(slots* src)
  47. {
  48.     void HAVE_spill(sequence*);
  49.     sequence s;
  50.     seq_dst(&s) = src;
  51.     HAVE_spill_int(&s);
  52.     src->modified = 0;
  53. }
  54. #endif
  55.  
  56. #if defined(HAVE_reload_int)
  57. void
  58. reload_int(slots* dst)
  59. {
  60.     void HAVE_reload(sequence*);
  61.     sequence s;
  62.     seq_dst(&s) = dst;
  63.     HAVE_reload_int(&s);
  64. }
  65. #endif
  66.  
  67. #if defined(HAVE_spill_float)
  68. void
  69. spill_float(slots* src)
  70. {
  71.     void HAVE_spill(sequence*);
  72.     sequence s;
  73.     seq_dst(&s) = src;
  74.     HAVE_spill_float(&s);
  75.     src->modified = 0;
  76. }
  77. #endif
  78.  
  79. #if defined(HAVE_reload_float)
  80. void
  81. reload_float(slots* dst)
  82. {
  83.     void HAVE_reload(sequence*);
  84.     sequence s;
  85.     seq_dst(&s) = dst;
  86.     HAVE_reload_float(&s);
  87. }
  88. #endif
  89.  
  90. #if defined(HAVE_spill_double)
  91. void
  92. spill_double(slots* src)
  93. {
  94.     void HAVE_spill(sequence*);
  95.     sequence s;
  96.     seq_dst(&s) = src;
  97.     HAVE_spill_double(&s);
  98.     src->modified = 0;
  99. }
  100. #endif
  101.  
  102. #if defined(HAVE_reload_double)
  103. void
  104. reload_double(slots* dst)
  105. {
  106.     void HAVE_reload(sequence*);
  107.     sequence s;
  108.     seq_dst(&s) = dst;
  109.     HAVE_reload_double(&s);
  110. }
  111. #endif
  112.  
  113. /* ----------------------------------------------------------------------- */
  114. /* Prologues and epilogues.                           */
  115. /*                                       */
  116.  
  117. void
  118. prologue(void)
  119. {
  120.     /* Emit prologue code */
  121.     slot_slot_slot(0, 0, 0, HAVE_prologue, Tnull);
  122. }
  123.  
  124. void
  125. epilogue(void)
  126. {
  127.     int i;
  128.  
  129.     slot_slot_slot(0, 0, 0, HAVE_epilogue, Tnull);
  130.  
  131.     /* Mark the return slots as used */
  132.     markReturns();
  133.  
  134.     /* All slots are now dead - detach them using overwrite */
  135.     if (flag_optimise) {
  136.         for (i = MAXSLOT - 1; i >= 0; i--) {
  137.             overwrite_optimise(slotinfo[i].insn);
  138.         }
  139.     }
  140.  
  141. }
  142.  
  143.  
  144. /* ----------------------------------------------------------------------- */
  145. /* Conditional monitor management.                       */
  146. /*                                       */
  147.  
  148. void
  149. mon_enter(methods* meth, slots* obj)
  150. {
  151.     /* Emit monitor entry if required */
  152.         if ((meth->accflags & ACC_SYNCHRONISED) != 0) {
  153.         end_basic_block();
  154.         if ((meth->accflags & ACC_STATIC) != 0) {
  155.             pusharg_ref_const((uintp)meth->class);
  156.         }
  157.         else {
  158.             pusharg_ref(obj);
  159.         }
  160.         call_ref((uintp)soft_monitorenter);
  161.         popargs(1);
  162.         start_basic_block();
  163.     }
  164. }
  165.  
  166. void
  167. mon_exit(methods* meth, slots* obj)
  168. {
  169.     /* Emit monitor exit if required */
  170.         if ((meth->accflags & ACC_SYNCHRONISED) != 0) {
  171.         end_basic_block();
  172.         if ((meth->accflags & ACC_STATIC) != 0) {
  173.             pusharg_ref_const((uintp)meth->class);
  174.         }
  175.         else {
  176.             pusharg_ref(obj);
  177.         }
  178.         call_ref((uintp)soft_monitorexit);
  179.         popargs(1);
  180.         start_basic_block();
  181.     }
  182. }
  183.  
  184. /* ----------------------------------------------------------------------- */
  185. /* Basic block and instruction management.                   */
  186. /*                                       */
  187.  
  188. void
  189. _start_basic_block(uintp pc, uintp stk)
  190. {
  191.     int i;
  192.  
  193.     /* Detach all slots from their creating instructions to
  194.      * avoid optimising back across the boundary.
  195.      */
  196.     if (flag_optimise) {
  197.         for (i = MAXSLOT - 1; i >= 0; i--) {
  198.             slotinfo[i].insn = 0;
  199.         }
  200.     }
  201.  
  202.     _slot_const_const(0, stk, pc, startBlock, Tnull);
  203. }
  204.  
  205. void
  206. _end_basic_block(uintp stk, uintp temp)
  207. {
  208.     _slot_const_const(0, stk, temp, endBlock, Tnull);
  209. }
  210.  
  211. void
  212. _start_instruction(uintp pc)
  213. {
  214.     void startInsn(sequence*);
  215.  
  216.     _slot_const_const(0, 0, pc, startInsn, Tnull);
  217. }
  218.  
  219. void
  220. _start_exception_block(uintp stk)
  221. {
  222.     /* Exception blocks act like function returns - the return
  223.      * value is the exception object.
  224.      */
  225.     return_ref(&stackinfo[stk]);
  226. }
  227.  
  228.  
  229. /* ----------------------------------------------------------------------- */
  230. /* Moves.                                   */
  231. /*                                       */
  232.  
  233. #if defined(HAVE_move_int_const)
  234. void
  235. move_int_const(slots* dst, jint val)
  236. {
  237.     slot_slot_const(dst, 0, val, HAVE_move_int_const, Tconst);
  238.     dst->v.tint = val;
  239. }
  240. #endif
  241.  
  242. void
  243. move_long_const(slots* dst, jlong val)
  244. {
  245. #if defined(HAVE_move_long_const)
  246.     lslot_slot_lconst(dst, 0, val, HAVE_move_long_const, Tconst);
  247.     dst->v.tint = val;
  248. #else
  249.     move_int_const(dst, (jint)(val & 0xFFFFFFFF));
  250.     move_int_const(dst+1, (jint)((val >> 32) & 0xFFFFFFFF));
  251. #endif
  252. }
  253.  
  254. #if defined(HAVE_move_float_const)
  255. void
  256. move_float_const(slots* dst, float val)
  257. {
  258.     slot_slot_fconst(dst, 0, val, HAVE_move_float_const, Tconst);
  259.     dst->v.tdouble = val;
  260. }
  261. #endif
  262.  
  263. #if defined(HAVE_move_double_const)
  264. void
  265. move_double_const(slots* dst, jdouble val)
  266. {
  267.     lslot_slot_fconst(dst, 0, val, HAVE_move_double_const, Tconst);
  268.     dst->v.tdouble = val;
  269. }
  270. #endif
  271.  
  272. #if defined(HAVE_move_int)
  273. void
  274. move_int(slots* dst, slots* src)
  275. {
  276.     slot_slot_slot(dst, 0, src, HAVE_move_int, Tcopy);
  277. }
  278. #endif
  279.  
  280. void
  281. move_long(slots* dst, slots* src)
  282. {
  283. #if defined(HAVE_move_long)
  284.     lslot_lslot_lslot(dst, 0, src, HAVE_move_long, Tcopy);
  285. #else
  286.     assert(dst != src+1);
  287.     move_int(dst, src);
  288.     move_int(dst+1, src+1);
  289. #endif
  290. }
  291.  
  292. #if defined(HAVE_move_float)
  293. void
  294. move_float(slots* dst, slots* src)
  295. {
  296.     slot_slot_slot(dst, 0, src, HAVE_move_float, Tcopy);
  297. }
  298. #endif
  299.  
  300. #if defined(HAVE_move_double)
  301. void
  302. move_double(slots* dst, slots* src)
  303. {
  304.     lslot_lslot_lslot(dst, 0, src, HAVE_move_double, Tcopy);
  305. }
  306. #endif
  307.  
  308. #if defined(HAVE_move_label_const)
  309. void
  310. move_label_const(slots* dst, label* lab)
  311. {
  312.     slot_slot_const(dst, 0, (int)lab, HAVE_move_label_const, Tnull);
  313. }
  314. #endif
  315.  
  316. void
  317. swap_int(slots* src, slots* src2)
  318. {
  319. #if defined(HAVE_swap_int)
  320.     slot_slot_slot(src, 0, src2, HAVE_swap_int, Tcomplex);
  321. #else
  322.     slots* tmp;
  323.     slot_alloctmp(tmp);
  324.     move_int(tmp, src);
  325.     move_int(src, src2);
  326.     move_int(src2, tmp);
  327. #endif
  328. }
  329.  
  330. void
  331. swap_long(slots* src, slots* src2)
  332. {
  333. #if defined(HAVE_swap_long)
  334.     lslot_lslot_lslot(src, 0, src2, HAVE_swap_long, Tcomplex);
  335. #else
  336.     swap_int(src, src2);
  337.     swap_int(src+1, src2+1);
  338. #endif
  339. }
  340.  
  341.  
  342.  
  343. /* ----------------------------------------------------------------------- */
  344. /* Arithmetic operators - add, sub, etc.                   */
  345. /*                                       */
  346.  
  347.  
  348. #if defined(HAVE_adc_int)
  349. void
  350. adc_int(slots* dst, slots* src, slots* src2)
  351. {
  352.     slot_slot_slot(dst, src, src2, HAVE_adc_int, Tcomplex);
  353. }
  354. #endif
  355.  
  356. void
  357. add_int_const(slots* dst, slots* src, jint val)
  358. {
  359. #if defined(HAVE_add_int_const)
  360.     slot_slot_const(dst, src, val, HAVE_add_int_const, Taddregconst);
  361. #else
  362.     slots* tmp;
  363.     slot_alloctmp(tmp);
  364.     move_int_const(tmp, val);
  365.     add_int(dst, src, tmp);
  366. #endif
  367. }
  368.  
  369. #if defined(HAVE_add_int)
  370. void
  371. add_int(slots* dst, slots* src, slots* src2)
  372. {
  373. #if defined(HAVE_add_int_const)
  374.     if (slot_type(src2) == Tconst) {
  375.         int ival = slot_value(src2);
  376.         add_int_const(dst, src, ival);
  377.     }
  378.     else if (slot_type(src) == Tconst) {
  379.         int ival = slot_value(src);
  380.         add_int_const(dst, src2, ival);
  381.     }
  382.     else
  383. #endif
  384.     {
  385.         slot_slot_slot(dst, src, src2, HAVE_add_int, Tcomplex);
  386.     }
  387. }
  388. #endif
  389.  
  390. void
  391. add_long(slots* dst, slots* src, slots* src2)
  392. {
  393. #if defined(HAVE_add_long)
  394. #if defined(HAVE_add_long_const)
  395.     if (slot_type(src2) == Tconst) {
  396.         add_long_const(dst, src, slot_value(src2));
  397.     }
  398.     else if (slot_type(src) == Tconst) {
  399.         add_long_const(dst, src2, slot_value(src));
  400.     }
  401.     else
  402. #endif
  403.     {
  404.         lslot_lslot_lslot(dst, src, src2, HAVE_add_long, Tcomplex);
  405.     }
  406. #else
  407.     add_int(dst, src, src2);
  408.     adc_int(dst+1, src+1, src2+1);
  409. #endif
  410. }
  411.  
  412. #if defined(HAVE_add_float)
  413. void
  414. add_float(slots* dst, slots* src, slots* src2)
  415. {
  416. #if defined(HAVE_add_float_const)
  417.     if (slot_type(src2) == Tconst) {
  418.         add_float_const(dst, src, slot_value(src2));
  419.     }
  420.     else if (slot_type(src) == Tconst) {
  421.         add_float_const(dst, src2, slot_value(src));
  422.     }
  423.     else
  424. #endif
  425.     {
  426.         slot_slot_slot(dst, src, src2, HAVE_add_float, Tcomplex);
  427.     }
  428. }
  429. #endif
  430.  
  431. #if defined(HAVE_add_double)
  432. void
  433. add_double(slots* dst, slots* src, slots* src2)
  434. {
  435. #if defined(HAVE_add_double_const)
  436.     if (slot_type(src2) == Tconst) {
  437.         add_double_const(dst, src, slot_value(src2));
  438.     }
  439.     else if (slot_type(src) == Tconst) {
  440.         add_double_const(dst, src2, slot_value(src));
  441.     }
  442.     else
  443. #endif
  444.     {
  445.         lslot_lslot_lslot(dst, src, src2, HAVE_add_double, Tcomplex);
  446.     }
  447. }
  448. #endif
  449.  
  450. #if defined(HAVE_sbc_int)
  451. void
  452. sbc_int(slots* dst, slots* src, slots* src2)
  453. {
  454.     slot_slot_slot(dst, src, src2, HAVE_sbc_int, Tcomplex);
  455. }
  456. #endif
  457.  
  458. void
  459. sub_int_const(slots* dst, slots* src, jint val)
  460. {
  461. #if defined(HAVE_sub_int_const)
  462.     slot_slot_const(dst, src, val, HAVE_sub_int_const, Tcomplex);
  463. #else
  464.     slots* tmp;
  465.     slot_alloctmp(tmp);
  466.     move_int_const(tmp, val);
  467.     sub_int(dst, src, tmp);
  468. #endif
  469. }
  470.  
  471. #if defined(HAVE_sub_int)
  472. void
  473. sub_int(slots* dst, slots* src, slots* src2)
  474. {
  475. #if defined(HAVE_sub_int_const)
  476.     if (slot_type(src2) == Tconst) {
  477.         int ival = slot_value(src2);
  478.         sub_int_const(dst, src, ival);
  479.     }
  480.     else
  481. #endif
  482.     {
  483.         slot_slot_slot(dst, src, src2, HAVE_sub_int, Tcomplex);
  484.     }
  485. }
  486. #endif
  487.  
  488. void
  489. sub_long(slots* dst, slots* src, slots* src2)
  490. {
  491. #if defined(HAVE_sub_long)
  492. #if defined(HAVE_sub_long_const)
  493.     if (slot_type(src2) == Tconst) {
  494.         sub_long_const(dst, src, slot_value(src2));
  495.     }
  496.     else
  497. #endif
  498.     {
  499.         lslot_lslot_lslot(dst, src, src2, HAVE_sub_long, Tcomplex);
  500.     }
  501. #else
  502.     sub_int(dst, src, src2);
  503.     sbc_int(dst+1, src+1, src2+1);
  504. #endif
  505. }
  506.  
  507. #if defined(HAVE_sub_float)
  508. void
  509. sub_float(slots* dst, slots* src, slots* src2)
  510. {
  511. #if defined(HAVE_sub_float_const)
  512.     if (slot_type(src2) == Tconst) {
  513.         sub_float_const(dst, src, slot_value(src2));
  514.     }
  515.     else
  516. #endif
  517.     {
  518.         slot_slot_slot(dst, src, src2, HAVE_sub_float, Tcomplex);
  519.     }
  520. }
  521. #endif
  522.  
  523. #if defined(HAVE_sub_double)
  524. void
  525. sub_double(slots* dst, slots* src, slots* src2)
  526. {
  527. #if defined(HAVE_sub_double_const)
  528.     if (slot_type(src2) == Tconst) {
  529.         sub_double_const(dst, src, slot_value(src2));
  530.     }
  531.     else
  532. #endif
  533.     {
  534.         lslot_lslot_lslot(dst, src, src2, HAVE_sub_double, Tcomplex);
  535.     }
  536. }
  537. #endif
  538.  
  539. void
  540. mul_int_const(slots* dst, slots* src, jint val)
  541. {
  542. #if defined(HAVE_mul_int_const)
  543.     slot_slot_const(dst, src, val, HAVE_mul_int_const, Tcomplex);
  544. #else
  545.     slots* tmp;
  546.     slot_alloctmp(tmp);
  547.     move_int_const(tmp, val);
  548.     mul_int(dst, src, tmp);
  549. #endif
  550. }
  551.  
  552. #if defined(HAVE_mul_int)
  553. void
  554. mul_int(slots* dst, slots* src, slots* src2)
  555. {
  556. #if defined(HAVE_mul_int_const)
  557.     if (slot_type(src2) == Tconst) {
  558.         mul_int_const(dst, src, slot_value(src2));
  559.     }
  560.     else if (slot_type(src) == Tconst) {
  561.         mul_int_const(dst, src2, slot_value(src));
  562.     }
  563.     else
  564. #endif
  565.     {
  566.         slot_slot_slot(dst, src, src2, HAVE_mul_int, Tcomplex);
  567.     }
  568. }
  569. #endif
  570.  
  571. void
  572. mul_long(slots* dst, slots* src, slots* src2)
  573. {
  574. #if defined(HAVE_mul_long)
  575.     lslot_lslot_lslot(dst, src, src2, HAVE_mul_long, Tcomplex);
  576. #else
  577.     end_basic_block();
  578.     pusharg_long(src2);
  579.     pusharg_long(src);
  580.     call_ref((uintp)soft_lmul);
  581.     popargs(4);
  582.     start_basic_block();
  583.     return_long(dst);
  584. #endif
  585. }
  586.  
  587. #if defined(HAVE_mul_float)
  588. void
  589. mul_float(slots* dst, slots* src, slots* src2)
  590. {
  591.     slot_slot_slot(dst, src, src2, HAVE_mul_float, Tcomplex);
  592. }
  593. #endif
  594.  
  595. #if defined(HAVE_mul_double)
  596. void
  597. mul_double(slots* dst, slots* src, slots* src2)
  598. {
  599.     lslot_lslot_lslot(dst, src, src2, HAVE_mul_double, Tcomplex);
  600. }
  601. #endif
  602.  
  603. #if defined(HAVE_div_int)
  604. void
  605. div_int(slots* dst, slots* src, slots* src2)
  606. {
  607.     slot_slot_slot(dst, src, src2, HAVE_div_int, Tcomplex);
  608. }
  609. #endif
  610.  
  611. void
  612. div_long(slots* dst, slots* src, slots* src2)
  613. {
  614. #if defined(HAVE_div_long)
  615.     lslot_lslot_lslot(dst, src, src2, HAVE_div_long, Tcomplex);
  616. #else
  617.     end_basic_block();
  618.     pusharg_long(src2);
  619.     pusharg_long(src);
  620.     call_ref((uintp)soft_ldiv);
  621.     popargs(4);
  622.     start_basic_block();
  623.     return_long(dst);
  624. #endif
  625. }
  626.  
  627. #if defined(HAVE_div_float)
  628. void
  629. div_float(slots* dst, slots* src, slots* src2)
  630. {
  631.     slot_slot_slot(dst, src, src2, HAVE_div_float, Tcomplex);
  632. }
  633. #endif
  634.  
  635. #if defined(HAVE_div_double)
  636. void
  637. div_double(slots* dst, slots* src, slots* src2)
  638. {
  639.     lslot_lslot_lslot(dst, src, src2, HAVE_div_double, Tcomplex);
  640. }
  641. #endif
  642.  
  643. #if defined(HAVE_rem_int)
  644. void
  645. rem_int(slots* dst, slots* src, slots* src2)
  646. {
  647.     slot_slot_slot(dst, src, src2, HAVE_rem_int, Tcomplex);
  648. }
  649. #endif
  650.  
  651. void
  652. rem_long(slots* dst, slots* src, slots* src2)
  653. {
  654. #if defined(HAVE_rem_long)
  655.     lslot_lslot_lslot(dst, src, src2, HAVE_rem_long, Tcomplex);
  656. #else
  657.     end_basic_block();
  658.     pusharg_long(src2);
  659.     pusharg_long(src);
  660.     call_ref((uintp)soft_lrem);
  661.     popargs(4);
  662.     start_basic_block();
  663.     return_long(dst);
  664. #endif
  665. }
  666.  
  667. void
  668. rem_float(slots* dst, slots* src, slots* src2)
  669. {
  670. #if defined(HAVE_rem_float)
  671.     slot_slot_slot(dst, src, src2, HAVE_rem_float, Tcomplex);
  672. #else
  673.     end_basic_block();
  674.     pusharg_float(src2);
  675.     pusharg_float(src);
  676.     call_ref((uintp)soft_frem);
  677.     popargs(2);
  678.     end_basic_block();
  679.     return_float(dst);
  680. #endif
  681. }
  682.  
  683. void
  684. rem_double(slots* dst, slots* src, slots* src2)
  685. {
  686. #if defined(HAVE_rem_double)
  687.     lslot_lslot_lslot(dst, src, src2, HAVE_rem_double, Tcomplex);
  688. #else
  689.     end_basic_block();
  690.     pusharg_double(src2);
  691.     pusharg_double(src);
  692.     call_ref((uintp)soft_freml);
  693.     popargs(4);
  694.     end_basic_block();
  695.     return_double(dst);
  696. #endif
  697. }
  698.  
  699. void
  700. neg_int(slots* dst, slots* src)
  701. {
  702. #if defined(HAVE_neg_int)
  703.     slot_slot_slot(dst, 0, src, HAVE_neg_int);
  704. #else
  705.     slots* tmp;
  706.     slot_alloctmp(tmp);
  707.     move_int_const(tmp, 0);
  708.     sub_int(dst, tmp, src);
  709. #endif
  710. }
  711.  
  712. void
  713. neg_long(slots* dst, slots* src)
  714. {
  715. #if defined(HAVE_neg_long)
  716.     lslot_lslot_lslot(dst, 0, src, HAVE_neg_long);
  717. #elif defined(HAVE_sbc_int)
  718.     slots* zero;
  719.     slot_alloctmp(zero);
  720.     move_int_const(zero, 0);
  721.     sub_int(dst, zero, src);
  722.     sbc_int(dst+1, zero, src+1);
  723. #elif defined(HAVE_adc_int_const)
  724.     neg_int(dst, src);
  725.     adc_int_const(dst+1, src+1, 0);
  726.     neg_int(dst+1, dst+1);
  727. #else
  728.     abort();
  729. #endif
  730. }
  731.  
  732. void
  733. neg_float(slots* dst, slots* src)
  734. {
  735. #if defined(HAVE_neg_float)
  736.     lslot_lslot_lslot(dst, 0, src, HAVE_neg_float);
  737. #else
  738.     slots* tmp;
  739.     slot_alloctmp(tmp);
  740.     move_float_const(tmp, 0);
  741.     sub_float(dst, tmp, src);
  742. #endif
  743. }
  744.  
  745. void
  746. neg_double(slots* dst, slots* src)
  747. {
  748. #if defined(HAVE_neg_double)
  749.     lslot_lslot_lslot(dst, 0, src, HAVE_neg_double);
  750. #else
  751.     slots* tmp;
  752.     slot_alloc2tmp(tmp);
  753.     move_double_const(tmp, 0);
  754.     sub_double(dst, tmp, src);
  755. #endif
  756. }
  757.  
  758.  
  759. /* ----------------------------------------------------------------------- */
  760. /* Logical operators - and, or, etc.                       */
  761. /*                                       */
  762.  
  763. void
  764. and_int_const(slots* dst, slots* src, jint val)
  765. {
  766. #if defined(HAVE_and_int_const)
  767.     slot_slot_slot(dst, src, src2, HAVE_and_int_val, Tcomplex);
  768. #else
  769.     slots* tmp;
  770.     slot_alloctmp(tmp);
  771.     move_int_const(tmp, val);
  772.     and_int(dst, src, tmp);
  773. #endif
  774. }
  775.  
  776. #if defined(HAVE_and_int)
  777. void
  778. and_int(slots* dst, slots* src, slots* src2)
  779. {
  780.     slot_slot_slot(dst, src, src2, HAVE_and_int, Tcomplex);
  781. }
  782. #endif
  783.  
  784. void
  785. and_long(slots* dst, slots* src, slots* src2)
  786. {
  787. #if defined(HAVE_and_long)
  788.     lslot_lslot_lslot(dst, src, src2, HAVE_and_long, Tcomplex);
  789. #else
  790.     and_int(dst, src, src2);
  791.     and_int(dst+1, src+1, src2+1);
  792. #endif
  793. }
  794.  
  795. #if defined(HAVE_or_int)
  796. void
  797. or_int(slots* dst, slots* src, slots* src2)
  798. {
  799.     slot_slot_slot(dst, src, src2, HAVE_or_int, Tcomplex);
  800. }
  801. #endif
  802.  
  803. void
  804. or_long(slots* dst, slots* src, slots* src2)
  805. {
  806. #if defined(HAVE_or_long)
  807.     lslot_lslot_lslot(dst, src, src2, HAVE_or_long, Tcomplex);
  808. #else
  809.     or_int(dst, src, src2);
  810.     or_int(dst+1, src+1, src2+1);
  811. #endif
  812. }
  813.  
  814. #if defined(HAVE_xor_int)
  815. void
  816. xor_int(slots* dst, slots* src, slots* src2)
  817. {
  818.     slot_slot_slot(dst, src, src2, HAVE_xor_int, Tcomplex);
  819. }
  820. #endif
  821.  
  822. void
  823. xor_long(slots* dst, slots* src, slots* src2)
  824. {
  825. #if defined(HAVE_xor_long)
  826.     lslot_lslot_lslot(dst, src, src2, HAVE_xor_long, Tcomplex);
  827. #else
  828.     xor_int(dst, src, src2);
  829.     xor_int(dst+1, src+1, src2+1);
  830. #endif
  831. }
  832.  
  833. void
  834. lshl_int_const(slots* dst, slots* src, jint val)
  835. {
  836. #if defined(HAVE_lshl_int_const)
  837.     slot_slot_const(dst, src, val, HAVE_lshl_int_const, Tcomplex);
  838. #else
  839.     slots* tmp;
  840.     slot_alloctmp(tmp);
  841.     move_int_const(tmp, val);
  842.     lshl_int(dst, src, tmp);
  843. #endif
  844. }
  845.  
  846. #if defined(HAVE_lshl_int)
  847. void
  848. lshl_int(slots* dst, slots* src, slots* src2)
  849. {
  850.     slot_slot_slot(dst, src, src2, HAVE_lshl_int, Tcomplex);
  851. }
  852. #endif
  853.  
  854. void
  855. lshl_long(slots* dst, slots* src, slots* src2)
  856. {
  857. #if defined(HAVE_lshl_long)
  858.     lslot_lslot_slot(dst, src, src2, HAVE_lshl_long, Tcomplex);
  859. #else
  860.     end_basic_block();
  861.     pusharg_int(src2);
  862.     pusharg_long(src);
  863.     call_ref((uintp)soft_lshll);
  864.     popargs(3);
  865.     start_basic_block();
  866.     return_long(dst);
  867. #endif
  868. }
  869.  
  870. void
  871. ashr_int_const(slots* dst, slots* src, jint val)
  872. {
  873. #if defined(HAVE_ashr_int_const)
  874.     slot_slot_slot(dst, src, src2, HAVE_ashr_int_val, Tcomplex);
  875. #else
  876.     slots* tmp;
  877.     slot_alloctmp(tmp);
  878.     move_int_const(tmp, val);
  879.     ashr_int(dst, src, tmp);
  880. #endif
  881. }
  882.  
  883. #if defined(HAVE_ashr_int)
  884. void
  885. ashr_int(slots* dst, slots* src, slots* src2)
  886. {
  887.     slot_slot_slot(dst, src, src2, HAVE_ashr_int, Tcomplex);
  888. }
  889. #endif
  890.  
  891. void
  892. ashr_long(slots* dst, slots* src, slots* src2)
  893. {
  894. #if defined(HAVE_ashr_long)
  895.     lslot_lslot_slot(dst, src, src2, HAVE_ashr_long, Tcomplex);
  896. #else
  897.     end_basic_block();
  898.     pusharg_int(src2);
  899.     pusharg_long(src);
  900.     call_ref((uintp)soft_ashrl);
  901.     popargs(3);
  902.     start_basic_block();
  903.     return_long(dst);
  904. #endif
  905. }
  906.  
  907. void
  908. lshr_int_const(slots* dst, slots* src, jint val)
  909. {
  910. #if defined(HAVE_lshr_int_const)
  911.     slot_slot_slot(dst, src, src2, HAVE_lshr_int_val, Tcomplex);
  912. #else
  913.     slots* tmp;
  914.     slot_alloctmp(tmp);
  915.     move_int_const(tmp, val);
  916.     lshr_int(dst, src, tmp);
  917. #endif
  918. }
  919.  
  920. #if defined(HAVE_lshr_int)
  921. void
  922. lshr_int(slots* dst, slots* src, slots* src2)
  923. {
  924.     slot_slot_slot(dst, src, src2, HAVE_lshr_int, Tcomplex);
  925. }
  926. #endif
  927.  
  928. void
  929. lshr_long(slots* dst, slots* src, slots* src2)
  930. {
  931. #if defined(HAVE_lshr_long)
  932.     lslot_lslot_slot(dst, src, src2, HAVE_lshr_long, Tcomplex);
  933. #else
  934.     end_basic_block();
  935.     pusharg_int(src2);
  936.     pusharg_long(src);
  937.     call_ref((uintp)soft_lshrl);
  938.     popargs(3);
  939.     start_basic_block();
  940.     return_long(dst);
  941. #endif
  942. }
  943.  
  944.  
  945.  
  946.  
  947. /* ----------------------------------------------------------------------- */
  948. /* Load and store.                               */
  949. /*                                       */
  950.  
  951. #if defined(HAVE_load_int)
  952. void
  953. load_int(slots* dst, slots* src)
  954. {
  955. #if defined(HAVE_load_int_addregconst)
  956.     if (src == dst && slot_type(src) == Taddregconst) {
  957.         slots* isrc = seq_slot(slot_insn(src), 1);
  958.         int ival = seq_value(slot_insn(src), 2);
  959.         slot_pop(src);
  960.         slot_slot_const(dst, isrc, ival, HAVE_load_int_addregconst, Tload);
  961.     }
  962.     else
  963. #endif
  964.     {
  965.         slot_slot_slot(dst, 0, src, HAVE_load_int, Tload);
  966.     }
  967. }
  968. #endif
  969.  
  970. void
  971. load_long(slots* dst, slots* src)
  972. {
  973. #if defined(HAVE_load_long)
  974.     lslot_lslot_lslot(dst, 0, src, HAVE_load_long, Tload);
  975. #else
  976.     slots* tmp;
  977.  
  978.     slot_alloctmp(tmp);
  979.     add_int_const(tmp, src, 4);
  980.     load_int(dst, src);
  981.     load_int(dst+1, tmp);
  982. #endif
  983. }
  984.  
  985. #if defined(HAVE_load_float)
  986. void
  987. load_float(slots* dst, slots* src)
  988. {
  989.     slot_slot_slot(dst, 0, src, HAVE_load_float, Tload);
  990. }
  991. #endif
  992.  
  993. #if defined(HAVE_load_double)
  994. void
  995. load_double(slots* dst, slots* src)
  996. {
  997.     lslot_lslot_slot(dst, 0, src, HAVE_load_double, Tload);
  998. }
  999. #endif
  1000.  
  1001. void
  1002. load_byte(slots* dst, slots* src)
  1003. {
  1004. #if defined(HAVE_load_byte)
  1005.     slot_slot_slot(dst, 0, src, HAVE_load_byte, Tload);
  1006. #else
  1007.     load_int(dst, src);
  1008.     lshl_int_const(dst, dst, 8 * (sizeof(jint) - sizeof(jbyte)));
  1009.     ashr_int_const(dst, dst, 8 * (sizeof(jint) - sizeof(jbyte)));
  1010. #endif
  1011. }
  1012.  
  1013. void
  1014. load_char(slots* dst, slots* src)
  1015. {
  1016. #if defined(HAVE_load_char)
  1017.     slot_slot_slot(dst, 0, src, HAVE_load_char, Tload);
  1018. #else
  1019.     load_int(dst, src);
  1020.     and_int_const(dst, dst, (1 << (8 * sizeof(jchar))) - 1);
  1021. #endif
  1022. }
  1023.  
  1024. void
  1025. load_short(slots* dst, slots* src)
  1026. {
  1027. #if defined(HAVE_load_short)
  1028.     slot_slot_slot(dst, 0, src, HAVE_load_short, Tload);
  1029. #else
  1030.     load_int(dst, src);
  1031.     lshl_int_const(dst, dst, 8 * (sizeof(jint) - sizeof(jshort)));
  1032.     ashr_int_const(dst, dst, 8 * (sizeof(jint) - sizeof(jshort)));
  1033. #endif
  1034. }
  1035.  
  1036. void
  1037. load_code_ref(slots* dst, slots* src)
  1038. {
  1039.     load_ref(dst, src);
  1040. }
  1041.  
  1042. void
  1043. load_key(slots* dst, slots* src)
  1044. {
  1045.     load_int(dst, src);
  1046. }
  1047.  
  1048. #if defined(HAVE_store_int)
  1049. void
  1050. store_int(slots* dst, slots* src)
  1051. {
  1052. #if defined(HAVE_store_int_addregconst)
  1053.     if (src == dst && slot_type(dst) == Taddregconst) {
  1054.         assert(slot_ref(dst) == 1);
  1055.         slot_slot_const(0, dst, src, HAVE_store_int_addregconst, Tstore);
  1056.         slot_ref(dst) = 0;
  1057.         slot_insn(dst) = 0;
  1058.     }
  1059.     else
  1060. #endif
  1061.     {
  1062.         slot_slot_slot(0, dst, src, HAVE_store_int, Tstore);
  1063.     }
  1064. }
  1065. #endif
  1066.  
  1067. void
  1068. store_long(slots* dst, slots* src)
  1069. {
  1070. #if defined(HAVE_store_long)
  1071.     lslot_lslot_lslot(0, dst, src, HAVE_store_long, Tstore);
  1072. #else
  1073.     slots* tmp;
  1074.  
  1075.     slot_alloctmp(tmp);
  1076.     add_int_const(tmp, dst, 4);
  1077.     store_int(dst, src);
  1078.     store_int(tmp, src+1);
  1079. #endif
  1080. }
  1081.  
  1082. #if defined(HAVE_store_float)
  1083. void
  1084. store_float(slots* dst, slots* src)
  1085. {
  1086.     slot_slot_slot(0, dst, src, HAVE_store_float, Tstore);
  1087. }
  1088. #endif
  1089.  
  1090. #if defined(HAVE_store_double)
  1091. void
  1092. store_double(slots* dst, slots* src)
  1093. {
  1094.     slot_slot_lslot(0, dst, src, HAVE_store_double, Tstore);
  1095. }
  1096. #endif
  1097.  
  1098. void
  1099. store_byte(slots* dst, slots* src)
  1100. {
  1101. #if defined(HAVE_store_byte)
  1102.     slot_slot_slot(0, dst, src, HAVE_store_byte, Tstore);
  1103. #else
  1104.     slots* tmp;
  1105.     slots* tmp2;
  1106.     slot_alloctmp(tmp);
  1107.     slot_alloctmp(tmp2);
  1108.     and_int_const(tmp, src, (1 << (8 * sizeof(jbyte))) - 1);
  1109.     load_int(tmp2, dst);
  1110.     and_int_const(tmp2, tmp2, -(1 << (8 * sizeof(jbyte))));
  1111.     or_int(tmp2, tmp2, tmp);
  1112.     store_int(dst, tmp2);
  1113. #endif
  1114. }
  1115.  
  1116. void
  1117. store_char(slots* dst, slots* src)
  1118. {
  1119. #if defined(HAVE_store_char)
  1120.     slot_slot_slot(0, dst, src, HAVE_store_char, Tstore);
  1121. #else
  1122.     slots* tmp;
  1123.     slots* tmp2;
  1124.     slot_alloctmp(tmp);
  1125.     slot_alloctmp(tmp2);
  1126.     and_int_const(tmp, src, (1 << (8 * sizeof(jchar))) - 1);
  1127.     load_int(tmp2, dst);
  1128.     and_int_const(tmp2, tmp2, -(1 << (8 * sizeof(jchar))));
  1129.     or_int(tmp2, tmp2, tmp);
  1130.     store_int(dst, tmp2);
  1131. #endif
  1132. }
  1133.  
  1134. void
  1135. store_short(slots* dst, slots* src)
  1136. {
  1137. #if defined(HAVE_store_short)
  1138.     slot_slot_slot(0, dst, src, HAVE_store_short, Tstore);
  1139. #else
  1140.     slots* tmp;
  1141.     slots* tmp2;
  1142.     slot_alloctmp(tmp);
  1143.     slot_alloctmp(tmp2);
  1144.     and_int_const(tmp, src, (1 << (8 * sizeof(jshort))) - 1);
  1145.     load_int(tmp2, dst);
  1146.     and_int_const(tmp2, tmp2, -(1 << (8 * sizeof(jshort))));
  1147.     or_int(tmp2, tmp2, tmp);
  1148.     store_int(dst, tmp2);
  1149. #endif
  1150. }
  1151.  
  1152.  
  1153.  
  1154.  
  1155. /* ----------------------------------------------------------------------- */
  1156. /* Function argument management.                       */
  1157. /*                                       */
  1158.  
  1159. void
  1160. pusharg_int_const(int val)
  1161. {
  1162. #if defined(HAVE_pusharg_int_const)
  1163.     slot_slot_const(0, 0, val, HAVE_pusharg_int_const, Tnull);
  1164.     argcount++;
  1165. #else
  1166.     slots* tmp;
  1167.     slot_alloctmp(tmp);
  1168.     move_int_const(tmp, val);
  1169.     pusharg_int(tmp);
  1170. #endif
  1171. }
  1172.  
  1173. #if defined(HAVE_pusharg_int)
  1174. void
  1175. pusharg_int(slots* src)
  1176. {
  1177. #if defined(HAVE_pusharg_int_const)
  1178.     if (slot_type(src) == Tconst) {
  1179.         int ival = slot_value(src);
  1180.         /* This shouldn't be necessary - but it is for now */
  1181.         slot_pop(src);
  1182.         pusharg_int_const(ival);
  1183.     }
  1184.     else
  1185. #endif
  1186.     {
  1187.         slot_slot_slot(0, 0, src, HAVE_pusharg_int, Tnull);
  1188.         argcount += 1;
  1189.     }
  1190. }
  1191. #endif
  1192.  
  1193. #if defined(HAVE_pusharg_float)
  1194. void
  1195. pusharg_float(slots* src)
  1196. {
  1197.     slot_slot_slot(0, 0, src, HAVE_pusharg_float, Tnull);
  1198.     argcount += 1;
  1199. }
  1200. #endif
  1201.  
  1202. #if defined(HAVE_pusharg_double)
  1203. void
  1204. pusharg_double(slots* src)
  1205. {
  1206.     lslot_lslot_lslot(0, 0, src, HAVE_pusharg_double, Tnull);
  1207.     argcount += 2;
  1208. }
  1209. #endif
  1210.  
  1211. void
  1212. pusharg_long(slots* src)
  1213. {
  1214. #if defined(HAVE_pusharg_long)
  1215.     lslot_lslot_lslot(0, 0, src, HAVE_pusharg_long, Tnull);
  1216.     argcount += 2;
  1217. #else
  1218.     pusharg_int(src+1);
  1219.     pusharg_int(src);
  1220. #endif
  1221. }
  1222.  
  1223. #if defined(HAVE_popargs)
  1224. void
  1225. popargs(int args)
  1226. {
  1227.     slot_slot_const(0, 0, argcount, HAVE_popargs, Tnull);
  1228.     argcount = 0;
  1229. }
  1230. #endif
  1231.  
  1232.  
  1233.  
  1234. /* ----------------------------------------------------------------------- */
  1235. /* Control flow changes.                           */
  1236. /*                                       */
  1237.  
  1238. #if defined(HAVE_branch)
  1239.  
  1240. #define    branch_a(l)    branch(l, ba)
  1241. #define    branch_eq(l)    branch(l, beq)
  1242. #define    branch_ne(l)    branch(l, bne)
  1243. #define    branch_lt(l)    branch(l, blt)
  1244. #define    branch_le(l)    branch(l, ble)
  1245. #define    branch_gt(l)    branch(l, bgt)
  1246. #define    branch_ge(l)    branch(l, bge)
  1247.  
  1248. void
  1249. branch(label* dst, int type)
  1250. {
  1251.     slot_const_const(0, (int)dst, type, HAVE_branch, Tnull);
  1252. }
  1253. #endif
  1254.  
  1255. #if defined(HAVE_branch_indirect)
  1256. void
  1257. branch_indirect(slots* dst)
  1258. {
  1259.     slot_slot_const(0, dst, ba, HAVE_branch_indirect, Tnull);
  1260. }
  1261. #endif
  1262.  
  1263. #if defined(HAVE_call_ref)
  1264. void
  1265. call_ref(uintp routine)
  1266. {
  1267.     label* l = nextLabel();
  1268.     l->to = routine;    /* What place does it goto */
  1269.     l->type = Labsolute|Lexternal;
  1270.     l->at = 0;
  1271.     l->from = 0;
  1272.     slot_const_const(0, (int)l, ba, HAVE_call_ref, Tnull);
  1273. }
  1274. #endif
  1275.  
  1276. #if defined(HAVE_call)
  1277. void
  1278. call(slots* dst)
  1279. {
  1280.     slot_slot_const(0, dst, ba, HAVE_call, Tnull);
  1281. }
  1282. #endif
  1283.  
  1284. #if defined(HAVE_ret)
  1285. void
  1286. ret(void)
  1287. {
  1288.     slot_slot_slot(0, 0, 0, HAVE_ret, Tnull);
  1289. }
  1290. #endif
  1291.  
  1292. #if defined(HAVE_return_int)
  1293. void
  1294. return_int(slots* dst)
  1295. {
  1296.     slot_slot_slot(dst, 0, 0, HAVE_return_int, Tnull);
  1297. }
  1298. #endif
  1299.  
  1300. #if defined(HAVE_return_long)
  1301. void
  1302. return_long(slots* dst)
  1303. {
  1304.     lslot_lslot_lslot(dst, 0, 0, HAVE_return_long, Tnull);
  1305. }
  1306. #endif
  1307.  
  1308. #if defined(HAVE_return_float)
  1309. void
  1310. return_float(slots* dst)
  1311. {
  1312.     slot_slot_slot(dst, 0, 0, HAVE_return_float, Tnull);
  1313. }
  1314. #endif
  1315.  
  1316. #if defined(HAVE_return_double)
  1317. void
  1318. return_double(slots* dst)
  1319. {
  1320.     lslot_lslot_lslot(dst, 0, 0, HAVE_return_double, Tnull);
  1321. }
  1322. #endif
  1323.  
  1324.  
  1325.  
  1326. /* ----------------------------------------------------------------------- */
  1327. /* Labels.                                   */
  1328. /*                                       */
  1329.  
  1330. label*
  1331. reference_label(int32 n)
  1332. {
  1333.     label* l;
  1334.  
  1335.     assert(n < MAXLABTAB);
  1336.     if (labtab[n] == 0) {
  1337.         l = nextLabel();
  1338.         labtab[n] = l;
  1339.         l->type = Lnull;
  1340.         l->at = 0;
  1341.         l->from = 0;
  1342.         l->to = 0;
  1343.     }
  1344.     else {
  1345.         l = labtab[n];
  1346.         labtab[n] = 0;
  1347.     }
  1348.     return (l);
  1349. }
  1350.  
  1351. label*
  1352. reference_code_label(int32 offset)
  1353. {
  1354.     label* l = nextLabel();
  1355.     l->at = 0;        /* Where is the jump */
  1356.     l->to = offset;    /* What place does it goto */
  1357.     l->from = 0;
  1358.     l->type = Lcode|Linternal;
  1359.     return (l);
  1360. }
  1361.  
  1362. label*
  1363. reference_table_label(int32 n)
  1364. {
  1365.     label* l;
  1366.  
  1367.     assert(n < MAXLABTAB);
  1368.     if (labtab[n] == 0) {
  1369.         l = nextLabel();
  1370.         labtab[n] = l;
  1371.         l->type = Lnull;
  1372.         l->at = 0;
  1373.         l->from = 0;
  1374.         l->to = 0;
  1375.     }
  1376.     else {
  1377.         l = labtab[n];
  1378.         labtab[n] = 0;
  1379.     }
  1380.     return (l);
  1381. }
  1382.  
  1383. slots*
  1384. stored_code_label(slots* dst)
  1385. {
  1386.     return (dst);
  1387. }
  1388.  
  1389. slots*
  1390. table_code_label(slots* dst)
  1391. {
  1392.     return (dst);
  1393. }
  1394.  
  1395. #if defined(HAVE_set_label)
  1396. void
  1397. set_label(int n)
  1398. {
  1399.     assert(n < MAXLABTAB);
  1400.     if (labtab[n] == 0) {
  1401.         labtab[n] = nextLabel();
  1402.         labtab[n]->type = Lgeneral|Linternal;
  1403.         labtab[n]->at = 0;
  1404.         labtab[n]->from = 0;
  1405.         labtab[n]->to = 0;
  1406.         slot_slot_const(0, 0, (int)labtab[n], HAVE_set_label, Tnull);
  1407.     }
  1408.     else {
  1409.         assert(labtab[n]->type == Lnull);
  1410.         labtab[n]->type = Lgeneral|Linternal;
  1411.         slot_slot_const(0, 0, (int)labtab[n], HAVE_set_label, Tnull);
  1412.         labtab[n] = 0;
  1413.     }
  1414. }
  1415. #endif
  1416.  
  1417. #if defined(HAVE_build_code_ref)
  1418. label*
  1419. build_code_ref(uint8* pos, uintp pc)
  1420. {
  1421.     label* l;
  1422.     int offset;
  1423.  
  1424.     offset = (int32)(pos[0] * 0x01000000 + pos[1] * 0x00010000 +
  1425.         pos[2] * 0x00000100 + pos[3] * 0x00000001);
  1426.     l = reference_code_label(pc+offset);
  1427.  
  1428.     slot_slot_const(0, 0, (int)l, HAVE_build_code_ref, Tnull);
  1429.     return (l);
  1430. }
  1431. #endif
  1432.  
  1433. #if defined(HAVE_build_key)
  1434. void
  1435. build_key(uint8* pos)
  1436. {
  1437.     jint val = pos[0] * 0x01000000 + pos[1] * 0x00010000 +
  1438.         pos[2] * 0x00000100 + pos[3] * 0x00000001;
  1439.  
  1440.     slot_slot_const(0, 0, val, HAVE_build_key, Tnull);
  1441. }
  1442. #endif
  1443.  
  1444.  
  1445. /* ----------------------------------------------------------------------- */
  1446. /* Comparisons.                                   */
  1447. /*                                       */
  1448.  
  1449. void
  1450. cmp_int_const(slots* dst, slots* src, jint val)
  1451. {
  1452. #if defined(HAVE_cmp_int_const)
  1453.     slot_slot_const(dst, src, val, HAVE_cmp_int_const, Tcomplex);
  1454. #else
  1455.     slots* tmp;
  1456.     slot_alloctmp(tmp);
  1457.     move_int_const(tmp, val);
  1458.     cmp_int(dst, src, tmp);
  1459. #endif
  1460. }
  1461.  
  1462. #if defined(HAVE_cmp_int)
  1463. void
  1464. cmp_int(slots* dst, slots* src, slots* src2)
  1465. {
  1466. #if defined(HAVE_cmp_int_const)
  1467.     if (slot_type(src2) == Tconst) {
  1468.         int ival = slot_value(src2);
  1469.         cmp_int_const(dst, src, ival);
  1470.     }
  1471.     else
  1472. #endif
  1473.     {
  1474.         slot_slot_slot(dst, src, src2, HAVE_cmp_int, Tcomplex);
  1475.     }
  1476. }
  1477. #endif
  1478.  
  1479. void
  1480. cmp_long(slots* dst, slots* src, slots* src2)
  1481. {
  1482. #if defined(HAVE_cmp_long)
  1483.     lslot_lslot_lslot(dst, src, src2, HAVE_cmp_long, Tcomplex);
  1484. #else
  1485.     end_basic_block();
  1486.     pusharg_long(src2);
  1487.     pusharg_long(src);
  1488.     call_ref((uintp)soft_lcmp);
  1489.     popargs(2);
  1490.     start_basic_block();
  1491.     return_int(dst);
  1492. #endif
  1493. }
  1494.  
  1495. void
  1496. cmpl_float(slots* dst, slots* src, slots* src2)
  1497. {
  1498. #if defined(HAVE_cmpl_float)
  1499.     abort();
  1500. #else
  1501.     end_basic_block();
  1502.     pusharg_float(src2);
  1503.     pusharg_float(src);
  1504.     call_ref((uintp)soft_fcmpl);
  1505.     popargs(2);
  1506.     start_basic_block();
  1507.     return_int(dst);
  1508. #endif
  1509. }
  1510.  
  1511. void
  1512. cmpl_double(slots* dst, slots* src, slots* src2)
  1513. {
  1514. #if defined(HAVE_cmpl_double)
  1515.     abort();
  1516. #else
  1517.     end_basic_block();
  1518.     pusharg_double(src2);
  1519.     pusharg_double(src);
  1520.     call_ref((uintp)soft_dcmpl);
  1521.     popargs(4);
  1522.     start_basic_block();
  1523.     return_int(dst);
  1524. #endif
  1525. }
  1526.  
  1527. void
  1528. cmpg_float(slots* dst, slots* src, slots* src2)
  1529. {
  1530. #if defined(HAVE_cmpg_float)
  1531.     abort();
  1532. #else
  1533.     end_basic_block();
  1534.     pusharg_float(src2);
  1535.     pusharg_float(src);
  1536.     call_ref((uintp)soft_fcmpg);
  1537.     popargs(2);
  1538.     start_basic_block();
  1539.     return_int(dst);
  1540. #endif
  1541. }
  1542.  
  1543. void
  1544. cmpg_double(slots* dst, slots* src, slots* src2)
  1545. {
  1546. #if defined(HAVE_cmpg_double)
  1547.     abort();
  1548. #else
  1549.     end_basic_block();
  1550.     pusharg_double(src2);
  1551.     pusharg_double(src);
  1552.     call_ref((uintp)soft_dcmpg);
  1553.     popargs(4);
  1554.     start_basic_block();
  1555.     return_int(dst);
  1556. #endif
  1557. }
  1558.  
  1559. /* ----------------------------------------------------------------------- */
  1560. /* Conversions.                                   */
  1561. /*                                       */
  1562.  
  1563. void
  1564. cvt_int_long(slots* dst, slots* src)
  1565. {
  1566. #if defined(HAVE_cvt_int_long) 
  1567.     lslot_lslot_slot(dst, 0, src, HAVE_cvt_int_long, Tcomplex);
  1568. #else
  1569.     move_int(dst, src);
  1570.     ashr_int_const(dst+1, dst, (8 * sizeof(jint)) - 1);
  1571. #endif
  1572. }
  1573.  
  1574. #if defined(HAVE_cvt_int_float) 
  1575. void
  1576. cvt_int_float(slots* dst, slots* src)
  1577. {
  1578.     slot_slot_slot(dst, 0, src, HAVE_cvt_int_float, Tcomplex);
  1579. }
  1580. #endif
  1581.  
  1582. #if defined(HAVE_cvt_int_double) 
  1583. void
  1584. cvt_int_double(slots* dst, slots* src)
  1585. {
  1586.     lslot_lslot_slot(dst, 0, src, HAVE_cvt_int_double, Tcomplex);
  1587. }
  1588. #endif
  1589.  
  1590. void
  1591. cvt_long_int(slots* dst, slots* src)
  1592. {
  1593.     move_int(dst, src);
  1594. }
  1595.  
  1596. #if defined(HAVE_cvt_long_float) 
  1597. void
  1598. cvt_long_float(slots* dst, slots* src)
  1599. {
  1600.     slot_slot_lslot(dst, 0, src, HAVE_cvt_long_float, Tcomplex);
  1601. }
  1602. #endif
  1603.  
  1604. #if defined(HAVE_cvt_long_double) 
  1605. void
  1606. cvt_long_double(slots* dst, slots* src)
  1607. {
  1608.     lslot_lslot_lslot(dst, 0, src, HAVE_cvt_long_double, Tcomplex);
  1609. }
  1610. #endif
  1611.  
  1612. #if defined(HAVE_cvt_float_int) 
  1613. void
  1614. cvt_float_int(slots* dst, slots* src)
  1615. {
  1616.     slot_slot_slot(dst, 0, src, HAVE_cvt_float_int, Tcomplex);
  1617. }
  1618. #endif
  1619.  
  1620. #if defined(HAVE_cvt_float_long) 
  1621. void
  1622. cvt_float_long(slots* dst, slots* src)
  1623. {
  1624.     lslot_lslot_slot(dst, 0, src, HAVE_cvt_float_long, Tcomplex);
  1625. }
  1626. #endif
  1627.  
  1628. #if defined(HAVE_cvt_float_double) 
  1629. void
  1630. cvt_float_double(slots* dst, slots* src)
  1631. {
  1632.     lslot_lslot_slot(dst, 0, src, HAVE_cvt_float_double, Tcomplex);
  1633. }
  1634. #endif
  1635.  
  1636. #if defined(HAVE_cvt_double_int) 
  1637. void
  1638. cvt_double_int(slots* dst, slots* src)
  1639. {
  1640.     slot_slot_lslot(dst, 0, src, HAVE_cvt_double_int, Tcomplex);
  1641. }
  1642. #endif
  1643.  
  1644. #if defined(HAVE_cvt_double_long) 
  1645. void
  1646. cvt_double_long(slots* dst, slots* src)
  1647. {
  1648.     lslot_lslot_lslot(dst, 0, src, HAVE_cvt_double_long, Tcomplex);
  1649. }
  1650. #endif
  1651.  
  1652. #if defined(HAVE_cvt_double_float) 
  1653. void
  1654. cvt_double_float(slots* dst, slots* src)
  1655. {
  1656.     slot_slot_lslot(dst, 0, src, HAVE_cvt_double_float, Tcomplex);
  1657. }
  1658. #endif
  1659.  
  1660. void
  1661. cvt_int_byte(slots* dst, slots* src)
  1662. {
  1663. #if defined(HAVE_cvt_int_byte) 
  1664.     slot_slot_slot(dst, 0, src, HAVE_cvt_int_byte, Tcomplex);
  1665. #else
  1666.     lshl_int_const(dst, src, 8 * (sizeof(jint) - sizeof(jbyte)));
  1667.     ashr_int_const(dst, dst, 8 * (sizeof(jint) - sizeof(jbyte)));
  1668. #endif
  1669. }
  1670.  
  1671. void
  1672. cvt_int_char(slots* dst, slots* src)
  1673. {
  1674.     and_int_const(dst, src, (1 << (8 * sizeof(jchar))) - 1);
  1675. }
  1676.  
  1677. void
  1678. cvt_int_short(slots* dst, slots* src)
  1679. {
  1680. #if defined(HAVE_cvt_int_short) 
  1681.     slot_slot_slot(dst, 0, src, HAVE_cvt_int_short, Tcomplex);
  1682. #else
  1683.     lshl_int_const(dst, src, 8 * (sizeof(jint) - sizeof(jshort)));
  1684.     ashr_int_const(dst, dst, 8 * (sizeof(jint) - sizeof(jshort)));
  1685. #endif
  1686. }
  1687.  
  1688.  
  1689.  
  1690. /* ----------------------------------------------------------------------- */
  1691. /* Breakpoints.                                   */
  1692. /*                                       */
  1693.  
  1694. void
  1695. breakpoint()
  1696. {
  1697.     abort();
  1698. }
  1699.  
  1700.  
  1701. /* ----------------------------------------------------------------------- */
  1702. /* Soft calls.                                   */
  1703. /*                                       */
  1704.  
  1705. void
  1706. softcall_lookupmethod(slots* dst, slots* pair, slots* table)
  1707. {
  1708.     slot_nowriteback(table);
  1709.     slot_nowriteback(pair);
  1710.     end_basic_block();
  1711.     pusharg_ref(pair);
  1712.     pusharg_ref(table);
  1713.     call_ref((uintp)soft_lookupmethod);
  1714.     popargs(2);
  1715.     start_basic_block();
  1716.     return_ref(dst);
  1717. }
  1718.  
  1719. void
  1720. softcall_badarrayindex(void)
  1721. {
  1722.     call_ref((uintp)soft_badarrayindex);
  1723. }
  1724.  
  1725. void
  1726. softcall_new(slots* dst, slots* classobj)
  1727. {
  1728.     slot_nowriteback(classobj);
  1729.     end_basic_block();
  1730.     pusharg_ref(classobj);
  1731.     call_ref((uintp)soft_new);
  1732.     popargs(1);
  1733.     start_basic_block();
  1734.     return_ref(dst);
  1735. }
  1736.  
  1737. void
  1738. softcall_newarray(slots* dst, slots* size, int type)
  1739. {
  1740.     slot_nowriteback(size);
  1741.     end_basic_block();
  1742.     pusharg_int(size);
  1743.     pusharg_int_const(type);
  1744.     call_ref((uintp)soft_newarray);
  1745.     popargs(2);
  1746.     start_basic_block();
  1747.     return_ref(dst);
  1748. }
  1749.  
  1750. void
  1751. softcall_anewarray(slots* dst, slots* size, slots* type)
  1752. {
  1753.     slot_nowriteback(size);
  1754.     slot_nowriteback(type);
  1755.     end_basic_block();
  1756.     pusharg_int(size);
  1757.     pusharg_ref(type);
  1758.     call_ref((uintp)soft_anewarray);
  1759.     popargs(2);
  1760.     start_basic_block();
  1761.     return_ref(dst);
  1762. }
  1763.  
  1764. void
  1765. softcall_multianewarray(slots* dst, int size, slots* stktop, slots* classobj)
  1766. {
  1767.     int i;
  1768.  
  1769.     slot_nowriteback(classobj);
  1770.     end_basic_block();
  1771.     for (i = 0; i < size; i++) {
  1772.         pusharg_int(&stktop[i]);
  1773.     }
  1774.     pusharg_int_const(size);
  1775.     pusharg_ref(classobj);
  1776.     call_ref((uintp)soft_multianewarray);
  1777.     popargs(size+2);
  1778.     start_basic_block();
  1779.     return_ref(dst);
  1780. }
  1781.  
  1782. void
  1783. softcall_athrow(slots* obj)
  1784. {
  1785.     slot_nowriteback(obj);
  1786.     end_basic_block();
  1787.     pusharg_ref(obj);
  1788.     call_ref((uintp)soft_athrow);
  1789.     popargs(1);
  1790.     start_basic_block();
  1791. }
  1792.  
  1793. void
  1794. softcall_checkcast(slots* obj, slots* class)
  1795. {
  1796.     /* Must keep 'obj' */
  1797.     slot_nowriteback(class);
  1798.     end_basic_block();
  1799.     pusharg_ref(obj);
  1800.     pusharg_ref(class);
  1801.     call_ref((uintp)soft_checkcast);
  1802.     popargs(2);
  1803.     start_basic_block();
  1804. }
  1805.  
  1806. void
  1807. softcall_instanceof(slots* dst, slots* obj, slots* class)
  1808. {
  1809.     slot_nowriteback(obj);
  1810.     slot_nowriteback(class);
  1811.     end_basic_block();
  1812.     pusharg_ref(obj);
  1813.     pusharg_ref(class);
  1814.     call_ref((uintp)soft_instanceof);
  1815.     popargs(2);
  1816.     start_basic_block();
  1817.     return_int(dst);
  1818. }
  1819.  
  1820. void
  1821. softcall_monitorenter(slots* mon)
  1822. {
  1823.     slot_nowriteback(mon);
  1824.     end_basic_block();
  1825.     pusharg_ref(mon);
  1826.     call_ref((uintp)soft_monitorenter);
  1827.     popargs(1);
  1828.     start_basic_block();
  1829. }
  1830.  
  1831. void
  1832. softcall_monitorexit(slots* mon)
  1833. {
  1834.     slot_nowriteback(mon);
  1835.     end_basic_block();
  1836.     pusharg_ref(mon);
  1837.     call_ref((uintp)soft_monitorexit);
  1838.     popargs(1);
  1839.     start_basic_block();
  1840. }
  1841.  
  1842. #if defined(GC_INCREMENTAL)
  1843. void
  1844. softcall_addtogc(slots* obj)
  1845. {
  1846.     end_basic_block();
  1847.     pusharg_ref(obj);
  1848.     call_ref((uintp)soft_addtogc);
  1849.     popargs(1);
  1850.     start_basic_block();
  1851. }
  1852. #endif
  1853.