| //===-------- Unsafe.inc - sun.misc.Unsafe implementation -----------------===// |
| // |
| // The VMKit project |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "VMStaticInstance.h" |
| #include <stdlib.h> |
| |
| /// fieldPtr - Compute the address of the field specified by the given |
| /// base/offset pair. Non-trivial due to our handling of static instances, |
| /// and this also handles null-checking as required. |
| /// |
| inline uint8 *fieldPtr(JavaObject *base, int64_t offset, |
| bool throwOnNull = true) { |
| |
| // For most uses, a 'null' base should throw an exception. |
| if (throwOnNull) verifyNull(base); |
| |
| if (base && VMStaticInstance::isVMStaticInstance(base)) |
| return (uint8*)((VMStaticInstance*)base)->getStaticInstance() + offset; |
| else |
| return (uint8*)base + offset; |
| } |
| |
| extern "C" { |
| |
| //===--- Base/Offset methods ----------------------------------------------===// |
| |
| /// staticFieldOffset - Return the offset of a particular static field |
| /// Only valid to be used with the corresponding staticFieldBase |
| /// |
| JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_staticFieldOffset( |
| JavaObject* unsafe, JavaObjectField* _field) { |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(_field, 0); |
| |
| jlong res = 0; |
| BEGIN_NATIVE_EXCEPTION(0) |
| |
| JavaField * field = JavaObjectField::getInternalField(_field); |
| assert(field); |
| |
| res = field->ptrOffset; |
| |
| END_NATIVE_EXCEPTION; |
| |
| return res; |
| } |
| |
| /// staticFieldBase - Return a JavaObject* representing the static instance. |
| /// Note that our static instances aren't actually java objects, so we use |
| /// a placeholder object "VMStaticInstance" that also ensures that |
| /// the corresponding class doesn't get GC'd underneath it. |
| /// |
| JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_staticFieldBase( |
| JavaObject* unsafe, JavaObjectField* _field) { |
| JavaObject* res = 0; |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(_field, 0); |
| llvm_gcroot(res, 0); |
| BEGIN_NATIVE_EXCEPTION(0) |
| |
| JavaField * field = JavaObjectField::getInternalField(_field); |
| assert(field); |
| field->classDef->initialiseClass(JavaThread::get()->getJVM()); |
| |
| res = VMStaticInstance::allocate(field->classDef); |
| |
| END_NATIVE_EXCEPTION; |
| |
| return res; |
| } |
| |
| /// arrayBaseOffset - Offset from the array object where the actual |
| /// element data begins. |
| /// |
| JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayBaseOffset( |
| JavaObject* unsafe, JavaObject* clazz) { |
| llvm_gcroot(clazz, 0); |
| llvm_gcroot(unsafe, 0); |
| // See JavaArray.h for arrays layout |
| return sizeof(JavaObject) + sizeof(ssize_t); |
| } |
| |
| /// arrayIndexScale - Indexing scale for the element type in |
| /// the specified array. For use with arrayBaseOffset, |
| /// NthElementPtr = ArrayObject + BaseOffset + N*IndexScale |
| /// Return '0' if our JVM stores the elements in a way that |
| /// makes this type of access impossible or unsupported. |
| /// |
| JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_arrayIndexScale( |
| JavaObject* unsafe, JavaObject* clazz) { |
| JavaObjectClass* jcl = 0; |
| llvm_gcroot(clazz, 0); |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(jcl, 0); |
| ClassArray* clArray = 0; |
| int size = 0; |
| |
| UserCommonClass* cl = JavaObjectClass::getClass(jcl = (JavaObjectClass*)clazz); |
| if (cl->isArray()) { |
| clArray = cl->asArrayClass(); |
| if(clArray->_baseClass->isPrimitive()) { |
| size = 1 << clArray->_baseClass->asPrimitiveClass()->logSize; |
| } else { |
| size = sizeof(JavaObject*); |
| } |
| } |
| return size; |
| } |
| |
| |
| |
| /// objectFieldOffset - Pointer offset of the specified field |
| /// |
| JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset( |
| JavaObject* Unsafe, JavaObjectField* Field) { |
| |
| llvm_gcroot(Field, 0); |
| llvm_gcroot(Unsafe, 0); |
| |
| JavaField* field = JavaObjectField::getInternalField(Field); |
| return (jlong)field->ptrOffset; |
| } |
| |
| //===--- Double-register addressing field accessors -----------------------===// |
| // See objectFieldOffset, staticFieldOffset, staticFieldBase |
| // Can also be an array, if/when we support arrayIndexScale/arrayBaseOffset |
| #define GET_PUT_OFFSET(Type,jtype,shorttype) \ |
| JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __Ljava_lang_Object_2J( \ |
| JavaObject* unsafe, JavaObject* base, jlong offset) { \ |
| jtype res = 0; \ |
| BEGIN_NATIVE_EXCEPTION(0) \ |
| jtype* ptr = (jtype*)fieldPtr(base,offset); \ |
| res = *ptr; \ |
| END_NATIVE_EXCEPTION \ |
| return res; \ |
| } \ |
| \ |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## __Ljava_lang_Object_2J ## shorttype( \ |
| JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \ |
| BEGIN_NATIVE_EXCEPTION(0) \ |
| jtype* ptr = (jtype*)fieldPtr(base, offset); \ |
| *ptr = val; \ |
| END_NATIVE_EXCEPTION \ |
| } |
| |
| //===--- Direct address read/write acccessors -----------------------------===// |
| #define GET_PUT_DIRECT(Type,jtype,shorttype) \ |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## __J ## shorttype( \ |
| JavaObject* unsafe, jlong ptr, jtype val) { \ |
| BEGIN_NATIVE_EXCEPTION(0) \ |
| *(jtype*)ptr = val; \ |
| END_NATIVE_EXCEPTION \ |
| } \ |
| \ |
| JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## __J( \ |
| JavaObject* unsafe, jlong ptr) { \ |
| jtype res = 0; \ |
| BEGIN_NATIVE_EXCEPTION(0) \ |
| res = *(jtype*)ptr; \ |
| END_NATIVE_EXCEPTION \ |
| return res; \ |
| } |
| |
| //===--- Volatile variant of field accessors ------------------------------===// |
| // Memory barriers after writes to ensure new value is seen elsewhere |
| #define GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \ |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## Volatile__J ## shorttype( \ |
| JavaObject* unsafe, jlong ptr, jtype val) { \ |
| BEGIN_NATIVE_EXCEPTION(0) \ |
| *(volatile jtype*)ptr = val; \ |
| __sync_synchronize(); \ |
| END_NATIVE_EXCEPTION \ |
| } \ |
| \ |
| JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## Volatile__J( \ |
| JavaObject* unsafe, jlong ptr) { \ |
| jtype res = 0; \ |
| BEGIN_NATIVE_EXCEPTION(0) \ |
| res = *(volatile jtype*)ptr; \ |
| END_NATIVE_EXCEPTION \ |
| return res; \ |
| } |
| |
| //===--- Volatile variant of direct address accessors ---------------------===// |
| #define GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype) \ |
| JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ## Volatile__Ljava_lang_Object_2J( \ |
| JavaObject* unsafe, JavaObject* base, jlong offset) { \ |
| jtype res = 0; \ |
| BEGIN_NATIVE_EXCEPTION(0) \ |
| volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \ |
| res = *ptr; \ |
| END_NATIVE_EXCEPTION \ |
| \ |
| return res; \ |
| } \ |
| \ |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ## Volatile__Ljava_lang_Object_2J ## shorttype( \ |
| JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \ |
| BEGIN_NATIVE_EXCEPTION(0) \ |
| volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \ |
| *ptr = val; \ |
| __sync_synchronize(); \ |
| END_NATIVE_EXCEPTION \ |
| } |
| |
| //===--- Ordered variant of field accessors -------------------------------===// |
| #define GET_PUT_FIELD_ORDERED(Type,jtype,shorttype) \ |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrdered ## Type( \ |
| JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \ |
| BEGIN_NATIVE_EXCEPTION(0) \ |
| volatile jtype* ptr = (volatile jtype*)fieldPtr(base,offset); \ |
| *ptr = val; \ |
| /* No memory barrier */ \ |
| END_NATIVE_EXCEPTION \ |
| } |
| |
| #define GET_PUT_ALL(Type,jtype,shorttype) \ |
| GET_PUT_OFFSET(Type,jtype,shorttype) \ |
| GET_PUT_DIRECT(Type,jtype,shorttype) \ |
| GET_PUT_OFFSET_VOLATILE(Type,jtype,shorttype) \ |
| GET_PUT_DIRECT_VOLATILE(Type,jtype,shorttype) |
| |
| GET_PUT_ALL(Boolean,jboolean,Z) |
| GET_PUT_ALL(Byte,jbyte,B) |
| GET_PUT_ALL(Char,jchar,C) |
| GET_PUT_ALL(Short,jshort,S) |
| GET_PUT_ALL(Int,jint,I) |
| GET_PUT_ALL(Long,jlong,J) // TODO: Long needs special handling! |
| GET_PUT_ALL(Float,jfloat,F) |
| GET_PUT_ALL(Double,jdouble,D) |
| |
| // Ordered: |
| GET_PUT_FIELD_ORDERED(Int,jint,I) |
| GET_PUT_FIELD_ORDERED(Long,jlong,J) |
| |
| //===--- Get/Put of Objects, due to GC needs special handling -------------===// |
| // JavaObject field accessors: |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObject__Ljava_lang_Object_2JLjava_lang_Object_2( |
| JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) { |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(base, 0); |
| llvm_gcroot(value, 0); |
| |
| JavaObject** ptr = (JavaObject**)fieldPtr(base, offset); |
| vmkit::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value); |
| } |
| |
| |
| JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObject__Ljava_lang_Object_2J( |
| JavaObject* unsafe, JavaObject* base, jlong offset) { |
| JavaObject * res = 0; |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(base, 0); |
| llvm_gcroot(res, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| JavaObject** ptr = (JavaObject**)fieldPtr(base, offset); |
| res = *ptr; |
| END_NATIVE_EXCEPTION; |
| |
| return res; |
| } |
| |
| // Volatile JavaObject field accessors: |
| // Never throws. |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile( |
| JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) { |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(base, 0); |
| llvm_gcroot(value, 0); |
| |
| JavaObject** ptr = (JavaObject**)fieldPtr(base, offset); |
| vmkit::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value); |
| // Ensure this value is seen. |
| __sync_synchronize(); |
| } |
| |
| JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_getObjectVolatile( |
| JavaObject* unsafe, JavaObject* base, jlong offset) { |
| JavaObject * res = 0; |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(base, 0); |
| llvm_gcroot(res, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| JavaObject* volatile* ptr = (JavaObject* volatile*)fieldPtr(base, offset); |
| res = *ptr; |
| END_NATIVE_EXCEPTION; |
| |
| return res; |
| } |
| |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putOrderedObject( |
| JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* value) { |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(base, 0); |
| llvm_gcroot(value, 0); |
| |
| JavaObject** ptr = (JavaObject**)fieldPtr(base, offset); |
| vmkit::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value); |
| // No barrier (difference between volatile and ordered) |
| } |
| |
| |
| //===--- CompareAndSwap field accessors -----------------------------------===// |
| // Never throws. |
| JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong( |
| JavaObject* unsafe, JavaObject* base, jlong offset, jlong expect, jlong update) { |
| |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(base, 0); |
| jlong *ptr; |
| jlong value; |
| |
| ptr = (jlong*)fieldPtr(base, offset); |
| |
| value = *ptr; |
| |
| if (value == expect) { |
| *ptr = update; |
| return true; |
| } else { |
| return false; |
| } |
| |
| } |
| |
| // Never throws. |
| JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt( |
| JavaObject* unsafe, JavaObject* base, jlong offset, jint expect, jint update) { |
| |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(base, 0); |
| jint *ptr; |
| |
| ptr = (jint *)fieldPtr(base, offset); |
| |
| return __sync_bool_compare_and_swap(ptr, expect, update); |
| } |
| |
| // Never throws. |
| JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject( |
| JavaObject* unsafe, JavaObject* base, jlong offset, JavaObject* expect, |
| JavaObject* update) { |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(base, 0); |
| llvm_gcroot(expect, 0); |
| llvm_gcroot(update, 0); |
| |
| JavaObject** ptr = (JavaObject**)fieldPtr(base, offset); |
| return vmkit::Collector::objectReferenceTryCASBarrier((gc*)base, (gc**)ptr, (gc*)expect, (gc*)update); |
| } |
| |
| |
| //===--- Class-related functions ------------------------------------------===// |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_ensureClassInitialized( |
| JavaObject* unsafe, JavaObject* clazz) { |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(clazz, 0); |
| BEGIN_NATIVE_EXCEPTION(0) |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| |
| UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, clazz, false); |
| assert(cl && cl->isClass()); |
| cl->asClass()->initialiseClass(vm); |
| |
| END_NATIVE_EXCEPTION; |
| } |
| |
| JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BII( |
| JavaObject* unsafe, JavaString *name, ArrayObject * bytesArr, jint off, jint len) { |
| UNIMPLEMENTED(); |
| } |
| |
| JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_defineClass__Ljava_lang_String_2_3BIILjava_lang_ClassLoader_2Ljava_security_ProtectionDomain_2( |
| JavaObject* unsafe, JavaString *name, ArrayObject * bytesArr, jint off, jint len, JavaObject * loader, JavaObject * pd) { |
| JavaObject* res = 0; |
| llvm_gcroot(res, 0); |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(name, 0); |
| llvm_gcroot(bytesArr, 0); |
| llvm_gcroot(loader, 0); |
| llvm_gcroot(pd, 0); |
| BEGIN_NATIVE_EXCEPTION(0) |
| |
| Jnjvm* vm = JavaThread::get()->getJVM(); |
| JnjvmClassLoader* JCL = NULL; |
| JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm); |
| |
| jint last = off + len; |
| if (last < bytesArr->size) { |
| assert(0 && "What exception to throw here?"); |
| } |
| ClassBytes * bytes = new (JCL->allocator, len) ClassBytes(len); |
| memcpy(bytes->elements, JavaArray::getElements(bytesArr)+off, len); |
| const UTF8* utfName = JavaString::javaToInternal(name, JCL->hashUTF8); |
| UserClass *cl = JCL->constructClass(utfName, bytes); |
| |
| if (cl) res = (JavaObject*)cl->getClassDelegatee(vm); |
| |
| END_NATIVE_EXCEPTION; |
| |
| return res; |
| } |
| |
| JNIEXPORT JavaObject* JNICALL Java_sun_misc_Unsafe_allocateInstance__Ljava_lang_Class_2( |
| JavaObject* unsafe, JavaObjectClass * clazz) { |
| JavaObject* res = 0; |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(clazz, 0); |
| llvm_gcroot(res, 0); |
| |
| BEGIN_NATIVE_EXCEPTION(0) |
| |
| JavaThread* th = JavaThread::get(); |
| Jnjvm* vm = th->getJVM(); |
| |
| UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, clazz, true); |
| if (cl->isClass()) |
| res = cl->asClass()->doNew(vm); |
| |
| END_NATIVE_EXCEPTION; |
| |
| return res; |
| } |
| |
| JNIEXPORT JavaObject* JNICALL Java_sun_Unsafe_defineAnonymousClass( |
| JavaObject* unsafe, ...) { |
| UNIMPLEMENTED(); |
| } |
| |
| //===--- Memory functions -------------------------------------------------===// |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_setMemory__JJB( |
| JavaObject* unsafe, long address, long bytes, jbyte value) { |
| memset((void*)address, value, bytes); |
| } |
| |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_copyMemory__JJJ( |
| JavaObject* unsafe, jlong src, jlong dst, jlong size) { |
| memcpy((void*)dst, (void*)src, size); |
| } |
| |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_copyMemory__Ljava_lang_Object_2JLjava_lang_Object_2JJ( |
| JavaObject* unsafe, |
| JavaObject* srcBase, jlong srcOffset, |
| JavaObject* dstBase, jlong dstOffset, |
| jlong size) { |
| BEGIN_NATIVE_EXCEPTION(0) |
| uint8_t* src = fieldPtr(srcBase, srcOffset, false /* Don't throw on null base*/ ); |
| uint8_t* dst = fieldPtr(dstBase, dstOffset, false /* Don't throw on null base*/ ); |
| memcpy(dst, src, size); |
| END_NATIVE_EXCEPTION |
| } |
| |
| JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_allocateMemory( |
| JavaObject* unsafe, jlong size) { |
| // TODO: Invalid size/OOM/etc handling! |
| jlong res = 0; |
| BEGIN_NATIVE_EXCEPTION(0) |
| res = (jlong)malloc(size); |
| END_NATIVE_EXCEPTION |
| return res; |
| } |
| |
| JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_reallocateMemory( |
| JavaObject* unsafe, jlong ptr, jlong newsize) { |
| // TODO: Invalid size/OOM/etc handling! |
| jlong res = 0; |
| BEGIN_NATIVE_EXCEPTION(0) |
| res = (jlong)realloc((void*)ptr, newsize); |
| END_NATIVE_EXCEPTION |
| return res; |
| } |
| |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_freeMemory( |
| JavaObject* unsafe, jlong ptr) { |
| // TODO: Exception handling... |
| BEGIN_NATIVE_EXCEPTION(0) |
| free((void*)ptr); |
| END_NATIVE_EXCEPTION |
| } |
| |
| JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_getAddress( |
| JavaObject* unsafe, jlong ptr) { |
| return (jlong)*(void**)ptr; |
| } |
| |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putAddress( |
| JavaObject* unsafe, jlong ptr, jlong val) { |
| *(void**)ptr = (void*)val; |
| } |
| |
| //===--- Park/Unpark thread support ---------------------------------------===// |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_park( |
| JavaObject* unsafe, jboolean isAbsolute, jlong time) { |
| //return; |
| llvm_gcroot(unsafe, 0); |
| JavaThread* thread = (JavaThread*)JavaThread::get(); |
| thread->parkLock.park(isAbsolute, time, thread); |
| } |
| |
| |
| //===--- Monitor support --------------------------------------------------===// |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_tryMonitorEnter( |
| JavaObject* unsafe, JavaObject * obj) { |
| //TODO: Implement me! |
| UNIMPLEMENTED(); |
| } |
| |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorEnter( |
| JavaObject* unsafe, JavaObject * obj) { |
| //TODO: Implement me! |
| UNIMPLEMENTED(); |
| } |
| |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_monitorExit( |
| JavaObject* unsafe, JavaObject * obj) { |
| //TODO: Implement me! |
| UNIMPLEMENTED(); |
| } |
| |
| //===--- Misc support functions -------------------------------------------===// |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_registerNatives(JavaObject*) { |
| // Nothing, we define the Unsafe methods with the expected signatures. |
| } |
| |
| JNIEXPORT void JNICALL Java_sun_misc_Unsafe_throwException( |
| JavaObject* unsafe, JavaObject * obj) { |
| llvm_gcroot(unsafe, 0); |
| llvm_gcroot(obj, 0); |
| |
| JavaThread::get()->throwException(obj); |
| } |
| |
| JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_pageSize( |
| JavaObject* unsafe) { |
| return vmkit::System::GetPageSize(); |
| } |
| |
| JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_addressSize( |
| JavaObject* unsafe) { |
| return vmkit::kWordSize; |
| } |
| |
| JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_getLoadAverage( |
| JavaObject* unsafe, ...) { |
| UNIMPLEMENTED(); |
| } |
| |
| } |