-/****************************** builtin.c **************************************
+/* builtin.c - functions for unsupported operations
- Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser,
+ M. Probst, S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck,
+ P. Tomsich, J. Wenninger
- See file COPYRIGHT for information on usage and disclaimer of warranties
+ This file is part of CACAO.
- Contains C functions for JavaVM Instructions that cannot be translated
- to machine language directly. Consequently, the generated machine code
- for these instructions contains function calls instead of machine
- instructions, using the C calling convention.
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2, or (at
+ your option) any later version.
- Authors: Reinhard Grafl EMAIL: cacao@complang.tuwien.ac.at
- Andreas Krall EMAIL: cacao@complang.tuwien.ac.at
- Mark Probst EMAIL: cacao@complang.tuwien.ac.at
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
- Last Change: 1996/12/03
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
-*******************************************************************************/
+ Contact: cacao@complang.tuwien.ac.at
+
+ Authors: Reinhard Grafl
+ Andreas Krall
+ Mark Probst
+
+ Contains C functions for JavaVM Instructions that cannot be
+ translated to machine language directly. Consequently, the
+ generated machine code for these instructions contains function
+ calls instead of machine instructions, using the C calling
+ convention.
+
+ $Id: builtin.c 557 2003-11-02 22:51:59Z twisti $
+
+*/
-#include <assert.h>
-#include <values.h>
+#include <assert.h>
#include "global.h"
#include "builtin.h"
-
#include "loader.h"
#include "tables.h"
-
#include "threads/thread.h"
-#include "threads/locks.h" /* schani */
+#include "threads/locks.h"
+#include "toolbox/loging.h"
#include "native-math.h"
+
builtin_descriptor builtin_desc[] = {
{(functionptr) builtin_instanceof, "instanceof"},
{(functionptr) builtin_checkcast, "checkcast"},
{(functionptr) asm_builtin_checkcast, "checkcast"},
{(functionptr) builtin_arrayinstanceof, "arrayinstanceof"},
+#if defined(__I386__)
+ {(functionptr) asm_builtin_arrayinstanceof,"arrayinstanceof"},
+#endif
{(functionptr) builtin_checkarraycast, "checkarraycast"},
{(functionptr) asm_builtin_checkarraycast, "checkarraycast"},
{(functionptr) asm_builtin_aastore, "aastore"},
{(functionptr) builtin_new, "new"},
- {(functionptr) builtin_anewarray, "anewarray"},
+ {(functionptr) builtin_anewarray, "anewarray"},
{(functionptr) builtin_newarray_array, "newarray_array"},
+#if defined(__I386__)
+ /* have 2 parameters (needs stack manipulation) */
+ {(functionptr) asm_builtin_anewarray, "anewarray"},
+ {(functionptr) asm_builtin_newarray_array, "newarray_array"},
+#endif
{(functionptr) builtin_newarray_boolean, "newarray_boolean"},
{(functionptr) builtin_newarray_char, "newarray_char"},
{(functionptr) builtin_newarray_float, "newarray_float"},
{(functionptr) asm_builtin_monitorenter, "monitorenter"},
{(functionptr) builtin_monitorexit, "monitorexit"},
{(functionptr) asm_builtin_monitorexit, "monitorexit"},
+#if !SUPPORT_DIVISION
{(functionptr) builtin_idiv, "idiv"},
{(functionptr) asm_builtin_idiv, "idiv"},
{(functionptr) builtin_irem, "irem"},
{(functionptr) asm_builtin_irem, "irem"},
+#endif
{(functionptr) builtin_ladd, "ladd"},
{(functionptr) builtin_lsub, "lsub"},
{(functionptr) builtin_lmul, "lmul"},
+#if !(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_MULDIV)
{(functionptr) builtin_ldiv, "ldiv"},
{(functionptr) asm_builtin_ldiv, "ldiv"},
{(functionptr) builtin_lrem, "lrem"},
{(functionptr) asm_builtin_lrem, "lrem"},
+#endif
{(functionptr) builtin_lshl, "lshl"},
{(functionptr) builtin_lshr, "lshr"},
{(functionptr) builtin_lushr, "lushr"},
{(functionptr) builtin_f2d, "f2d"},
{(functionptr) builtin_d2i, "d2i"},
{(functionptr) builtin_d2l, "d2l"},
+#if defined(__I386__)
+ {(functionptr) asm_builtin_f2i, "f2i"},
+ {(functionptr) asm_builtin_f2l, "f2l"},
+ {(functionptr) asm_builtin_d2i, "d2i"},
+ {(functionptr) asm_builtin_d2l, "d2l"},
+#endif
{(functionptr) builtin_d2f, "d2f"},
{(functionptr) NULL, "unknown"}
- };
+};
/*****************************************************************************
{
if (super->flags & ACC_INTERFACE)
return (sub->vftbl->interfacetablelength > super->index) &&
- (sub->vftbl->interfacetable[-super->index] != NULL);
+ (sub->vftbl->interfacetable[-super->index] != NULL);
/*
- while (sub != 0)
- if (sub == super)
- return 1;
- else
- sub = sub->super;
+ while (sub != 0)
+ if (sub == super)
+ return 1;
+ else
+ sub = sub->super;
- return 0;
+ return 0;
*/
return (unsigned) (sub->vftbl->baseval - super->vftbl->baseval) <=
- (unsigned) (super->vftbl->diffval);
+ (unsigned) (super->vftbl->diffval);
}
s4 builtin_instanceof(java_objectheader *obj, classinfo *class)
{
- #ifdef DEBUG
+#ifdef DEBUG
log_text ("builtin_instanceof called");
- #endif
+#endif
if (!obj) return 0;
return builtin_isanysubclass (obj->vftbl->class, class);
if (builtin_isanysubclass (obj->vftbl->class, class))
return 1;
- #if DEBUG
+#if DEBUG
printf ("#### checkcast failed ");
utf_display (obj->vftbl->class->name);
printf (" -> ");
utf_display (class->name);
printf ("\n");
- #endif
+#endif
return 0;
}
******************************************************************************/
-static s4 builtin_descriptorscompatible
- (constant_arraydescriptor *desc, constant_arraydescriptor *target)
+static s4 builtin_descriptorscompatible(constant_arraydescriptor *desc, constant_arraydescriptor *target)
{
if (desc==target) return 1;
if (desc->arraytype != target->arraytype) return 0;
switch (target->arraytype) {
- case ARRAYTYPE_OBJECT:
- return builtin_isanysubclass (desc->objectclass, target->objectclass);
- case ARRAYTYPE_ARRAY:
- return builtin_descriptorscompatible
- (desc->elementdescriptor, target->elementdescriptor);
- default: return 1;
- }
+ case ARRAYTYPE_OBJECT:
+ return builtin_isanysubclass (desc->objectclass, target->objectclass);
+ case ARRAYTYPE_ARRAY:
+ return builtin_descriptorscompatible
+ (desc->elementdescriptor, target->elementdescriptor);
+ default: return 1;
+ }
}
printf ("#### checkarraycast failed 1\n");
#endif
return 0;
- }
+ }
if (a->arraytype != desc->arraytype) {
#ifdef DEBUG
printf ("#### checkarraycast failed 2\n");
#endif
return 0;
- }
+ }
switch (a->arraytype) {
- case ARRAYTYPE_OBJECT: {
- java_objectarray *oa = (java_objectarray*) o;
- int result = builtin_isanysubclass (oa->elementtype, desc->objectclass);
+ case ARRAYTYPE_OBJECT: {
+ java_objectarray *oa = (java_objectarray*) o;
+ int result = builtin_isanysubclass (oa->elementtype, desc->objectclass);
#ifdef DEBUG
- if (!result)
- printf ("#### checkarraycast failed 3\n");
+ if (!result)
+ printf ("#### checkarraycast failed 3\n");
#endif
- return result;
- }
- case ARRAYTYPE_ARRAY: {
- java_arrayarray *aa = (java_arrayarray*) o;
- int result = builtin_descriptorscompatible
- (aa->elementdescriptor, desc->elementdescriptor);
+ return result;
+ }
+ case ARRAYTYPE_ARRAY: {
+ java_arrayarray *aa = (java_arrayarray*) o;
+ int result = builtin_descriptorscompatible
+ (aa->elementdescriptor, desc->elementdescriptor);
#ifdef DEBUG
- if (!result)
- printf ("#### checkarraycast failed 4\n");
+ if (!result)
+ printf ("#### checkarraycast failed 4\n");
#endif
- return result;
- }
- default:
- return 1;
- }
+ return result;
+ }
+ default:
+ return 1;
+ }
}
-s4 builtin_arrayinstanceof
- (java_objectheader *obj, constant_arraydescriptor *desc)
+s4 builtin_arrayinstanceof(java_objectheader *obj, constant_arraydescriptor *desc)
{
if (!obj) return 1;
return builtin_checkarraycast (obj, desc);
sprintf(logtext, "Builtin exception thrown: ");
utf_sprint(logtext + strlen(logtext), local_exceptionptr->vftbl->class->name);
dolog();
- }
+ }
exceptionptr = local_exceptionptr;
return local_exceptionptr;
}
case ARRAYTYPE_OBJECT:
if ( ! builtin_checkcast (o, a->elementtype) ) {
return 0;
- }
+ }
return 1;
break;
case ARRAYTYPE_ARRAY:
if ( ! builtin_checkarraycast
- (o, ((java_arrayarray*)a)->elementdescriptor) ) {
+ (o, ((java_arrayarray*)a)->elementdescriptor) ) {
return 0;
- }
+ }
return 1;
break;
#define ALIGNMENT 3
#define align_size(size) ((size + ((1 << ALIGNMENT) - 1)) & ~((1 << ALIGNMENT) - 1))
-java_objectheader *builtin_new (classinfo *c)
+java_objectheader *builtin_new(classinfo *c)
{
java_objectheader *o;
#ifdef SIZE_FROM_CLASSINFO
c->alignedsize = align_size(c->instancesize);
- o = heap_allocate ( c->alignedsize, true, c->finalizer );
+ o = heap_allocate(c->alignedsize, true, c->finalizer);
#else
- o = heap_allocate ( c->instancesize, true, c->finalizer );
+ o = heap_allocate(c->instancesize, true, c->finalizer);
#endif
if (!o) return NULL;
- memset (o, 0, c->instancesize);
+ memset(o, 0, c->instancesize);
+
+ o->vftbl = c->vftbl;
- o -> vftbl = c -> vftbl;
return o;
}
*****************************************************************************/
+void XXX_copy_vftbl(vftbl **dest, vftbl *src)
+{
+ *dest = mem_alloc(sizeof(vftbl) + sizeof(methodptr)*(src->vftbllength-1));
+ memcpy(*dest, src, sizeof(vftbl) - sizeof(methodptr));
+ memcpy(&(*dest)->table, &src->table, src->vftbllength * sizeof(methodptr));
+}
+
+void XXX_use_class_as_object(classinfo *c, char *cname)
+{
+ vftbl *vt = class_get(utf_new_char(cname))->vftbl;
+ vftbl *newtbl;
+ if (!c->classvftbl) {
+ c->classvftbl = true;
+ XXX_copy_vftbl(&newtbl, vt);
+ newtbl->class = c->header.vftbl->class;
+ newtbl->baseval = c->header.vftbl->baseval;
+ newtbl->diffval = c->header.vftbl->diffval;
+ c->header.vftbl = newtbl;
+ }
+}
+
static
void* __builtin_newarray(s4 base_size,
s4 size,
bool references,
int elementsize,
- int arraytype)
+ int arraytype,
+ classinfo *el)
{
java_arrayheader *a;
+
#ifdef SIZE_FROM_CLASSINFO
s4 alignedsize = align_size(base_size + (size-1) * elementsize);
- a = heap_allocate ( alignedsize, true, NULL );
+ a = heap_allocate( alignedsize, references, NULL );
#else
- a = heap_allocate ( sizeof(java_objectarray) + (size-1) * elementsize,
- references,
- NULL);
+ a = heap_allocate(sizeof(java_objectarray) + (size-1) * elementsize,
+ references,
+ NULL);
#endif
if (!a) return NULL;
memset(a, 0, base_size + (size-1) * elementsize);
#endif
- a -> objheader.vftbl = class_array -> vftbl;
+#if 0
+ {
+ classinfo *c;
+
+ switch (arraytype) {
+ case ARRAYTYPE_INT:
+ c = create_array_class(utf_new_char("[I"));
+ XXX_use_class_as_object(c, "int");
+ break;
+
+ case ARRAYTYPE_LONG:
+ c = create_array_class(utf_new_char("[J"));
+ XXX_use_class_as_object(c, "long");
+ break;
+
+ case ARRAYTYPE_FLOAT:
+ c = create_array_class(utf_new_char("[F"));
+ XXX_use_class_as_object(c, "float");
+ break;
+
+ case ARRAYTYPE_DOUBLE:
+ c = create_array_class(utf_new_char("[D"));
+ XXX_use_class_as_object(c, "double");
+ break;
+
+ case ARRAYTYPE_BYTE:
+ c = create_array_class(utf_new_char("[B"));
+ XXX_use_class_as_object(c, "byte");
+ break;
+
+ case ARRAYTYPE_CHAR:
+ c = create_array_class(utf_new_char("[C"));
+ XXX_use_class_as_object(c, "char");
+ break;
+
+ case ARRAYTYPE_SHORT:
+ c = create_array_class(utf_new_char("[S"));
+ XXX_use_class_as_object(c, "short");
+ break;
+
+ case ARRAYTYPE_BOOLEAN:
+ c = create_array_class(utf_new_char("[Z"));
+ XXX_use_class_as_object(c, "boolean");
+ break;
+
+ case ARRAYTYPE_OBJECT:
+ {
+ char *cname, *buf;
+ cname = heap_allocate(utf_strlen(el->name), false, NULL);
+ utf_sprint(cname, el->name);
+ buf = heap_allocate(strlen(cname) + 3, false, NULL);
+ /* printf("\n\n[L%s;\n\n", cname); */
+ sprintf(buf, "[L%s;", cname);
+ c = create_array_class(utf_new_char(buf));
+ /* MFREE(buf, char, strlen(cname) + 3); */
+ /* MFREE(cname, char, utf_strlen(el->name)); */
+ XXX_use_class_as_object(c, cname);
+ }
+ break;
+
+ case ARRAYTYPE_ARRAY:
+ c = create_array_class(utf_new_char("[["));
+ XXX_use_class_as_object(c, "java/lang/Boolean");
+ break;
+
+ default:
+ panic("unknown array type");
+ }
+
+ a->objheader.vftbl = c->vftbl;
+ }
+#else
+ a->objheader.vftbl = class_array->vftbl;
+#endif
a -> size = size;
#ifdef SIZE_FROM_CLASSINFO
a -> alignedsize = alignedsize;
size,
true,
sizeof(void*),
- ARRAYTYPE_OBJECT);
+ ARRAYTYPE_OBJECT,
+ elementtype);
if (!a) return NULL;
a -> elementtype = elementtype;
*****************************************************************************/
java_arrayarray *builtin_newarray_array
- (s4 size, constant_arraydescriptor *elementdesc)
+(s4 size, constant_arraydescriptor *elementdesc)
{
java_arrayarray *a;
a = (java_arrayarray*)__builtin_newarray(sizeof(java_arrayarray),
size,
true,
sizeof(void*),
- ARRAYTYPE_ARRAY);
+ ARRAYTYPE_ARRAY,
+ elementdesc->objectclass);
if (!a) return NULL;
a -> elementdescriptor = elementdesc;
size,
false,
sizeof(u1),
- ARRAYTYPE_BOOLEAN);
+ ARRAYTYPE_BOOLEAN,
+ NULL);
return a;
}
size,
false,
sizeof(u2),
- ARRAYTYPE_CHAR);
+ ARRAYTYPE_CHAR,
+ NULL);
return a;
}
size,
false,
sizeof(float),
- ARRAYTYPE_FLOAT);
+ ARRAYTYPE_FLOAT,
+ NULL);
return a;
}
size,
false,
sizeof(double),
- ARRAYTYPE_DOUBLE);
+ ARRAYTYPE_DOUBLE,
+ NULL);
return a;
}
size,
false,
sizeof(u1),
- ARRAYTYPE_BYTE);
+ ARRAYTYPE_BYTE,
+ NULL);
return a;
}
{
java_shortarray *a;
a = (java_shortarray*)__builtin_newarray(sizeof(java_shortarray),
- size,
- false,
- sizeof(s2),
- ARRAYTYPE_SHORT);
+ size,
+ false,
+ sizeof(s2),
+ ARRAYTYPE_SHORT,
+ NULL);
return a;
}
size,
false,
sizeof(s4),
- ARRAYTYPE_INT);
+ ARRAYTYPE_INT,
+ NULL);
return a;
}
size,
false,
sizeof(s8),
- ARRAYTYPE_LONG);
+ ARRAYTYPE_LONG,
+ NULL);
return a;
}
/* Helper functions */
static java_arrayheader *multianewarray_part (java_intarray *dims, int thisdim,
- constant_arraydescriptor *desc)
+ constant_arraydescriptor *desc)
{
u4 size,i;
java_arrayarray *a;
default: panic ("Invalid arraytype in multianewarray");
}
- }
+ }
/* if the last dimension has not been reached yet */
for (i=0; i<size; i++) {
java_arrayheader *ea =
- multianewarray_part (dims, thisdim+1, desc->elementdescriptor);
+ multianewarray_part (dims, thisdim+1, desc->elementdescriptor);
if (!ea) return NULL;
a -> data[i] = ea;
- }
+ }
return (java_arrayheader*) a;
}
java_arrayheader *builtin_multianewarray (java_intarray *dims,
- constant_arraydescriptor *desc)
+ constant_arraydescriptor *desc)
{
return multianewarray_part (dims, 0, desc);
}
static java_arrayheader *nmultianewarray_part (int n, long *dims, int thisdim,
- constant_arraydescriptor *desc)
+ constant_arraydescriptor *desc)
{
int size, i;
java_arrayarray *a;
return (java_arrayheader*) builtin_newarray_long(size);
case ARRAYTYPE_OBJECT:
return (java_arrayheader*) builtin_anewarray(size,
- desc->objectclass);
+ desc->objectclass);
case ARRAYTYPE_ARRAY:
return (java_arrayheader*) builtin_newarray_array(size,
- desc->elementdescriptor);
+ desc->elementdescriptor);
default: panic ("Invalid arraytype in multianewarray");
}
- }
+ }
/* if the last dimension has not been reached yet */
if (!ea) return NULL;
a -> data[i] = ea;
- }
+ }
return (java_arrayheader*) a;
}
java_arrayheader *builtin_nmultianewarray (int size,
- constant_arraydescriptor *desc, long *dims)
+ constant_arraydescriptor *desc, long *dims)
{
(void) builtin_newarray_int(size); /* for compatibility with -old */
return nmultianewarray_part (size, dims, 0, desc);
if (builtin_canstore(a,o)) {
a->data[index] = o;
return 1;
- }
+ }
return 0;
}
u4 methodindent=0;
java_objectheader *builtin_trace_exception (java_objectheader *exceptionptr,
- methodinfo *method, int *pos, int noindent) {
+ methodinfo *method, int *pos, int noindent) {
if (!noindent)
methodindent--;
else
printf("(NOSYNC)");
printf("(%p) at position %p\n", method->entrypoint, pos);
- }
+ }
else
printf("call_java_method\n");
fflush (stdout);
- }
+ }
return exceptionptr;
}
-void builtin_trace_args(long a0, long a1, long a2, long a3, long a4, long a5,
+#ifdef TRACE_ARGS_NUM
+void builtin_trace_args(s8 a0, s8 a1, s8 a2, s8 a3, s8 a4, s8 a5,
+#if TRACE_ARGS_NUM > 6
+ s8 a6, s8 a7,
+#endif
methodinfo *method)
{
- sprintf (logtext, " ");
+ int i;
+ for (i=0; i<methodindent; i++)
+ logtext[i] = '\t';
sprintf (logtext+methodindent, "called: ");
utf_sprint (logtext+strlen(logtext), method->class->name);
sprintf (logtext+strlen(logtext), ".");
utf_sprint (logtext+strlen(logtext), method->descriptor);
sprintf (logtext+strlen(logtext), "(");
switch (method->paramcount) {
- case 6:
- sprintf(logtext+strlen(logtext), "%lx, %lx, %lx, %lx, %lx, %lx",
- a0, a1, a2, a3, a4, a5);
- break;
- case 5:
- sprintf(logtext+strlen(logtext), "%lx, %lx, %lx, %lx, %lx",
- a0, a1, a2, a3, a4);
- break;
- case 4:
- sprintf(logtext+strlen(logtext), "%lx, %lx, %lx, %lx",
- a0, a1, a2, a3);
- break;
- case 3:
- sprintf(logtext+strlen(logtext), "%lx, %lx, %lx", a0, a1, a2);
- break;
- case 2:
- sprintf(logtext+strlen(logtext), "%lx, %lx", a0, a1);
- break;
- case 1:
- sprintf(logtext+strlen(logtext), "%lx", a0);
- break;
- }
+ case 0:
+ break;
+
+#if defined(__I386__)
+ case 1:
+ sprintf(logtext+strlen(logtext), "%llx", a0);
+ break;
+
+ case 2:
+ sprintf(logtext+strlen(logtext), "%llx, %llx", a0, a1);
+ break;
+
+ case 3:
+ sprintf(logtext+strlen(logtext), "%llx, %llx, %llx", a0, a1, a2);
+ break;
+
+ case 4:
+ sprintf(logtext+strlen(logtext), "%llx, %llx, %llx, %llx",
+ a0, a1, a2, a3);
+ break;
+
+ case 5:
+ sprintf(logtext+strlen(logtext), "%llx, %llx, %llx, %llx, %llx",
+ a0, a1, a2, a3, a4);
+ break;
+
+ case 6:
+ sprintf(logtext+strlen(logtext), "%llx, %llx, %llx, %llx, %llx, %llx",
+ a0, a1, a2, a3, a4, a5);
+ break;
+
+#if TRACE_ARGS_NUM > 6
+ case 7:
+ sprintf(logtext+strlen(logtext), "%llx, %llx, %llx, %llx, %llx, %llx, %llx",
+ a0, a1, a2, a3, a4, a5, a6);
+ break;
+
+ case 8:
+ sprintf(logtext+strlen(logtext), "%llx, %llx, %llx, %llx, %llx, %llx, %llx, %llx",
+ a0, a1, a2, a3, a4, a5, a6, a7);
+ break;
+
+ default:
+ sprintf(logtext+strlen(logtext), "%llx, %llx, %llx, %llx, %llx, %llx, %llx, %llx, ...(%d)",
+ a0, a1, a2, a3, a4, a5, a6, a7, method->paramcount - 8);
+ break;
+#else
+ default:
+ sprintf(logtext+strlen(logtext), "%llx, %llx, %llx, %llx, %llx, %llx, ...(%d)",
+ a0, a1, a2, a3, a4, a5, method->paramcount - 6);
+ break;
+#endif
+#else
+ case 1:
+ sprintf(logtext+strlen(logtext), "%lx", a0);
+ break;
+
+ case 2:
+ sprintf(logtext+strlen(logtext), "%lx, %lx", a0, a1);
+ break;
+
+ case 3:
+ sprintf(logtext+strlen(logtext), "%lx, %lx, %lx", a0, a1, a2);
+ break;
+
+ case 4:
+ sprintf(logtext+strlen(logtext), "%lx, %lx, %lx, %lx",
+ a0, a1, a2, a3);
+ break;
+
+ case 5:
+ sprintf(logtext+strlen(logtext), "%lx, %lx, %lx, %lx, %lx",
+ a0, a1, a2, a3, a4);
+ break;
+
+ case 6:
+ sprintf(logtext+strlen(logtext), "%lx, %lx, %lx, %lx, %lx, %lx",
+ a0, a1, a2, a3, a4, a5);
+ break;
+
+#if TRACE_ARGS_NUM > 6
+ case 7:
+ sprintf(logtext+strlen(logtext), "%lx, %lx, %lx, %lx, %lx, %lx, %lx",
+ a0, a1, a2, a3, a4, a5, a6);
+ break;
+
+ case 8:
+ sprintf(logtext+strlen(logtext), "%lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx",
+ a0, a1, a2, a3, a4, a5, a6, a7);
+ break;
+
+ default:
+ sprintf(logtext+strlen(logtext), "%lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx, ...(%d)",
+ a0, a1, a2, a3, a4, a5, a6, a7, method->paramcount - 8);
+ break;
+#else
+ default:
+ sprintf(logtext+strlen(logtext), "%lx, %lx, %lx, %lx, %lx, %lx, ...(%d)",
+ a0, a1, a2, a3, a4, a5, method->paramcount - 6);
+ break;
+#endif
+#endif
+ }
sprintf (logtext+strlen(logtext), ")");
dolog ();
methodindent++;
}
+#endif
void builtin_displaymethodstart(methodinfo *method)
{
methodindent++;
}
-void builtin_displaymethodstop(methodinfo *method, long l, double d)
+void builtin_displaymethodstop(methodinfo *method, s8 l, double d, float f)
{
+ int i;
+ for (i=0; i<methodindent; i++)
+ logtext[i] = '\t';
methodindent--;
- sprintf (logtext, " ");
sprintf (logtext+methodindent, "finished: ");
utf_sprint (logtext+strlen(logtext), method->class->name);
sprintf (logtext+strlen(logtext), ".");
utf_sprint (logtext+strlen(logtext), method->name);
utf_sprint (logtext+strlen(logtext), method->descriptor);
switch (method->returntype) {
- case TYPE_INT:
- case TYPE_LONG:
- case TYPE_ADDRESS:
- sprintf (logtext+strlen(logtext), "->%ld", l);
- break;
- case TYPE_FLOAT:
- case TYPE_DOUBLE:
- sprintf (logtext+strlen(logtext), "->%g", d);
- break;
- }
+ case TYPE_INT:
+ sprintf (logtext+strlen(logtext), "->%d", (s4) l);
+ break;
+ case TYPE_LONG:
+#if defined(__I386__)
+ sprintf(logtext+strlen(logtext), "->%lld", (s8) l);
+#else
+ sprintf(logtext+strlen(logtext), "->%ld", (s8) l);
+#endif
+ break;
+ case TYPE_ADDRESS:
+#if defined(__I386__)
+ sprintf(logtext+strlen(logtext), "->%p", (u1*) ((s4) l));
+#else
+ sprintf(logtext+strlen(logtext), "->%p", (u1*) l);
+#endif
+ break;
+ case TYPE_FLOAT:
+ sprintf (logtext+strlen(logtext), "->%g", f);
+ break;
+ case TYPE_DOUBLE:
+ sprintf (logtext+strlen(logtext), "->%g", d);
+ break;
+ }
dolog ();
}
void builtin_displaymethodexception(methodinfo *method)
{
- sprintf (logtext, " ");
+ int i;
+ for (i=0; i<methodindent; i++)
+ logtext[i] = '\t';
sprintf (logtext+methodindent, "exception abort: ");
utf_sprint (logtext+strlen(logtext), method->class->name);
sprintf (logtext+strlen(logtext), ".");
entry = &mutexHashTable[hashValue];
if (entry->object != 0)
- {
- if (entry->mutex.count == 0 && entry->conditionCount == 0)
{
- entry->object = 0;
+ if (entry->mutex.count == 0 && entry->conditionCount == 0)
+ {
+ entry->object = 0;
+ entry->mutex.holder = 0;
+ entry->mutex.count = 0;
+ entry->mutex.muxWaiters = 0;
+ }
+ else
+ {
+ while (entry->next != 0 && entry->object != object)
+ entry = entry->next;
+
+ if (entry->object != object)
+ {
+ entry->next = firstFreeOverflowEntry;
+ firstFreeOverflowEntry = firstFreeOverflowEntry->next;
+
+ entry = entry->next;
+ entry->object = 0;
+ entry->next = 0;
+ assert(entry->conditionCount == 0);
+ }
+ }
+ }
+ else
+ {
entry->mutex.holder = 0;
entry->mutex.count = 0;
entry->mutex.muxWaiters = 0;
}
- else
- {
- while (entry->next != 0 && entry->object != object)
- entry = entry->next;
-
- if (entry->object != object)
- {
- entry->next = firstFreeOverflowEntry;
- firstFreeOverflowEntry = firstFreeOverflowEntry->next;
-
- entry = entry->next;
- entry->object = 0;
- entry->next = 0;
- assert(entry->conditionCount == 0);
- }
- }
- }
- else
- {
- entry->mutex.holder = 0;
- entry->mutex.count = 0;
- entry->mutex.muxWaiters = 0;
- }
if (entry->object == 0)
entry->object = object;
if (entry->object == object)
internal_unlock_mutex(&entry->mutex);
else
- {
- while (entry->next != 0 && entry->next->object != object)
- entry = entry->next;
+ {
+ while (entry->next != 0 && entry->next->object != object)
+ entry = entry->next;
- assert(entry->next != 0);
+ assert(entry->next != 0);
- internal_unlock_mutex(&entry->next->mutex);
+ internal_unlock_mutex(&entry->next->mutex);
- if (entry->next->mutex.count == 0 && entry->conditionCount == 0)
- {
- mutexHashEntry *unlinked = entry->next;
+ if (entry->next->mutex.count == 0 && entry->conditionCount == 0)
+ {
+ mutexHashEntry *unlinked = entry->next;
- entry->next = unlinked->next;
- unlinked->next = firstFreeOverflowEntry;
- firstFreeOverflowEntry = unlinked;
+ entry->next = unlinked->next;
+ unlinked->next = firstFreeOverflowEntry;
+ firstFreeOverflowEntry = unlinked;
+ }
}
- }
}
#endif
hashValue = MUTEX_HASH_VALUE(o);
if (mutexHashTable[hashValue].object == o)
- {
- if (mutexHashTable[hashValue].mutex.count == 1
- && mutexHashTable[hashValue].mutex.muxWaiters != 0)
- internal_unlock_mutex_for_object(o);
- else
- --mutexHashTable[hashValue].mutex.count;
- }
+ {
+ if (mutexHashTable[hashValue].mutex.count == 1
+ && mutexHashTable[hashValue].mutex.muxWaiters != 0)
+ internal_unlock_mutex_for_object(o);
+ else
+ --mutexHashTable[hashValue].mutex.count;
+ }
else
internal_unlock_mutex_for_object(o);
if (finitef(a)) {
if (finitef(b)) return a+b;
else return b;
- }
+ }
else {
if (finitef(b)) return a;
else {
if (copysignf(1.0, a)==copysignf(1.0, b)) return a;
else return FLT_NAN;
- }
}
+ }
}
float builtin_fsub (float a, float b)
if (finitef(b)) return a*b;
else {
if (a==0) return FLT_NAN;
- else return copysignf(b, copysignf(1.0, b)*a);
- }
+ else return copysignf(b, copysignf(1.0, b)*a);
}
+ }
else {
if (finitef(b)) {
if (b==0) return FLT_NAN;
- else return copysignf(a, copysignf(1.0, a)*b);
- }
+ else return copysignf(a, copysignf(1.0, a)*b);
+ }
else {
return copysignf(a, copysignf(1.0, a)*copysignf(1.0, b));
- }
}
+ }
}
float builtin_fdiv (float a, float b)
return FLT_POSINF;
else if (a < 0)
return FLT_NEGINF;
- }
}
+ }
return FLT_NAN;
}
float builtin_frem (float a, float b)
{
-
-/* return (float) builtin_drem((double) a, (double) b); */
-
- float f;
-
- if (finite((double) a) && finite((double) b)) {
- f = a / b;
- if (finite((double) f))
- return fmodf(a, b);
- return FLT_NAN;
- }
- if (isnan((double) b))
- return FLT_NAN;
- if (finite((double) a))
- return a;
- return FLT_NAN;
-
-/* float f;
-
- if (finitef(a) && finitef(b)) {
- f = a / b;
- if (finitef(f))
- return a - floorf(f) * b;
- return FLT_NAN;
- }
- if (isnanf(b))
- return FLT_NAN;
- if (finitef(a))
- return a;
- return FLT_NAN; */
+ return fmodf(a, b);
}
if (isnanf(a)) return a;
else {
if (finitef(a)) return -a;
- else return copysignf(a,-copysignf(1.0, a));
- }
+ else return copysignf(a,-copysignf(1.0, a));
+ }
}
s4 builtin_fcmpl (float a, float b)
if (!finitef(a) || !finitef(b)) {
a = finitef(a) ? 0 : copysignf(1.0, a);
b = finitef(b) ? 0 : copysignf(1.0, b);
- }
+ }
if (a>b) return 1;
if (a==b) return 0;
return -1;
if (!finitef(a) || !finitef(b)) {
a = finitef(a) ? 0 : copysignf(1.0, a);
b = finitef(b) ? 0 : copysignf(1.0, b);
- }
+ }
if (a>b) return 1;
if (a==b) return 0;
return -1;
if (finite(a)) {
if (finite(b)) return a+b;
else return b;
- }
+ }
else {
if (finite(b)) return a;
else {
if (copysign(1.0, a)==copysign(1.0, b)) return a;
else return DBL_NAN;
- }
}
+ }
}
double builtin_dsub (double a, double b)
if (finite(b)) return a*b;
else {
if (a==0) return DBL_NAN;
- else return copysign(b, copysign(1.0, b)*a);
- }
+ else return copysign(b, copysign(1.0, b)*a);
}
+ }
else {
if (finite(b)) {
if (b==0) return DBL_NAN;
- else return copysign(a, copysign(1.0, a)*b);
- }
+ else return copysign(a, copysign(1.0, a)*b);
+ }
else {
return copysign(a, copysign(1.0, a)*copysign(1.0, b));
- }
}
+ }
}
double builtin_ddiv (double a, double b)
return DBL_POSINF;
else if (a < 0)
return DBL_NEGINF;
- }
}
+ }
return DBL_NAN;
}
double builtin_drem (double a, double b)
{
- double d;
-
- if (finite(a) && finite(b)) {
- d = a / b;
- if (finite(d)) {
- if ((d < 1.0) && (d > 0.0))
- return a;
- return fmod(a, b);
- }
- return DBL_NAN;
- }
- if (isnan(b))
- return DBL_NAN;
- if (finite(a))
- return a;
- return DBL_NAN;
+ return fmod(a, b);
}
double builtin_dneg (double a)
if (isnan(a)) return a;
else {
if (finite(a)) return -a;
- else return copysign(a,-copysign(1.0, a));
- }
+ else return copysign(a,-copysign(1.0, a));
+ }
}
s4 builtin_dcmpl (double a, double b)
if (!finite(a) || !finite(b)) {
a = finite(a) ? 0 : copysign(1.0, a);
b = finite(b) ? 0 : copysign(1.0, b);
- }
+ }
if (a>b) return 1;
if (a==b) return 0;
return -1;
if (!finite(a) || !finite(b)) {
a = finite(a) ? 0 : copysign(1.0, a);
b = finite(b) ? 0 : copysign(1.0, b);
- }
+ }
if (a>b) return 1;
if (a==b) return 0;
return -1;
float builtin_i2f (s4 a)
{
-float f = (float) a;
-return f;
+ float f = (float) a;
+ return f;
}
double builtin_i2d (s4 a)
{
-double d = (double) a;
-return d;
+ double d = (double) a;
+ return d;
}
s4 builtin_f2i(float a)
{
-return builtin_d2i((double) a);
+ return builtin_d2i((double) a);
-/* float f;
+ /* float f;
- if (isnanf(a))
+ if (isnanf(a))
return 0;
- if (finitef(a)) {
+ if (finitef(a)) {
if (a > 2147483647)
- return 2147483647;
+ return 2147483647;
if (a < (-2147483648))
- return (-2147483648);
+ return (-2147483648);
return (s4) a;
}
- f = copysignf((float) 1.0, a);
- if (f > 0)
+ f = copysignf((float) 1.0, a);
+ if (f > 0)
return 2147483647;
- return (-2147483648); */
+ return (-2147483648); */
}
s8 builtin_f2l (float a)
{
-return builtin_d2l((double) a);
+ return builtin_d2l((double) a);
-/* float f;
+ /* float f;
- if (finitef(a)) {
+ if (finitef(a)) {
if (a > 9223372036854775807L)
- return 9223372036854775807L;
+ return 9223372036854775807L;
if (a < (-9223372036854775808L))
- return (-9223372036854775808L);
+ return (-9223372036854775808L);
return (s8) a;
}
- if (isnanf(a))
+ if (isnanf(a))
return 0;
- f = copysignf((float) 1.0, a);
- if (f > 0)
+ f = copysignf((float) 1.0, a);
+ if (f > 0)
return 9223372036854775807L;
- return (-9223372036854775808L); */
+ return (-9223372036854775808L); */
}
else {
if (isnanf(a)) return DBL_NAN;
else return copysign(DBL_POSINF, (double) copysignf(1.0, a) );
- }
+ }
}
if (finite(a)) {
if (a >= 2147483647)
return 2147483647;
- if (a <= (-2147483648))
- return (-2147483648);
+ if (a <= (-2147483647-1))
+ return (-2147483647-1);
return (s4) a;
- }
+ }
if (isnan(a))
return 0;
d = copysign(1.0, a);
if (d > 0)
return 2147483647;
- return (-2147483648);
+ return (-2147483647-1);
}
double d;
if (finite(a)) {
- if (a >= 9223372036854775807L)
- return 9223372036854775807L;
- if (a <= (-9223372036854775807L-1))
- return (-9223372036854775807L-1);
+ if (a >= 9223372036854775807LL)
+ return 9223372036854775807LL;
+ if (a <= (-9223372036854775807LL-1))
+ return (-9223372036854775807LL-1);
return (s8) a;
- }
+ }
if (isnan(a))
return 0;
d = copysign(1.0, a);
if (d > 0)
- return 9223372036854775807L;
- return (-9223372036854775807L-1);
+ return 9223372036854775807LL;
+ return (-9223372036854775807LL-1);
}
else {
if (isnan(a)) return FLT_NAN;
else return copysignf (FLT_POSINF, (float) copysign(1.0, a));
- }
+ }
}
projects / cacao.git / blobdiff