[vmkit-commits] [vmkit] r69886 - in /vmkit/trunk/lib/JnJVM: Classpath/ClasspathVMRuntime.cpp Compiler/JnjvmModule.cpp LLVMRuntime/runtime-default.ll LLVMRuntime/runtime-isolate.ll LLVMRuntime/runtime-service.ll VMCore/JavaRuntimeJIT.cpp
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Thu Apr 23 04:47:32 PDT 2009
Author: geoffray
Date: Thu Apr 23 06:47:14 2009
New Revision: 69886
URL: http://llvm.org/viewvc/llvm-project?rev=69886&view=rev
Log:
Make namking more consistent (all jnjvm runtime functions
are named with a "jnjvm" prefix).
Modified:
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp
vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-service.ll
vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=69886&r1=69885&r2=69886&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Thu Apr 23 06:47:14 2009
@@ -75,7 +75,7 @@
#endif
typedef int (*onLoad_t)(const void**, void*);
-extern "C" void jniProceedPendingException();
+extern "C" void jnjvmJNIProceedPendingException();
// Calls the JNI_OnLoad function of a dynamic library.
void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm) {
@@ -92,7 +92,7 @@
if (setjmp((jumpbuf_t)buf) == 0) {
onLoad(&vm->javavmEnv, res);
}
- jniProceedPendingException();
+ jnjvmJNIProceedPendingException();
}
}
Modified: vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp?rev=69886&r1=69885&r2=69886&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JnjvmModule.cpp Thu Apr 23 06:47:14 2009
@@ -327,8 +327,8 @@
module->addTypeName("CacheNode", CacheNodeType);
module->addTypeName("Enveloppe", EnveloppeType);
- InterfaceLookupFunction = module->getFunction("jnjvmVirtualLookup");
- MultiCallNewFunction = module->getFunction("multiCallNew");
+ InterfaceLookupFunction = module->getFunction("jnjvmInterfaceLookup");
+ MultiCallNewFunction = module->getFunction("jnjvmMultiCallNew");
ForceLoadedCheckFunction = module->getFunction("forceLoadedCheck");
InitialisationCheckFunction = module->getFunction("initialisationCheck");
ForceInitialisationCheckFunction =
@@ -339,7 +339,7 @@
ArrayLengthFunction = module->getFunction("arrayLength");
GetVTFunction = module->getFunction("getVT");
GetClassFunction = module->getFunction("getClass");
- ClassLookupFunction = module->getFunction("classLookup");
+ ClassLookupFunction = module->getFunction("jnjvmClassLookup");
GetVTFromClassFunction = module->getFunction("getVTFromClass");
GetVTFromClassArrayFunction = module->getFunction("getVTFromClassArray");
GetVTFromCommonClassFunction = module->getFunction("getVTFromCommonClass");
@@ -355,36 +355,36 @@
GetStaticInstanceFunction = module->getFunction("getStaticInstance");
GetDisplayFunction = module->getFunction("getDisplay");
GetVTInDisplayFunction = module->getFunction("getVTInDisplay");
- AquireObjectFunction = module->getFunction("JavaObjectAquire");
- ReleaseObjectFunction = module->getFunction("JavaObjectRelease");
- OverflowThinLockFunction = module->getFunction("overflowThinLock");
+ AquireObjectFunction = module->getFunction("jnjvmJavaObjectAquire");
+ ReleaseObjectFunction = module->getFunction("jnjvmJavaObjectRelease");
+ OverflowThinLockFunction = module->getFunction("jnjvmOverflowThinLock");
- VirtualFieldLookupFunction = module->getFunction("virtualFieldLookup");
- StaticFieldLookupFunction = module->getFunction("staticFieldLookup");
+ VirtualFieldLookupFunction = module->getFunction("jnjvmVirtualFieldLookup");
+ StaticFieldLookupFunction = module->getFunction("jnjvmStaticFieldLookup");
JniProceedPendingExceptionFunction =
- module->getFunction("jniProceedPendingException");
- GetSJLJBufferFunction = module->getFunction("getSJLJBuffer");
+ module->getFunction("jnjvmJNIProceedPendingException");
+ GetSJLJBufferFunction = module->getFunction("jnjvmGetSJLJBuffer");
NullPointerExceptionFunction =
module->getFunction("jnjvmNullPointerException");
ClassCastExceptionFunction = module->getFunction("jnjvmClassCastException");
IndexOutOfBoundsExceptionFunction =
- module->getFunction("indexOutOfBoundsException");
+ module->getFunction("jnjvmIndexOutOfBoundsException");
NegativeArraySizeExceptionFunction =
- module->getFunction("negativeArraySizeException");
- OutOfMemoryErrorFunction = module->getFunction("outOfMemoryError");
+ module->getFunction("jnjvmNegativeArraySizeException");
+ OutOfMemoryErrorFunction = module->getFunction("jnjvmOutOfMemoryError");
ArrayStoreExceptionFunction = module->getFunction("jnjvmArrayStoreException");
JavaObjectAllocateFunction = module->getFunction("gcmalloc");
- PrintExecutionFunction = module->getFunction("printExecution");
- PrintMethodStartFunction = module->getFunction("printMethodStart");
- PrintMethodEndFunction = module->getFunction("printMethodEnd");
+ PrintExecutionFunction = module->getFunction("jnjvmPrintExecution");
+ PrintMethodStartFunction = module->getFunction("jnjvmPrintMethodStart");
+ PrintMethodEndFunction = module->getFunction("jnjvmPrintMethodEnd");
- ThrowExceptionFunction = module->getFunction("JavaThreadThrowException");
+ ThrowExceptionFunction = module->getFunction("jnjvmThrowException");
- GetArrayClassFunction = module->getFunction("getArrayClass");
+ GetArrayClassFunction = module->getFunction("jnjvmGetArrayClass");
GetFinalInt8FieldFunction = module->getFunction("getFinalInt8Field");
GetFinalInt16FieldFunction = module->getFunction("getFinalInt16Field");
@@ -395,22 +395,22 @@
GetFinalObjectFieldFunction = module->getFunction("getFinalObjectField");
#ifdef ISOLATE
- StringLookupFunction = module->getFunction("stringLookup");
+ StringLookupFunction = module->getFunction("jnjvmStringLookup");
#ifdef ISOLATE_SHARING
- EnveloppeLookupFunction = module->getFunction("enveloppeLookup");
+ EnveloppeLookupFunction = module->getFunction("jnjvmEnveloppeLookup");
GetCtpCacheNodeFunction = module->getFunction("getCtpCacheNode");
GetCtpClassFunction = module->getFunction("getCtpClass");
GetJnjvmExceptionClassFunction =
module->getFunction("getJnjvmExceptionClass");
GetJnjvmArrayClassFunction = module->getFunction("getJnjvmArrayClass");
- StaticCtpLookupFunction = module->getFunction("staticCtpLookup");
- SpecialCtpLookupFunction = module->getFunction("specialCtpLookup");
+ StaticCtpLookupFunction = module->getFunction("jnjvmStaticCtpLookup");
+ SpecialCtpLookupFunction = module->getFunction("jnjvmSpecialCtpLookup");
#endif
#endif
#ifdef SERVICE
- ServiceCallStartFunction = module->getFunction("serviceCallStart");
- ServiceCallStopFunction = module->getFunction("serviceCallStop");
+ ServiceCallStartFunction = module->getFunction("jnjvmServiceCallStart");
+ ServiceCallStopFunction = module->getFunction("jnjvmServiceCallStop");
#endif
#ifdef WITH_TRACER
@@ -421,7 +421,7 @@
#endif
#ifndef WITHOUT_VTABLE
- VirtualLookupFunction = module->getFunction("vtableLookup");
+ VirtualLookupFunction = module->getFunction("jnjvmVirtualTableLookup");
#endif
GetLockFunction = module->getFunction("getLock");
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll?rev=69886&r1=69885&r2=69886&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Thu Apr 23 06:47:14 2009
@@ -118,12 +118,12 @@
;;;;;;;;;;;;;;;;;;;;;;;; Generic Runtime methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; virtualLookup - Used for interface calls.
-declare i8* @jnjvmVirtualLookup(%CacheNode*, %JavaObject*)
+;;; jnjvmInterfaceLookup - Used for interface calls.
+declare i8* @jnjvmInterfaceLookup(%CacheNode*, %JavaObject*)
-;;; multiCallNew - Allocate multi-dimensional arrays. This will go to allocation
-;;; specific methods.
-declare %JavaObject* @multiCallNew(%JavaCommonClass*, i32, ...)
+;;; jnjvmMultiCallNew - Allocate multi-dimensional arrays. This will go to
+;;; allocation specific methods.
+declare %JavaObject* @jnjvmMultiCallNew(%JavaCommonClass*, i32, ...)
;;; initialisationCheck - Checks if the class has been initialized and
;;; initializes if not. This is used for initialization barriers in an isolate
@@ -149,33 +149,33 @@
declare i8* @getConstantPoolAt(i8* (%JavaClass*, i32, ...)*, i8**,
%JavaClass*, i32, ...) readnone
-;;; vtableLookup - Look up the offset in a virtual table of a specific
-;;; function. This function takes a class and an index to lookup in the
+;;; jnjvmVirtualTableLookup - Look up the offset in a virtual table of a
+;;; specific function. This function takes a class and an index to lookup in the
;;; constant pool and returns and stores it in the constant pool cache.
-declare i8* @vtableLookup(%JavaClass*, i32, ...)
+declare i8* @jnjvmVirtualTableLookup(%JavaClass*, i32, ...)
-;;; newLookup - Look up a specific class. The function takes a class and an
-;;; index to lookup in the constant pool and returns and stores it in the
+;;; jnjvmClassLookup - Look up a specific class. The function takes a class and
+;;; an index to lookup in the constant pool and returns and stores it in the
;;; constant pool cache.
-declare i8* @classLookup(%JavaClass*, i32, ...)
+declare i8* @jnjvmClassLookup(%JavaClass*, i32, ...)
-;;; virtualFieldLookup - Look up a specific virtual field.
-declare i8* @virtualFieldLookup(%JavaClass*, i32, ...)
+;;; jnjvmVirtualFieldLookup - Look up a specific virtual field.
+declare i8* @jnjvmVirtualFieldLookup(%JavaClass*, i32, ...)
-;;; staticFieldLookup - Look up a specific static field.
-declare i8* @staticFieldLookup(%JavaClass*, i32, ...)
+;;; jnjvmStaticFieldLookup - Look up a specific static field.
+declare i8* @jnjvmStaticFieldLookup(%JavaClass*, i32, ...)
-;;; JavaObjectAquire - This function is called when starting a synchronized
+;;; jnjvmJavaObjectAquire - This function is called when starting a synchronized
;;; block or method.
-declare void @JavaObjectAquire(%JavaObject*)
+declare void @jnjvmJavaObjectAquire(%JavaObject*)
-;;; JavaObjectRelease - This function is called when leaving a synchronized
+;;; jnjvmJavaObjectRelease - This function is called when leaving a synchronized
;;; block or method.
-declare void @JavaObjectRelease(%JavaObject*)
+declare void @jnjvmJavaObjectRelease(%JavaObject*)
-;;; overflowThinLock - Change a thin lock to a fat lock when the thin lock
+;;; jnjvmOverflowThinLock - Change a thin lock to a fat lock when the thin lock
;;; overflows
-declare void @overflowThinLock(%JavaObject*)
+declare void @jnjvmOverflowThinLock(%JavaObject*)
;;; isAssignableFrom - Returns if a type is a subtype of another type.
declare i1 @isAssignableFrom(%VT*, %VT*) readnone
@@ -194,9 +194,9 @@
;;; yet.
declare %JavaObject* @jnjvmRuntimeDelegatee(%JavaCommonClass*) readnone
-;;; getArrayClass - Get the array user class of the user class.
-declare %JavaClassArray* @getArrayClass(%JavaCommonClass*,
- %JavaClassArray**) readnone
+;;; jnjvmGetArrayClass - Get the array user class of the user class.
+declare %JavaClassArray* @jnjvmGetArrayClass(%JavaCommonClass*,
+ %JavaClassArray**) readnone
declare i8 @getFinalInt8Field(i8*) readnone
declare i16 @getFinalInt16Field(i16*) readnone
@@ -212,14 +212,14 @@
declare %JavaObject* @jnjvmNullPointerException()
declare %JavaObject* @jnjvmClassCastException(%JavaObject*, %JavaCommonClass*)
-declare %JavaObject* @indexOutOfBoundsException(%JavaObject*, i32)
-declare %JavaObject* @negativeArraySizeException(i32)
-declare %JavaObject* @outOfMemoryError(i32)
+declare %JavaObject* @jnjvmIndexOutOfBoundsException(%JavaObject*, i32)
+declare %JavaObject* @jnjvmNegativeArraySizeException(i32)
+declare %JavaObject* @jnjvmOutOfMemoryError(i32)
declare %JavaObject* @jnjvmArrayStoreException(%VT*)
-declare void @JavaThreadThrowException(%JavaObject*)
+declare void @jnjvmThrowException(%JavaObject*)
-declare void @jniProceedPendingException()
-declare i8* @getSJLJBuffer()
+declare void @jnjvmJNIProceedPendingException()
+declare i8* @jnjvmGetSJLJBuffer()
declare %JavaObject* @gcmalloc(i32, %VT*)
@@ -227,6 +227,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Debugging methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-declare void @printExecution(i32, i32, %JavaMethod*)
-declare void @printMethodStart(%JavaMethod*)
-declare void @printMethodEnd(%JavaMethod*)
+declare void @jnjvmPrintExecution(i32, i32, %JavaMethod*)
+declare void @jnjvmPrintMethodStart(%JavaMethod*)
+declare void @jnjvmPrintMethodEnd(%JavaMethod*)
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll?rev=69886&r1=69885&r2=69886&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll Thu Apr 23 06:47:14 2009
@@ -19,20 +19,20 @@
;;;;;;;;;;;;;;;;;;;;;;;; Isolate specific methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; enveloppeLookup - Find the enveloppe for the current user class.
-declare i8* @enveloppeLookup(%JavaClass*, i32, ...) readnone
+;;; jnjvmEnveloppeLookup - Find the enveloppe for the current user class.
+declare i8* @jnjvmEnveloppeLookup(%JavaClass*, i32, ...) readnone
-;;; stringLookup - Find the isolate-specific string at the given offset in the
-;;; constant pool.
-declare i8* @stringLookup(%JavaClass*, i32, ...) readnone
-
-;;; staticCtpLookup - Find the user constant pool at the given offset in the
-;;; constant pool.
-declare i8* @staticCtpLookup(%JavaClass*, i32, ...) readnone
-
-;;; specialCtpLookup - Find the user constant pool at the given offset in the
-;;; constant pool.
-declare i8** @specialCtpLookup(i8**, i32, i8**) readnone
+;;; jnjvmStringLookup - Find the isolate-specific string at the given offset in
+;;; the constant pool.
+declare i8* @jnjvmStringLookup(%JavaClass*, i32, ...) readnone
+
+;;; jnjvmStaticCtpLookup - Find the user constant pool at the given offset in
+;;; the constant pool.
+declare i8* @jnjvmStaticCtpLookup(%JavaClass*, i32, ...) readnone
+
+;;; jnjvmSpecialCtpLookup - Find the user constant pool at the given offset in
+;;; the constant pool.
+declare i8** @jnjvmSpecialCtpLookup(i8**, i32, i8**) readnone
;;; getCtpCacheNode - Get the constant pool cache of a cache node. This is a
;;; constant call because the cache node never changes.
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-service.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-service.ll?rev=69886&r1=69885&r2=69886&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-service.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-service.ll Thu Apr 23 06:47:14 2009
@@ -2,8 +2,8 @@
;;;;;;;;;;;;;;;;;;;;;;;; Service specific methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; serviceCallStart - Mark the switching between services.
-declare void @serviceCallStart(i8*, i8*)
+;;; jnjvmServiceCallStart - Mark the switching between services.
+declare void @jnjvmServiceCallStart(i8*, i8*)
-;;; serviceCallStop - Mark the switching between services.
-declare void @serviceCallStop(i8*, i8*)
+;;; jnjvmServiceCallStop - Mark the switching between services.
+declare void @jnjvmServiceCallStop(i8*, i8*)
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=69886&r1=69885&r2=69886&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Thu Apr 23 06:47:14 2009
@@ -25,7 +25,7 @@
using namespace jnjvm;
// Throws if the method is not found.
-extern "C" void* jnjvmVirtualLookup(CacheNode* cache, JavaObject *obj) {
+extern "C" void* jnjvmInterfaceLookup(CacheNode* cache, JavaObject *obj) {
void* res = 0;
@@ -99,7 +99,7 @@
}
// Throws if the field is not found.
-extern "C" void* virtualFieldLookup(UserClass* caller, uint32 index) {
+extern "C" void* jnjvmVirtualFieldLookup(UserClass* caller, uint32 index) {
void* res = 0;
@@ -134,7 +134,7 @@
}
// Throws if the field or its class is not found.
-extern "C" void* staticFieldLookup(UserClass* caller, uint32 index) {
+extern "C" void* jnjvmStaticFieldLookup(UserClass* caller, uint32 index) {
void* res = 0;
@@ -179,7 +179,7 @@
#ifndef WITHOUT_VTABLE
// Throws if the method is not found.
-extern "C" void* vtableLookup(UserClass* caller, uint32 index, ...) {
+extern "C" void* jnjvmVirtualTableLookup(UserClass* caller, uint32 index, ...) {
void* res = 0;
@@ -229,7 +229,7 @@
#endif
// Throws if the class is not found.
-extern "C" void* classLookup(UserClass* caller, uint32 index) {
+extern "C" void* jnjvmClassLookup(UserClass* caller, uint32 index) {
void* res = 0;
@@ -318,7 +318,7 @@
}
// Throws if one of the dimension is negative.
-extern "C" JavaArray* multiCallNew(UserClassArray* cl, uint32 len, ...) {
+extern "C" JavaArray* jnjvmMultiCallNew(UserClassArray* cl, uint32 len, ...) {
JavaArray* res = 0;
BEGIN_NATIVE_EXCEPTION(1)
@@ -338,8 +338,8 @@
}
// Throws if the class can not be resolved.
-extern "C" UserClassArray* getArrayClass(UserCommonClass* cl,
- UserClassArray** dcl) {
+extern "C" UserClassArray* jnjvmGetArrayClass(UserCommonClass* cl,
+ UserClassArray** dcl) {
UserClassArray* res = 0;
BEGIN_NATIVE_EXCEPTION(1)
@@ -362,7 +362,7 @@
}
// Does not call Java code.
-extern "C" void jniProceedPendingException() {
+extern "C" void jnjvmJNIProceedPendingException() {
JavaThread* th = JavaThread::get();
jmp_buf* buf = th->sjlj_buffers.back();
@@ -384,7 +384,7 @@
}
// Never throws.
-extern "C" void* getSJLJBuffer() {
+extern "C" void* jnjvmGetSJLJBuffer() {
JavaThread* th = JavaThread::get();
mvm::Allocator& allocator = th->getJVM()->gcAllocator;
void** buf = (void**)allocator.allocateTemporaryMemory(sizeof(jmp_buf));
@@ -399,22 +399,22 @@
}
// Never throws.
-extern "C" void JavaObjectAquire(JavaObject* obj) {
+extern "C" void jnjvmJavaObjectAquire(JavaObject* obj) {
obj->acquire();
}
// Never throws.
-extern "C" void JavaObjectRelease(JavaObject* obj) {
+extern "C" void jnjvmJavaObjectRelease(JavaObject* obj) {
obj->release();
}
// Does not call any Java code.
-extern "C" void JavaThreadThrowException(JavaObject* obj) {
+extern "C" void jnjvmThrowException(JavaObject* obj) {
return JavaThread::get()->throwException(obj);
}
// Never throws.
-extern "C" void overflowThinLock(JavaObject* obj) {
+extern "C" void jnjvmOverflowThinLock(JavaObject* obj) {
obj->overflowThinLock();
}
@@ -440,7 +440,7 @@
}
// Creates a Java object and then throws it.
-extern "C" JavaObject* negativeArraySizeException(sint32 val) {
+extern "C" JavaObject* jnjvmNegativeArraySizeException(sint32 val) {
JavaObject *exc = 0;
JavaThread *th = JavaThread::get();
@@ -460,7 +460,7 @@
}
// Creates a Java object and then throws it.
-extern "C" JavaObject* outOfMemoryError(sint32 val) {
+extern "C" JavaObject* jnjvmOutOfMemoryError(sint32 val) {
JavaObject *exc = 0;
JavaThread *th = JavaThread::get();
@@ -501,8 +501,8 @@
}
// Creates a Java object and then throws it.
-extern "C" JavaObject* indexOutOfBoundsException(JavaObject* obj,
- sint32 index) {
+extern "C" JavaObject* jnjvmIndexOutOfBoundsException(JavaObject* obj,
+ sint32 index) {
JavaObject *exc = 0;
JavaThread *th = JavaThread::get();
More information about the vmkit-commits
mailing list