Changes: Andreas Krall
Roman Obermaiser
Mark Probst
+ Edwin Steiner
- $Id: loader.c 669 2003-11-23 14:04:20Z edwin $
+ $Id: loader.c 771 2003-12-13 23:11:08Z stefan $
*/
#include <sys/stat.h>
#include "global.h"
#include "loader.h"
+#include "main.h"
#include "native.h"
#include "tables.h"
#include "builtin.h"
#include "toolbox/memory.h"
#include "toolbox/loging.h"
#include "threads/thread.h"
+#include "threads/locks.h"
#include <sys/stat.h>
#ifdef USE_ZLIB
/* global variables ***********************************************************/
-bool opt_rt = false; /* true if RTA parse should be used RT-CO */
-bool opt_xta = false; /* true if XTA parse should be used XTA-CO */
-bool opt_vta = false; /* true if VTA parse should be used VTA-CO */
-
int count_class_infos = 0; /* variables for measurements */
int count_const_pool_len = 0;
int count_vftbl_len = 0;
int count_class_loads = 0;
int count_class_inits = 0;
-bool loadverbose = false; /* switches for debug messages */
-bool linkverbose = false;
-bool initverbose = false;
-
-bool makeinitializations = true;
-
-bool getloadingtime = false; /* to measure the runtime */
-long int loadingtime = 0;
-
static s4 interfaceindex; /* sequential numbering of interfaces */
list unloadedclasses; /* list of all referenced but not loaded classes */
/* utf-symbols for pointer comparison of frequently used strings */
-static utf *utf_innerclasses; /* InnerClasses */
-static utf *utf_constantvalue; /* ConstantValue */
-static utf *utf_code; /* Code */
-static utf *utf_finalize; /* finalize */
-static utf *utf_fidesc; /* ()V changed */
-static utf *utf_clinit; /* <clinit> */
-static utf *utf_initsystemclass; /* initializeSystemClass */
-static utf *utf_systemclass; /* java/lang/System */
-static utf *utf_vmclassloader; /*java/lang/VMClassLoader*/
-static utf *utf_vmclass; /*java/lang/VMClassLoader*/
+static utf *utf_innerclasses; /* InnerClasses */
+static utf *utf_constantvalue; /* ConstantValue */
+static utf *utf_code; /* Code */
+static utf *utf_finalize; /* finalize */
+static utf *utf_fidesc; /* ()V changed */
+static utf *utf_clinit; /* <clinit> */
+static utf *utf_initsystemclass; /* initializeSystemClass */
+static utf *utf_systemclass; /* java/lang/System */
+static utf *utf_vmclassloader; /* java/lang/VMClassLoader */
+static utf *utf_vmclass; /* java/lang/VMClassLoader */
static utf *utf_initialize;
static utf *utf_initializedesc;
+
+#ifdef USE_ZLIB
+static unzFile uf = 0;
+#endif
+
+
utf* clinit_desc(){
return utf_fidesc;
}
utf* clinit_name(){
return utf_clinit;
}
+
+
/* important system classes ***************************************************/
classinfo *class_java_lang_Object;
/* Pseudo classes for the typechecker */
classinfo *pseudo_class_Arraystub = NULL;
classinfo *pseudo_class_Null = NULL;
+classinfo *pseudo_class_New = NULL;
vftbl *pseudo_class_Arraystub_vftbl = NULL;
/* stefan */
static int loader_inited = 0;
+
/******************************************************************************
structure for primitive classes: contains the class for wrapping the
java_objectheader *proto_java_lang_ArrayStoreException;
java_objectheader *proto_java_lang_ThreadDeath;
-
/************* functions for reading classdata *********************************
getting classdata in blocks of variable size
static u1 *classbuf_pos; /* current position in classfile buffer */
static int classbuffer_size; /* size of classfile-data */
+/* assert that at least <len> bytes are left to read */
+/* <len> is limited to the range of non-negative s4 values */
+#define ASSERT_LEFT(len) \
+ do {if ( ((s4)(len)) < 0 \
+ || ((classbuffer + classbuffer_size) - classbuf_pos - 1) < (len)) \
+ panic("Unexpected end of classfile"); } while(0)
+
/* transfer block of classfile data into a buffer */
-#define suck_nbytes(buffer,len) memcpy(buffer,classbuf_pos+1,len); \
- classbuf_pos+=len;
+#define suck_nbytes(buffer,len) \
+ do {ASSERT_LEFT(len); \
+ memcpy(buffer,classbuf_pos+1,len); \
+ classbuf_pos+=len;} while (0)
/* skip block of classfile data */
-#define skip_nbytes(len) classbuf_pos+=len;
+#define skip_nbytes(len) \
+ do {ASSERT_LEFT(len); \
+ classbuf_pos+=len;} while(0)
inline u1 suck_u1()
{
+ ASSERT_LEFT(1);
return *++classbuf_pos;
}
inline u2 suck_u2()
/* get u8 from classfile data */
-
-static u8 suck_u8 ()
+static u8 suck_u8()
{
#if U8_AVAILABLE
- u8 lo,hi;
+ u8 lo, hi;
hi = suck_u4();
lo = suck_u4();
- return (hi<<32) + lo;
+ return (hi << 32) + lo;
#else
u8 v;
v.high = suck_u4();
#endif
}
-/* get float from classfile data */
-static float suck_float ()
+/* get float from classfile data */
+static float suck_float()
{
float f;
#if !WORDS_BIGENDIAN
u1 buffer[4];
u2 i;
- for (i=0; i<4; i++) buffer[3-i] = suck_u1 ();
- memcpy ( (u1*) (&f), buffer, 4);
+ for (i = 0; i < 4; i++) buffer[3 - i] = suck_u1();
+ memcpy((u1*) (&f), buffer, 4);
#else
- suck_nbytes ( (u1*) (&f), 4 );
+ suck_nbytes((u1*) (&f), 4);
#endif
PANICIF (sizeof(float) != 4, "Incompatible float-format");
return f;
}
+
/* get double from classfile data */
-static double suck_double ()
+static double suck_double()
{
double d;
#if !WORDS_BIGENDIAN
u1 buffer[8];
u2 i;
- for (i=0; i<8; i++) buffer[7-i] = suck_u1 ();
- memcpy ( (u1*) (&d), buffer, 8);
+ for (i = 0; i < 8; i++) buffer[7 - i] = suck_u1 ();
+ memcpy((u1*) (&d), buffer, 8);
#else
- suck_nbytes ( (u1*) (&d), 8 );
+ suck_nbytes((u1*) (&d), 8);
#endif
PANICIF (sizeof(double) != 8, "Incompatible double-format" );
return d;
}
+
/************************** function suck_init *********************************
called once at startup, sets the searchpath for the classfiles
*******************************************************************************/
-void suck_init (char *cpath)
+void suck_init(char *cpath)
{
classpath = cpath;
classbuffer = NULL;
*******************************************************************************/
-
-bool suck_start (utf *classname) {
+bool suck_start(utf *classname)
+{
#define MAXFILENAME 1000 /* maximum length of a filename */
/* extract directory from searchpath */
filenamelen = 0;
- while ((*pathpos) && (*pathpos!=':')) {
- PANICIF (filenamelen >= MAXFILENAME, "Filename too long") ;
+ while ((*pathpos) && (*pathpos != ':')) {
+ PANICIF (filenamelen >= MAXFILENAME, "Filename too long");
filename[filenamelen++] = *(pathpos++);
}
- isZip=0;
- if (filenamelen>4) {
- if ( ((filename[filenamelen-1]=='p') || (filename[filenamelen-1]=='P')) &
- ((filename[filenamelen-2]=='i') || (filename[filenamelen-1]=='I')) &
- ((filename[filenamelen-3]=='z') || (filename[filenamelen-1]=='Z')) ) {
- isZip=1;
+ isZip = 0;
+ if (filenamelen > 4) {
+ if ( ((filename[filenamelen - 1] == 'p') || (filename[filenamelen - 1] == 'P')) &
+ ((filename[filenamelen - 2] == 'i') || (filename[filenamelen - 2] == 'I')) &
+ ((filename[filenamelen - 3] == 'z') || (filename[filenamelen - 3] == 'Z')) ) {
+ isZip = 1;
}
}
if (isZip) {
#ifdef USE_ZLIB
-
- unzFile uf;
-
- filename[filenamelen++]='\0';
- uf=unzOpen(filename);
- if (uf!=0) {
+ filename[filenamelen++] = '\0';
+ if (uf == 0) uf = unzOpen(filename);
+ if (uf != 0) {
utf_ptr = classname->text;
- filenamelen=0;
+ filenamelen = 0;
while (utf_ptr < utf_end(classname)) {
PANICIF (filenamelen >= MAXFILENAME, "Filename too long");
c = *utf_ptr++;
c = '?';
filename[filenamelen++] = c;
}
- strcpy (filename+filenamelen, ".class");
- /*log_text(filename);*/
- if (unzLocateFile(uf,filename,1 /*case sensitive*/)==UNZ_OK) {
+ strcpy(filename + filenamelen, ".class");
+ if (cacao_locate(uf,classname) == UNZ_OK) {
unz_file_info file_info;
log_text("Class found in zip file");
- if (unzGetCurrentFileInfo(uf,&file_info,filename,
- sizeof(filename),NULL,0,NULL,0) ==UNZ_OK) {
- if (unzOpenCurrentFile(uf)==UNZ_OK) {
+ if (unzGetCurrentFileInfo(uf, &file_info, filename,
+ sizeof(filename), NULL, 0, NULL, 0) == UNZ_OK) {
+ if (unzOpenCurrentFile(uf) == UNZ_OK) {
classbuffer_size = file_info.uncompressed_size;
classbuffer = MNEW(u1, classbuffer_size);
- classbuf_pos = classbuffer-1;
+ classbuf_pos = classbuffer - 1;
/*printf("classfile size: %d\n",file_info.uncompressed_size);*/
- if (unzReadCurrentFile(uf,classbuffer,classbuffer_size)==classbuffer_size) {
+ if (unzReadCurrentFile(uf, classbuffer, classbuffer_size) == classbuffer_size) {
unzCloseCurrentFile(uf);
return true;
} else {
- MFREE(classbuffer,u1,classbuffer_size);
+ MFREE(classbuffer, u1, classbuffer_size);
log_text("Error while unzipping");
}
} else log_text("Error while opening file in archive");
} else log_text("Error while retrieving fileinfo");
- };
+ }
unzCloseCurrentFile(uf);
}
/* add suffix */
- strcpy (filename+filenamelen, ".class");
+ strcpy(filename + filenamelen, ".class");
classfile = fopen(filename, "r");
if (classfile) { /* file exists */
/* determine size of classfile */
- err = stat (filename, &buffer);
+ /* dolog("File: %s",filename); */
+
+ err = stat(filename, &buffer);
if (!err) { /* read classfile data */
classbuffer_size = buffer.st_size;
classbuffer = MNEW(u1, classbuffer_size);
- classbuf_pos = classbuffer-1;
+ classbuf_pos = classbuffer - 1;
fread(classbuffer, 1, classbuffer_size, classfile);
fclose(classfile);
return true;
}
}
if (verbose) {
- sprintf (logtext, "Warning: Can not open class file '%s'", filename);
- dolog();
+ dolog("Warning: Can not open class file '%s'", filename);
}
return false;
*******************************************************************************/
-void suck_stop () {
-
+void suck_stop()
+{
/* determine amount of classdata not retrieved by suck-operations */
- int classdata_left = ((classbuffer+classbuffer_size)-classbuf_pos-1);
+ int classdata_left = ((classbuffer + classbuffer_size) - classbuf_pos - 1);
- if (classdata_left > 0) {
+ if (classdata_left > 0) {
/* surplus */
- sprintf (logtext,"There are %d access bytes at end of classfile",
- classdata_left);
- dolog();
+ dolog("There are %d access bytes at end of classfile",
+ classdata_left);
+ /* XXX panic? */
}
/* free memory */
classbuffer = NULL;
}
+
/******************************************************************************/
/******************* Some support functions ***********************************/
/******************************************************************************/
static void skipattribute ()
{
+ u4 len;
suck_u2 ();
- skip_nbytes(suck_u4());
+ len = suck_u4();
+ skip_nbytes(len);
}
/********************** Function: skipattributebody ****************************
static void skipattributebody ()
{
- skip_nbytes(suck_u4());
+ u4 len;
+ len = suck_u4();
+ skip_nbytes(len);
}
/************************* Function: skipattributes ****************************
/* check type of constantpool entry */
if (c->cptags[pos] != ctype) {
- sprintf (logtext, "Type mismatch on constant: %d requested, %d here (innerclass_getconstant)",
+ error ("Type mismatch on constant: %d requested, %d here (innerclass_getconstant)",
(int) ctype, (int) c->cptags[pos] );
- error();
}
return c->cpinfos[pos];
static void checkfielddescriptor (char *utf_ptr, char *end_pos)
{
+ class_from_descriptor(utf_ptr,end_pos,NULL,
+ CLASSLOAD_NEW
+ | CLASSLOAD_NULLPRIMITIVE
+ | CLASSLOAD_NOVOID
+ | CLASSLOAD_CHECKEND);
+#if 0
char *tstart; /* pointer to start of classname */
char ch;
char *start = utf_ptr;
/* exceeding characters */
if (utf_ptr!=end_pos) panic ("descriptor has exceeding chars");
+#endif
}
{
char *utf_ptr = d->text; /* current position in utf text */
char *end_pos = utf_end(d); /* points behind utf string */
- char *tstart; /* pointer to start of classname */
- char c,ch;
- char *start;
/* method descriptor must start with parenthesis */
- /* XXX check length */
- if (*utf_ptr++ != '(') panic ("Missing '(' in method descriptor");
+ if (utf_ptr == end_pos || *utf_ptr++ != '(') panic ("Missing '(' in method descriptor");
+
+ /* check arguments */
+ while (utf_ptr != end_pos && *utf_ptr != ')') {
+ class_from_descriptor(utf_ptr,end_pos,&utf_ptr,
+ CLASSLOAD_NEW
+ | CLASSLOAD_NULLPRIMITIVE
+ | CLASSLOAD_NOVOID);
+ }
+
+ if (utf_ptr == end_pos) panic("Missing return type in method descriptor");
+ utf_ptr++; /* skip ')' */
+ class_from_descriptor(utf_ptr,end_pos,NULL,
+ CLASSLOAD_NEW
+ | CLASSLOAD_NULLPRIMITIVE
+ | CLASSLOAD_CHECKEND);
+
+#if 0
/* XXX check length */
/* check arguments */
while ((c = *utf_ptr++) != ')') {
else
/* treat as field-descriptor */
checkfielddescriptor (utf_ptr,end_pos);
+#endif
}
+
/***************** Function: print_arraydescriptor ****************************
Debugging helper for displaying an arraydescriptor
*******************************************************************************/
-void
-print_arraydescriptor(FILE *file,arraydescriptor *desc)
+void print_arraydescriptor(FILE *file, arraydescriptor *desc)
{
if (!desc) {
- fprintf(file,"<NULL>");
+ fprintf(file, "<NULL>");
return;
}
- fprintf(file,"{");
+ fprintf(file, "{");
if (desc->componentvftbl) {
if (desc->componentvftbl->class)
- utf_fprint(file,desc->componentvftbl->class->name);
+ utf_fprint(file, desc->componentvftbl->class->name);
else
- fprintf(file,"<no classinfo>");
+ fprintf(file, "<no classinfo>");
}
else
- fprintf(file,"0");
+ fprintf(file, "0");
- fprintf(file,",");
+ fprintf(file, ",");
if (desc->elementvftbl) {
if (desc->elementvftbl->class)
- utf_fprint(file,desc->elementvftbl->class->name);
+ utf_fprint(file, desc->elementvftbl->class->name);
else
- fprintf(file,"<no classinfo>");
+ fprintf(file, "<no classinfo>");
}
else
- fprintf(file,"0");
- fprintf(file,",%d,%d,%d,%d}",desc->arraytype,desc->dimension,
- desc->dataoffset,desc->componentsize);
+ fprintf(file, "0");
+ fprintf(file, ",%d,%d,%d,%d}", desc->arraytype, desc->dimension,
+ desc->dataoffset, desc->componentsize);
}
+
/******************************************************************************/
/************************** Functions for fields ****************************/
/******************************************************************************/
f -> descriptor = class_getconstant (c, suck_u2(), CONSTANT_Utf8); /* JavaVM descriptor */
f -> type = jtype = desc_to_type (f->descriptor); /* data type */
f -> offset = 0; /* offset from start of object */
+ f -> class = c;
f->xta = NULL;
switch (f->type) {
case TYPE_FLOAT: f->value.f = 0.0; break;
case TYPE_DOUBLE: f->value.d = 0.0; break;
case TYPE_ADDRESS: f->value.a = NULL;
- heap_addreference (&(f->value.a)); /* make global reference (GC) */
+/* heap_addreference (&(f->value.a)); /* make global reference (GC) */
break;
case TYPE_LONG:
#if U8_AVAILABLE
/**************** Function: field_display (debugging only) ********************/
-void field_display (fieldinfo *f)
+void field_display(fieldinfo *f)
{
- printf (" ");
- printflags (f -> flags);
- printf (" ");
- utf_display (f -> name);
- printf (" ");
- utf_display (f -> descriptor);
- printf (" offset: %ld\n", (long int) (f -> offset) );
+ printf(" ");
+ printflags(f->flags);
+ printf(" ");
+ utf_display(f->name);
+ printf(" ");
+ utf_display(f->descriptor);
+ printf(" offset: %ld\n", (long int) (f->offset));
}
*******************************************************************************/
-static void method_load (methodinfo *m, classinfo *c)
+static void method_load(methodinfo *m, classinfo *c)
{
- u4 attrnum,i,e;
+ u4 attrnum, i, e;
#ifdef STATISTICS
count_all_methods++;
#endif
- m -> class = c;
+ m->class = c;
- m -> flags = suck_u2 ();
- m -> name = class_getconstant (c, suck_u2(), CONSTANT_Utf8);
- m -> descriptor = class_getconstant (c, suck_u2(), CONSTANT_Utf8);
+ m->flags = suck_u2();
+ m->name = class_getconstant(c, suck_u2(), CONSTANT_Utf8);
+ m->descriptor = class_getconstant(c, suck_u2(), CONSTANT_Utf8);
+ checkmethoddescriptor(m->descriptor);
- m -> jcode = NULL;
- m -> exceptiontable = NULL;
- m -> entrypoint = NULL;
- m -> mcode = NULL;
- m -> stubroutine = NULL;
- m -> methodUsed = NOTUSED;
- m -> monoPoly = MONO;
- m -> subRedefs = 0;
- m -> subRedefsUsed = 0;
+ m->jcode = NULL;
+ m->exceptiontable = NULL;
+ m->entrypoint = NULL;
+ m->mcode = NULL;
+ m->stubroutine = NULL;
+ m->methodUsed = NOTUSED;
+ m->monoPoly = MONO;
+ m->subRedefs = 0;
+ m->subRedefsUsed = 0;
m->xta = NULL;
- if (! (m->flags & ACC_NATIVE) ) {
- m -> stubroutine = createcompilerstub (m);
- }
- else {
+ if (!(m->flags & ACC_NATIVE)) {
+ m->stubroutine = createcompilerstub(m);
- functionptr f = native_findfunction
- (c->name, m->name, m->descriptor, (m->flags & ACC_STATIC) != 0);
+ } else {
+ functionptr f = native_findfunction(c->name, m->name, m->descriptor,
+ (m->flags & ACC_STATIC) != 0);
if (f) {
- m -> stubroutine = createnativestub (f, m);
- }
+ m->stubroutine = createnativestub(f, m);
}
+ }
attrnum = suck_u2();
- for (i=0; i<attrnum; i++) {
+ for (i = 0; i < attrnum; i++) {
utf *aname;
- aname = class_getconstant (c, suck_u2(), CONSTANT_Utf8);
+ aname = class_getconstant(c, suck_u2(), CONSTANT_Utf8);
- if ( aname != utf_code) {
- skipattributebody ();
- }
- else {
- if (m -> jcode) panic ("Two code-attributes for one method!");
+ if (aname != utf_code) {
+ skipattributebody();
+
+ } else {
+ u4 codelen;
+ if (m->jcode)
+ panic("Two code-attributes for one method!");
suck_u4();
- m -> maxstack = suck_u2();
- m -> maxlocals = suck_u2();
- m -> jcodelength = suck_u4();
- m -> jcode = MNEW (u1, m->jcodelength);
- suck_nbytes (m->jcode, m->jcodelength);
- m -> exceptiontablelength = suck_u2 ();
- m -> exceptiontable =
- MNEW (exceptiontable, m->exceptiontablelength);
+ m->maxstack = suck_u2();
+ m->maxlocals = suck_u2();
+ codelen = suck_u4();
+ if (codelen == 0)
+ panic("bytecode has zero length");
+ if (codelen > 65536)
+ panic("bytecode too long");
+ m->jcodelength = codelen;
+ m->jcode = MNEW(u1, m->jcodelength);
+ suck_nbytes(m->jcode, m->jcodelength);
+ m->exceptiontablelength = suck_u2();
+ m->exceptiontable =
+ MNEW(exceptiontable, m->exceptiontablelength);
#ifdef STATISTICS
- count_vmcode_len += m->jcodelength + 18;
- count_extable_len += 8 * m->exceptiontablelength;
+ count_vmcode_len += m->jcodelength + 18;
+ count_extable_len += 8 * m->exceptiontablelength;
#endif
- for (e=0; e < m->exceptiontablelength; e++) {
+ for (e = 0; e < m->exceptiontablelength; e++) {
u4 idx;
- m -> exceptiontable[e].startpc = suck_u2();
- m -> exceptiontable[e].endpc = suck_u2();
- m -> exceptiontable[e].handlerpc = suck_u2();
+ m->exceptiontable[e].startpc = suck_u2();
+ m->exceptiontable[e].endpc = suck_u2();
+ m->exceptiontable[e].handlerpc = suck_u2();
idx = suck_u2();
- if (!idx) m -> exceptiontable[e].catchtype = NULL;
- else {
- m -> exceptiontable[e].catchtype =
- class_getconstant (c, idx, CONSTANT_Class);
- }
- }
+ if (!idx) {
+ m->exceptiontable[e].catchtype = NULL;
- skipattributes ( suck_u2() );
- }
-
- }
+ } else {
+ m->exceptiontable[e].catchtype =
+ class_getconstant(c, idx, CONSTANT_Class);
+ }
+ }
+ skipattributes(suck_u2());
+ }
+ }
}
+
/********************* Function: method_free ***********************************
frees all memory that was allocated for this method
*******************************************************************************/
-static void method_free (methodinfo *m)
+static void method_free(methodinfo *m)
{
- if (m->jcode) MFREE (m->jcode, u1, m->jcodelength);
- if (m->exceptiontable)
- MFREE (m->exceptiontable, exceptiontable, m->exceptiontablelength);
- if (m->mcode) CFREE (m->mcode, m->mcodelength);
+ if (m->jcode)
+ MFREE(m->jcode, u1, m->jcodelength);
+
+ if (m->exceptiontable)
+ MFREE(m->exceptiontable, exceptiontable, m->exceptiontablelength);
+
+ if (m->mcode)
+ CFREE(m->mcode, m->mcodelength);
+
if (m->stubroutine) {
- if (m->flags & ACC_NATIVE) removenativestub (m->stubroutine);
- else removecompilerstub (m->stubroutine);
+ if (m->flags & ACC_NATIVE) {
+ removenativestub(m->stubroutine);
+
+ } else {
+ removecompilerstub(m->stubroutine);
}
+ }
}
/************** Function: method_display (debugging only) **************/
-void method_display (methodinfo *m)
+void method_display(methodinfo *m)
{
- printf (" ");
- printflags (m -> flags);
- printf (" ");
- utf_display (m -> name);
- printf (" ");
- utf_display (m -> descriptor);
- printf ("\n");
+ printf(" ");
+ printflags(m->flags);
+ printf(" ");
+ utf_display(m->name);
+ printf(" ");
+ utf_display(m->descriptor);
+ printf("\n");
}
*******************************************************************************/
-voidptr class_getconstant (classinfo *c, u4 pos, u4 ctype)
+voidptr class_getconstant(classinfo *c, u4 pos, u4 ctype)
{
/* invalid position in constantpool */
- if (pos >= c->cpcount)
- panic ("Attempt to access constant outside range");
+ if (pos >= c->cpcount)
+ panic("Attempt to access constant outside range");
/* check type of constantpool entry */
if (c->cptags[pos] != ctype) {
class_showconstantpool(c);
- sprintf (logtext, "Type mismatch on constant: %d requested, %d here (class_getconstant)",
- (int) ctype, (int) c->cptags[pos] );
- error();
- }
+ error("Type mismatch on constant: %d requested, %d here (class_getconstant)",
+ (int) ctype, (int) c->cptags[pos]);
+ }
return c->cpinfos[pos];
}
*******************************************************************************/
-u4 class_constanttype (classinfo *c, u4 pos)
+u4 class_constanttype(classinfo *c, u4 pos)
{
- if (pos >= c->cpcount)
- panic ("Attempt to access constant outside range");
+ if (pos >= c->cpcount)
+ panic("Attempt to access constant outside range");
+
return c->cptags[pos];
}
*******************************************************************************/
-static void class_loadcpool (classinfo *c)
+static void class_loadcpool(classinfo *c)
{
/* The following structures are used to save information which cannot be
/* number of bytes in the bytes array (not string-length) */
u4 length = suck_u2();
cptags [idx] = CONSTANT_Utf8;
+ /* validate the string */
+ ASSERT_LEFT(length);
+ if (!is_valid_utf(classbuf_pos+1, classbuf_pos+1+length))
+ panic("Invalid UTF-8 string");
/* insert utf-string into the utf-symboltable */
cpinfos [idx] = utf_new(classbuf_pos+1, length);
/* skip bytes of the string */
}
default:
- sprintf (logtext, "Unkown constant type: %d",(int) t);
- error ();
+ error ("Unkown constant type: %d",(int) t);
} /* end switch */
break;
case CONSTANT_InterfaceMethodref:
case CONSTANT_Methodref: /* check validity of descriptor */
+ /* XXX check special names (<init>) */
checkmethoddescriptor (fmi->descriptor);
break;
}
*******************************************************************************/
-static int class_load (classinfo *c)
+static int class_load(classinfo *c)
{
u4 i;
u4 mi,ma;
/* output for debugging purposes */
if (loadverbose) {
-
- sprintf (logtext, "Loading class: ");
- utf_sprint (logtext+strlen(logtext), c->name );
- dolog();
- }
+ char logtext[MAXLOGTEXT];
+ sprintf(logtext, "Loading class: ");
+ utf_sprint(logtext + strlen(logtext), c->name);
+ log_text(logtext);
+ }
/* load classdata, throw exception on error */
- if (!suck_start (c->name)) {
- throw_classnotfoundexception2(c->name);
+ if (!suck_start(c->name)) {
+ throw_noclassdeffounderror_message(c->name);
return false;
}
mi = suck_u2();
ma = suck_u2();
if (ma != MAJOR_VERSION && (ma != MAJOR_VERSION+1 || mi != 0)) {
- sprintf (logtext, "File version %d.%d is not supported",
- (int) ma, (int) mi);
- error();
- }
+ error("File version %d.%d is not supported", (int) ma, (int) mi);
+ }
- class_loadcpool (c);
+ class_loadcpool(c);
/*JOWENN*/
- c->erroneous_state=0;
- c->initializing_thread=0;
+ c->erroneous_state = 0;
+ c->initializing_thread = 0;
/*JOWENN*/
- c -> classUsed = NOTUSED; /* not used initially CO-RT */
- c -> impldBy = NULL;
+ c->classUsed = NOTUSED; /* not used initially CO-RT */
+ c->impldBy = NULL;
/* ACC flags */
- c -> flags = suck_u2 ();
+ c->flags = suck_u2();
+ /*if (!(c->flags & ACC_PUBLIC)) { log_text("CLASS NOT PUBLIC"); } JOWENN*/
+
/* this class */
- suck_u2 ();
+ suck_u2();
/* retrieve superclass */
- if ( (i = suck_u2 () ) ) {
- c -> super = class_getconstant (c, i, CONSTANT_Class);
- }
- else {
- c -> super = NULL;
- }
+ if ((i = suck_u2())) {
+ c->super = class_getconstant(c, i, CONSTANT_Class);
+
+ } else {
+ c->super = NULL;
+ }
/* retrieve interfaces */
- c -> interfacescount = suck_u2 ();
- c -> interfaces = MNEW (classinfo*, c -> interfacescount);
- for (i=0; i < c -> interfacescount; i++) {
- c -> interfaces [i] =
- class_getconstant (c, suck_u2(), CONSTANT_Class);
- }
+ c->interfacescount = suck_u2();
+ c->interfaces = MNEW(classinfo*, c->interfacescount);
+ for (i = 0; i < c->interfacescount; i++) {
+ c->interfaces [i] =
+ class_getconstant(c, suck_u2(), CONSTANT_Class);
+ }
/* load fields */
- c -> fieldscount = suck_u2 ();
+ c->fieldscount = suck_u2();
/* utf_display(c->name);
printf(" ,Fieldscount: %d\n",c->fieldscount);*/
- c -> fields = GCNEW (fieldinfo, c -> fieldscount);
- for (i=0; i < c -> fieldscount; i++) {
- field_load (&(c->fields[i]), c);
- }
+ c->fields = GCNEW(fieldinfo, c->fieldscount);
+ for (i = 0; i < c->fieldscount; i++) {
+ field_load(&(c->fields[i]), c);
+ }
/* load methods */
- c -> methodscount = suck_u2 ();
- c -> methods = MNEW (methodinfo, c -> methodscount);
- for (i=0; i < c -> methodscount; i++) {
- method_load (&(c -> methods [i]), c);
- }
+ c->methodscount = suck_u2();
+ c->methods = MNEW(methodinfo, c->methodscount);
+ for (i = 0; i < c->methodscount; i++) {
+ method_load(&(c->methods[i]), c);
+ }
#ifdef STATISTICS
- count_class_infos += sizeof(classinfo*) * c -> interfacescount;
- count_class_infos += sizeof(fieldinfo) * c -> fieldscount;
- count_class_infos += sizeof(methodinfo) * c -> methodscount;
+ count_class_infos += sizeof(classinfo*) * c->interfacescount;
+ count_class_infos += sizeof(fieldinfo) * c->fieldscount;
+ count_class_infos += sizeof(methodinfo) * c->methodscount;
#endif
/* load variable-length attribute structures */
- attribute_load (suck_u2(), c);
+ attribute_load(suck_u2(), c);
/* free memory */
- suck_stop ();
+ suck_stop();
/* remove class from list of unloaded classes and
add to list of unlinked classes */
- list_remove (&unloadedclasses, c);
- list_addlast (&unlinkedclasses, c);
+ list_remove(&unloadedclasses, c);
+ list_addlast(&unlinkedclasses, c);
+
+ c->loaded = true;
return true;
}
*******************************************************************************/
-static s4 class_highestinterface (classinfo *c)
+static s4 class_highestinterface(classinfo *c)
{
s4 h;
s4 i;
- if ( ! (c->flags & ACC_INTERFACE) ) {
- sprintf (logtext, "Interface-methods count requested for non-interface: ");
- utf_sprint (logtext+strlen(logtext), c->name);
- error();
- }
+ if (!(c->flags & ACC_INTERFACE)) {
+ char logtext[MAXLOGTEXT];
+ sprintf(logtext, "Interface-methods count requested for non-interface: ");
+ utf_sprint(logtext + strlen(logtext), c->name);
+ error(logtext);
+ }
h = c->index;
- for (i=0; i<c->interfacescount; i++) {
- s4 h2 = class_highestinterface (c->interfaces[i]);
- if (h2>h) h=h2;
- }
+ for (i = 0; i < c->interfacescount; i++) {
+ s4 h2 = class_highestinterface(c->interfaces[i]);
+ if (h2 > h) h = h2;
+ }
+
return h;
}
*******************************************************************************/
-void
-class_new_array(classinfo *c)
+void class_new_array(classinfo *c)
{
classinfo *comp = NULL;
methodinfo *clone;
int namelen;
+ /* XXX remove */ /* dolog("class_new_array: %s",c->name->text); */
+
/* Array classes are not loaded from classfiles. */
list_remove (&unloadedclasses, c);
/* Check array class name */
namelen = c->name->blength;
if (namelen < 2 || c->name->text[0] != '[')
- panic("Invalid array class name.");
+ panic("Invalid array class name");
/* Check the component type */
switch (c->name->text[1]) {
case 'L':
/* c is an array of objects. */
if (namelen < 4 || c->name->text[namelen-1] != ';')
- panic("Invalid array class name.");
+ panic("Invalid array class name");
comp = class_new(utf_new(c->name->text + 2,namelen - 3));
break;
}
/* Setup the array class */
c->super = class_java_lang_Object;
+ c->flags = ACC_PUBLIC | ACC_FINAL | ACC_ABSTRACT;
c->interfacescount = 2;
- c->interfaces = MNEW(classinfo*,2);
+ c->interfaces = MNEW(classinfo*,2); /* XXX use GC? */
c->interfaces[0] = class_java_lang_Cloneable;
c->interfaces[1] = class_java_io_Serializable;
c->methodscount = 1;
- c->methods = MNEW (methodinfo, c->methodscount);
+ c->methods = MNEW (methodinfo, c->methodscount); /* XXX use GC? */
clone = c->methods;
- memset(clone,0,sizeof(methodinfo));
+ memset(clone, 0, sizeof(methodinfo));
clone->flags = ACC_PUBLIC; /* XXX protected? */
clone->name = utf_new_char("clone");
clone->descriptor = utf_new_char("()Ljava/lang/Object;");
clone->class = c;
- clone->stubroutine = createnativestub(&builtin_clone_array,clone);
+ clone->stubroutine = createnativestub((functionptr) &builtin_clone_array, clone);
clone->monoPoly = MONO; /* XXX should be poly? */
/* XXX: field: length? */
* Array classes which are created after the other classes have been
* loaded and linked are linked explicitely.
*/
+ c->loaded=true;
+
if (loader_inited)
- loader_load(c->name);
+ loader_load(c->name); /* XXX handle errors */
}
+
/****************** Function: class_link_array *********************************
This function is called by class_link to create the
*******************************************************************************/
-static
-arraydescriptor *
-class_link_array(classinfo *c)
+static arraydescriptor *class_link_array(classinfo *c)
{
classinfo *comp = NULL;
int namelen = c->name->blength;
if (compvftbl->arraydesc) {
desc->elementvftbl = compvftbl->arraydesc->elementvftbl;
desc->dimension = compvftbl->arraydesc->dimension + 1;
+ desc->elementtype = compvftbl->arraydesc->elementtype;
}
else {
desc->elementvftbl = compvftbl;
desc->dimension = 1;
+ desc->elementtype = ARRAYTYPE_OBJECT;
}
}
else {
desc->componentvftbl = NULL;
desc->elementvftbl = NULL;
desc->dimension = 1;
+ desc->elementtype = desc->arraytype;
}
return desc;
}
+
/********************** Function: class_link ***********************************
Tries to link a class. The super class and every implemented interface must
vftbllength = supervftbllength = 0;
c->finalizer = NULL;
- }
- else {
+
+ } else {
if (!super->linked) {
list_remove(&unlinkedclasses, c);
list_addlast(&unlinkedclasses, c);
if (linkverbose) {
- sprintf (logtext, "Linking Class: ");
- utf_sprint (logtext+strlen(logtext), c->name );
- dolog ();
+ char logtext[MAXLOGTEXT];
+ sprintf(logtext, "Linking Class: ");
+ utf_sprint(logtext + strlen(logtext), c->name );
+ log_text(logtext);
}
/* compute vftbl length */
}
#ifdef STATISTICS
- count_vftbl_len += sizeof(vftbl) + sizeof(methodptr)*(vftbllength-1);
+ count_vftbl_len += sizeof(vftbl) + (sizeof(methodptr) * (vftbllength - 1));
#endif
/* compute interfacetable length */
fieldinfo *f = &(c->fields[i]);
if (!(f->flags & ACC_STATIC) ) {
- dsize = desc_typesize (f->descriptor);
- c->instancesize = ALIGN (c->instancesize, dsize);
+ dsize = desc_typesize(f->descriptor);
+ c->instancesize = ALIGN(c->instancesize, dsize);
f->offset = c->instancesize;
c->instancesize += dsize;
}
/* initialize interfacetable and interfacevftbllength */
- v->interfacevftbllength = MNEW (s4, interfacetablelength);
+ v->interfacevftbllength = MNEW(s4, interfacetablelength);
#ifdef STATISTICS
count_vftbl_len += (4 + sizeof(s4)) * v->interfacetablelength;
for (c2 = c; c2 != NULL; c2 = c2->super)
for (i = 0; i < c2->interfacescount; i++) {
- class_addinterface (c, c2->interfaces[i]);
+ class_addinterface(c, c2->interfaces[i]);
}
/* add finalizer method (not for java.lang.Object) */
if (fidesc == NULL)
fidesc = utf_fidesc;
- fi = class_findmethod (c, finame, fidesc);
+ fi = class_findmethod(c, finame, fidesc);
if (fi != NULL) {
if (!(fi->flags & ACC_STATIC)) {
c->finalizer = fi;
c->linked = true;
- list_remove (&unlinkedclasses, c);
- list_addlast (&linkedclasses, c);
-
+ list_remove(&unlinkedclasses, c);
+ list_addlast(&linkedclasses, c);
}
*******************************************************************************/
-static void class_free (classinfo *c)
+static void class_free(classinfo *c)
{
s4 i;
vftbl *v;
- class_freecpool (c);
+ class_freecpool(c);
- MFREE (c->interfaces, classinfo*, c->interfacescount);
+ MFREE(c->interfaces, classinfo*, c->interfacescount);
for (i = 0; i < c->fieldscount; i++)
field_free(&(c->fields[i]));
for (i = 0; i < c->methodscount; i++)
method_free(&(c->methods[i]));
- MFREE (c->methods, methodinfo, c->methodscount);
+ MFREE(c->methods, methodinfo, c->methodscount);
if ((v = c->vftbl) != NULL) {
if (v->arraydesc)
mem_free(v->arraydesc,sizeof(arraydescriptor));
for (i = 0; i < v->interfacetablelength; i++) {
- MFREE (v->interfacetable[-i], methodptr, v->interfacevftbllength[i]);
- }
- MFREE (v->interfacevftbllength, s4, v->interfacetablelength);
+ MFREE(v->interfacetable[-i], methodptr, v->interfacevftbllength[i]);
+ }
+ MFREE(v->interfacevftbllength, s4, v->interfacetablelength);
i = sizeof(vftbl) + sizeof(methodptr) * (v->vftbllength - 1) +
sizeof(methodptr*) * (v->interfacetablelength -
(v->interfacetablelength > 0));
v = (vftbl*) (((methodptr*) v) - (v->interfacetablelength - 1) *
(v->interfacetablelength > 1));
- mem_free (v, i);
- }
+ mem_free(v, i);
+ }
if (c->innerclasscount)
- MFREE (c->innerclass, innerclassinfo, c->innerclasscount);
+ MFREE(c->innerclass, innerclassinfo, c->innerclasscount);
/* if (c->classvftbl)
mem_free(c->header.vftbl, sizeof(vftbl) + sizeof(methodptr)*(c->vftbl->vftbllength-1)); */
- FREE (c, classinfo);
+ GCFREE(c);
}
+
/************************* Function: class_findfield ***************************
Searches a 'classinfo' structure for a field having the given name and
*******************************************************************************/
-
-fieldinfo *class_findfield (classinfo *c, utf *name, utf *desc)
+fieldinfo *class_findfield(classinfo *c, utf *name, utf *desc)
{
s4 i;
-
for (i = 0; i < c->fieldscount; i++) {
if ((c->fields[i].name == name) && (c->fields[i].descriptor == desc))
return &(c->fields[i]);
}
- panic ("Can not find field given in CONSTANT_Fieldref");
+ panic("Can not find field given in CONSTANT_Fieldref");
+
+ /* keep compiler happy */
return NULL;
}
*******************************************************************************/
-s4 class_findmethodIndex (classinfo *c, utf *name, utf *desc)
+s4 class_findmethodIndex(classinfo *c, utf *name, utf *desc)
{
s4 i;
#if defined(JOWENN_DEBUG1) || defined(JOWENN_DEBUG2)
#ifdef JOWENN_DEBUG1
buffer_len =
- utf_strlen(name) + utf_strlen(desc) +utf_strlen(c->name)+ 64;
+ utf_strlen(name) + utf_strlen(desc) + utf_strlen(c->name) + 64;
buffer = MNEW(char, buffer_len);
strcpy(buffer, "class_findmethod: method:");
- utf_sprint(buffer+strlen(buffer), name);
- strcpy(buffer+strlen(buffer), ", desc: ");
- utf_sprint(buffer+strlen(buffer), desc);
- strcpy(buffer+strlen(buffer), ", classname: ");
- utf_sprint(buffer+strlen(buffer), c->name);
+ utf_sprint(buffer + strlen(buffer), name);
+ strcpy(buffer + strlen(buffer), ", desc: ");
+ utf_sprint(buffer + strlen(buffer), desc);
+ strcpy(buffer + strlen(buffer), ", classname: ");
+ utf_sprint(buffer + strlen(buffer), c->name);
log_text(buffer);
for (i = 0; i < c->methodscount; i++) {
#ifdef JOWENN_DEBUG2
buffer_len =
- utf_strlen(c->methods[i].name) + utf_strlen(c->methods[i].descriptor)+ 64;
+ utf_strlen(c->methods[i].name) + utf_strlen(c->methods[i].descriptor)+ 64;
buffer = MNEW(char, buffer_len);
strcpy(buffer, "class_findmethod: comparing to method:");
- utf_sprint(buffer+strlen(buffer), c->methods[i].name);
- strcpy(buffer+strlen(buffer), ", desc: ");
- utf_sprint(buffer+strlen(buffer), c->methods[i].descriptor);
+ utf_sprint(buffer + strlen(buffer), c->methods[i].name);
+ strcpy(buffer + strlen(buffer), ", desc: ");
+ utf_sprint(buffer + strlen(buffer), c->methods[i].descriptor);
log_text(buffer);
MFREE(buffer, char, buffer_len);
- #endif
+#endif
if ((c->methods[i].name == name) && ((desc == NULL) ||
- (c->methods[i].descriptor == desc)))
+ (c->methods[i].descriptor == desc))) {
return i;
}
+ }
+
#ifdef JOWENN_DEBUG2
class_showconstantpool(c);
log_text("class_findmethod: returning NULL");
#endif
+
return -1;
}
-
/************************* Function: class_findmethod **************************
Searches a 'classinfo' structure for a method having the given name and
*******************************************************************************/
-methodinfo *class_findmethod (classinfo *c, utf *name, utf *desc)
+methodinfo *class_findmethod(classinfo *c, utf *name, utf *desc)
{
#if 0
s4 i;
#ifdef JOWENN_DEBUG1
buffer_len =
- utf_strlen(name) + utf_strlen(desc) +utf_strlen(c->name)+ 64;
+ utf_strlen(name) + utf_strlen(desc) + utf_strlen(c->name) + 64;
buffer = MNEW(char, buffer_len);
strcpy(buffer, "class_findmethod: method:");
- utf_sprint(buffer+strlen(buffer), name);
- strcpy(buffer+strlen(buffer), ", desc: ");
- utf_sprint(buffer+strlen(buffer), desc);
- strcpy(buffer+strlen(buffer), ", classname: ");
- utf_sprint(buffer+strlen(buffer), c->name);
+ utf_sprint(buffer + strlen(buffer), name);
+ strcpy(buffer + strlen(buffer), ", desc: ");
+ utf_sprint(buffer + strlen(buffer), desc);
+ strcpy(buffer + strlen(buffer), ", classname: ");
+ utf_sprint(buffer + strlen(buffer), c->name);
log_text(buffer);
for (i = 0; i < c->methodscount; i++) {
#ifdef JOWENN_DEBUG2
buffer_len =
- utf_strlen(c->methods[i].name) + utf_strlen(c->methods[i].descriptor)+ 64;
+ utf_strlen(c->methods[i].name) + utf_strlen(c->methods[i].descriptor)+ 64;
buffer = MNEW(char, buffer_len);
strcpy(buffer, "class_findmethod: comparing to method:");
- utf_sprint(buffer+strlen(buffer), c->methods[i].name);
- strcpy(buffer+strlen(buffer), ", desc: ");
- utf_sprint(buffer+strlen(buffer), c->methods[i].descriptor);
+ utf_sprint(buffer + strlen(buffer), c->methods[i].name);
+ strcpy(buffer + strlen(buffer), ", desc: ");
+ utf_sprint(buffer + strlen(buffer), c->methods[i].descriptor);
log_text(buffer);
MFREE(buffer, char, buffer_len);
- #endif
-
+#endif
if ((c->methods[i].name == name) && ((desc == NULL) ||
- (c->methods[i].descriptor == desc)))
+ (c->methods[i].descriptor == desc))) {
return &(c->methods[i]);
}
+ }
#ifdef JOWENN_DEBUG2
class_showconstantpool(c);
log_text("class_findmethod: returning NULL");
#endif
return NULL;
#endif
- s4 idx=class_findmethodIndex(c,name,desc);
+
+ s4 idx=class_findmethodIndex(c, name, desc);
/* if (idx==-1) log_text("class_findmethod: method not found");*/
- if (idx==-1) return NULL;
+ if (idx == -1) return NULL;
+
return &(c->methods[idx]);
}
+/*********************** Function: class_fetchmethod **************************
+
+ like class_findmethod, but aborts with an error if the method is not found
+*******************************************************************************/
+methodinfo *class_fetchmethod(classinfo *c, utf *name, utf *desc)
+{
+ methodinfo *mi;
+ mi = class_findmethod(c, name, desc);
+
+ if (!mi) {
+ log_plain("Class: "); if (c) log_plain_utf(c->name); log_nl();
+ log_plain("Method: "); if (name) log_plain_utf(name); log_nl();
+ log_plain("Descriptor: "); if (desc) log_plain_utf(desc); log_nl();
+ panic("Method not found");
+ }
+
+ return mi;
+}
/************************* Function: class_findmethod_approx ******************
*******************************************************************************/
-methodinfo *class_findmethod_approx (classinfo *c, utf *name, utf *desc)
+methodinfo *class_findmethod_approx(classinfo *c, utf *name, utf *desc)
{
s4 i;
- for (i = 0; i < c->methodscount; i++)
+ for (i = 0; i < c->methodscount; i++) {
if (c->methods[i].name == name) {
utf *meth_descr = c->methods[i].descriptor;
return &(c->methods[i]);
if (desc->blength <= meth_descr->blength) {
- /* current position in utf text */
- char *desc_utf_ptr = desc->text;
- char *meth_utf_ptr = meth_descr->text;
- /* points behind utf strings */
- char *desc_end = utf_end(desc);
- char *meth_end = utf_end(meth_descr);
- char ch;
-
- /* compare argument types */
- while (desc_utf_ptr<desc_end && meth_utf_ptr<meth_end) {
-
- if ((ch=*desc_utf_ptr++) != (*meth_utf_ptr++))
- break; /* no match */
-
- if (ch==')')
- return &(c->methods[i]); /* all parameter types equal */
- }
+ /* current position in utf text */
+ char *desc_utf_ptr = desc->text;
+ char *meth_utf_ptr = meth_descr->text;
+ /* points behind utf strings */
+ char *desc_end = utf_end(desc);
+ char *meth_end = utf_end(meth_descr);
+ char ch;
+
+ /* compare argument types */
+ while (desc_utf_ptr < desc_end && meth_utf_ptr < meth_end) {
+
+ if ((ch = *desc_utf_ptr++) != (*meth_utf_ptr++))
+ break; /* no match */
+
+ if (ch == ')')
+ return &(c->methods[i]); /* all parameter types equal */
+ }
}
}
+ }
return NULL;
}
+
/***************** Function: class_resolvemethod_approx ***********************
Searches a class and every super class for a method (without paying
*******************************************************************************/
-methodinfo *class_resolvemethod_approx (classinfo *c, utf *name, utf *desc)
+methodinfo *class_resolvemethod_approx(classinfo *c, utf *name, utf *desc)
{
while (c) {
/* search for method (ignore returntype) */
- methodinfo *m = class_findmethod_approx (c, name, desc);
+ methodinfo *m = class_findmethod_approx(c, name, desc);
/* method found */
if (m) return m;
/* search superclass */
c = c->super;
- }
+ }
+
return NULL;
}
*******************************************************************************/
-methodinfo *class_resolvemethod (classinfo *c, utf *name, utf *desc)
+methodinfo *class_resolvemethod(classinfo *c, utf *name, utf *desc)
{
while (c) {
methodinfo *m = class_findmethod(c, name, desc);
/* search superclass */
c = c->super;
}
+
return NULL;
}
-
/************************* Function: class_issubclass **************************
Checks if sub is a descendant of super.
{
for (;;) {
if (!sub) return false;
- if (sub==super) return true;
- sub = sub -> super;
+ if (sub == super) return true;
+ sub = sub->super;
}
}
-
/****************** Initialization function for classes ******************
In Java, every class can have a static initialization function. This
*******************************************************************************/
-#ifdef USE_THREADS
-extern int blockInts;
-#endif
-
void class_init(classinfo *c)
{
- methodinfo *m;
- java_objectheader *exceptionptr;
- s4 i;
- int b;
-
-
- if (!makeinitializations)
- return;
- if (c->initialized)
- return;
- c -> initialized = true;
+ methodinfo *m;
+ s4 i;
+#ifdef USE_THREADS
+ int b;
+#endif
+ if (!makeinitializations)
+ return;
+ if (c->initialized)
+ return;
+ c->initialized = true;
#ifdef STATISTICS
- count_class_inits++;
+ count_class_inits++;
#endif
- if (c->super)
- class_init (c->super);
- for (i=0; i < c->interfacescount; i++)
- class_init(c->interfaces[i]); /* real */
-
- m = class_findmethod (c, utf_clinit, utf_fidesc);
- if (!m) {
- if (initverbose) {
- sprintf (logtext, "Class ");
- utf_sprint (logtext+strlen(logtext), c->name);
- sprintf (logtext+strlen(logtext), " has no initializer");
- dolog ();
- }
-/* goto callinitialize;*/
- return;
- }
-
- if (! (m->flags & ACC_STATIC))
- panic ("Class initializer is not static!");
-
- if (initverbose) {
- sprintf (logtext, "Starting initializer for class: ");
- utf_sprint (logtext+strlen(logtext), c->name);
- dolog ();
- }
+ if (c->super)
+ class_init (c->super);
+ for (i = 0; i < c->interfacescount; i++)
+ class_init(c->interfaces[i]); /* real */
+
+ m = class_findmethod(c, utf_clinit, utf_fidesc);
+ if (!m) {
+ if (initverbose) {
+ char logtext[MAXLOGTEXT];
+ sprintf(logtext, "Class ");
+ utf_sprint(logtext + strlen(logtext), c->name);
+ sprintf(logtext + strlen(logtext), " has no initializer");
+ log_text(logtext);
+ }
+ /* goto callinitialize;*/
+ return;
+ }
+
+ if (!(m->flags & ACC_STATIC))
+ panic("Class initializer is not static!");
+
+ if (initverbose) {
+ char logtext[MAXLOGTEXT];
+ sprintf(logtext, "Starting initializer for class: ");
+ utf_sprint(logtext + strlen(logtext), c->name);
+ log_text(logtext);
+ }
#ifdef USE_THREADS
- b = blockInts;
- blockInts = 0;
+ b = blockInts;
+ blockInts = 0;
#endif
- exceptionptr = asm_calljavamethod(m, NULL, NULL, NULL, NULL);
+ asm_calljavafunction(m, NULL, NULL, NULL, NULL);
#ifdef USE_THREADS
- assert(blockInts == 0);
- blockInts = b;
+ assert(blockInts == 0);
+ blockInts = b;
#endif
- if (exceptionptr) {
- printf ("#### Initializer of ");
- utf_display (c->name);
- printf (" has thrown: ");
- utf_display (exceptionptr->vftbl->class->name);
- printf ("\n");
- fflush (stdout);
- }
-
- if (initverbose) {
- sprintf (logtext, "Finished initializer for class: ");
- utf_sprint (logtext+strlen(logtext), c->name);
- dolog ();
- }
- if (c->name == utf_systemclass) {
- /* class java.lang.System requires explicit initialization */
-
- if (initverbose)
- printf ("#### Initializing class System");
-
- /* find initializing method */
- m = class_findmethod (c,
- utf_initsystemclass,
- utf_fidesc);
+ if (exceptionptr) {
+ printf("#### Initializer of ");
+ utf_display(c->name);
+ printf(" has thrown: ");
+ utf_display(exceptionptr->vftbl->class->name);
+ printf("\n");
+ fflush(stdout);
+ }
- if (!m) {
- /* no method found */
- /* printf("initializeSystemClass failed"); */
- return;
- }
- #ifdef USE_THREADS
- b = blockInts;
- blockInts = 0;
- #endif
+ if (initverbose) {
+ char logtext[MAXLOGTEXT];
+ sprintf(logtext, "Finished initializer for class: ");
+ utf_sprint(logtext + strlen(logtext), c->name);
+ log_text(logtext);
+ }
+ if (c->name == utf_systemclass) {
+ /* class java.lang.System requires explicit initialization */
- exceptionptr = asm_calljavamethod (m, NULL,NULL,NULL,NULL);
+ if (initverbose)
+ printf("#### Initializing class System");
- #ifdef USE_THREADS
- assert(blockInts == 0);
- blockInts = b;
- #endif
+ /* find initializing method */
+ m = class_findmethod(c,
+ utf_initsystemclass,
+ utf_fidesc);
+
+ if (!m) {
+ /* no method found */
+ /* printf("initializeSystemClass failed"); */
+ return;
+ }
- if (exceptionptr) {
- printf ("#### initializeSystemClass has thrown: ");
- utf_display (exceptionptr->vftbl->class->name);
- printf ("\n");
- fflush (stdout);
- }
- }
+#ifdef USE_THREADS
+ b = blockInts;
+ blockInts = 0;
+#endif
-}
+ asm_calljavafunction(m, NULL, NULL, NULL, NULL);
+#ifdef USE_THREADS
+ assert(blockInts == 0);
+ blockInts = b;
+#endif
+ if (exceptionptr) {
+ printf("#### initializeSystemClass has thrown: ");
+ utf_display(exceptionptr->vftbl->class->name);
+ printf("\n");
+ fflush(stdout);
+ }
+ }
+}
/********* Function: find_class_method_constant *********/
+
int find_class_method_constant (classinfo *c, utf * c1, utf* m1, utf* d1)
{
u4 i;
static int loader_load_running = 0;
-classinfo *loader_load (utf *topname)
+classinfo *loader_load(utf *topname)
{
classinfo *top;
classinfo *c;
- long int starttime=0,stoptime=0;
+ s8 starttime = 0;
+ s8 stoptime = 0;
+ classinfo *notlinkable;
+
+#if defined(USE_THREADS) && defined(NATIVE_THREADS)
+ pthread_mutex_lock(&compiler_mutex);
+#endif
/* avoid recursive calls */
if (loader_load_running)
return class_new(topname);
+
loader_load_running++;
- intsDisable(); /* schani */
+ intsDisable();
if (getloadingtime)
starttime = getcputime();
- top = class_new (topname);
+ top = class_new(topname);
/* load classes */
- while ( (c = list_first(&unloadedclasses)) ) {
- if (!class_load (c)) {
- list_remove (&unloadedclasses, c);
- top=NULL;
- }
- }
+ while ((c = list_first(&unloadedclasses))) {
+ if (!class_load(c)) {
+ if (linkverbose)
+ dolog("Failed to load class");
+ list_remove(&unloadedclasses, c);
+ top = NULL;
+ }
+ }
/* link classes */
- while ( (c = list_first(&unlinkedclasses)) ) {
- class_link (c);
- }
+ if (linkverbose)
+ dolog("Linking...");
+
+ /* XXX added a hack to break infinite linking loops. A better
+ * linking algorithm would be nice. -Edwin */
+ notlinkable = NULL;
+ while ((c = list_first(&unlinkedclasses))) {
+ class_link(c);
+ if (!c->linked) {
+ if (!notlinkable)
+ notlinkable = c;
+ else if (notlinkable == c) {
+ /* We tried to link this class for the second time and
+ * no other classes were linked in between, so we are
+ * caught in a loop.
+ */
+ if (linkverbose)
+ dolog("Cannot resolve linking dependencies");
+ top = NULL;
+ if (!exceptionptr)
+ throw_linkageerror_message(c->name);
+ break;
+ }
+
+ } else
+ notlinkable = NULL;
+ }
+ if (linkverbose)
+ dolog("Linking done.");
if (loader_inited)
loader_compute_subclasses();
/* measure time */
if (getloadingtime) {
stoptime = getcputime();
- loadingtime += (stoptime-starttime);
- }
+ loadingtime += (stoptime - starttime);
+ }
- intsRestore(); /* schani */
loader_load_running--;
+ /* check if a former loader_load call tried to load/link the class and
+ failed. This is needed because the class didn't appear in the
+ undloadclasses or unlinkedclasses list during this class. */
+ if (top) {
+ if (!top->loaded) {
+ if (linkverbose) dolog("Failed to load class (former call)");
+ throw_noclassdeffounderror_message(top->name);
+ top = NULL;
+
+ } else if (!top->linked) {
+ if (linkverbose)
+ dolog("Failed to link class (former call)");
+ throw_linkageerror_message(top->name);
+ top = NULL;
+ }
+ }
+
+ intsRestore();
+
+#if defined(USE_THREADS) && defined(NATIVE_THREADS)
+ pthread_mutex_unlock(&compiler_mutex);
+#endif
+
+ /* XXX DEBUG */ if (linkverbose && !top) dolog("returning NULL from loader_load");
+
return top;
}
+/****************** Function: loader_load_sysclass ****************************
+
+ Loads and links the class desired class and each class and interface
+ referenced by it.
+
+ The pointer to the classinfo is stored in *top if top != NULL.
+ The pointer is also returned.
+
+ If the class could not be loaded the function aborts with an error.
+
+*******************************************************************************/
+
+classinfo *loader_load_sysclass(classinfo **top,utf *topname)
+{
+ classinfo *cls;
+
+ if ((cls = loader_load(topname)) == NULL) {
+ log_plain("Could not important system class: ");
+ log_plain_utf(topname);
+ log_nl();
+ panic("Could not load important system class");
+ }
+
+ if (top) *top = cls;
+
+ return cls;
+}
/**************** function: create_primitive_classes ***************************
classinfo *c = class_new ( utf_new_char(primitivetype_table[i].name) );
c -> classUsed = NOTUSED; /* not used initially CO-RT */
c -> impldBy = NULL;
-
+
/* prevent loader from loading primitive class */
list_remove (&unloadedclasses, c);
+ c->loaded=true;
/* add to unlinked classes */
list_addlast (&unlinkedclasses, c);
- c -> super = class_java_lang_Object;
+/*JOWENN primitive types don't have objects as super class c -> super = class_java_lang_Object; */
class_link (c);
primitivetype_table[i].class_primitive = c;
if (primitivetype_table[i].arrayname) {
c = class_new( utf_new_char(primitivetype_table[i].arrayname) );
primitivetype_table[i].arrayclass = c;
+ c->loaded=true;
if (!c->linked) class_link(c);
primitivetype_table[i].arrayvftbl = c->vftbl;
}
utf_ptr....first character of descriptor
end_ptr....first character after the end of the string
next.......if non-NULL, *next is set to the first character after
- the descriptor
- mode.......what to do if a class descriptor is parsed successfully:
+ the descriptor. (Undefined if an error occurs.)
+
+ mode.......a combination (binary or) of the following flags:
+
+ (Flags marked with * are the default settings.)
+
+ What to do if a reference type descriptor is parsed successfully:
+
CLASSLOAD_SKIP...skip it and return something != NULL
- CLASSLOAD_NEW....get classinfo * via class_new
+ * CLASSLOAD_NEW....get classinfo * via class_new
CLASSLOAD_LOAD...get classinfo * via loader_load
- If the descriptor is invalid the return value is NULL
+ How to handle primitive types:
+
+ * CLASSLOAD_PRIMITIVE.......return primitive class (eg. "int")
+ CLASSLOAD_NULLPRIMITIVE...return NULL for primitive types
+
+ How to handle "V" descriptors:
+
+ * CLASSLOAD_VOID.....handle it like other primitive types
+ CLASSLOAD_NOVOID...treat it as an error
+
+ How to deal with extra characters after the end of the
+ descriptor:
+
+ * CLASSLOAD_NOCHECKEND...ignore (useful for parameter lists)
+ CLASSLOAD_CHECKEND.....treat them as an error
+
+ How to deal with errors:
+
+ * CLASSLOAD_PANIC....abort execution with an error message
+ CLASSLOAD_NOPANIC..return NULL on error
********************************************************************************/
-classinfo *class_from_descriptor(char *utf_ptr,char *end_ptr,char **next,int mode)
+classinfo *class_from_descriptor(char *utf_ptr, char *end_ptr,
+ char **next, int mode)
{
char *start = utf_ptr;
bool error = false;
utf *name;
-
+
SKIP_FIELDDESCRIPTOR_SAFE(utf_ptr,end_ptr,error);
- if (error) return NULL;
- if (next) *next = utf_ptr;
- switch (*start) {
- case 'L':
- start++;
- utf_ptr--;
- /* fallthrough */
- case '[':
- if (mode == CLASSLOAD_SKIP) return class_java_lang_Object;
- name = utf_new(start,utf_ptr-start);
- return (mode == CLASSLOAD_LOAD) ? loader_load(name) : class_new(name);
- default:
- return class_primitive_from_sig(*start);
+ if (mode & CLASSLOAD_CHECKEND)
+ error |= (utf_ptr != end_ptr);
+
+ if (!error) {
+ if (next) *next = utf_ptr;
+
+ switch (*start) {
+ case 'V':
+ if (mode & CLASSLOAD_NOVOID)
+ break;
+ /* FALLTHROUGH! */
+ case 'I':
+ case 'J':
+ case 'F':
+ case 'D':
+ case 'B':
+ case 'C':
+ case 'S':
+ case 'Z':
+ return (mode & CLASSLOAD_NULLPRIMITIVE)
+ ? NULL
+ : class_primitive_from_sig(*start);
+
+ case 'L':
+ start++;
+ utf_ptr--;
+ /* FALLTHROUGH! */
+ case '[':
+ if (mode & CLASSLOAD_SKIP) return class_java_lang_Object;
+ name = utf_new(start,utf_ptr-start);
+ return (mode & CLASSLOAD_LOAD)
+ ? loader_load(name) : class_new(name); /* XXX */
+ }
+ }
+
+ /* An error occurred */
+ if (mode & CLASSLOAD_NOPANIC)
+ return NULL;
+
+ log_plain("Invalid descriptor at beginning of '");
+ log_plain_utf(utf_new(start, end_ptr-start));
+ log_plain("'");
+ log_nl();
+
+ panic("Invalid descriptor");
+
+ /* keep compiler happy */
+ return NULL;
+}
+
+
+/******************* function: type_from_descriptor ****************************
+
+ return the basic type indicated by the given descriptor
+
+ This function parses a descriptor and returns its basic type as
+ TYPE_INT, TYPE_LONG, TYPE_FLOAT, TYPE_DOUBLE, TYPE_ADDRESS or TYPE_VOID.
+
+ cls...if non-NULL the referenced variable is set to the classinfo *
+ returned by class_from_descriptor.
+
+ For documentation of the arguments utf_ptr, end_ptr, next and mode
+ see class_from_descriptor. The only difference is that
+ type_from_descriptor always uses CLASSLOAD_PANIC.
+
+********************************************************************************/
+
+int type_from_descriptor(classinfo **cls, char *utf_ptr, char *end_ptr,
+ char **next, int mode)
+{
+ classinfo *mycls;
+ if (!cls) cls = &mycls;
+ *cls = class_from_descriptor(utf_ptr, end_ptr, next, mode & (~CLASSLOAD_NOPANIC));
+ switch (*utf_ptr) {
+ case 'B':
+ case 'C':
+ case 'I':
+ case 'S':
+ case 'Z':
+ return TYPE_INT;
+ case 'D':
+ return TYPE_DOUBLE;
+ case 'F':
+ return TYPE_FLOAT;
+ case 'J':
+ return TYPE_LONG;
+ case 'V':
+ return TYPE_VOID;
}
+ return TYPE_ADDRESS;
}
+
/*************** function: create_pseudo_classes *******************************
create pseudo classes used by the typechecker
********************************************************************************/
-static void
-create_pseudo_classes()
+static void create_pseudo_classes()
{
/* pseudo class for Arraystubs (extends java.lang.Object) */
- pseudo_class_Arraystub = class_new( utf_new_char(";Arraystub;") );
- list_remove(&unloadedclasses,pseudo_class_Arraystub);
+ pseudo_class_Arraystub = class_new(utf_new_char("$ARRAYSTUB$"));
+ list_remove(&unloadedclasses, pseudo_class_Arraystub);
pseudo_class_Arraystub->super = class_java_lang_Object;
pseudo_class_Arraystub->interfacescount = 2;
- pseudo_class_Arraystub->interfaces = MNEW(classinfo*,2);
- pseudo_class_Arraystub->interfaces[0] =
- class_java_lang_Cloneable;
- pseudo_class_Arraystub->interfaces[1] =
- class_java_io_Serializable;
+ pseudo_class_Arraystub->interfaces = MNEW(classinfo*, 2);
+ pseudo_class_Arraystub->interfaces[0] = class_java_lang_Cloneable;
+ pseudo_class_Arraystub->interfaces[1] = class_java_io_Serializable;
- list_addlast(&unlinkedclasses,pseudo_class_Arraystub);
+ list_addlast(&unlinkedclasses, pseudo_class_Arraystub);
class_link(pseudo_class_Arraystub);
pseudo_class_Arraystub_vftbl = pseudo_class_Arraystub->vftbl;
/* pseudo class representing the null type */
- pseudo_class_Null = class_new( utf_new_char(";Null;") );
- list_remove(&unloadedclasses,pseudo_class_Null);
+ pseudo_class_Null = class_new(utf_new_char("$NULL$"));
+ list_remove(&unloadedclasses, pseudo_class_Null);
pseudo_class_Null->super = class_java_lang_Object;
- list_addlast(&unlinkedclasses,pseudo_class_Null);
+ list_addlast(&unlinkedclasses, pseudo_class_Null);
class_link(pseudo_class_Null);
+
+ /* pseudo class representing new uninitialized objects */
+
+ pseudo_class_New = class_new( utf_new_char("$NEW$") );
+ list_remove(&unloadedclasses,pseudo_class_New);
+
+ pseudo_class_New->super = class_java_lang_Object;
+
+ list_addlast(&unlinkedclasses,pseudo_class_New);
+ class_link(pseudo_class_New);
}
+
/********************** Function: loader_init **********************************
Initializes all lists and loads all classes required for the system or the
*******************************************************************************/
-void loader_init (u1 * stackbottom)
+void loader_init(u1 * stackbottom)
{
interfaceindex = 0;
-
log_text("Entering loader_init");
-
list_init (&unloadedclasses, OFFSET(classinfo, listnode) );
list_init (&unlinkedclasses, OFFSET(classinfo, listnode) );
utf_clinit = utf_new_char("<clinit>");
utf_initsystemclass = utf_new_char("initializeSystemClass");
utf_systemclass = utf_new_char("java/lang/System");
- utf_vmclassloader =utf_new_char("java/lang/VMClassLoader");
- utf_initialize =utf_new_char("initialize");
- utf_initializedesc =utf_new_char("(I)V");
-
- utf_vmclass =utf_new_char("java/lang/VMClass");
-
- /* create some important classes */
- /* These classes have to be created now because the classinfo
- * pointers are used in the loading code.
- */
- class_java_lang_Object = class_new( utf_new_char ("java/lang/Object") );
- class_java_lang_String = class_new( utf_new_char("java/lang/String") );
- class_java_lang_Cloneable = class_new( utf_new_char ("java/lang/Cloneable") );
- class_java_io_Serializable = class_new( utf_new_char ("java/io/Serializable") );
-
- log_text("loader_init: java/lang/Object");
- /* load the classes which were created above */
- loader_load (class_java_lang_Object->name);
-
- loader_inited=1; /*JOWENN*/
-
- class_java_lang_Throwable =
- loader_load( utf_new_char("java/lang/Throwable") );
-
- log_text("loader_init: loader_load: java/lang/ClassCastException");
- class_java_lang_ClassCastException =
- loader_load ( utf_new_char ("java/lang/ClassCastException") );
- class_java_lang_NullPointerException =
- loader_load ( utf_new_char ("java/lang/NullPointerException") );
- class_java_lang_ArrayIndexOutOfBoundsException = loader_load (
- utf_new_char ("java/lang/ArrayIndexOutOfBoundsException") );
- class_java_lang_NegativeArraySizeException = loader_load (
- utf_new_char ("java/lang/NegativeArraySizeException") );
- class_java_lang_OutOfMemoryError = loader_load (
- utf_new_char ("java/lang/OutOfMemoryError") );
- class_java_lang_ArrayStoreException =
- loader_load ( utf_new_char ("java/lang/ArrayStoreException") );
- class_java_lang_ArithmeticException =
- loader_load ( utf_new_char ("java/lang/ArithmeticException") );
- class_java_lang_ThreadDeath = /* schani */
- loader_load ( utf_new_char ("java/lang/ThreadDeath") );
- /* create classes representing primitive types */
- create_primitive_classes();
-
- /* create classes used by the typechecker */
- create_pseudo_classes();
-
- /* correct vftbl-entries (retarded loading of class java/lang/String) */
- stringtable_update();
-#ifdef USE_THREADS
- if (stackbottom!=0)
- initLocks();
-#endif
+ utf_vmclassloader = utf_new_char("java/lang/VMClassLoader");
+ utf_initialize = utf_new_char("initialize");
+ utf_initializedesc = utf_new_char("(I)V");
+
+ utf_vmclass = utf_new_char("java/lang/VMClass");
+
+ /* create some important classes */
+ /* These classes have to be created now because the classinfo
+ * pointers are used in the loading code.
+ */
+ class_java_lang_Object = class_new(utf_new_char("java/lang/Object"));
+ class_java_lang_String = class_new(utf_new_char("java/lang/String"));
+ class_java_lang_Cloneable = class_new(utf_new_char("java/lang/Cloneable"));
+ class_java_io_Serializable = class_new(utf_new_char("java/io/Serializable"));
+
+ log_text("loader_init: java/lang/Object");
+ /* load the classes which were created above */
+ loader_load_sysclass(NULL, class_java_lang_Object->name);
+
+ loader_inited = 1; /*JOWENN*/
+
+ loader_load_sysclass(&class_java_lang_Throwable,
+ utf_new_char("java/lang/Throwable"));
+
+ log_text("loader_init: loader_load: java/lang/ClassCastException");
+ loader_load_sysclass(&class_java_lang_ClassCastException,
+ utf_new_char ("java/lang/ClassCastException"));
+ loader_load_sysclass(&class_java_lang_NullPointerException,
+ utf_new_char ("java/lang/NullPointerException"));
+ loader_load_sysclass(&class_java_lang_ArrayIndexOutOfBoundsException,
+ utf_new_char ("java/lang/ArrayIndexOutOfBoundsException"));
+ loader_load_sysclass(&class_java_lang_NegativeArraySizeException,
+ utf_new_char ("java/lang/NegativeArraySizeException"));
+ loader_load_sysclass(&class_java_lang_OutOfMemoryError,
+ utf_new_char ("java/lang/OutOfMemoryError"));
+ loader_load_sysclass(&class_java_lang_ArrayStoreException,
+ utf_new_char ("java/lang/ArrayStoreException"));
+ loader_load_sysclass(&class_java_lang_ArithmeticException,
+ utf_new_char ("java/lang/ArithmeticException"));
+ loader_load_sysclass(&class_java_lang_ThreadDeath,
+ utf_new_char ("java/lang/ThreadDeath"));
+
+ /* create classes representing primitive types */
+ create_primitive_classes();
+ /* create classes used by the typechecker */
+ create_pseudo_classes();
+ /* correct vftbl-entries (retarded loading of class java/lang/String) */
+ stringtable_update();
- log_text("loader_init: creating global proto_java_lang_ClassCastException");
- proto_java_lang_ClassCastException =
- builtin_new(class_java_lang_ClassCastException);
- heap_addreference ( (void**) &proto_java_lang_ClassCastException);
+#ifdef USE_THREADS
+ if (stackbottom!=0)
+ initLocks();
+#endif
- log_text("loader_init: proto_java_lang_ClassCastException has been initialized");
+ log_text("loader_init: creating global proto_java_lang_ClassCastException");
+ proto_java_lang_ClassCastException =
+ builtin_new(class_java_lang_ClassCastException);
+/* heap_addreference((void**) &proto_java_lang_ClassCastException); */
- proto_java_lang_NullPointerException =
- builtin_new(class_java_lang_NullPointerException);
- heap_addreference ( (void**) &proto_java_lang_NullPointerException);
- log_text("loader_init: proto_java_lang_NullPointerException has been initialized");
+ log_text("loader_init: proto_java_lang_ClassCastException has been initialized");
- proto_java_lang_ArrayIndexOutOfBoundsException =
- builtin_new(class_java_lang_ArrayIndexOutOfBoundsException);
- heap_addreference ( (void**) &proto_java_lang_ArrayIndexOutOfBoundsException);
+ proto_java_lang_NullPointerException =
+ builtin_new(class_java_lang_NullPointerException);
+/* heap_addreference((void**) &proto_java_lang_NullPointerException); */
+ log_text("loader_init: proto_java_lang_NullPointerException has been initialized");
- proto_java_lang_NegativeArraySizeException =
- builtin_new(class_java_lang_NegativeArraySizeException);
- heap_addreference ( (void**) &proto_java_lang_NegativeArraySizeException);
+ proto_java_lang_ArrayIndexOutOfBoundsException =
+ builtin_new(class_java_lang_ArrayIndexOutOfBoundsException);
+/* heap_addreference((void**) &proto_java_lang_ArrayIndexOutOfBoundsException); */
- proto_java_lang_OutOfMemoryError =
- builtin_new(class_java_lang_OutOfMemoryError);
- heap_addreference ( (void**) &proto_java_lang_OutOfMemoryError);
+ proto_java_lang_NegativeArraySizeException =
+ builtin_new(class_java_lang_NegativeArraySizeException);
+/* heap_addreference((void**) &proto_java_lang_NegativeArraySizeException); */
- proto_java_lang_ArithmeticException =
- builtin_new(class_java_lang_ArithmeticException);
- heap_addreference ( (void**) &proto_java_lang_ArithmeticException);
+ proto_java_lang_OutOfMemoryError =
+ builtin_new(class_java_lang_OutOfMemoryError);
+/* heap_addreference((void**) &proto_java_lang_OutOfMemoryError); */
- proto_java_lang_ArrayStoreException =
- builtin_new(class_java_lang_ArrayStoreException);
- heap_addreference ( (void**) &proto_java_lang_ArrayStoreException);
+ proto_java_lang_ArithmeticException =
+ builtin_new(class_java_lang_ArithmeticException);
+/* heap_addreference((void**) &proto_java_lang_ArithmeticException); */
- proto_java_lang_ThreadDeath = /* schani */
- builtin_new(class_java_lang_ThreadDeath);
- heap_addreference ( (void**) &proto_java_lang_ThreadDeath);
+ proto_java_lang_ArrayStoreException =
+ builtin_new(class_java_lang_ArrayStoreException);
+/* heap_addreference((void**) &proto_java_lang_ArrayStoreException); */
- loader_inited = 1;
+ proto_java_lang_ThreadDeath = /* schani */
+ builtin_new(class_java_lang_ThreadDeath);
+/* heap_addreference((void**) &proto_java_lang_ThreadDeath); */
+ loader_inited = 1;
}
-
-
/********************* Function: loader_initclasses ****************************
Initializes all loaded but uninitialized classes
{
classinfo *c;
+#if defined(USE_THREADS) && defined(NATIVE_THREADS)
+ pthread_mutex_lock(&compiler_mutex);
+#endif
+
intsDisable(); /* schani */
if (makeinitializations) {
}
intsRestore(); /* schani */
+
+#if defined(USE_THREADS) && defined(NATIVE_THREADS)
+ pthread_mutex_unlock(&compiler_mutex);
+#endif
}
static s4 classvalue;
-static void loader_compute_class_values (classinfo *c)
+static void loader_compute_class_values(classinfo *c)
{
classinfo *subs;
while (subs != NULL) {
loader_compute_class_values(subs);
subs = subs->nextsub;
- }
+ }
c->vftbl->diffval = classvalue - c->vftbl->baseval;
/*
printf("\n");
}
*/
-
}
-void loader_compute_subclasses ()
+void loader_compute_subclasses()
{
classinfo *c;
intsDisable(); /* schani */
- c = list_first (&linkedclasses);
+ c = list_first(&linkedclasses);
while (c) {
if (!(c->flags & ACC_INTERFACE)) {
c->nextsub = 0;
c->sub = 0;
- }
- c = list_next (&linkedclasses, c);
}
+ c = list_next (&linkedclasses, c);
+ }
c = list_first (&linkedclasses);
while (c) {
if (!(c->flags & ACC_INTERFACE) && (c->super != NULL)) {
c->nextsub = c->super->sub;
c->super->sub = c;
- }
- c = list_next (&linkedclasses, c);
}
+ c = list_next (&linkedclasses, c);
+ }
+
classvalue = 0;
+#if defined(USE_THREADS) && defined(NATIVE_THREADS)
+ cast_lock();
+#endif
loader_compute_class_values(class_java_lang_Object);
+#if defined(USE_THREADS) && defined(NATIVE_THREADS)
+ cast_unlock();
+#endif
intsRestore(); /* schani */
}
-
/******************** function classloader_buffer ******************************
sets buffer for reading classdata
void classload_buffer(u1 *buf, int len)
{
- classbuffer = buf;
- classbuffer_size = len;
- classbuf_pos = buf - 1;
+ classbuffer = buf;
+ classbuffer_size = len;
+ classbuf_pos = buf - 1;
}
*******************************************************************************/
-void loader_close ()
+void loader_close()
{
classinfo *c;
- while ( (c=list_first(&unloadedclasses)) ) {
- list_remove (&unloadedclasses,c);
- class_free (c);
- }
- while ( (c=list_first(&unlinkedclasses)) ) {
- list_remove (&unlinkedclasses,c);
- class_free (c);
- }
- while ( (c=list_first(&linkedclasses)) ) {
- list_remove (&linkedclasses,c);
- class_free (c);
- }
+ while ((c = list_first(&unloadedclasses))) {
+ list_remove(&unloadedclasses, c);
+ class_free(c);
+ }
+ while ((c = list_first(&unlinkedclasses))) {
+ list_remove(&unlinkedclasses, c);
+ class_free(c);
+ }
+ while ((c = list_first(&linkedclasses))) {
+ list_remove(&linkedclasses, c);
+ class_free(c);
+ }
}
projects / cacao.git / blobdiff