/* src/native/native.c - table of native functions
- Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
- R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
- C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
- Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
+ E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
+ J. Wenninger, Institut f. Computersprachen - TU Wien
This file is part of CACAO.
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.
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
- Contact: cacao@complang.tuwien.ac.at
+ Contact: cacao@cacaojvm.org
Authors: Reinhard Grafl
Roman Obermaisser
Changes: Christian Thalinger
- $Id: native.c 2519 2005-05-23 12:04:09Z twisti $
+ $Id: native.c 4357 2006-01-22 23:33:38Z twisti $
*/
+#include "config.h"
+
#include <assert.h>
-#include "config.h"
-#include "types.h"
+#if !defined(ENABLE_STATICVM)
+# include <ltdl.h>
+#endif
+
+#include "vm/types.h"
+
#include "cacao/cacao.h"
#include "mm/memory.h"
#include "native/jni.h"
#include "vm/builtin.h"
#include "vm/exceptions.h"
#include "vm/global.h"
+#include "vm/hashtable.h"
#include "vm/loader.h"
#include "vm/options.h"
#include "vm/resolve.h"
#include "vm/stringlocal.h"
-#include "vm/tables.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/jit.h"
#include "native/include/java_lang_VMThrowable.h"
#include "native/include/java_lang_reflect_Constructor.h"
#include "native/include/java_lang_reflect_Field.h"
-#include "native/include/java_lang_reflect_Proxy.h"
#include "native/include/java_lang_reflect_Method.h"
+#include "native/include/java_lang_reflect_VMProxy.h"
#include "native/include/java_security_VMAccessController.h"
-#if defined(STATIC_CLASSPATH)
+#if defined(ENABLE_STATICVM)
/* these are required to prevent compiler warnings */
#include "native/nativetable.inc"
-#else /* defined(STATIC_CLASSPATH) */
+#else /* defined(ENABLE_STATICVM) */
/* Ensure that symbols for functions implemented within CACAO are used and */
/* exported to dlopen. */
(functionptr) Java_java_lang_VMClass_getClassLoader,
(functionptr) Java_java_lang_VMClass_forName,
(functionptr) Java_java_lang_VMClass_isArray,
- (functionptr) Java_java_lang_VMClass_initialize,
- (functionptr) Java_java_lang_VMClass_loadArrayClass,
(functionptr) Java_java_lang_VMClass_throwException,
(functionptr) Java_java_lang_VMClassLoader_defineClass,
(functionptr) Java_java_lang_VMClassLoader_loadClass,
(functionptr) Java_java_lang_VMClassLoader_getPrimitiveClass,
(functionptr) Java_java_lang_VMClassLoader_nativeGetResources,
+ (functionptr) Java_java_lang_VMClassLoader_findLoadedClass,
(functionptr) Java_java_lang_VMObject_getClass,
(functionptr) Java_java_lang_VMObject_clone,
(functionptr) Java_java_lang_reflect_Field_setFloat,
(functionptr) Java_java_lang_reflect_Field_setDouble,
- (functionptr) Java_java_lang_reflect_Proxy_getProxyClass0,
- (functionptr) Java_java_lang_reflect_Proxy_getProxyData0,
- (functionptr) Java_java_lang_reflect_Proxy_generateProxyClass0,
-
(functionptr) Java_java_lang_reflect_Method_getModifiers,
(functionptr) Java_java_lang_reflect_Method_getReturnType,
(functionptr) Java_java_lang_reflect_Method_getParameterTypes,
(functionptr) Java_java_lang_reflect_Method_getExceptionTypes,
(functionptr) Java_java_lang_reflect_Method_invokeNative,
+ (functionptr) Java_java_lang_reflect_VMProxy_getProxyClass,
+ (functionptr) Java_java_lang_reflect_VMProxy_getProxyData,
+ (functionptr) Java_java_lang_reflect_VMProxy_generateProxyClass,
+
(functionptr) Java_java_security_VMAccessController_getStack,
};
-#endif /* defined(STATIC_CLASSPATH) */
-
-
-/************* use classinfo structure as java.lang.Class object **************/
-
-void use_class_as_object(classinfo *c)
-{
- if (!c->classvftbl) {
- /* is the class loaded */
- if (!c->loaded) {
-/* if (!class_load(c)) */
-/* throw_exception_exit(); */
- log_text("use_class_as_object: class_load should not happen");
- assert(0);
- }
-
- /* is the class linked */
- if (!c->linked)
- if (!link_class(c))
- throw_exception_exit();
-
- assert(class_java_lang_Class);
-
- c->header.vftbl = class_java_lang_Class->vftbl;
- c->classvftbl = true;
- }
-}
-
+#endif /* defined(ENABLE_STATICVM) */
-/************************** tables for methods ********************************/
-#undef JOWENN_DEBUG
-#undef JOWENN_DEBUG1
+/* tables for methods *********************************************************/
-#ifdef STATIC_CLASSPATH
+#ifdef ENABLE_STATICVM
#define NATIVETABLESIZE (sizeof(nativetable)/sizeof(struct nativeref))
/* table for fast string comparison */
#endif
-/* XXX don't define this in a header file!!! */
-
-static struct nativeCall nativeCalls[] =
-{
-#include "nativecalls.inc"
-};
+/* global variables ***********************************************************/
-#define NATIVECALLSSIZE (sizeof(nativeCalls) / sizeof(struct nativeCall))
-
-struct nativeCompCall nativeCompCalls[NATIVECALLSSIZE];
+#if !defined(ENABLE_STATICVM)
+static hashtable hashtable_library;
+static lt_dlhandle mainhandle;
+#endif
/* native_loadclasses **********************************************************
bool native_init(void)
{
-#if !defined(STATIC_CLASSPATH)
+#if !defined(ENABLE_STATICVM)
void *p;
/* We need to access the dummy native table, not only to remove a warning */
/* but to be sure that the table is not optimized away (gcc does this */
/* since 3.4). */
+
p = &dummynativetable;
+
+ /* initialize libltdl */
+
+ if (lt_dlinit()) {
+ /* XXX how can we throw an exception here? */
+ log_text(lt_dlerror());
+
+ return false;
+ }
+
+ /* get the handle for the main program */
+
+ if (!(mainhandle = lt_dlopen(NULL)))
+ return false;
+
+ /* initialize library hashtable, 10 entries should be enough */
+
+ hashtable_create(&hashtable_library, 10);
+
#endif
/* everything's ok */
}
-/*********************** Function: native_findfunction *************************
+/* native_hashtable_library_add ************************************************
- Looks up a method (must have the same class name, method name, descriptor
- and 'static'ness) and returns a function pointer to it.
- Returns: function pointer or NULL (if there is no such method)
+ Adds an entry to the native library hashtable.
- Remark: For faster operation, the names/descriptors are converted from C
- strings to Unicode the first time this function is called.
+*******************************************************************************/
+
+#if !defined(ENABLE_STATICVM)
+void native_hashtable_library_add(utf *filename, java_objectheader *loader,
+ lt_dlhandle handle)
+{
+ hashtable_library_loader_entry *le;
+ hashtable_library_name_entry *ne; /* library name */
+ u4 key; /* hashkey */
+ u4 slot; /* slot in hashtable */
+
+ /* normally addresses are aligned to 4, 8 or 16 bytes */
+
+ key = ((u4) (ptrint) loader) >> 4; /* align to 16-byte boundaries */
+ slot = key & (hashtable_library.size - 1);
+ le = hashtable_library.ptr[slot];
+
+ /* search external hash chain for the entry */
+
+ while (le) {
+ if (le->loader == loader)
+ break;
+
+ le = le->hashlink; /* next element in external chain */
+ }
+
+ /* no loader found? create a new entry */
+
+ if (!le) {
+ le = NEW(hashtable_library_loader_entry);
+
+ le->loader = loader;
+ le->namelink = NULL;
+
+ /* insert entry into hashtable */
+
+ le->hashlink =
+ (hashtable_library_loader_entry *) hashtable_library.ptr[slot];
+ hashtable_library.ptr[slot] = le;
+
+ /* update number of hashtable-entries */
+
+ hashtable_library.entries++;
+ }
+
+
+ /* search for library name */
+
+ ne = le->namelink;
+
+ while (ne) {
+ if (ne->name == filename)
+ return;
+
+ ne = ne->hashlink; /* next element in external chain */
+ }
+
+ /* not found? add the library name to the classloader */
+
+ ne = NEW(hashtable_library_name_entry);
+
+ ne->name = filename;
+ ne->handle = handle;
+
+ /* insert entry into external chain */
+
+ ne->hashlink = le->namelink;
+ le->namelink = ne;
+}
+#endif /* !defined(ENABLE_STATICVM) */
+
+
+/* native_hashtable_library_find ***********************************************
+
+ Find an entry in the native library hashtable.
*******************************************************************************/
-functionptr native_findfunction(utf *cname, utf *mname,
- utf *desc, bool isstatic)
+#if !defined(ENABLE_STATICVM)
+hashtable_library_name_entry *native_hashtable_library_find(utf *filename,
+ java_objectheader *loader)
+{
+ hashtable_library_loader_entry *le;
+ hashtable_library_name_entry *ne; /* library name */
+ u4 key; /* hashkey */
+ u4 slot; /* slot in hashtable */
+
+ /* normally addresses are aligned to 4, 8 or 16 bytes */
+
+ key = ((u4) (ptrint) loader) >> 4; /* align to 16-byte boundaries */
+ slot = key & (hashtable_library.size - 1);
+ le = hashtable_library.ptr[slot];
+
+ /* search external hash chain for the entry */
+
+ while (le) {
+ if (le->loader == loader)
+ break;
+
+ le = le->hashlink; /* next element in external chain */
+ }
+
+ /* no loader found? return NULL */
+
+ if (!le)
+ return NULL;
+
+ /* search for library name */
+
+ ne = le->namelink;
+
+ while (ne) {
+ if (ne->name == filename)
+ return ne;
+
+ ne = ne->hashlink; /* next element in external chain */
+ }
+
+ /* return entry, if no entry was found, ne is NULL */
+
+ return ne;
+}
+#endif /* !defined(ENABLE_STATICVM) */
+
+
+/* native_findfunction *********************************************************
+
+ Looks up a method (must have the same class name, method name,
+ descriptor and 'static'ness) and returns a function pointer to it.
+ Returns: function pointer or NULL (if there is no such method)
+
+ Remark: For faster operation, the names/descriptors are converted
+ from C strings to Unicode the first time this function is called.
+
+*******************************************************************************/
+
+#if defined(ENABLE_STATICVM)
+functionptr native_findfunction(utf *cname, utf *mname, utf *desc,
+ bool isstatic)
{
-#ifdef STATIC_CLASSPATH
- int i;
/* entry of table for fast string comparison */
struct nativecompref *n;
- /* for warning message if no function is found */
- char *buffer;
- int buffer_len;
+ s4 i;
isstatic = isstatic ? true : false;
for (i = 0; i < NATIVETABLESIZE; i++) {
nativecomptable[i].classname =
utf_new_char(nativetable[i].classname);
+
nativecomptable[i].methodname =
utf_new_char(nativetable[i].methodname);
- nativecomptable[i].descriptor =
+
+ nativecomptable[i].descriptor =
utf_new_char(nativetable[i].descriptor);
- nativecomptable[i].isstatic =
- nativetable[i].isstatic;
- nativecomptable[i].func =
- nativetable[i].func;
+
+ nativecomptable[i].isstatic = nativetable[i].isstatic;
+ nativecomptable[i].func = nativetable[i].func;
}
+
nativecompdone = true;
}
-#ifdef JOWENN_DEBUG
- buffer_len =
- utf_strlen(cname) + utf_strlen(mname) + utf_strlen(desc) + 64;
-
- buffer = MNEW(char, buffer_len);
-
- strcpy(buffer, "searching matching function in native table:");
- utf_sprint(buffer+strlen(buffer), mname);
- strcpy(buffer+strlen(buffer), ": ");
- utf_sprint(buffer+strlen(buffer), desc);
- strcpy(buffer+strlen(buffer), " for class ");
- utf_sprint(buffer+strlen(buffer), cname);
-
- log_text(buffer);
-
- MFREE(buffer, char, buffer_len);
-#endif
-
for (i = 0; i < NATIVETABLESIZE; i++) {
n = &(nativecomptable[i]);
if (cname == n->classname && mname == n->methodname &&
desc == n->descriptor && isstatic == n->isstatic)
return n->func;
-#ifdef JOWENN_DEBUG
- else {
- if (cname == n->classname && mname == n->methodname ) log_text("static and descriptor mismatch");
-
- else {
- buffer_len =
- utf_strlen(n->classname) + utf_strlen(n->methodname) + utf_strlen(n->descriptor) + 64;
-
- buffer = MNEW(char, buffer_len);
+ }
- strcpy(buffer, "comparing with:");
- utf_sprint(buffer+strlen(buffer), n->methodname);
- strcpy (buffer+strlen(buffer), ": ");
- utf_sprint(buffer+strlen(buffer), n->descriptor);
- strcpy(buffer+strlen(buffer), " for class ");
- utf_sprint(buffer+strlen(buffer), n->classname);
+
+ /* no function was found, throw exception */
- log_text(buffer);
+ *exceptionptr =
+ new_exception_utfmessage(string_java_lang_UnsatisfiedLinkError,
+ mname);
- MFREE(buffer, char, buffer_len);
- }
- }
-#endif
- }
+ return NULL;
+}
+#endif /* defined(ENABLE_STATICVM) */
-
- /* no function was found, display warning */
- buffer_len =
- utf_strlen(cname) + utf_strlen(mname) + utf_strlen(desc) + 64;
+/* native_make_overloaded_function *********************************************
- buffer = MNEW(char, buffer_len);
+ XXX
- strcpy(buffer, "warning: native function ");
- utf_sprint(buffer + strlen(buffer), mname);
- strcpy(buffer + strlen(buffer), ": ");
- utf_sprint(buffer + strlen(buffer), desc);
- strcpy(buffer + strlen(buffer), " not found in class ");
- utf_sprint(buffer + strlen(buffer), cname);
+*******************************************************************************/
- log_text(buffer);
+#if !defined(ENABLE_STATICVM)
+static char *native_make_overloaded_function(char *name, utf *desc)
+{
+ char *newname;
+ s4 namelen;
+ char *utf_ptr;
+ u2 c;
+ s4 i;
+
+ utf_ptr = desc->text;
+ namelen = strlen(name) + strlen("__") + strlen("0");
+
+ /* calculate additional length */
+
+ while ((c = utf_nextu2(&utf_ptr)) != ')') {
+ switch (c) {
+ case 'Z':
+ case 'B':
+ case 'C':
+ case 'S':
+ case 'I':
+ case 'J':
+ case 'F':
+ case 'D':
+ namelen++;
+ break;
+ case '[':
+ namelen += 2;
+ break;
+ case 'L':
+ namelen++;
+ while (utf_nextu2(&utf_ptr) != ';')
+ namelen++;
+ namelen += 2;
+ break;
+ case '(':
+ break;
+ default:
+ assert(0);
+ }
+ }
- MFREE(buffer, char, buffer_len);
-/* exit(1); */
+ /* reallocate memory */
+
+ i = strlen(name);
+
+ newname = DMNEW(char, namelen);
+ MCOPY(newname, name, char, i);
+
+ utf_ptr = desc->text;
+
+ newname[i++] = '_';
+ newname[i++] = '_';
+
+ while ((c = utf_nextu2(&utf_ptr)) != ')') {
+ switch (c) {
+ case 'Z':
+ case 'B':
+ case 'C':
+ case 'S':
+ case 'J':
+ case 'I':
+ case 'F':
+ case 'D':
+ newname[i++] = c;
+ break;
+ case '[':
+ newname[i++] = '_';
+ newname[i++] = '3';
+ break;
+ case 'L':
+ newname[i++] = 'L';
+ while ((c = utf_nextu2(&utf_ptr)) != ';')
+ if (((c >= 'a') && (c <= 'z')) ||
+ ((c >= 'A') && (c <= 'Z')) ||
+ ((c >= '0') && (c <= '9')))
+ newname[i++] = c;
+ else
+ newname[i++] = '_';
+ newname[i++] = '_';
+ newname[i++] = '2';
+ break;
+ case '(':
+ break;
+ default:
+ assert(0);
+ }
+ }
- /* keep compiler happy */
- return NULL;
-#else
-/* dynamic classpath */
- return 0;
-#endif
+ /* close string */
+
+ newname[i] = '\0';
+
+ return newname;
}
-/****************** function class_findfield_approx ****************************
-
- searches in 'classinfo'-structure for a field with the
- specified name
+/* native_resolve_function *****************************************************
+
+ Resolves a native function, maybe from a dynamic library.
*******************************************************************************/
-
-fieldinfo *class_findfield_approx(classinfo *c, utf *name)
+
+functionptr native_resolve_function(methodinfo *m)
{
- s4 i;
+ lt_ptr sym;
+ char *name;
+ char *newname;
+ s4 namelen;
+ char *utf_ptr;
+ char *utf_endptr;
+ s4 dumpsize;
+ hashtable_library_loader_entry *le;
+ hashtable_library_name_entry *ne;
+ u4 key; /* hashkey */
+ u4 slot; /* slot in hashtable */
+ u4 i;
+
+
+ /* verbose output */
+
+ if (opt_verbosejni) {
+ printf("[Dynamic-linking native method ");
+ utf_display_classname(m->class->name);
+ printf(".");
+ utf_display(m->name);
+ printf(" ... ");
+ }
+
+ /* calculate length of native function name */
+
+ namelen = strlen("Java_") + utf_strlen(m->class->name) + strlen("_") +
+ utf_strlen(m->name) + strlen("0");
+
+ /* check for underscores in class name */
+
+ utf_ptr = m->class->name->text;
+ utf_endptr = UTF_END(m->class->name);
+
+ while (utf_ptr < utf_endptr)
+ if (utf_nextu2(&utf_ptr) == '_')
+ namelen++;
- for (i = 0; i < c->fieldscount; i++) {
- /* compare field names */
- if ((c->fields[i].name == name))
- return &(c->fields[i]);
+ /* check for underscores in method name */
+
+ utf_ptr = m->name->text;
+ utf_endptr = UTF_END(m->name);
+
+ while (utf_ptr < utf_endptr)
+ if (utf_nextu2(&utf_ptr) == '_')
+ namelen++;
+
+ /* allocate memory */
+
+ dumpsize = dump_size();
+
+ name = DMNEW(char, namelen);
+
+
+ /* generate name of native functions */
+
+ strcpy(name, "Java_");
+ i = strlen("Java_");
+
+ utf_ptr = m->class->name->text;
+ utf_endptr = UTF_END(m->class->name);
+
+ for (; utf_ptr < utf_endptr; utf_ptr++, i++) {
+ name[i] = *utf_ptr;
+
+ /* escape sequence for '_' is '_1' */
+
+ if (name[i] == '_')
+ name[++i] = '1';
+
+ /* replace '/' with '_' */
+
+ if (name[i] == '/')
+ name[i] = '_';
}
- /* field was not found, raise exception */
- *exceptionptr = new_exception(string_java_lang_NoSuchFieldException);
+ /* seperator between class and method */
- return NULL;
-}
+ name[i++] = '_';
+ utf_ptr = m->name->text;
+ utf_endptr = UTF_END(m->name);
-s4 class_findfield_index_approx(classinfo *c, utf *name)
-{
- s4 i;
+ for (; utf_ptr < utf_endptr; utf_ptr++, i++) {
+ name[i] = *utf_ptr;
+
+ /* escape sequence for '_' is '_1' */
- for (i = 0; i < c->fieldscount; i++) {
- /* compare field names */
- if ((c->fields[i].name == name))
- return i;
+ if (name[i] == '_')
+ name[++i] = '1';
}
- /* field was not found, raise exception */
- *exceptionptr = new_exception(string_java_lang_NoSuchFieldException);
+ /* close string */
+
+ name[i] = '\0';
+
+
+ /* generate overloaded function (having the types in it's name) */
+
+ newname = native_make_overloaded_function(name, m->descriptor);
+
+ /* check the library hash entries of the classloader of the methods's */
+ /* class */
+
+ sym = NULL;
+
+ /* normally addresses are aligned to 4, 8 or 16 bytes */
+
+ key = ((u4) (ptrint) m->class->classloader) >> 4; /* align to 16-byte */
+ slot = key & (hashtable_library.size - 1);
+ le = hashtable_library.ptr[slot];
+
+ /* iterate through loaders in this hash slot */
+
+ while (le && !sym) {
+ /* iterate through names in this loader */
+
+ ne = le->namelink;
+
+ while (ne && !sym) {
+ sym = lt_dlsym(ne->handle, name);
+
+ if (!sym)
+ sym = lt_dlsym(ne->handle, newname);
+
+ ne = ne->hashlink;
+ }
- return -1;
+ le = le->hashlink;
+ }
+
+ if (sym)
+ if (opt_verbosejni)
+ printf("JNI ]\n");
+
+
+ /* if not found, try to find the native function symbol in the main */
+ /* program */
+
+ if (!sym) {
+ sym = lt_dlsym(mainhandle, name);
+
+ if (!sym)
+ sym = lt_dlsym(mainhandle, newname);
+
+ if (sym)
+ if (opt_verbosejni)
+ printf("internal ]\n");
+ }
+
+
+ /* no symbol found? throw exception */
+
+ if (!sym)
+ *exceptionptr =
+ new_exception_utfmessage(string_java_lang_UnsatisfiedLinkError,
+ m->name);
+
+ /* release memory */
+
+ dump_release(dumpsize);
+
+ return (functionptr) (ptrint) sym;
}
+#endif /* !defined(ENABLE_STATICVM) */
/* native_new_and_init *********************************************************
if (!o)
return NULL;
- /* find initializer */
+ /* try to find the initializer */
m = class_findmethod(c, utf_init, utf_void__void);
- /* initializer not found */
+ /* ATTENTION: returning the object here is ok, since the class may
+ not have an initializer */
if (!m)
return o;
/* call initializer */
- asm_calljavafunction(m, o, NULL, NULL, NULL);
+ ASM_CALLJAVAFUNCTION(m, o, NULL, NULL, NULL);
return o;
}
/* call initializer */
- asm_calljavafunction(m, o, s, NULL, NULL);
+ ASM_CALLJAVAFUNCTION(m, o, s, NULL, NULL);
return o;
}
/* call initializer */
- asm_calljavafunction(m, o, (void *) (ptrint) i, NULL, NULL);
+ ASM_CALLJAVAFUNCTION(m, o, (void *) (ptrint) i, NULL, NULL);
return o;
}
/* call initializer */
- asm_calljavafunction(m, o, t, NULL, NULL);
+ ASM_CALLJAVAFUNCTION(m, o, t, NULL, NULL);
return o;
}
-void copy_vftbl(vftbl_t **dest, vftbl_t *src)
-{
- *dest = src;
-#if 0
- /* XXX this kind of copying does not work (in the general
- * case). The interface tables would have to be copied, too. I
- * don't see why we should make a copy anyway. -Edwin
- */
- *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));
-#endif
-}
-
-
-/******************************************************************************************
-
- creates method signature (excluding return type) from array of
- class-objects representing the parameters of the method
-
-*******************************************************************************************/
-
-
-utf *create_methodsig(java_objectarray* types, char *retType)
-{
- char *buffer; /* buffer for building the desciptor */
- char *pos; /* current position in buffer */
- utf *result; /* the method signature */
- u4 buffer_size = 3; /* minimal size=3: room for parenthesis and returntype */
- u4 i, j;
-
- if (!types) return NULL;
-
- /* determine required buffer-size */
- for (i = 0; i < types->header.size; i++) {
- classinfo *c = (classinfo *) types->data[i];
- buffer_size = buffer_size + c->name->blength + 2;
- }
-
- if (retType) buffer_size += strlen(retType);
-
- /* allocate buffer */
- buffer = MNEW(char, buffer_size);
- pos = buffer;
-
- /* method-desciptor starts with parenthesis */
- *pos++ = '(';
-
- for (i = 0; i < types->header.size; i++) {
- char ch;
-
- /* current argument */
- classinfo *c = (classinfo *) types->data[i];
-
- /* current position in utf-text */
- char *utf_ptr = c->name->text;
-
- /* determine type of argument */
- if ((ch = utf_nextu2(&utf_ptr)) == '[') {
- /* arrayclass */
- for (utf_ptr--; utf_ptr < utf_end(c->name); utf_ptr++) {
- *pos++ = *utf_ptr; /* copy text */
- }
-
- } else {
- /* check for primitive types */
- for (j = 0; j < PRIMITIVETYPE_COUNT; j++) {
- char *utf_pos = utf_ptr - 1;
- char *primitive = primitivetype_table[j].wrapname;
-
- /* compare text */
- while (utf_pos < utf_end(c->name)) {
- if (*utf_pos++ != *primitive++) goto nomatch;
- }
-
- /* primitive type found */
- *pos++ = primitivetype_table[j].typesig;
- goto next_type;
-
- nomatch:
- ;
- }
-
- /* no primitive type and no arrayclass, so must be object */
- *pos++ = 'L';
-
- /* copy text */
- for (utf_ptr--; utf_ptr < utf_end(c->name); utf_ptr++) {
- *pos++ = *utf_ptr;
- }
-
- *pos++ = ';';
-
- next_type:
- ;
- }
- }
-
- *pos++ = ')';
-
- if (retType) {
- for (i = 0; i < strlen(retType); i++) {
- *pos++ = retType[i];
- }
- }
-
- /* create utf-string */
- result = utf_new(buffer, (pos - buffer));
- MFREE(buffer, char, buffer_size);
-
- return result;
-}
-
+/* native_get_parametertypes ***************************************************
-/* get_parametertypes **********************************************************
-
- use the descriptor of a method to generate a java/lang/Class array
- which contains the classes of the parametertypes of the method
+ Use the descriptor of a method to generate a java/lang/Class array
+ which contains the classes of the parametertypes of the method.
*******************************************************************************/
-java_objectarray* get_parametertypes(methodinfo *m)
+java_objectarray *native_get_parametertypes(methodinfo *m)
{
- methoddesc *descr = m->parseddesc; /* method-descriptor */
- java_objectarray* result;
- int parametercount = descr->paramcount;
- int i;
+ methoddesc *md;
+ typedesc *paramtypes;
+ s4 paramcount;
+ java_objectarray *oa;
+ s4 i;
- /* create class-array */
- assert(class_java_lang_Class);
+ md = m->parseddesc;
- result = builtin_anewarray(parametercount, class_java_lang_Class);
+ /* is the descriptor fully parsed? */
- /* get classes */
- for (i = 0; i < parametercount; i++) {
- if (!resolve_class_from_typedesc(descr->paramtypes + i,false,
- (classinfo **) (result->data + i)))
- return NULL; /* exception */
- use_class_as_object((classinfo*) result->data[i]);
- }
-
- return result;
-}
-
-
-/* get_exceptiontypes **********************************************************
-
- get the exceptions which can be thrown by a method
-
-*******************************************************************************/
-
-java_objectarray* get_exceptiontypes(methodinfo *m)
-{
- u2 excount;
- u2 i;
- java_objectarray *result;
- classinfo *cls;
-
- excount = m->thrownexceptionscount;
-
- /* create class-array */
- assert(class_java_lang_Class);
-
- result = builtin_anewarray(excount, class_java_lang_Class);
+ if (!m->parseddesc->params)
+ if (!descriptor_params_from_paramtypes(md, m->flags))
+ return NULL;
- for (i = 0; i < excount; i++) {
- if (!resolve_classref_or_classinfo(NULL,m->thrownexceptions[i],resolveEager,false,&cls))
- return NULL; /* exception */
- use_class_as_object(cls);
- result->data[i] = (java_objectheader *)cls;
- }
+ paramtypes = md->paramtypes;
+ paramcount = md->paramcount;
- return result;
-}
+ /* skip `this' pointer */
+ if (!(m->flags & ACC_STATIC)) {
+ paramtypes++;
+ paramcount--;
+ }
-/******************************************************************************************
+ /* create class-array */
- get the returntype class of a method
+ oa = builtin_anewarray(paramcount, class_java_lang_Class);
-*******************************************************************************************/
+ if (!oa)
+ return NULL;
-classinfo *get_returntype(methodinfo *m)
-{
- classinfo *cls;
+ /* get classes */
- if (!resolve_class_from_typedesc(&(m->parseddesc->returntype),false,&cls))
- return NULL; /* exception */
+ for (i = 0; i < paramcount; i++)
+ if (!resolve_class_from_typedesc(¶mtypes[i], true, false,
+ (classinfo **) &oa->data[i]))
+ return NULL;
- use_class_as_object(cls);
- return cls;
+ return oa;
}
-/*****************************************************************************/
-/*****************************************************************************/
-
-
-/*--------------------------------------------------------*/
-void printNativeCall(nativeCall nc) {
- int i,j;
-
- printf("\n%s's Native Methods call:\n",nc.classname); fflush(stdout);
- for (i=0; i<nc.methCnt; i++) {
- printf("\tMethod=%s %s\n",nc.methods[i].methodname, nc.methods[i].descriptor);fflush(stdout);
-
- for (j=0; j<nc.callCnt[i]; j++) {
- printf("\t\t<%i,%i>aCalled = %s %s %s\n",i,j,
- nc.methods[i].methodCalls[j].classname,
- nc.methods[i].methodCalls[j].methodname,
- nc.methods[i].methodCalls[j].descriptor);fflush(stdout);
- }
- }
- printf("-+++++--------------------\n");fflush(stdout);
-}
+/* native_get_exceptiontypes ***************************************************
-/*--------------------------------------------------------*/
-void printCompNativeCall(nativeCompCall nc) {
- int i,j;
- printf("printCompNativeCall BEGIN\n");fflush(stdout);
- printf("\n%s's Native Comp Methods call:\n",nc.classname->text);fflush(stdout);
- utf_display(nc.classname); fflush(stdout);
-
- for (i=0; i<nc.methCnt; i++) {
- printf("\tMethod=%s %s\n",nc.methods[i].methodname->text,nc.methods[i].descriptor->text);fflush(stdout);
- utf_display(nc.methods[i].methodname); fflush(stdout);
- utf_display(nc.methods[i].descriptor);fflush(stdout);
- printf("\n");fflush(stdout);
-
- for (j=0; j<nc.callCnt[i]; j++) {
- printf("\t\t<%i,%i>bCalled = ",i,j);fflush(stdout);
- utf_display(nc.methods[i].methodCalls[j].classname);fflush(stdout);
- utf_display(nc.methods[i].methodCalls[j].methodname); fflush(stdout);
- utf_display(nc.methods[i].methodCalls[j].descriptor);fflush(stdout);
- printf("\n");fflush(stdout);
- }
- }
-printf("---------------------\n");fflush(stdout);
-}
+ Get the exceptions which can be thrown by a method.
+*******************************************************************************/
-/*--------------------------------------------------------*/
-classMeth findNativeMethodCalls(utf *c, utf *m, utf *d )
+java_objectarray *native_get_exceptiontypes(methodinfo *m)
{
- int i = 0;
- int j = 0;
- int cnt = 0;
- classMeth mc;
- mc.i_class = i;
- mc.j_method = j;
- mc.methCnt = cnt;
-
- return mc;
-}
-
-/*--------------------------------------------------------*/
-nativeCall* findNativeClassCalls(char *aclassname ) {
-int i;
-
-for (i=0;i<NATIVECALLSSIZE; i++) {
- /* convert table to utf later to speed up search */
- if (strcmp(nativeCalls[i].classname, aclassname) == 0)
- return &nativeCalls[i];
- }
-
-return NULL;
-}
-/*--------------------------------------------------------*/
-/*--------------------------------------------------------*/
-void utfNativeCall(nativeCall nc, nativeCompCall *ncc) {
- int i,j;
-
-
- ncc->classname = utf_new_char(nc.classname);
- ncc->methCnt = nc.methCnt;
-
- for (i=0; i<nc.methCnt; i++) {
- ncc->methods[i].methodname = utf_new_char(nc.methods[i].methodname);
- ncc->methods[i].descriptor = utf_new_char(nc.methods[i].descriptor);
- ncc->callCnt[i] = nc.callCnt[i];
-
- for (j=0; j<nc.callCnt[i]; j++) {
-
- ncc->methods[i].methodCalls[j].classname = utf_new_char(nc.methods[i].methodCalls[j].classname);
-
- if (strcmp("", nc.methods[i].methodCalls[j].methodname) != 0) {
- ncc->methods[i].methodCalls[j].methodname = utf_new_char(nc.methods[i].methodCalls[j].methodname);
- ncc->methods[i].methodCalls[j].descriptor = utf_new_char(nc.methods[i].methodCalls[j].descriptor);
- }
- else {
- ncc->methods[i].methodCalls[j].methodname = NULL;
- ncc->methods[i].methodCalls[j].descriptor = NULL;
- }
- }
- }
-}
+ java_objectarray *oa;
+ classinfo *c;
+ u2 i;
+ /* create class-array */
+ oa = builtin_anewarray(m->thrownexceptionscount, class_java_lang_Class);
-/*--------------------------------------------------------*/
-
-bool natcall2utf(bool natcallcompdone) {
-int i;
+ if (!oa)
+ return NULL;
-if (natcallcompdone)
- return true;
+ for (i = 0; i < m->thrownexceptionscount; i++) {
+ if (!resolve_classref_or_classinfo(NULL, m->thrownexceptions[i],
+ resolveEager, true, false, &c))
+ return NULL;
-for (i=0;i<NATIVECALLSSIZE; i++) {
- utfNativeCall (nativeCalls[i], &nativeCompCalls[i]);
- }
+ oa->data[i] = (java_objectheader *) c;
+ }
-return true;
+ return oa;
}
-/*--------------------------------------------------------*/
+/* native_get_returntype *******************************************************
-java_objectarray *builtin_asm_createclasscontextarray(classinfo **end, classinfo **start)
-{
- /* XXX platform dependend */
-
- java_objectarray *tmpArray;
- int i;
- classinfo **current;
- classinfo *c;
- size_t size;
-
- size = (((size_t) start) - ((size_t) end)) / sizeof(classinfo*);
-
- /*printf("end %p, start %p, size %ld\n",end,start,size);*/
-
- if (size > 0) {
- if (*start == class_java_lang_SecurityManager) {
- size--;
- start--;
- }
- }
-
- tmpArray = builtin_anewarray(size, class_java_lang_Class);
-
- for(i = 0, current = start; i < size; i++, current--) {
- c = *current;
- /* printf("%d\n",i);
- utf_display(c->name);*/
- use_class_as_object(c);
- tmpArray->data[i] = (java_objectheader *) c;
- }
-
- return tmpArray;
-}
+ Get the returntype class of a method.
+*******************************************************************************/
-java_lang_ClassLoader *builtin_asm_getclassloader(classinfo **end, classinfo **start)
+classinfo *native_get_returntype(methodinfo *m)
{
- /* XXX platform dependend */
-
- int i;
- classinfo **current;
classinfo *c;
- classinfo *privilegedAction;
- size_t size;
-
- size = (((size_t) start) - ((size_t) end)) / sizeof(classinfo*);
-
- /* log_text("builtin_asm_getclassloader");
- printf("end %p, start %p, size %ld\n",end,start,size);*/
-
- if (!class_java_lang_SecurityManager)
- if (!load_class_bootstrap(utf_new_char("java/lang/SecurityManager"),&class_java_lang_SecurityManager))
- return NULL;
-
- if (size > 0) {
- if (*start == class_java_lang_SecurityManager) {
- size--;
- start--;
- }
- }
- if (!load_class_bootstrap(utf_new_char("java/security/PrivilegedAction"),&privilegedAction))
+ if (!resolve_class_from_typedesc(&(m->parseddesc->returntype), true, false,
+ &c))
return NULL;
- for(i = 0, current = start; i < size; i++, current--) {
- c = *current;
-
- if (c == privilegedAction)
- return NULL;
-
- if (c->classloader)
- return (java_lang_ClassLoader *) c->classloader;
- }
-
- return NULL;
+ return c;
}
projects / cacao.git / blobdiff