calls instead of machine instructions, using the C calling
convention.
- $Id: builtin.c 1113 2004-06-02 10:31:09Z twisti $
+ $Id: builtin.c 1296 2004-07-10 17:02:15Z stefan $
*/
#include <assert.h>
#include <string.h>
#include <math.h>
-#include "main.h"
+#include "options.h"
#include "builtin.h"
#include "native.h"
#include "loader.h"
return res;
}
-s4 builtin_isanysubclass_vftbl(vftbl *sub,vftbl *super)
+s4 builtin_isanysubclass_vftbl(vftbl_t *sub,vftbl_t *super)
{
s4 res;
int base;
*****************************************************************************/
-s4 builtin_checkarraycast(java_objectheader *o, vftbl *target)
+s4 builtin_checkarraycast(java_objectheader *o, vftbl_t *target)
{
arraydescriptor *desc;
}
-s4 builtin_arrayinstanceof(java_objectheader *obj, vftbl *target)
+s4 builtin_arrayinstanceof(java_objectheader *obj, vftbl_t *target)
{
if (!obj) return 1;
return builtin_checkarraycast(obj, target);
char logtext[MAXLOGTEXT];
sprintf(logtext, "Builtin exception thrown: ");
if (local_exceptionptr) {
+ java_lang_Throwable *t = (java_lang_Throwable *) local_exceptionptr;
+
utf_sprint_classname(logtext + strlen(logtext),
local_exceptionptr->vftbl->class->name);
+ if (t->detailMessage) {
+ sprintf(logtext + strlen(logtext), ": %s",
+ javastring_tochar(t->detailMessage));
+ }
+
} else {
sprintf(logtext + strlen(logtext), "Error: <Nullpointer instead of exception>");
}
{
arraydescriptor *desc;
arraydescriptor *valuedesc;
- vftbl *componentvftbl;
- vftbl *valuevftbl;
+ vftbl_t *componentvftbl;
+ vftbl_t *valuevftbl;
int dim_m1;
int base;
castinfo classvalues;
s4 builtin_canstore_onedim (java_objectarray *a, java_objectheader *o)
{
arraydescriptor *desc;
- vftbl *elementvftbl;
- vftbl *valuevftbl;
+ vftbl_t *elementvftbl;
+ vftbl_t *valuevftbl;
s4 res;
int base;
castinfo classvalues;
* one-dimensional array of a class type */
s4 builtin_canstore_onedim_class(java_objectarray *a, java_objectheader *o)
{
- vftbl *elementvftbl;
- vftbl *valuevftbl;
+ vftbl_t *elementvftbl;
+ vftbl_t *valuevftbl;
s4 res;
castinfo classvalues;
*****************************************************************************/
-java_arrayheader *builtin_newarray(s4 size, vftbl *arrayvftbl)
+java_arrayheader *builtin_newarray(s4 size, vftbl_t *arrayvftbl)
{
java_arrayheader *a;
arraydescriptor *desc;
******************************************************************************/
-java_arrayheader *builtin_nmultianewarray(int n, vftbl *arrayvftbl, long *dims)
+java_arrayheader *builtin_nmultianewarray(int n, vftbl_t *arrayvftbl, long *dims)
/* java_arrayheader *builtin_nmultianewarray(int n, classinfo *arrayclass, long *dims) */
{
s4 size, i;
java_arrayheader *a;
- vftbl *componentvftbl;
+ vftbl_t *componentvftbl;
/* utf_display(arrayclass->name); */
#if !defined(NATIVE_THREADS)
int hashValue;
- /*log_text("Monitor enter");*/
-
- assert(blockInts == 0);
-
++blockInts;
hashValue = MUTEX_HASH_VALUE(o);
internal_lock_mutex_for_object(o);
--blockInts;
-
- assert(blockInts == 0);
#else
- monitorEnter((threadobject*) THREADOBJECT, o);
+ monitorEnter((threadobject *) THREADOBJECT, o);
#endif
#endif
}
-
-void builtin_monitorexit (java_objectheader *o)
+/*
+ * Locks the class object - needed for static synchronized methods.
+ * The use_class_as_object call is needed in order to circumvent a
+ * possible deadlock with builtin_monitorenter called by another
+ * thread calling use_class_as_object.
+ */
+void builtin_staticmonitorenter(classinfo *c)
{
+ use_class_as_object(c);
+ builtin_monitorenter(&c->header);
+}
+
+void builtin_monitorexit(java_objectheader *o)
+{
#if defined(USE_THREADS)
#if !defined(NATIVE_THREADS)
int hashValue;
- /* log_text("Monitor leave"); */
-
- assert(blockInts == 0);
-
++blockInts;
hashValue = MUTEX_HASH_VALUE(o);
internal_unlock_mutex_for_object(o);
--blockInts;
-
- assert(blockInts == 0);
#else
- monitorExit((threadobject*) THREADOBJECT, o);
+ monitorExit((threadobject *) THREADOBJECT, o);
#endif
#endif
}
size_t s;
s=(end-begin);
/*printf ("begin: %p, end: %p, diff: %ld, size :%ld\n",begin,end,s,s*sizeof(stacktraceelement));*/
+ *el=heap_allocate(sizeof(stacktraceelement)*(s+1), true, 0);
+#if 0
*el=MNEW(stacktraceelement,s+1); /*GC*/
+#endif
memcpy(*el,begin,(end-begin)*sizeof(stacktraceelement));
(*el)[s].method=0;
#if defined(__GNUC__)