vmkit/lib/j3/vm/j3method.cc - llvm-archive - Git at Google

 #include "vmkit/safepoint.h"

 #include "j3/j3method.h"
 #include "j3/j3class.h"
 #include "j3/j3classloader.h"
 #include "j3/j3constants.h"
 #include "j3/j3.h"
 #include "j3/j3mangler.h"
 #include "j3/j3thread.h"
 #include "j3/j3codegen.h"
 #include "j3/j3trampoline.h"
 #include "j3/j3attribute.h"
 #include "j3/j3reader.h"

 #include "llvm/IR/Type.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Function.h"
 #include "llvm/Linker.h"

 #include "llvm/ExecutionEngine/GenericValue.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"

 #include <vector>

 using namespace j3;

 J3Method::J3Method(uint16_t access, J3Class* cl, const vmkit::Name* name, J3Signature* signature) {
 	_access = access;
 	_cl = cl;
 	_name = name;
 	_signature = signature;
 	_index = -1;
 }

 J3Attributes* J3Method::codeAttributes() {
 	if(!_codeAttributes) {
 		J3* vm = J3Thread::get()->vm();
 		J3Attribute* codeAttr = attributes()->lookup(vm->codeAttribute);
 		if(codeAttr) {
 			J3Reader reader(cl()->bytes());
 			reader.seek(codeAttr->offset()+8, reader.SeekSet);
 			reader.seek(reader.readU4(), reader.SeekCur);
 			reader.seek(reader.readU2()*8, reader.SeekCur);
 			_codeAttributes = cl()->readAttributes(&reader);
 		}
 	}
 	return _codeAttributes;
 }

 vmkit::CompilationUnit* J3Method::unit() {
 	return cl()->loader();
 }

 uint64_t J3Method::inlineWeight() {
 	if(J3Thread::get()->vm()->options()->enableInlining)
 		return vmkit::Symbol::inlineWeight();
 	else
 		return (uint64_t)-1;
 }

 uint32_t J3Method::interfaceIndex() {
 	return cl()->loader()->interfaceIndex(this);
 }

 uint32_t J3Method::index()  {
 	return _index;
 }

 void J3Method::markCompiled(llvm::Function* llvmFunction, void* fnPtr) {
 	_llvmFunction = llvmFunction;
 	_fnPtr = fnPtr;
 }

 void* J3Method::fnPtr() {
 	return _fnPtr;
 }

 J3Signature::function_t J3Method::cxxCaller() {
 	return signature()->caller(access());
 }

 void J3Method::aotSnapshot(llvm::Linker* linker) {
 	if(_llvmFunction) {
 		std::string err;
 		linker->linkInModule(_llvmFunction->getParent(), llvm::Linker::DestroySource, &err);
 	}
 }

 void J3Method::ensureCompiled(uint32_t mode) {
 	if(((mode & J3CodeGen::WithMethod) && !fnPtr()) || ((mode & J3CodeGen::WithCaller) && !cxxCaller())) {
 		//fprintf(stderr, "materializing: %s::%s%s\n", cl()->name()->cStr(), name()->cStr(), signature()->name()->cStr());
 		J3CodeGen::translate(this, mode | cl()->loader()->compilationMode());
  	}
 }

 void* J3Method::functionPointerOrStaticTrampoline() {
 	if(fnPtr())
 		return fnPtr();
 	if(!_staticTrampoline)
 		_staticTrampoline = J3Trampoline::buildStaticTrampoline(cl()->loader()->allocator(), this);
 	return _staticTrampoline;
 }

 void* J3Method::functionPointerOrVirtualTrampoline() {
 	if(fnPtr())
 		return fnPtr();
 	if(!_virtualTrampoline)
 		_virtualTrampoline = J3Trampoline::buildVirtualTrampoline(cl()->loader()->allocator(), this);
 	return _virtualTrampoline;
 }

 void* J3Method::getSymbolAddress() {
 	return functionPointerOrStaticTrampoline();
 }

 void J3Method::setIndex(uint32_t index) {
 	_index = index;
 }

 void J3Method::postInitialise(uint32_t access, J3Attributes* attributes) {
 	if((access & J3Cst::ACC_STATIC) != (_access & J3Cst::ACC_STATIC))
 		J3::classFormatError(cl(), "trying to modify the static flag of %s", cl()->name()->cStr());
 	_access = access;
 	_attributes = attributes;
 }

 J3Method* J3Method::resolve(J3ObjectHandle* obj) {
 	J3* vm = J3Thread::get()->vm();
 	if(vm->options()->debugLinking)
 		fprintf(stderr, "virtual linking %s::%s\n", cl()->name()->cStr(), name()->cStr());
 	vmkit::Names* n = vm->names();
 	return obj->vt()->type()->asObjectType()->findMethod(0, name(), signature());
 }

 J3Value J3Method::internalInvoke(J3Value* args) {
 #if 1
 	return cxxCaller()(fnPtr(), args);
 #else
 	J3Value res;
 	try {
 		res = cxxCaller()(fnPtr(), args);
 	} catch(void* e) {
 		fprintf(stderr, " catch exception %p during the execution of %s::%s%s\n",
 						e, cl()->name()->cStr(), name()->cStr(), signature()->name()->cStr());
 		throw e;
 	}
 	return res;
 #endif
 }

 J3Value J3Method::internalInvoke(J3ObjectHandle* handle, J3Value* inArgs) {
 	cl()->initialise();
 	ensureCompiled(J3CodeGen::WithMethod | J3CodeGen::WithCaller);  /* force the generation of the code and thus of the functionType */

 	J3Value* reIn;
 	if(handle) {
 		uint32_t n = signature()->functionType(J3Cst::ACC_STATIC)->getNumParams();
 		reIn = (J3Value*)alloca((n+1)*sizeof(J3Value));
 		reIn[0].valObject = handle;
 		memcpy(reIn+1, inArgs, n*sizeof(J3Value));
 	} else
 		reIn = inArgs;

 	return internalInvoke(reIn);
 }

 J3Value J3Method::internalInvoke(J3ObjectHandle* handle, va_list va) {
 	cl()->initialise();
 	ensureCompiled(J3CodeGen::WithMethod | J3CodeGen::WithCaller);  /* force the generation of the code and thus of the functionType */

 	llvm::FunctionType* fType = signature()->functionType(J3Cst::ACC_STATIC);      /* static signature for va */
 	J3Value* args = (J3Value*)alloca(sizeof(J3Value)*(fType->getNumParams() + 1));
 	J3* vm = J3Thread::get()->vm();
 	uint32_t i = 0;

 	if(handle)
 		args[i++].valObject = handle;

 	for(llvm::FunctionType::param_iterator cur=fType->param_begin(); cur!=fType->param_end(); cur++, i++) {
 		llvm::Type* t = *cur;

 		if(0) {}
 #define doIt(id, ctype, lt, scale)							\
 		else if(t == vm->type##id->llvmType())			\
 			args[i].val##id = va_arg(va, ctype);
 		onJavaPrimitives(doIt)
 		else
 			args[i].valObject = va_arg(va, J3ObjectHandle*);
 #undef doIt
 	}

 	return internalInvoke(args);
 }

 J3Value J3Method::invokeStatic(J3Value* args) {
 	return internalInvoke(0, args);
 }

 J3Value J3Method::invokeStatic(va_list va) {
 	return internalInvoke(0, va);
 }

 J3Value J3Method::invokeSpecial(J3ObjectHandle* handle, J3Value* args) {
 	return internalInvoke(handle, args);
 }

 J3Value J3Method::invokeSpecial(J3ObjectHandle* handle, va_list va) {
 	return internalInvoke(handle, va);
 }

 J3Value J3Method::invokeVirtual(J3ObjectHandle* handle, J3Value* args) {
 	return resolve(handle)->internalInvoke(handle, args);
 }

 J3Value J3Method::invokeVirtual(J3ObjectHandle* handle, va_list va) {
 	return resolve(handle)->internalInvoke(handle, va);
 }

 J3Value J3Method::invokeStatic(...) {
 	va_list va;
 	va_start(va, this);
 	J3Value res = invokeStatic(va);
 	va_end(va);
 	return res;
 }

 J3Value J3Method::invokeSpecial(J3ObjectHandle* handle, ...) {
 	va_list va;
 	va_start(va, this);
 	J3Value res = invokeSpecial(handle, va);
 	va_end(va);
 	return res;
 }

 J3Value J3Method::invokeVirtual(J3ObjectHandle* handle, ...) {
 	va_list va;
 	va_start(va, this);
 	J3Value res = invokeVirtual(handle, va);
 	va_end(va);
 	return res;
 }

 void J3Method::buildLLVMNames(J3Class* from) {
 	const char* prefix = "stub_";
 	uint32_t plen = 5;
 	J3Mangler mangler(from);

 	mangler.mangle(mangler.j3Id)->mangle(cl()->name(), name())->mangle(signature());

 	uint32_t length = mangler.length() + plen;
 	_llvmAllNames = (char*)cl()->loader()->allocator()->allocate(length + 1);
 	memcpy(_llvmAllNames, prefix, plen);
 	memcpy(_llvmAllNames+plen, mangler.cStr(), mangler.length());
 	_llvmAllNames[length] = 0;
 }

 char* J3Method::llvmFunctionName(J3Class* from) {
 	if(!_llvmAllNames)
 		buildLLVMNames(from ? from : cl());
 	return _llvmAllNames + 5;
 }

 char* J3Method::llvmStubName(J3Class* from) {
 	if(!_llvmAllNames)
 		buildLLVMNames(from ? from : cl());
 	return _llvmAllNames + 0;
 }

 void J3Method::dump() {
 	printf("Method: %s %s::%s\n", signature()->name()->cStr(), cl()->name()->cStr(), name()->cStr());
 }

 void J3Method::registerNative(void* fnPtr) {
 	if(_nativeFnPtr)
 		J3::noSuchMethodError("unable to dynamically modify a native function", cl(), name(), signature());
 	_nativeFnPtr = fnPtr;
 }

 J3Method* J3Method::nativeMethod(J3ObjectHandle* handle) {
 	J3* vm = J3Thread::get()->vm();
 	if(handle->vt()->type() == vm->constructorClass) {
 		J3Class* cl = J3ObjectType::nativeClass(handle->getObject(vm->constructorClassClass))->asClass();
 		uint32_t slot = handle->getInteger(vm->constructorClassSlot);
 		J3Method* res = cl->methods()[slot];
 		if(res->name() != vm->initName)
 			J3::internalError("nativeName with a java.lang.reflect.Constructor with a non-constructot method");
 		return res;
 	} else
 		J3::internalError("implement me: nativeMethod with method");
 }

 J3ObjectHandle* J3Method::javaMethod() {
 	if(!_javaMethod) {
 		cl()->lock();
 		if(!_javaMethod) {
 			J3ObjectHandle* prev = J3Thread::get()->tell();
 			J3* vm = J3Thread::get()->vm();

 			uint32_t nbIns = signature()->nbIns();

 			J3ObjectHandle* parameters = J3ObjectHandle::doNewArray(vm->classClass->getArray(), nbIns);

 			for(uint32_t i=0; i<nbIns; i++)
 				parameters->setObjectAt(i, signature()->javaIns(i)->javaClass(0));

 			J3Attribute* exceptionAttribute = attributes()->lookup(vm->exceptionsAttribute);
 			J3ObjectHandle* exceptions;

 			if(exceptionAttribute)
 				J3::internalError("implement me: excp");
 			else
 				exceptions = J3ObjectHandle::doNewArray(vm->classClass->getArray(), 0);

 			J3ObjectHandle* annotations = cl()->asClass()->extractAttribute(attributes()->lookup(vm->annotationsAttribute));
 			J3ObjectHandle* paramAnnotations = cl()->asClass()->extractAttribute(attributes()->lookup(vm->paramAnnotationsAttribute));

 			if(name() == vm->initName) {
 				_javaMethod = cl()->loader()->globalReferences()->add(J3ObjectHandle::doNewObject(vm->constructorClass));

 				vm->constructorClassInit->invokeSpecial(_javaMethod,
 																								cl()->javaClass(0),
 																								parameters,
 																								exceptions,
 																								access(),
 																								slot(),
 																								vm->nameToString(signature()->name(), 0),
 																								annotations,
 																								paramAnnotations);
 			} else {
 				J3ObjectHandle* annotationDefault = cl()->asClass()->extractAttribute(attributes()->lookup(vm->annotationDefaultAttribute));

 				_javaMethod = cl()->loader()->globalReferences()->add(J3ObjectHandle::doNewObject(vm->methodClass));

 				vm->methodClassInit->invokeSpecial(_javaMethod,
 																					 cl()->javaClass(0),
 																					 vm->nameToString(name(), 0),
 																					 parameters,
 																					 signature()->javaOut()->javaClass(0),
 																					 exceptions,
 																					 access(),
 																					 slot(),
 																					 vm->nameToString(signature()->name(), 0),
 																					 annotations,
 																					 paramAnnotations,
 																					 annotationDefault);
 			}

 			J3Thread::get()->restore(prev);
 		}
 		cl()->unlock();
 	}

 	return _javaMethod;
 }
	#include "vmkit/safepoint.h"

	#include "j3/j3method.h"
	#include "j3/j3class.h"
	#include "j3/j3classloader.h"
	#include "j3/j3constants.h"
	#include "j3/j3.h"
	#include "j3/j3mangler.h"
	#include "j3/j3thread.h"
	#include "j3/j3codegen.h"
	#include "j3/j3trampoline.h"
	#include "j3/j3attribute.h"
	#include "j3/j3reader.h"

	#include "llvm/IR/Type.h"
	#include "llvm/IR/Module.h"
	#include "llvm/IR/Function.h"
	#include "llvm/Linker.h"

	#include "llvm/ExecutionEngine/GenericValue.h"
	#include "llvm/ExecutionEngine/ExecutionEngine.h"

	#include <vector>

	using namespace j3;

	J3Method::J3Method(uint16_t access, J3Class* cl, const vmkit::Name* name, J3Signature* signature) {
	_access = access;
	_cl = cl;
	_name = name;
	_signature = signature;
	_index = -1;
	}

	J3Attributes* J3Method::codeAttributes() {
	if(!_codeAttributes) {
	J3* vm = J3Thread::get()->vm();
	J3Attribute* codeAttr = attributes()->lookup(vm->codeAttribute);
	if(codeAttr) {
	J3Reader reader(cl()->bytes());
	reader.seek(codeAttr->offset()+8, reader.SeekSet);
	reader.seek(reader.readU4(), reader.SeekCur);
	reader.seek(reader.readU2()*8, reader.SeekCur);
	_codeAttributes = cl()->readAttributes(&reader);
	}
	}
	return _codeAttributes;
	}

	vmkit::CompilationUnit* J3Method::unit() {
	return cl()->loader();
	}

	uint64_t J3Method::inlineWeight() {
	if(J3Thread::get()->vm()->options()->enableInlining)
	return vmkit::Symbol::inlineWeight();
	else
	return (uint64_t)-1;
	}

	uint32_t J3Method::interfaceIndex() {
	return cl()->loader()->interfaceIndex(this);
	}

	uint32_t J3Method::index() {
	return _index;
	}

	void J3Method::markCompiled(llvm::Function* llvmFunction, void* fnPtr) {
	_llvmFunction = llvmFunction;
	_fnPtr = fnPtr;
	}

	void* J3Method::fnPtr() {
	return _fnPtr;
	}

	J3Signature::function_t J3Method::cxxCaller() {
	return signature()->caller(access());
	}

	void J3Method::aotSnapshot(llvm::Linker* linker) {
	if(_llvmFunction) {
	std::string err;
	linker->linkInModule(_llvmFunction->getParent(), llvm::Linker::DestroySource, &err);
	}
	}

	void J3Method::ensureCompiled(uint32_t mode) {
	if(((mode & J3CodeGen::WithMethod) && !fnPtr()) \|\| ((mode & J3CodeGen::WithCaller) && !cxxCaller())) {
	//fprintf(stderr, "materializing: %s::%s%s\n", cl()->name()->cStr(), name()->cStr(), signature()->name()->cStr());
	J3CodeGen::translate(this, mode \| cl()->loader()->compilationMode());
	}
	}

	void* J3Method::functionPointerOrStaticTrampoline() {
	if(fnPtr())
	return fnPtr();
	if(!_staticTrampoline)
	_staticTrampoline = J3Trampoline::buildStaticTrampoline(cl()->loader()->allocator(), this);
	return _staticTrampoline;
	}

	void* J3Method::functionPointerOrVirtualTrampoline() {
	if(fnPtr())
	return fnPtr();
	if(!_virtualTrampoline)
	_virtualTrampoline = J3Trampoline::buildVirtualTrampoline(cl()->loader()->allocator(), this);
	return _virtualTrampoline;
	}

	void* J3Method::getSymbolAddress() {
	return functionPointerOrStaticTrampoline();
	}

	void J3Method::setIndex(uint32_t index) {
	_index = index;
	}

	void J3Method::postInitialise(uint32_t access, J3Attributes* attributes) {
	if((access & J3Cst::ACC_STATIC) != (_access & J3Cst::ACC_STATIC))
	J3::classFormatError(cl(), "trying to modify the static flag of %s", cl()->name()->cStr());
	_access = access;
	_attributes = attributes;
	}

	J3Method* J3Method::resolve(J3ObjectHandle* obj) {
	J3* vm = J3Thread::get()->vm();
	if(vm->options()->debugLinking)
	fprintf(stderr, "virtual linking %s::%s\n", cl()->name()->cStr(), name()->cStr());
	vmkit::Names* n = vm->names();
	return obj->vt()->type()->asObjectType()->findMethod(0, name(), signature());
	}

	J3Value J3Method::internalInvoke(J3Value* args) {
	#if 1
	return cxxCaller()(fnPtr(), args);
	#else
	J3Value res;
	try {
	res = cxxCaller()(fnPtr(), args);
	} catch(void* e) {
	fprintf(stderr, " catch exception %p during the execution of %s::%s%s\n",
	e, cl()->name()->cStr(), name()->cStr(), signature()->name()->cStr());
	throw e;
	}
	return res;
	#endif
	}

	J3Value J3Method::internalInvoke(J3ObjectHandle* handle, J3Value* inArgs) {
	cl()->initialise();
	ensureCompiled(J3CodeGen::WithMethod \| J3CodeGen::WithCaller); /* force the generation of the code and thus of the functionType */

	J3Value* reIn;
	if(handle) {
	uint32_t n = signature()->functionType(J3Cst::ACC_STATIC)->getNumParams();
	reIn = (J3Value)alloca((n+1)sizeof(J3Value));
	reIn[0].valObject = handle;
	memcpy(reIn+1, inArgs, n*sizeof(J3Value));
	} else
	reIn = inArgs;

	return internalInvoke(reIn);
	}

	J3Value J3Method::internalInvoke(J3ObjectHandle* handle, va_list va) {
	cl()->initialise();
	ensureCompiled(J3CodeGen::WithMethod \| J3CodeGen::WithCaller); /* force the generation of the code and thus of the functionType */

	llvm::FunctionType* fType = signature()->functionType(J3Cst::ACC_STATIC); /* static signature for va */
	J3Value* args = (J3Value)alloca(sizeof(J3Value)(fType->getNumParams() + 1));
	J3* vm = J3Thread::get()->vm();
	uint32_t i = 0;

	if(handle)
	args[i++].valObject = handle;

	for(llvm::FunctionType::param_iterator cur=fType->param_begin(); cur!=fType->param_end(); cur++, i++) {
	llvm::Type* t = *cur;

	if(0) {}
	#define doIt(id, ctype, lt, scale) \
	else if(t == vm->type##id->llvmType()) \
	args[i].val##id = va_arg(va, ctype);
	onJavaPrimitives(doIt)
	else
	args[i].valObject = va_arg(va, J3ObjectHandle*);
	#undef doIt
	}

	return internalInvoke(args);
	}

	J3Value J3Method::invokeStatic(J3Value* args) {
	return internalInvoke(0, args);
	}

	J3Value J3Method::invokeStatic(va_list va) {
	return internalInvoke(0, va);
	}

	J3Value J3Method::invokeSpecial(J3ObjectHandle* handle, J3Value* args) {
	return internalInvoke(handle, args);
	}

	J3Value J3Method::invokeSpecial(J3ObjectHandle* handle, va_list va) {
	return internalInvoke(handle, va);
	}

	J3Value J3Method::invokeVirtual(J3ObjectHandle* handle, J3Value* args) {
	return resolve(handle)->internalInvoke(handle, args);
	}

	J3Value J3Method::invokeVirtual(J3ObjectHandle* handle, va_list va) {
	return resolve(handle)->internalInvoke(handle, va);
	}

	J3Value J3Method::invokeStatic(...) {
	va_list va;
	va_start(va, this);
	J3Value res = invokeStatic(va);
	va_end(va);
	return res;
	}

	J3Value J3Method::invokeSpecial(J3ObjectHandle* handle, ...) {
	va_list va;
	va_start(va, this);
	J3Value res = invokeSpecial(handle, va);
	va_end(va);
	return res;
	}

	J3Value J3Method::invokeVirtual(J3ObjectHandle* handle, ...) {
	va_list va;
	va_start(va, this);
	J3Value res = invokeVirtual(handle, va);
	va_end(va);
	return res;
	}

	void J3Method::buildLLVMNames(J3Class* from) {
	const char* prefix = "stub_";
	uint32_t plen = 5;
	J3Mangler mangler(from);

	mangler.mangle(mangler.j3Id)->mangle(cl()->name(), name())->mangle(signature());

	uint32_t length = mangler.length() + plen;
	_llvmAllNames = (char*)cl()->loader()->allocator()->allocate(length + 1);
	memcpy(_llvmAllNames, prefix, plen);
	memcpy(_llvmAllNames+plen, mangler.cStr(), mangler.length());
	_llvmAllNames[length] = 0;
	}

	char* J3Method::llvmFunctionName(J3Class* from) {
	if(!_llvmAllNames)
	buildLLVMNames(from ? from : cl());
	return _llvmAllNames + 5;
	}

	char* J3Method::llvmStubName(J3Class* from) {
	if(!_llvmAllNames)
	buildLLVMNames(from ? from : cl());
	return _llvmAllNames + 0;
	}

	void J3Method::dump() {
	printf("Method: %s %s::%s\n", signature()->name()->cStr(), cl()->name()->cStr(), name()->cStr());
	}

	void J3Method::registerNative(void* fnPtr) {
	if(_nativeFnPtr)
	J3::noSuchMethodError("unable to dynamically modify a native function", cl(), name(), signature());
	_nativeFnPtr = fnPtr;
	}

	J3Method* J3Method::nativeMethod(J3ObjectHandle* handle) {
	J3* vm = J3Thread::get()->vm();
	if(handle->vt()->type() == vm->constructorClass) {
	J3Class* cl = J3ObjectType::nativeClass(handle->getObject(vm->constructorClassClass))->asClass();
	uint32_t slot = handle->getInteger(vm->constructorClassSlot);
	J3Method* res = cl->methods()[slot];
	if(res->name() != vm->initName)
	J3::internalError("nativeName with a java.lang.reflect.Constructor with a non-constructot method");
	return res;
	} else
	J3::internalError("implement me: nativeMethod with method");
	}

	J3ObjectHandle* J3Method::javaMethod() {
	if(!_javaMethod) {
	cl()->lock();
	if(!_javaMethod) {
	J3ObjectHandle* prev = J3Thread::get()->tell();
	J3* vm = J3Thread::get()->vm();

	uint32_t nbIns = signature()->nbIns();

	J3ObjectHandle* parameters = J3ObjectHandle::doNewArray(vm->classClass->getArray(), nbIns);

	for(uint32_t i=0; i<nbIns; i++)
	parameters->setObjectAt(i, signature()->javaIns(i)->javaClass(0));

	J3Attribute* exceptionAttribute = attributes()->lookup(vm->exceptionsAttribute);
	J3ObjectHandle* exceptions;

	if(exceptionAttribute)
	J3::internalError("implement me: excp");
	else
	exceptions = J3ObjectHandle::doNewArray(vm->classClass->getArray(), 0);

	J3ObjectHandle* annotations = cl()->asClass()->extractAttribute(attributes()->lookup(vm->annotationsAttribute));
	J3ObjectHandle* paramAnnotations = cl()->asClass()->extractAttribute(attributes()->lookup(vm->paramAnnotationsAttribute));

	if(name() == vm->initName) {
	_javaMethod = cl()->loader()->globalReferences()->add(J3ObjectHandle::doNewObject(vm->constructorClass));

	vm->constructorClassInit->invokeSpecial(_javaMethod,
	cl()->javaClass(0),
	parameters,
	exceptions,
	access(),
	slot(),
	vm->nameToString(signature()->name(), 0),
	annotations,
	paramAnnotations);
	} else {
	J3ObjectHandle* annotationDefault = cl()->asClass()->extractAttribute(attributes()->lookup(vm->annotationDefaultAttribute));

	_javaMethod = cl()->loader()->globalReferences()->add(J3ObjectHandle::doNewObject(vm->methodClass));

	vm->methodClassInit->invokeSpecial(_javaMethod,
	cl()->javaClass(0),
	vm->nameToString(name(), 0),
	parameters,
	signature()->javaOut()->javaClass(0),
	exceptions,
	access(),
	slot(),
	vm->nameToString(signature()->name(), 0),
	annotations,
	paramAnnotations,
	annotationDefault);
	}

	J3Thread::get()->restore(prev);
	}
	cl()->unlock();
	}

	return _javaMethod;
	}