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 / soft.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  8KB  |  477 lines
  1. /* 
  2.  * soft.c
  3.  * Soft instruction support.
  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    MDBG(s)
  15. #define    ADBG(s)
  16. #define    CDBG(s)
  17.  
  18. #if MDBG(1) - 1 == 0 
  19. #undef CDBG
  20. #define    CDBG(s) s
  21. #endif
  22.  
  23. #include "config.h"
  24. #include <stdio.h>
  25. #include <assert.h>
  26. #include <math.h>
  27. #include <stdarg.h>
  28. #include "gtypes.h"
  29. #include "bytecode.h"
  30. #include "slots.h"
  31. #include "soft.h"
  32. #include "access.h"
  33. #include "object.h"
  34. #include "constants.h"
  35. #include "classMethod.h"
  36. #include "lookup.h"
  37. #include "errors.h"
  38. #include "exception.h"
  39. #include "locks.h"
  40.  
  41. #if defined(HAVE_REMAINDER)
  42. #elif defined(HAVE_FMOD)
  43. #define    remainder    fmod
  44. #else
  45. #error "Need some form of remainder"
  46. #endif
  47. #if !defined(HAVE_REMAINDERF)
  48. #define    remainderf(a, b) (float)remainder((double)a, (double)b)
  49. #endif
  50.  
  51. /* If we dont' have isinf() assume nothing is */
  52. #if !defined(HAVE_ISINF)
  53. #define    isinf(x)    0
  54. #endif
  55. /* If we don't have isnan() assume nothing is */
  56. #if !defined(HAVE_ISNAN)
  57. #define    isnan(x)    0
  58. #endif
  59.  
  60. static jint instanceof(classes*, classes*);
  61.  
  62. /*
  63.  * soft_new
  64.  */
  65. void*
  66. soft_new(classes* c)
  67. {
  68.     object* obj;
  69.  
  70.     obj = alloc_object(c, false);
  71.  
  72. ADBG(    printf("New object of type %s (%d,%x)\n", c->name, c->fsize, obj);
  73.         fflush(stdout);                        )
  74.  
  75.     return (obj);
  76. }
  77.  
  78. /*
  79.  * soft_newarray
  80.  */
  81. void*
  82. soft_newarray(jint type, jint size)
  83. {
  84.     object* obj;
  85.  
  86.     if (size < 0) {
  87.         throwException(NegativeArraySizeException);
  88.     }
  89.         
  90.     obj = alloc_array(size, type);
  91.         
  92. ADBG(    printf("New object of %d type (%d,%x)\n", type, size, obj);
  93.     fflush(stdout);                            )
  94.  
  95.     return (obj);
  96. }
  97.  
  98. /*
  99.  * soft_anewarray.
  100.  */
  101. void*
  102. soft_anewarray(classes* c, jint size)
  103. {
  104.         object* obj;
  105.  
  106.     if (size < 0) {
  107.         throwException(NegativeArraySizeException);
  108.     }
  109.         
  110.     obj = alloc_objectarray(size, c->sig);
  111.         
  112. ADBG(    printf("New object array of type %s (%d,%x)\n", c->name, size, obj);
  113.         fflush(stdout);                        )
  114.  
  115.     return (obj);
  116. }
  117.  
  118. /*
  119.  * soft_multianewarray.
  120.  */
  121. #define    MAXDIMS    16
  122.  
  123. #if defined(INTERPRETER)
  124. void*
  125. soft_multianewarray(classes* class, jint dims, slots* args)
  126. {
  127.         int arraydims[MAXDIMS];
  128.         object* obj;
  129.         jint arg;
  130.         int i; 
  131.  
  132.         assert(dims < MAXDIMS);
  133.  
  134.         /* Extract the dimensions into an array */
  135.         for (i = 0; i < dims; i++) {
  136.         arg = args[i].v.tint;
  137.                 if (arg < 0) {
  138.                         throwException(NegativeArraySizeException);
  139.                 }  
  140.                 arraydims[i] = arg;
  141.         }
  142.         arraydims[i] = 0;
  143.  
  144.         /* Mmm, okay now build the array using the wonders of recursion */
  145.         obj = alloc_multiarray(arraydims, class->name);
  146.  
  147.         /* Return the base object */
  148.     return (obj);
  149. }
  150. #endif
  151.  
  152. #if defined(TRANSLATOR)
  153. void*
  154. soft_multianewarray(classes* class, jint dims, ...)
  155. {
  156.     va_list ap;
  157.     int arraydims[MAXDIMS];
  158.     int i;
  159.     jint arg;
  160.     object* obj;
  161.  
  162.     assert(dims < MAXDIMS);
  163.  
  164.     /* Extract the dimensions into an array */
  165.     va_start(ap, dims);
  166.     for (i = 0; i < dims; i++) {
  167.         arg = va_arg(ap, jint);
  168.         if (arg < 0) {
  169.                         throwException(NegativeArraySizeException);
  170.         }
  171.         arraydims[i] = arg;
  172.     }
  173.     arraydims[i] = 0;
  174.     va_end(ap);
  175.  
  176.     /* Mmm, okay now build the array using the wonders of recursion */
  177.     obj = alloc_multiarray(arraydims, class->name);
  178.  
  179.     /* Return the base object */
  180.     return (obj);
  181. }
  182. #endif
  183.  
  184. /*
  185.  * soft_monitorenter.
  186.  */
  187. void
  188. soft_monitorenter(object* o)
  189. {
  190.     lockMutex(o);
  191. }
  192.  
  193. /*
  194.  * soft_monitorexit.
  195.  */
  196. void
  197. soft_monitorexit(object* o)
  198. {
  199.     unlockMutex(o);
  200. }
  201.  
  202. /*
  203.  * soft_lookupmethod.
  204.  * (Note. dispatchTable could be methodTable - it doesn't matter)
  205.  */
  206. void*
  207. soft_lookupmethod(dispatchTable* tab, strpair* pair)
  208. {
  209.     classes* cls;
  210.     methods* meth;
  211.     void* func;
  212.  
  213.     cls = tab->class;
  214.  
  215.     meth = findMethod(cls, pair);
  216.     if (meth == 0) {
  217.         throwException(NoSuchMethodError);
  218.     }
  219.  
  220.  
  221. #if defined(TRANSLATOR)
  222.     func = meth->ncode;
  223. #elif defined(INTERPRETER)
  224.     func = (void*)meth;
  225. #else
  226.     abort();
  227. #endif
  228.  
  229. CDBG(    printf("Calling %s:%s%s @ 0x%x\n",
  230.         cls->name, pair->s1, pair->s2, func);
  231.         fflush(stdout);                        )
  232.  
  233. #if MDBG(1) - 1 == -1
  234.     /* Fill in dispatchTable and methodTable cache */
  235.     cls->mtable->m[pair->hash % MAXMETHOD].tag = pair;
  236.     cls->mtable->m[pair->hash % MAXMETHOD].method = func;
  237.     cls->dtable->m[meth->idx].method = func;
  238. #endif
  239.  
  240.     return (func);
  241. }
  242.  
  243. /*
  244.  * soft_checkcast.
  245.  */
  246. void
  247. soft_checkcast(classes* c, object* o)
  248. {
  249.         classes* oc;
  250.  
  251.         /* Null can be cast to anything */
  252.         if (o == 0) {
  253.                 return;
  254.         }
  255.  
  256.     /* If object is instance of class, return */
  257.     if (soft_instanceof(c, o)) {
  258.         return;
  259.     }
  260.  
  261.     /* Otherwise throw exception */
  262.         throwException(ClassCastException);
  263. }
  264.  
  265. /*
  266.  * soft_instanceof.
  267.  */
  268. jint
  269. soft_instanceof(classes* c, object* o)
  270. {
  271.     /* Null object are never instances of anything */
  272.     if (o == 0) {
  273.         return (0);
  274.     }
  275.  
  276.     return (instanceof(c, o->dtable->class));
  277. }
  278.  
  279. static
  280. jint
  281. instanceof(classes* c, classes* oc)
  282. {
  283.     int i;
  284.  
  285.     if (oc == c) {
  286.         return (1);
  287.     }
  288.  
  289.     if (oc == 0) {
  290.         return (0);
  291.     }
  292.  
  293.     if (instanceof(c, oc->superclass)) {
  294.         return (1);
  295.     }
  296.  
  297.         for (i = 0; i < oc->interface_len; i++) {
  298.                 if (instanceof(c, oc->interfaces[i])) {      
  299.                         return (1);
  300.                 }
  301.         }
  302.  
  303.         return (0);
  304. }
  305.  
  306. /*
  307.  * soft_athrow.
  308.  */
  309. void
  310. soft_athrow(object* o)
  311. {
  312.     throwExternalException(o);
  313. }
  314.  
  315. /*
  316.  * soft_badarrayindex.
  317.  */
  318. void
  319. soft_badarrayindex(void)
  320. {
  321.     throwException(ArrayIndexOutOfBoundsException);
  322. }
  323.  
  324. /*
  325.  * soft_dcmpg
  326.  */
  327. jint
  328. soft_dcmpg(jdouble v1, jdouble v2)
  329. {
  330.     jint ret;
  331.     if ((!isinf(v1) && isnan(v1)) || (!isinf(v2) && isnan(v2))) {
  332.         ret = 1;
  333.     }
  334.     else if (v1 > v2) {
  335.         ret = 1;
  336.     }
  337.     else if (v1 == v2) { 
  338.         ret = 0;
  339.     }
  340.     else {
  341.         ret = -1;
  342.     }
  343.  
  344.     return (ret);
  345. }
  346.  
  347. /*
  348.  * soft_dcmpl
  349.  */
  350. jint
  351. soft_dcmpl(jdouble v1, jdouble v2)
  352. {
  353.         jint ret;
  354.     if ((!isinf(v1) && isnan(v1)) || (!isinf(v2) && isnan(v2))) {
  355.         ret = -1;
  356.     }
  357.         else if (v1 > v2) {
  358.                 ret = 1;
  359.         }
  360.         else if (v1 == v2) { 
  361.                 ret = 0;
  362.         }
  363.         else {
  364.                 ret = -1;
  365.         }
  366.     return (ret);
  367. }
  368.  
  369. /*
  370.  * soft_fcmpg
  371.  */
  372. jint
  373. soft_fcmpg(jfloat v1, jfloat v2)
  374. {
  375.         jint ret;
  376.     if ((!isinf(v1) && isnan(v1)) || (!isinf(v2) && isnan(v2))) {
  377.         ret = 1;
  378.     }
  379.         else if (v1 > v2) {
  380.                 ret = 1;
  381.         }
  382.         else if (v1 == v2) {
  383.                 ret = 0;
  384.         }
  385.         else {
  386.                 ret = -1;
  387.         }
  388.     return (ret);
  389. }
  390.  
  391. /*
  392.  * soft_fcmpg
  393.  */
  394. jint
  395. soft_fcmpl(jfloat v1, jfloat v2)
  396. {
  397.         jint ret;  
  398.     if ((!isinf(v1) && isnan(v1)) || (!isinf(v2) && isnan(v2))) {
  399.         ret = -1;
  400.     }
  401.         else if (v1 > v2) {
  402.                 ret = 1;
  403.         }
  404.         else if (v1 == v2) {
  405.                 ret = 0;
  406.         }
  407.         else {
  408.                 ret = -1;
  409.         }
  410.     return (ret);
  411. }
  412.  
  413. #if defined(TRANSLATOR)
  414. jlong
  415. soft_lmul(jlong v1, jlong v2)
  416. {
  417.     return (v1 * v2);
  418. }
  419.  
  420. jlong
  421. soft_ldiv(jlong v1, jlong v2)
  422. {
  423.     return (v1 / v2);
  424. }
  425.  
  426. jlong
  427. soft_lrem(jlong v1, jlong v2)
  428. {
  429.     return (v1 % v2);
  430. }
  431.  
  432. jfloat
  433. soft_frem(jfloat v1, jfloat v2)
  434. {
  435.     return (remainderf(v1, v2));
  436. }
  437.  
  438. jdouble
  439. soft_freml(jdouble v1, jdouble v2)
  440. {
  441.     return (remainder(v1, v2));
  442. }
  443.  
  444. jlong
  445. soft_lshll(jlong v1, jint v2)
  446. {
  447.     return (v1 << (v2 & 63));
  448. }
  449.  
  450. jlong
  451. soft_ashrl(jlong v1, jint v2)
  452. {
  453.     return (v1 >> (v2 & 63));
  454. }
  455.  
  456. jlong
  457. soft_lshrl(jlong v1, jint v2)
  458. {
  459.     return (((uint64)v1) >> (v2 & 63));
  460. }
  461.  
  462. jint
  463. soft_lcmp(jlong v1, jlong v2)
  464. {
  465.     jlong lcc = v2 - v1;
  466.     if (lcc < 0) {
  467.         return (-1);
  468.     }
  469.     else if (lcc > 0) {
  470.         return (1);
  471.     }
  472.     else {
  473.         return (0);
  474.     }
  475. }
  476. #endif
  477.