[vmkit-commits] [vmkit] r105346 - in /vmkit/trunk: lib/J3/Classpath/ lib/J3/Compiler/ lib/J3/VMCore/ mmtk/mmtk-j3/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Wed Jun 2 14:27:17 PDT 2010
Author: geoffray
Date: Wed Jun 2 16:27:17 2010
New Revision: 105346
URL: http://llvm.org/viewvc/llvm-project?rev=105346&view=rev
Log:
Make JavaArray virtual functions static.
Modified:
vmkit/trunk/lib/J3/Classpath/ClasspathConstructor.inc
vmkit/trunk/lib/J3/Classpath/ClasspathMethod.inc
vmkit/trunk/lib/J3/Classpath/ClasspathVMClass.inc
vmkit/trunk/lib/J3/Classpath/ClasspathVMClassLoader.inc
vmkit/trunk/lib/J3/Classpath/ClasspathVMObject.inc
vmkit/trunk/lib/J3/Classpath/ClasspathVMRuntime.inc
vmkit/trunk/lib/J3/Classpath/ClasspathVMStackWalker.inc
vmkit/trunk/lib/J3/Classpath/ClasspathVMSystem.inc
vmkit/trunk/lib/J3/Classpath/ClasspathVMThrowable.inc
vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
vmkit/trunk/lib/J3/VMCore/JavaArray.h
vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
vmkit/trunk/lib/J3/VMCore/JavaClass.h
vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp
vmkit/trunk/lib/J3/VMCore/JavaString.cpp
vmkit/trunk/lib/J3/VMCore/Jni.cpp
vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/J3/VMCore/LockedMap.h
vmkit/trunk/lib/J3/VMCore/Reader.cpp
vmkit/trunk/lib/J3/VMCore/Reader.h
vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp
vmkit/trunk/lib/J3/VMCore/Zip.cpp
vmkit/trunk/mmtk/mmtk-j3/RuntimeHelpers.cpp
vmkit/trunk/mmtk/mmtk-j3/Strings.cpp
Modified: vmkit/trunk/lib/J3/Classpath/ClasspathConstructor.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Classpath/ClasspathConstructor.inc?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Classpath/ClasspathConstructor.inc (original)
+++ vmkit/trunk/lib/J3/Classpath/ClasspathConstructor.inc Wed Jun 2 16:27:17 2010
@@ -70,12 +70,12 @@
}
static JavaObject* proceedConstructor(JavaObjectConstructor* cons,
- JavaArray* args,
+ ArrayObject* args,
JavaObject* Clazz, jint index)
__attribute__ ((noinline));
static JavaObject* proceedConstructor(JavaObjectConstructor* cons,
- JavaArray* args,
+ ArrayObject* args,
JavaObject* Clazz, jint index) {
JavaObject* res = 0;
JavaObject* excp = 0;
@@ -89,7 +89,7 @@
Jnjvm* vm = JavaThread::get()->getJVM();
JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
UserClass* cl = JavaObjectConstructor::getClass(cons);
- sint32 nbArgs = args ? args->size : 0;
+ sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
Signdef* sign = meth->getSignature();
sint32 size = sign->nbArguments;
@@ -105,7 +105,7 @@
if (cl) {
cl->initialiseClass(vm);
res = cl->doNew(vm);
- JavaObject** ptr = (JavaObject**)(void*)(args->elements);
+ JavaObject** ptr = (JavaObject**)ArrayObject::getElements(args);
Typedef* const* arguments = sign->getArgumentsType();
// Store the arguments, unboxing primitives if necessary.
@@ -148,7 +148,7 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectConstructor* cons, JavaArray* args, JavaObject* Clazz, jint index) {
+JavaObjectConstructor* cons, ArrayObject* args, JavaObject* Clazz, jint index) {
JavaObject* res = 0;
Modified: vmkit/trunk/lib/J3/Classpath/ClasspathMethod.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Classpath/ClasspathMethod.inc?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Classpath/ClasspathMethod.inc (original)
+++ vmkit/trunk/lib/J3/Classpath/ClasspathMethod.inc Wed Jun 2 16:27:17 2010
@@ -91,11 +91,11 @@
}
static JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,
- JavaArray* args, JavaObject* Cl, jint index)
+ ArrayObject* args, JavaObject* Cl, jint index)
__attribute__((noinline));
static JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,
- JavaArray* args, JavaObject* Cl, jint index) {
+ ArrayObject* args, JavaObject* Cl, jint index) {
JavaObject* res = 0;
JavaObject* exc = 0;
@@ -111,7 +111,7 @@
JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
- sint32 nbArgs = args ? args->size : 0;
+ sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
Signdef* sign = meth->getSignature();
sint32 size = sign->nbArguments;
@@ -140,7 +140,7 @@
cl->initialiseClass(vm);
}
- JavaObject** ptr = (JavaObject**)(void*)(args->elements);
+ JavaObject** ptr = ArrayObject::getElements(args);
Typedef* const* arguments = sign->getArgumentsType();
for (sint32 i = 0; i < size; ++i) {
JavaObject::decapsulePrimitive(ptr[i], vm, &buf[i], arguments[i]);
@@ -242,7 +242,7 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectMethod* Meth, JavaObject* obj, JavaArray* args, JavaObject* Cl, jint index) {
+JavaObjectMethod* Meth, JavaObject* obj, ArrayObject* args, JavaObject* Cl, jint index) {
JavaObject* res = 0;
llvm_gcroot(res, 0);
Modified: vmkit/trunk/lib/J3/Classpath/ClasspathVMClass.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Classpath/ClasspathVMClass.inc?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Classpath/ClasspathVMClass.inc (original)
+++ vmkit/trunk/lib/J3/Classpath/ClasspathVMClass.inc Wed Jun 2 16:27:17 2010
@@ -123,7 +123,8 @@
UserClass* Cons = vm->upcalls->newConstructor;
tmp = Cons->doNew(vm);
vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, &Cl, i);
- ret->elements[index++] = tmp;
+ ArrayObject::setElement(ret, tmp, index);
+ index++;
}
}
}
@@ -187,7 +188,8 @@
tmp = Meth->doNew(vm);
str = vm->internalUTF8ToStr(meth->name);
upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, &Cl, &str, i);
- ret->elements[index++] = tmp;
+ ArrayObject::setElement(ret, tmp, index);
+ index++;
}
}
}
@@ -457,7 +459,8 @@
tmp = Field->doNew(vm);
name = vm->internalUTF8ToStr(field->name);
vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, &Cl, &name, i);
- ret->elements[index++] = tmp;
+ ArrayObject::setElement(ret, tmp, index);
+ index++;
}
}
}
@@ -486,7 +489,7 @@
for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
UserClass* klass = cl->interfaces[i];
- res->elements[i] = klass->getClassDelegatee(vm);
+ ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
}
END_NATIVE_EXCEPTION
@@ -560,7 +563,7 @@
for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
UserClass* klass = cl->innerClasses[i];
if (!publicOnly || isPublic(klass->innerAccess))
- result->elements[i] = klass->getClassDelegatee(vm);
+ ArrayObject::setElement(result, klass->getClassDelegatee(vm), i);
}
}
Modified: vmkit/trunk/lib/J3/Classpath/ClasspathVMClassLoader.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Classpath/ClasspathVMClassLoader.inc?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Classpath/ClasspathVMClassLoader.inc (original)
+++ vmkit/trunk/lib/J3/Classpath/ClasspathVMClassLoader.inc Wed Jun 2 16:27:17 2010
@@ -357,7 +357,7 @@
Jnjvm* vm = JavaThread::get()->getJVM();
obj = (ArrayObject*)vm->upcalls->ArrayOfString->doNew(NUM_BOOT_PACKAGES, vm);
for (uint32 i = 0; i < NUM_BOOT_PACKAGES; ++i) {
- obj->elements[i] = vm->asciizToStr(bootPackages[i]);
+ ArrayObject::setElement(obj, vm->asciizToStr(bootPackages[i]), i);
}
END_NATIVE_EXCEPTION
Modified: vmkit/trunk/lib/J3/Classpath/ClasspathVMObject.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Classpath/ClasspathVMObject.inc?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Classpath/ClasspathVMObject.inc (original)
+++ vmkit/trunk/lib/J3/Classpath/ClasspathVMObject.inc Wed Jun 2 16:27:17 2010
@@ -42,7 +42,7 @@
base->asPrimitiveClass()->logSize : (sizeof(JavaObject*) == 8 ? 3 : 2);
size = sizeof(JavaObject) + sizeof(ssize_t) +
- (((JavaArray*)src)->size << logSize);
+ (JavaArray::getSize(src) << logSize);
} else {
assert(cl->isClass() && "Not a class!");
size = cl->asClass()->getVirtualSize();
Modified: vmkit/trunk/lib/J3/Classpath/ClasspathVMRuntime.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Classpath/ClasspathVMRuntime.inc?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Classpath/ClasspathVMRuntime.inc (original)
+++ vmkit/trunk/lib/J3/Classpath/ClasspathVMRuntime.inc Wed Jun 2 16:27:17 2010
@@ -57,11 +57,11 @@
uint32 size = (uint32)(lgPre + lgLib + lgPost);
array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm);
- uint16* elements = array->elements;
+ uint16* elements = ArrayUInt16::getElements(array);
memmove(elements, vm->bootstrapLoader->prelib->elements,
lgPre * sizeof(uint16));
- memmove(&(elements[lgPre]), &(utf8Lib->elements[stLib]),
+ memmove(&(elements[lgPre]), ArrayUInt16::getElements(utf8Lib) + stLib,
lgLib * sizeof(uint16));
memmove(&(elements[lgPre + lgLib]), vm->bootstrapLoader->postlib->elements,
lgPost * sizeof(uint16));
@@ -74,12 +74,6 @@
}
-#if defined(__MACH__)
-typedef int* jumpbuf_t;
-#else
-typedef __jmp_buf_tag* jumpbuf_t;
-#endif
-
typedef int (*onLoad_t)(const void**, void*);
extern "C" void j3EndJNI(uint32** old);
extern "C" void j3StartJNI(uint32* num, uint32** old, mvm::KnownFrame* Frame);
Modified: vmkit/trunk/lib/J3/Classpath/ClasspathVMStackWalker.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Classpath/ClasspathVMStackWalker.inc?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Classpath/ClasspathVMStackWalker.inc (original)
+++ vmkit/trunk/lib/J3/Classpath/ClasspathVMStackWalker.inc Wed Jun 2 16:27:17 2010
@@ -49,7 +49,7 @@
for (uint32 i = 0; i != finalSize; ++i) {
JavaMethod* meth = (JavaMethod*)buffer[i];
assert(meth && "Wrong stack trace");
- result->elements[i] = meth->classDef->getClassDelegatee(vm);
+ ArrayObject::setElement(result, meth->classDef->getClassDelegatee(vm), i);
}
END_NATIVE_EXCEPTION
Modified: vmkit/trunk/lib/J3/Classpath/ClasspathVMSystem.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Classpath/ClasspathVMSystem.inc?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Classpath/ClasspathVMSystem.inc (original)
+++ vmkit/trunk/lib/J3/Classpath/ClasspathVMSystem.inc Wed Jun 2 16:27:17 2010
@@ -25,9 +25,9 @@
JNIEnv *env,
jclass _cl,
#endif
-JavaArray* src,
+JavaObject* src,
jint sstart,
-JavaArray* dst,
+JavaObject* dst,
jint dstart,
jint len) {
@@ -56,13 +56,16 @@
UserCommonClass* dstType = td->baseClass();
UserCommonClass* srcType = ts->baseClass();
- if (len > src->size) {
+ sint32 srcSize = JavaArray::getSize(src);
+ sint32 dstSize = JavaArray::getSize(dst);
+
+ if (len > srcSize) {
th->pendingException = vm->CreateIndexOutOfBoundsException(len);
- } else if (len > dst->size) {
+ } else if (len > dstSize) {
th->pendingException = vm->CreateIndexOutOfBoundsException(len);
- } else if (len + sstart > src->size) {
+ } else if (len + sstart > srcSize) {
th->pendingException = vm->CreateIndexOutOfBoundsException(len + sstart);
- } else if (len + dstart > dst->size) {
+ } else if (len + dstart > dstSize) {
th->pendingException = vm->CreateIndexOutOfBoundsException(len + dstart);
} else if (dstart < 0) {
th->pendingException = vm->CreateIndexOutOfBoundsException(dstart);
@@ -82,7 +85,7 @@
bool doThrow = false;
if (!(dstType->isPrimitive())) {
while (i < sstart + len && !doThrow) {
- cur = ((ArrayObject*)src)->elements[i];
+ cur = ArrayObject::getElement((ArrayObject*)src, i);
if (cur) {
if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
doThrow = true;
@@ -96,8 +99,8 @@
uint32 logSize = dstType->isPrimitive() ?
dstType->asPrimitiveClass()->logSize : (sizeof(JavaObject*) == 8 ? 3 : 2);
- void* ptrDst = (void*)((int64_t)(dst->elements) + (dstart << logSize));
- void* ptrSrc = (void*)((int64_t)(src->elements) + (sstart << logSize));
+ void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) + (dstart << logSize));
+ void* ptrSrc = (void*)((int64_t)JavaArray::getElements(src) + (sstart << logSize));
memmove(ptrDst, ptrSrc, length << logSize);
if (doThrow) {
Modified: vmkit/trunk/lib/J3/Classpath/ClasspathVMThrowable.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Classpath/ClasspathVMThrowable.inc?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Classpath/ClasspathVMThrowable.inc (original)
+++ vmkit/trunk/lib/J3/Classpath/ClasspathVMThrowable.inc Wed Jun 2 16:27:17 2010
@@ -38,16 +38,15 @@
ClassArray* cl = sizeof(void*) == 4 ? vm->upcalls->ArrayOfInt :
vm->upcalls->ArrayOfLong;
- JavaArray* result = (JavaArray*) cl->doNew(length, vm);
- void** tab = (void**)result->elements;
+ JavaObject* result = (JavaObject*) cl->doNew(length, vm);
+ void** tab = (void**)JavaArray::getElements(result);
// Get the frame context.
th->getFrameContext(tab);
// Set the tempory data in the new VMThrowable object.
vmThrowable = vm->upcalls->newVMThrowable->doNew(vm);
- uint64 ptr = (uint64)vmThrowable + vm->upcalls->vmDataVMThrowable->ptrOffset;
- ((JavaObject**)ptr)[0] = result;
+ vm->upcalls->vmDataVMThrowable->setObjectField(vmThrowable, result);
return vmThrowable;
}
@@ -116,21 +115,23 @@
#endif
JavaObject* vmthrow, JavaObject* throwable) {
- ArrayObject* result = 0;
+ ArrayObject* result = NULL;
+ JavaObject* stack = NULL;
llvm_gcroot(vmthrow, 0);
llvm_gcroot(throwable, 0);
llvm_gcroot(result, 0);
+ llvm_gcroot(stack, 0);
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
JavaField* field = vm->upcalls->vmDataVMThrowable;
- JavaArray* stack = (JavaArray*)field->getObjectField(vmthrow);
+ stack = field->getObjectField(vmthrow);
// remove the VMThrowable.fillInStackTrace method and the last method
// on the stack.
sint32 index = 2;;
- while (index != stack->size) {
- mvm::MethodInfo* MI = vm->IPToMethodInfo(stack->elements[index]);
+ while (index != JavaArray::getSize(stack)) {
+ mvm::MethodInfo* MI = vm->IPToMethodInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
if (MI->MethodType != 1) ++index;
else {
JavaMethod* meth = (JavaMethod*)MI->getMetaInfo();
@@ -143,8 +144,8 @@
sint32 size = 0;
sint32 cur = index;
- while (cur < stack->size) {
- mvm::MethodInfo* MI = vm->IPToMethodInfo(stack->elements[cur]);
+ while (cur < JavaArray::getSize(stack)) {
+ mvm::MethodInfo* MI = vm->IPToMethodInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
++cur;
if (MI->MethodType == 1) ++size;
}
@@ -153,11 +154,11 @@
vm->upcalls->stackTraceArray->doNew(size, vm);
cur = 0;
- for (sint32 i = index; i < stack->size; ++i) {
- mvm::MethodInfo* MI = vm->IPToMethodInfo(stack->elements[i]);
+ for (sint32 i = index; i < JavaArray::getSize(stack); ++i) {
+ mvm::MethodInfo* MI = vm->IPToMethodInfo(ArrayPtr::getElement((ArrayPtr*)stack, i));
if (MI->MethodType == 1) {
JavaMethod* meth = (JavaMethod*)MI->getMetaInfo();
- result->elements[cur] = consStackElement(meth, stack->elements[i]);
+ ArrayObject::setElement(result, consStackElement(meth, ArrayPtr::getElement((ArrayPtr*)stack, i)), cur);
cur++;
}
}
@@ -168,4 +169,3 @@
}
}
-
Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Wed Jun 2 16:27:17 2010
@@ -341,7 +341,7 @@
}
std::vector<const Type*> Elemts;
- const ArrayType* ATy = ArrayType::get(Ty, ((JavaArray*)obj)->size);
+ const ArrayType* ATy = ArrayType::get(Ty, JavaArray::getSize(obj));
Elemts.push_back(JavaIntrinsics.JavaObjectType->getContainedType(0));
Elemts.push_back(JavaIntrinsics.pointerSizeType);
Elemts.push_back(ATy);
@@ -1240,7 +1240,7 @@
template<typename T>
Constant* JavaAOTCompiler::CreateConstantFromIntArray(const T* val, const Type* Ty) {
std::vector<const Type*> Elemts;
- const ArrayType* ATy = ArrayType::get(Ty, val->size);
+ const ArrayType* ATy = ArrayType::get(Ty, T::getSize(val));
Elemts.push_back(JavaIntrinsics.JavaObjectType->getContainedType(0));
Elemts.push_back(JavaIntrinsics.pointerSizeType);
@@ -1251,11 +1251,11 @@
std::vector<Constant*> Cts;
Cts.push_back(CreateConstantForBaseObject(JavaObject::getClass(val)));
- Cts.push_back(ConstantInt::get(JavaIntrinsics.pointerSizeType, val->size));
+ Cts.push_back(ConstantInt::get(JavaIntrinsics.pointerSizeType, T::getSize(val)));
std::vector<Constant*> Vals;
- for (sint32 i = 0; i < val->size; ++i) {
- Vals.push_back(ConstantInt::get(Ty, (uint64)val->elements[i]));
+ for (sint32 i = 0; i < T::getSize(val); ++i) {
+ Vals.push_back(ConstantInt::get(Ty, (uint64)T::getElement(val, i)));
}
Cts.push_back(ConstantArray::get(ATy, Vals));
@@ -1266,7 +1266,7 @@
template<typename T>
Constant* JavaAOTCompiler::CreateConstantFromFPArray(const T* val, const Type* Ty) {
std::vector<const Type*> Elemts;
- const ArrayType* ATy = ArrayType::get(Ty, val->size);
+ const ArrayType* ATy = ArrayType::get(Ty, T::getSize(val));
Elemts.push_back(JavaIntrinsics.JavaObjectType->getContainedType(0));
Elemts.push_back(JavaIntrinsics.pointerSizeType);
@@ -1277,11 +1277,11 @@
std::vector<Constant*> Cts;
Cts.push_back(CreateConstantForBaseObject(JavaObject::getClass(val)));
- Cts.push_back(ConstantInt::get(JavaIntrinsics.pointerSizeType, val->size));
+ Cts.push_back(ConstantInt::get(JavaIntrinsics.pointerSizeType, T::getSize(val)));
std::vector<Constant*> Vals;
- for (sint32 i = 0; i < val->size; ++i) {
- Vals.push_back(ConstantFP::get(Ty, (double)val->elements[i]));
+ for (sint32 i = 0; i < T::getSize(val); ++i) {
+ Vals.push_back(ConstantFP::get(Ty, (double)T::getElement(val, i)));
}
Cts.push_back(ConstantArray::get(ATy, Vals));
@@ -1292,7 +1292,7 @@
Constant* JavaAOTCompiler::CreateConstantFromObjectArray(const ArrayObject* val) {
std::vector<const Type*> Elemts;
const llvm::Type* Ty = JavaIntrinsics.JavaObjectType;
- const ArrayType* ATy = ArrayType::get(Ty, val->size);
+ const ArrayType* ATy = ArrayType::get(Ty, ArrayObject::getSize(val));
Elemts.push_back(JavaIntrinsics.JavaObjectType->getContainedType(0));
Elemts.push_back(JavaIntrinsics.pointerSizeType);
@@ -1303,12 +1303,13 @@
std::vector<Constant*> Cts;
Cts.push_back(CreateConstantForBaseObject(JavaObject::getClass(val)));
- Cts.push_back(ConstantInt::get(JavaIntrinsics.pointerSizeType, val->size));
+ Cts.push_back(ConstantInt::get(JavaIntrinsics.pointerSizeType,
+ ArrayObject::getSize(val)));
std::vector<Constant*> Vals;
- for (sint32 i = 0; i < val->size; ++i) {
- if (val->elements[i]) {
- Vals.push_back(getFinalObject(val->elements[i],
+ for (sint32 i = 0; i < ArrayObject::getSize(val); ++i) {
+ if (ArrayObject::getElement(val, i)) {
+ Vals.push_back(getFinalObject(ArrayObject::getElement(val, i),
JavaObject::getClass(val)->asArrayClass()->baseClass()));
} else {
Vals.push_back(Constant::getNullValue(JavaIntrinsics.JavaObjectType));
Modified: vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp Wed Jun 2 16:27:17 2010
@@ -950,13 +950,14 @@
}
}
- exploreOpcodes(&compilingClass->bytes->elements[start], codeLen);
+ // TODO: THIS IS UNSAFE!
+ exploreOpcodes(ArrayUInt8::getElements(compilingClass->bytes) + start, codeLen);
if (returnType != Type::getVoidTy(*llvmContext)) {
endNode = PHINode::Create(returnType, "", endBlock);
}
- compileOpcodes(&compilingClass->bytes->elements[start], codeLen);
+ compileOpcodes(ArrayUInt8::getElements(compilingClass->bytes) + start, codeLen);
PRINT_DEBUG(JNJVM_COMPILE, 1, COLOR_NORMAL,
"--> end inline compiling %s.%s\n",
@@ -1185,7 +1186,8 @@
}
}
- exploreOpcodes(&compilingClass->bytes->elements[start], codeLen);
+ // TODO: THIS IS UNSAFE!
+ exploreOpcodes(ArrayUInt8::getElements(compilingClass->bytes) + start, codeLen);
endBlock = createBasicBlock("end");
@@ -1241,7 +1243,8 @@
currentBlock = noStackOverflow;
}
- compileOpcodes(&compilingClass->bytes->elements[start], codeLen);
+ // TODO: THIS IS UNSAFE!
+ compileOpcodes(ArrayUInt8::getElements(compilingClass->bytes) + start, codeLen);
assert(stack.size() == 0 && "Stack not empty after compiling bytecode");
// Fix a javac(?) bug where a method only throws an exception and does
Modified: vmkit/trunk/lib/J3/VMCore/JavaArray.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaArray.h?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaArray.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaArray.h Wed Jun 2 16:27:17 2010
@@ -36,7 +36,7 @@
/// {JavaObject, size, [0 * T]}.
template <class T>
class TJavaArray : public JavaObject {
-public:
+private:
/// size - The (constant) size of the array.
ssize_t size;
@@ -44,28 +44,67 @@
/// actual size of the Java array. This is to facilitate Java array accesses
/// in JnJVM code. The size should be set to zero, but this is invalid C99.
T elements[1];
-};
-/// JavaArray - This class is just a placeholder for constants and for the
-/// virtual table of arrays.
-class JavaArray : public TJavaArray<void*> {
public:
-
- /// MaxArraySize - The maximum size a Java array can have. Allocating an
- /// array with a bigger size than MaxArraySize raises an out of memory
- /// error.
- static const sint32 MaxArraySize;
+ static int32_t getSize(const TJavaArray* self) {
+ llvm_gcroot(self, 0);
+ return self->size;
+ }
- /// JVM representation of Java arrays of primitive types.
- static const unsigned int T_BOOLEAN;
- static const unsigned int T_CHAR;
- static const unsigned int T_FLOAT;
- static const unsigned int T_DOUBLE;
- static const unsigned int T_BYTE;
- static const unsigned int T_SHORT;
- static const unsigned int T_INT;
- static const unsigned int T_LONG;
+ static T getElement(const TJavaArray* self, uint32_t i) {
+ llvm_gcroot(self, 0);
+ return self->elements[i];
+ }
+
+ static void setElement(TJavaArray* self, T value, uint32_t i) {
+ llvm_gcroot(self, 0);
+ self->elements[i] = value;
+ }
+
+ static const T* getElements(const TJavaArray* self) {
+ llvm_gcroot(self, 0);
+ return self->elements;
+ }
+
+ static T* getElements(TJavaArray* self) {
+ llvm_gcroot(self, 0);
+ return self->elements;
+ }
+
+ friend class JavaArray;
+};
+
+class ArrayObject : public JavaObject {
+private:
+ /// size - The (constant) size of the array.
+ ssize_t size;
+
+ /// elements - Elements of this array. The size here is different than the
+ /// actual size of the Java array. This is to facilitate Java array accesses
+ /// in JnJVM code. The size should be set to zero, but this is invalid C99.
+ JavaObject* elements[1];
+
+public:
+ static int32_t getSize(const ArrayObject* self) {
+ llvm_gcroot(self, 0);
+ return self->size;
+ }
+ static JavaObject* getElement(const ArrayObject* self, uint32_t i) {
+ llvm_gcroot(self, 0);
+ return self->elements[i];
+ }
+
+ static void setElement(ArrayObject* self, JavaObject* value, uint32_t i) {
+ llvm_gcroot(self, 0);
+ llvm_gcroot(value, 0);
+ self->elements[i] = value;
+ }
+
+ static JavaObject** getElements(ArrayObject* self) {
+ llvm_gcroot(self, 0);
+ return self->elements;
+ }
};
/// Instantiation of the TJavaArray class for Java arrays.
@@ -82,10 +121,49 @@
ARRAYCLASS(ArrayLong, sint64);
ARRAYCLASS(ArrayFloat, float);
ARRAYCLASS(ArrayDouble, double);
-ARRAYCLASS(ArrayObject, JavaObject*);
+ARRAYCLASS(ArrayPtr, void*);
#undef ARRAYCLASS
+/// JavaArray - This class is just a placeholder for constants.
+class JavaArray {
+public:
+ /// MaxArraySize - The maximum size a Java array can have. Allocating an
+ /// array with a bigger size than MaxArraySize raises an out of memory
+ /// error.
+ static const sint32 MaxArraySize;
+
+ /// JVM representation of Java arrays of primitive types.
+ static const unsigned int T_BOOLEAN;
+ static const unsigned int T_CHAR;
+ static const unsigned int T_FLOAT;
+ static const unsigned int T_DOUBLE;
+ static const unsigned int T_BYTE;
+ static const unsigned int T_SHORT;
+ static const unsigned int T_INT;
+ static const unsigned int T_LONG;
+
+ static void setSize(JavaObject* array, int size) {
+ llvm_gcroot(array, 0);
+ ((ArrayUInt8*)array)->size = size;
+ }
+
+ static sint32 getSize(const JavaObject* array) {
+ llvm_gcroot(array, 0);
+ return ((const ArrayUInt8*)array)->size;
+ }
+
+ static const unsigned char* getElements(const JavaObject* array) {
+ llvm_gcroot(array, 0);
+ return ((const ArrayUInt8*)array)->elements;
+ }
+
+ static unsigned char* getElements(JavaObject* array) {
+ llvm_gcroot(array, 0);
+ return ((ArrayUInt8*)array)->elements;
+ }
+};
+
} // end namespace j3
#endif
Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaClass.cpp Wed Jun 2 16:27:17 2010
@@ -253,7 +253,7 @@
access = ACC_FINAL | ACC_ABSTRACT | ACC_PUBLIC | JNJVM_ARRAY;
}
-JavaArray* UserClassArray::doNew(sint32 n, Jnjvm* vm) {
+JavaObject* UserClassArray::doNew(sint32 n, Jnjvm* vm) {
if (n < 0)
vm->negativeArraySizeException(n);
else if (n > JavaArray::MaxArraySize)
@@ -262,20 +262,21 @@
return doNew(n);
}
-JavaArray* UserClassArray::doNew(sint32 n) {
+JavaObject* UserClassArray::doNew(sint32 n) {
+ JavaObject* res = NULL;
+ llvm_gcroot(res, 0);
UserCommonClass* cl = baseClass();
-
uint32 logSize = cl->isPrimitive() ?
cl->asPrimitiveClass()->logSize : (sizeof(JavaObject*) == 8 ? 3 : 2);
VirtualTable* VT = virtualVT;
uint32 size = sizeof(JavaObject) + sizeof(ssize_t) + (n << logSize);
- JavaArray* res = (JavaArray*)gc::operator new(size, VT);
- res->size = n;
+ res = (JavaObject*)gc::operator new(size, VT);
+ JavaArray::setSize(res, n);
return res;
}
-JavaArray* UserClassArray::doNew(sint32 n, mvm::BumpPtrAllocator& allocator,
- bool temp) {
+JavaObject* UserClassArray::doNew(sint32 n, mvm::BumpPtrAllocator& allocator,
+ bool temp) {
UserCommonClass* cl = baseClass();
uint32 logSize = cl->isPrimitive() ?
@@ -283,17 +284,17 @@
VirtualTable* VT = virtualVT;
uint32 size = sizeof(JavaObject) + sizeof(ssize_t) + (n << logSize);
- JavaArray* res = 0;
+ JavaObject* res = 0;
// If the array is not temporary, use the allocator.
if (!temp) {
- res = (JavaArray*)allocator.Allocate(size, "Array");
+ res = (JavaObject*)allocator.Allocate(size, "Array");
} else {
// Otherwise, allocate with the malloc
- res = (JavaArray*)malloc(size);
+ res = (JavaObject*)malloc(size);
}
((void**)res)[0] = VT;
- res->size = n;
+ JavaArray::setSize(res, n);
return res;
}
@@ -1082,7 +1083,7 @@
res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(sign->nbArguments,vm);
for (uint32 index = 0; index < sign->nbArguments; ++index) {
- res->elements[index] = getClassType(vm, loader, arguments[index]);
+ ArrayObject::setElement(res, getClassType(vm, loader, arguments[index]), index);
}
return res;
@@ -1115,7 +1116,7 @@
UserCommonClass* cl = ctp->loadClass(idx);
assert(cl->asClass() && "Wrong exception type");
cl->asClass()->resolveClass();
- res->elements[i] = cl->getClassDelegatee(vm);
+ ArrayObject::setElement(res, cl->getClassDelegatee(vm), i);
}
return res;
}
@@ -1359,18 +1360,25 @@
uint32 i = 0;
for (sint32 j = 0; j < classDef->name->size; ++j) {
- if (classDef->name->elements[j] == '/') res->elements[i++] = '.';
- else res->elements[i++] = classDef->name->elements[j];
+ if (classDef->name->elements[j] == '/') {
+ ArrayUInt16::setElement(res, '.', i);
+ } else {
+ ArrayUInt16::setElement(res, classDef->name->elements[j], i);
+ }
+ i++;
}
- res->elements[i++] = '.';
+ ArrayUInt16::setElement(res, '.', i);
+ i++;
for (sint32 j = 0; j < name->size; ++j) {
- res->elements[i++] = name->elements[j];
+ ArrayUInt16::setElement(res, name->elements[j], i);
+ i++;
}
for (sint32 j = 0; j < type->size; ++j) {
- res->elements[i++] = type->elements[j];
+ ArrayUInt16::setElement(res, type->elements[j], i);
+ i++;
}
return res;
Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.h?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaClass.h Wed Jun 2 16:27:17 2010
@@ -928,9 +928,9 @@
/// doNew - Allocate a new array with the given allocator.
///
- JavaArray* doNew(sint32 n, mvm::BumpPtrAllocator& allocator,
+ JavaObject* doNew(sint32 n, mvm::BumpPtrAllocator& allocator,
bool temp = false);
- JavaArray* doNew(sint32 n);
+ JavaObject* doNew(sint32 n);
/// _baseClass - The base class of the array.
///
@@ -944,7 +944,7 @@
/// doNew - Allocate a new array in the given vm.
///
- JavaArray* doNew(sint32 n, Jnjvm* vm);
+ JavaObject* doNew(sint32 n, Jnjvm* vm);
/// ClassArray - Construct a Java array class with the given name.
///
Modified: vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp Wed Jun 2 16:27:17 2010
@@ -252,11 +252,11 @@
}
// Throws if one of the dimension is negative.
-static JavaArray* multiCallNewIntern(UserClassArray* cl, uint32 len,
- sint32* dims, Jnjvm* vm) {
+static JavaObject* multiCallNewIntern(UserClassArray* cl, uint32 len,
+ sint32* dims, Jnjvm* vm) {
assert(len > 0 && "Negative size given by VMKit");
- JavaArray* _res = cl->doNew(dims[0], vm);
+ JavaObject* _res = cl->doNew(dims[0], vm);
ArrayObject* res = 0;
llvm_gcroot(_res, 0);
llvm_gcroot(res, 0);
@@ -268,13 +268,15 @@
UserClassArray* base = (UserClassArray*)_base;
if (dims[0] > 0) {
for (sint32 i = 0; i < dims[0]; ++i) {
- res->elements[i] = multiCallNewIntern(base, (len - 1),
- &dims[1], vm);
+ ArrayObject::setElement(
+ res, multiCallNewIntern(base, (len - 1), &dims[1], vm), i);
}
} else {
for (uint32 i = 1; i < len; ++i) {
sint32 p = dims[i];
- if (p < 0) JavaThread::get()->getJVM()->negativeArraySizeException(p);
+ if (p < 0) {
+ JavaThread::get()->getJVM()->negativeArraySizeException(p);
+ }
}
}
}
@@ -282,8 +284,8 @@
}
// Throws if one of the dimension is negative.
-extern "C" JavaArray* j3MultiCallNew(UserClassArray* cl, uint32 len, ...) {
- JavaArray* res = 0;
+extern "C" JavaObject* j3MultiCallNew(UserClassArray* cl, uint32 len, ...) {
+ JavaObject* res = 0;
llvm_gcroot(res, 0);
BEGIN_NATIVE_EXCEPTION(1)
Modified: vmkit/trunk/lib/J3/VMCore/JavaString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaString.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaString.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaString.cpp Wed Jun 2 16:27:17 2010
@@ -38,7 +38,7 @@
// No need to call the Java function: both the Java function and
// this function do the same thing.
res->value = array;
- res->count = array->size;
+ res->count = ArrayUInt16::getSize(array);
res->offset = 0;
res->cachedHashCode = 0;
return res;
@@ -47,7 +47,7 @@
char* JavaString::strToAsciiz() {
char* buf = new char[count + 1];
for (sint32 i = 0; i < count; ++i) {
- buf[i] = value->elements[i + offset];
+ buf[i] = ArrayUInt16::getElement(value, i + offset);
}
buf[count] = 0;
return buf;
@@ -60,12 +60,11 @@
llvm_gcroot(array, 0);
assert(self->value && "String without an array?");
- if (self->offset || (self->count != self->value->size)) {
+ if (self->offset || (self->count != ArrayUInt16::getSize(self->value))) {
array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(self->count, vm);
- uint16* buf = array->elements;
-
for (sint32 i = 0; i < count; i++) {
- buf[i] = self->value->elements[i + self->offset];
+ ArrayUInt16::setElement(
+ array, ArrayUInt16::getElement(value, i + self->offset), i);
}
return array;
} else {
@@ -88,11 +87,13 @@
array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(name->size, vm);
- uint16* java = array->elements;
for (sint32 i = 0; i < name->size; i++) {
uint16 cur = name->elements[i];
- if (cur == '/') java[i] = '.';
- else java[i] = cur;
+ if (cur == '/') {
+ ArrayUInt16::setElement(array, '.', i);
+ } else {
+ ArrayUInt16::setElement(array, cur, i);
+ }
}
return vm->constructString(array);
@@ -102,13 +103,15 @@
const JavaString* self = this;
llvm_gcroot(self, 0);
- uint16* java = (uint16*)alloca(sizeof(uint16) * self->count);
+ uint16* java = new uint16[self->count];
for (sint32 i = 0; i < count; ++i) {
- uint16 cur = self->value->elements[offset + i];
+ uint16 cur = ArrayUInt16::getElement(self->value, offset + i);
if (cur == '.') java[i] = '/';
else java[i] = cur;
}
- return map->lookupOrCreateReader(java, self->count);
+ const UTF8* res = map->lookupOrCreateReader(java, self->count);
+ delete[] java;
+ return res;
}
Modified: vmkit/trunk/lib/J3/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jni.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jni.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jni.cpp Wed Jun 2 16:27:17 2010
@@ -2654,10 +2654,10 @@
BEGIN_JNI_EXCEPTION
// Local object references.
- JavaArray* array = *(JavaArray**)_array;
+ JavaObject* array = *(JavaObject**)_array;
llvm_gcroot(array, 0);
- RETURN_FROM_JNI(array->size);
+ RETURN_FROM_JNI(JavaArray::getSize(array));
END_JNI_EXCEPTION
RETURN_FROM_JNI(0);
@@ -2692,7 +2692,7 @@
if (initialElement) {
for (sint32 i = 0; i < length; ++i) {
- res->elements[i] = initialElement;
+ ArrayObject::setElement(res, initialElement, i);
}
}
@@ -2717,10 +2717,12 @@
JavaThread* th = JavaThread::get();
Jnjvm* vm = th->getJVM();
- if (index >= array->size) vm->indexOutOfBounds(array, index);
+ if (index >= ArrayObject::getSize(array)) {
+ vm->indexOutOfBounds(array, index);
+ }
// Store local refererence.
- res = array->elements[index];
+ res = ArrayObject::getElement(array, index);
jobject ret = (jobject)th->pushJNIRef(res);
RETURN_FROM_JNI(ret);
@@ -2742,11 +2744,12 @@
llvm_gcroot(array, 0);
llvm_gcroot(val, 0);
- if (index >= array->size)
+ if (index >= ArrayObject::getSize(array)) {
JavaThread::get()->getJVM()->indexOutOfBounds(array, index);
+ }
// Store global reference.
- array->elements[index] = val;
+ ArrayObject::setElement(array, val, index);
RETURN_VOID_FROM_JNI;
@@ -2896,9 +2899,9 @@
if (isCopy) (*isCopy) = true;
- sint32 len = array->size * sizeof(uint8);
+ sint32 len = ArrayUInt8::getSize(array) * sizeof(uint8);
void* buffer = malloc(len);
- memcpy(buffer, array->elements, len);
+ memcpy(buffer, ArrayUInt8::getElements(array), len);
RETURN_FROM_JNI((jboolean*)buffer);
@@ -2917,9 +2920,9 @@
if (isCopy) (*isCopy) = true;
- sint32 len = array->size * sizeof(uint8);
+ sint32 len = ArraySInt8::getSize(array) * sizeof(uint8);
void* buffer = malloc(len);
- memcpy(buffer, array->elements, len);
+ memcpy(buffer, ArraySInt8::getElements(array), len);
RETURN_FROM_JNI((jbyte*)buffer);
@@ -2938,9 +2941,9 @@
if (isCopy) (*isCopy) = true;
- sint32 len = array->size * sizeof(uint16);
+ sint32 len = ArrayUInt16::getSize(array) * sizeof(uint16);
void* buffer = malloc(len);
- memcpy(buffer, array->elements, len);
+ memcpy(buffer, ArrayUInt16::getElements(array), len);
RETURN_FROM_JNI((jchar*)buffer);
@@ -2960,9 +2963,9 @@
if (isCopy) (*isCopy) = true;
- sint32 len = array->size * sizeof(sint16);
+ sint32 len = ArraySInt16::getSize(array) * sizeof(sint16);
void* buffer = malloc(len);
- memcpy(buffer, array->elements, len);
+ memcpy(buffer, ArraySInt16::getElements(array), len);
RETURN_FROM_JNI((jshort*)buffer);
@@ -2981,9 +2984,9 @@
if (isCopy) (*isCopy) = true;
- sint32 len = array->size * sizeof(sint32);
+ sint32 len = ArraySInt32::getSize(array) * sizeof(sint32);
void* buffer = malloc(len);
- memcpy(buffer, array->elements, len);
+ memcpy(buffer, ArraySInt32::getElements(array), len);
RETURN_FROM_JNI((jint*)buffer);
@@ -3002,9 +3005,9 @@
if (isCopy) (*isCopy) = true;
- sint32 len = array->size * sizeof(sint64);
+ sint32 len = ArrayLong::getSize(array) * sizeof(sint64);
void* buffer = malloc(len);
- memcpy(buffer, array->elements, len);
+ memcpy(buffer, ArrayLong::getElements(array), len);
RETURN_FROM_JNI((jlong*)buffer);
@@ -3024,9 +3027,9 @@
if (isCopy) (*isCopy) = true;
- sint32 len = array->size * sizeof(float);
+ sint32 len = ArrayFloat::getSize(array) * sizeof(float);
void* buffer = malloc(len);
- memcpy(buffer, array->elements, len);
+ memcpy(buffer, ArrayFloat::getElements(array), len);
RETURN_FROM_JNI((jfloat*)buffer);
@@ -3046,9 +3049,9 @@
if (isCopy) (*isCopy) = true;
- sint32 len = array->size * sizeof(double);
+ sint32 len = ArrayDouble::getSize(array) * sizeof(double);
void* buffer = malloc(len);
- memcpy(buffer, array->elements, len);
+ memcpy(buffer, ArrayDouble::getElements(array), len);
RETURN_FROM_JNI((jdouble*)buffer);
@@ -3065,11 +3068,11 @@
if (mode == JNI_ABORT) {
free(elems);
} else {
- JavaArray* array = *(JavaArray**)_array;
+ ArrayUInt8* array = *(ArrayUInt8**)_array;
llvm_gcroot(array, 0);
- sint32 len = array->size;
- memcpy(array->elements, elems, len);
+ sint32 len = ArrayUInt8::getSize(array);
+ memcpy(ArrayUInt8::getElements(array), elems, len);
if (mode == 0) free(elems);
}
@@ -3088,11 +3091,11 @@
if (mode == JNI_ABORT) {
free(elems);
} else {
- JavaArray* array = *(JavaArray**)_array;
+ ArraySInt16* array = *(ArraySInt16**)_array;
llvm_gcroot(array, 0);
- sint32 len = array->size;
- memcpy(array->elements, elems, len);
+ sint32 len = ArraySInt16::getSize(array);
+ memcpy(ArraySInt16::getElements(array), elems, len);
if (mode == 0) free(elems);
}
@@ -3111,11 +3114,11 @@
if (mode == JNI_ABORT) {
free(elems);
} else {
- JavaArray* array = *(JavaArray**)_array;
+ ArrayUInt16* array = *(ArrayUInt16**)_array;
llvm_gcroot(array, 0);
- sint32 len = array->size << 1;
- memcpy(array->elements, elems, len);
+ sint32 len = ArrayUInt16::getSize(array) << 1;
+ memcpy(ArrayUInt16::getElements(array), elems, len);
if (mode == 0) free(elems);
}
@@ -3134,11 +3137,11 @@
if (mode == JNI_ABORT) {
free(elems);
} else {
- JavaArray* array = *(JavaArray**)_array;
+ ArraySInt16* array = *(ArraySInt16**)_array;
llvm_gcroot(array, 0);
- sint32 len = array->size << 1;
- memcpy(array->elements, elems, len);
+ sint32 len = ArraySInt16::getSize(array) << 1;
+ memcpy(ArraySInt16::getElements(array), elems, len);
if (mode == 0) free(elems);
}
@@ -3157,11 +3160,11 @@
if (mode == JNI_ABORT) {
free(elems);
} else {
- JavaArray* array = *(JavaArray**)_array;
+ ArraySInt32* array = *(ArraySInt32**)_array;
llvm_gcroot(array, 0);
- sint32 len = array->size << 2;
- memcpy(array->elements, elems, len);
+ sint32 len = ArraySInt32::getSize(array) << 2;
+ memcpy(ArraySInt32::getElements(array), elems, len);
if (mode == 0) free(elems);
}
@@ -3180,11 +3183,11 @@
if (mode == JNI_ABORT) {
free(elems);
} else {
- JavaArray* array = *(JavaArray**)_array;
+ ArrayLong* array = *(ArrayLong**)_array;
llvm_gcroot(array, 0);
- sint32 len = array->size << 3;
- memcpy(array->elements, elems, len);
+ sint32 len = ArrayLong::getSize(array) << 3;
+ memcpy(ArrayLong::getElements(array), elems, len);
if (mode == 0) free(elems);
}
@@ -3202,11 +3205,11 @@
if (mode == JNI_ABORT) {
free(elems);
} else {
- JavaArray* array = *(JavaArray**)_array;
+ ArrayFloat* array = *(ArrayFloat**)_array;
llvm_gcroot(array, 0);
- sint32 len = array->size << 2;
- memcpy(array->elements, elems, len);
+ sint32 len = ArrayFloat::getSize(array) << 2;
+ memcpy(ArrayFloat::getElements(array), elems, len);
if (mode == 0) free(elems);
}
@@ -3225,11 +3228,11 @@
if (mode == JNI_ABORT) {
free(elems);
} else {
- JavaArray* array = *(JavaArray**)_array;
+ ArrayDouble* array = *(ArrayDouble**)_array;
llvm_gcroot(array, 0);
- sint32 len = array->size << 3;
- memcpy(array->elements, elems, len);
+ sint32 len = ArrayDouble::getSize(array) << 3;
+ memcpy(ArrayDouble::getElements(array), elems, len);
if (mode == 0) free(elems);
}
@@ -3246,7 +3249,7 @@
ArrayUInt8* Array = *(ArrayUInt8**)array;
llvm_gcroot(Array, 0);
- memcpy(buf, &(Array->elements[start]), len * sizeof(uint8));
+ memcpy(buf, ArrayUInt8::getElements(Array) + start, len * sizeof(uint8));
END_JNI_EXCEPTION
@@ -3261,7 +3264,7 @@
ArraySInt8* Array = *(ArraySInt8**)array;
llvm_gcroot(Array, 0);
- memcpy(buf, &(Array->elements[start]), len * sizeof(sint8));
+ memcpy(buf, ArraySInt8::getElements(Array) + start, len * sizeof(uint8));
END_JNI_EXCEPTION
@@ -3276,7 +3279,7 @@
ArrayUInt16* Array = *(ArrayUInt16**)array;
llvm_gcroot(Array, 0);
- memcpy(buf, &(Array->elements[start]), len * sizeof(uint16));
+ memcpy(buf, ArrayUInt16::getElements(Array) + start, len * sizeof(uint16));
END_JNI_EXCEPTION
@@ -3291,7 +3294,7 @@
ArraySInt16* Array = *(ArraySInt16**)array;
llvm_gcroot(Array, 0);
- memcpy(buf, &(Array->elements[start]), len * sizeof(sint16));
+ memcpy(buf, ArraySInt16::getElements(Array) + start, len * sizeof(sint16));
END_JNI_EXCEPTION
@@ -3306,7 +3309,7 @@
ArraySInt32* Array = *(ArraySInt32**)array;
llvm_gcroot(Array, 0);
- memcpy(buf, &(Array->elements[start]), len * sizeof(sint32));
+ memcpy(buf, ArraySInt32::getElements(Array) + start, len * sizeof(sint32));
END_JNI_EXCEPTION
@@ -3321,7 +3324,7 @@
ArrayLong* Array = *(ArrayLong**)array;
llvm_gcroot(Array, 0);
- memcpy(buf, &(Array->elements[start]), len * sizeof(sint64));
+ memcpy(buf, ArrayLong::getElements(Array) + start, len * sizeof(sint64));
END_JNI_EXCEPTION
@@ -3336,7 +3339,7 @@
ArrayFloat* Array = *(ArrayFloat**)array;
llvm_gcroot(Array, 0);
- memcpy(buf, &(Array->elements[start]), len * sizeof(float));
+ memcpy(buf, ArrayFloat::getElements(Array) + start, len * sizeof(float));
END_JNI_EXCEPTION
@@ -3351,7 +3354,7 @@
ArrayDouble* Array = *(ArrayDouble**)array;
llvm_gcroot(Array, 0);
- memcpy(buf, &(Array->elements[start]), len * sizeof(double));
+ memcpy(buf, ArrayDouble::getElements(Array) + start, len * sizeof(double));
END_JNI_EXCEPTION
@@ -3366,7 +3369,7 @@
ArrayUInt8* Array = *(ArrayUInt8**)array;
llvm_gcroot(Array, 0);
- memcpy(&(Array->elements[start]), buf, len * sizeof(uint8));
+ memcpy(ArrayUInt8::getElements(Array) + start, buf, len * sizeof(uint8));
END_JNI_EXCEPTION
@@ -3381,7 +3384,7 @@
ArraySInt8* Array = *(ArraySInt8**)array;
llvm_gcroot(Array, 0);
- memcpy(&(Array->elements[start]), buf, len * sizeof(sint8));
+ memcpy(ArraySInt8::getElements(Array) + start, buf, len * sizeof(sint8));
END_JNI_EXCEPTION
@@ -3396,7 +3399,7 @@
ArrayUInt16* Array = *(ArrayUInt16**)array;
llvm_gcroot(Array, 0);
- memcpy(&(Array->elements[start]), buf, len * sizeof(uint16));
+ memcpy(ArrayUInt16::getElements(Array) + start, buf, len * sizeof(uint16));
END_JNI_EXCEPTION
@@ -3411,7 +3414,7 @@
ArraySInt16* Array = *(ArraySInt16**)array;
llvm_gcroot(Array, 0);
- memcpy(&(Array->elements[start]), buf, len * sizeof(sint16));
+ memcpy(ArraySInt16::getElements(Array) + start, buf, len * sizeof(sint16));
END_JNI_EXCEPTION
@@ -3426,7 +3429,7 @@
ArraySInt32* Array = *(ArraySInt32**)array;
llvm_gcroot(Array, 0);
- memcpy(&(Array->elements[start]), buf, len * sizeof(sint32));
+ memcpy(ArraySInt32::getElements(Array) + start, buf, len * sizeof(sint32));
END_JNI_EXCEPTION
@@ -3441,7 +3444,7 @@
ArrayLong* Array = *(ArrayLong**)array;
llvm_gcroot(Array, 0);
- memcpy(&(Array->elements[start]), buf, len * sizeof(sint64));
+ memcpy(ArrayLong::getElements(Array) + start, buf, len * sizeof(sint64));
END_JNI_EXCEPTION
@@ -3456,7 +3459,7 @@
ArrayFloat* Array = *(ArrayFloat**)array;
llvm_gcroot(Array, 0);
- memcpy(&(Array->elements[start]), buf, len * sizeof(float));
+ memcpy(ArrayFloat::getElements(Array) + start, buf, len * sizeof(float));
END_JNI_EXCEPTION
@@ -3471,7 +3474,7 @@
ArrayDouble* Array = *(ArrayDouble**)array;
llvm_gcroot(Array, 0);
- memcpy(&(Array->elements[start]), buf, len * sizeof(double));
+ memcpy(ArrayDouble::getElements(Array) + start, buf, len * sizeof(double));
END_JNI_EXCEPTION
@@ -3564,16 +3567,16 @@
void *GetPrimitiveArrayCritical(JNIEnv *env, jarray _array, jboolean *isCopy) {
BEGIN_JNI_EXCEPTION
- JavaArray* array = *(JavaArray**)_array;
+ JavaObject* array = *(JavaObject**)_array;
llvm_gcroot(array, 0);
if (isCopy) (*isCopy) = true;
UserClassArray* cl = JavaObject::getClass(array)->asArrayClass();
uint32 logSize = cl->baseClass()->asPrimitiveClass()->logSize;
- sint32 len = array->size << logSize;
+ sint32 len = JavaArray::getSize(array) << logSize;
void* buffer = malloc(len);
- memcpy(buffer, array->elements, len);
+ memcpy(buffer, JavaArray::getElements(array), len);
RETURN_FROM_JNI((jchar*)buffer);
@@ -3590,13 +3593,13 @@
if (mode == JNI_ABORT) {
free(carray);
} else {
- JavaArray* array = *(JavaArray**)_array;
+ JavaObject* array = *(JavaObject**)_array;
llvm_gcroot(array, 0);
UserClassArray* cl = JavaObject::getClass(array)->asArrayClass();
uint32 logSize = cl->baseClass()->asPrimitiveClass()->logSize;
- sint32 len = array->size << logSize;
- memcpy(array->elements, carray, len);
+ sint32 len = JavaArray::getSize(array) << logSize;
+ memcpy(JavaArray::getElements(array), carray, len);
if (mode == 0) free(carray);
}
Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp Wed Jun 2 16:27:17 2010
@@ -480,33 +480,40 @@
uint32 i = 0;
- msg->elements[i++] = 'u';
- msg->elements[i++] = 'n';
- msg->elements[i++] = 'a';
- msg->elements[i++] = 'b';
- msg->elements[i++] = 'l';
- msg->elements[i++] = 'e';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 't';
- msg->elements[i++] = 'o';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 'f';
- msg->elements[i++] = 'i';
- msg->elements[i++] = 'n';
- msg->elements[i++] = 'd';
- msg->elements[i++] = ' ';
-
- for (sint32 j = 0; j < name->size; ++j)
- msg->elements[i++] = name->elements[j];
-
- msg->elements[i++] = ' ';
- msg->elements[i++] = 'i';
- msg->elements[i++] = 'n';
- msg->elements[i++] = ' ';
+ ArrayUInt16::setElement(msg, 'u', i); i++;
+ ArrayUInt16::setElement(msg, 'n', i); i++;
+ ArrayUInt16::setElement(msg, 'a', i); i++;
+ ArrayUInt16::setElement(msg, 'b', i); i++;
+ ArrayUInt16::setElement(msg, 'l', i); i++;
+ ArrayUInt16::setElement(msg, 'e', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 't', i); i++;
+ ArrayUInt16::setElement(msg, 'o', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 'f', i); i++;
+ ArrayUInt16::setElement(msg, 'i', i); i++;
+ ArrayUInt16::setElement(msg, 'n', i); i++;
+ ArrayUInt16::setElement(msg, 'd', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+
+ for (sint32 j = 0; j < name->size; ++j) {
+ ArrayUInt16::setElement(msg, name->elements[j], i);
+ i++;
+ }
+
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 'i', i); i++;
+ ArrayUInt16::setElement(msg, 'n', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
for (sint32 j = 0; j < cl->name->size; ++j) {
- if (cl->name->elements[j] == '/') msg->elements[i++] = '.';
- else msg->elements[i++] = cl->name->elements[j];
+ if (cl->name->elements[j] == '/') {
+ ArrayUInt16::setElement(msg, '.', i);
+ i++;
+ } else {
+ ArrayUInt16::setElement(msg, cl->name->elements[i], i);
+ i++;
+ }
}
str = vm->constructString(msg);
@@ -544,25 +551,28 @@
uint32 i = 0;
- msg->elements[i++] = 'u';
- msg->elements[i++] = 'n';
- msg->elements[i++] = 'a';
- msg->elements[i++] = 'b';
- msg->elements[i++] = 'l';
- msg->elements[i++] = 'e';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 't';
- msg->elements[i++] = 'o';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 'l';
- msg->elements[i++] = 'o';
- msg->elements[i++] = 'a';
- msg->elements[i++] = 'd';
- msg->elements[i++] = ' ';
+ ArrayUInt16::setElement(msg, 'u', i); i++;
+ ArrayUInt16::setElement(msg, 'n', i); i++;
+ ArrayUInt16::setElement(msg, 'a', i); i++;
+ ArrayUInt16::setElement(msg, 'b', i); i++;
+ ArrayUInt16::setElement(msg, 'l', i); i++;
+ ArrayUInt16::setElement(msg, 'e', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 't', i); i++;
+ ArrayUInt16::setElement(msg, 'o', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 'l', i); i++;
+ ArrayUInt16::setElement(msg, 'o', i); i++;
+ ArrayUInt16::setElement(msg, 'a', i); i++;
+ ArrayUInt16::setElement(msg, 'd', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
for (sint32 j = 0; j < name->size; ++j) {
- if (name->elements[j] == '/') msg->elements[i++] = '.';
- else msg->elements[i++] = name->elements[j];
+ if (name->elements[j] == '/') {
+ ArrayUInt16::setElement(msg, '.', i); i++;
+ } else {
+ ArrayUInt16::setElement(msg, name->elements[i], i); i++;
+ }
}
str = vm->constructString(msg);
@@ -579,25 +589,28 @@
uint32 i = 0;
- msg->elements[i++] = 'u';
- msg->elements[i++] = 'n';
- msg->elements[i++] = 'a';
- msg->elements[i++] = 'b';
- msg->elements[i++] = 'l';
- msg->elements[i++] = 'e';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 't';
- msg->elements[i++] = 'o';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 'l';
- msg->elements[i++] = 'o';
- msg->elements[i++] = 'a';
- msg->elements[i++] = 'd';
- msg->elements[i++] = ' ';
+ ArrayUInt16::setElement(msg, 'u', i); i++;
+ ArrayUInt16::setElement(msg, 'n', i); i++;
+ ArrayUInt16::setElement(msg, 'a', i); i++;
+ ArrayUInt16::setElement(msg, 'b', i); i++;
+ ArrayUInt16::setElement(msg, 'l', i); i++;
+ ArrayUInt16::setElement(msg, 'e', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 't', i); i++;
+ ArrayUInt16::setElement(msg, 'o', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 'l', i); i++;
+ ArrayUInt16::setElement(msg, 'o', i); i++;
+ ArrayUInt16::setElement(msg, 'a', i); i++;
+ ArrayUInt16::setElement(msg, 'd', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
for (sint32 j = name->offset; j < name->offset + name->count; ++j) {
- if (name->value->elements[j] == '/') msg->elements[i++] = '.';
- else msg->elements[i++] = name->value->elements[j];
+ if (ArrayUInt16::getElement(name->value, j) == '/') {
+ ArrayUInt16::setElement(msg, '.', i); i++;
+ } else {
+ ArrayUInt16::setElement(msg, ArrayUInt16::getElement(name->value, j), i);
+ }
}
str = vm->constructString(msg);
@@ -630,51 +643,57 @@
uint32 i = 0;
- msg->elements[i++] = 't';
- msg->elements[i++] = 'r';
- msg->elements[i++] = 'y';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 't';
- msg->elements[i++] = 'o';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 'l';
- msg->elements[i++] = 'o';
- msg->elements[i++] = 'a';
- msg->elements[i++] = 'd';
- msg->elements[i++] = ' ';
+ ArrayUInt16::setElement(msg, 't', i);
+ ArrayUInt16::setElement(msg, 'r', i);
+ ArrayUInt16::setElement(msg, 'y', i);
+ ArrayUInt16::setElement(msg, ' ', i);
+ ArrayUInt16::setElement(msg, 't', i);
+ ArrayUInt16::setElement(msg, 'o', i);
+ ArrayUInt16::setElement(msg, ' ', i);
+ ArrayUInt16::setElement(msg, 'l', i);
+ ArrayUInt16::setElement(msg, 'o', i);
+ ArrayUInt16::setElement(msg, 'a', i);
+ ArrayUInt16::setElement(msg, 'd', i);
+ ArrayUInt16::setElement(msg, ' ', i);
for (sint32 j = 0; j < cl->name->size; ++j) {
- if (cl->name->elements[j] == '/') msg->elements[i++] = '.';
- else msg->elements[i++] = cl->name->elements[j];
+ if (cl->name->elements[j] == '/') {
+ ArrayUInt16::setElement(msg, '.', i); i++;
+ } else {
+ ArrayUInt16::setElement(msg, cl->name->elements[j], i); i++;
+ }
}
- msg->elements[i++] = ' ';
- msg->elements[i++] = 'a';
- msg->elements[i++] = 'n';
- msg->elements[i++] = 'd';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 'f';
- msg->elements[i++] = 'o';
- msg->elements[i++] = 'u';
- msg->elements[i++] = 'n';
- msg->elements[i++] = 'd';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 'c';
- msg->elements[i++] = 'l';
- msg->elements[i++] = 'a';
- msg->elements[i++] = 's';
- msg->elements[i++] = 's';
- msg->elements[i++] = ' ';
- msg->elements[i++] = 'n';
- msg->elements[i++] = 'a';
- msg->elements[i++] = 'm';
- msg->elements[i++] = 'e';
- msg->elements[i++] = 'd';
- msg->elements[i++] = ' ';
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 'a', i); i++;
+ ArrayUInt16::setElement(msg, 'n', i); i++;
+ ArrayUInt16::setElement(msg, 'd', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 'f', i); i++;
+ ArrayUInt16::setElement(msg, 'o', i); i++;
+ ArrayUInt16::setElement(msg, 'u', i); i++;
+ ArrayUInt16::setElement(msg, 'n', i); i++;
+ ArrayUInt16::setElement(msg, 'd', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 'c', i); i++;
+ ArrayUInt16::setElement(msg, 'l', i); i++;
+ ArrayUInt16::setElement(msg, 'a', i); i++;
+ ArrayUInt16::setElement(msg, 's', i); i++;
+ ArrayUInt16::setElement(msg, 's', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
+ ArrayUInt16::setElement(msg, 'n', i); i++;
+ ArrayUInt16::setElement(msg, 'a', i); i++;
+ ArrayUInt16::setElement(msg, 'm', i); i++;
+ ArrayUInt16::setElement(msg, 'e', i); i++;
+ ArrayUInt16::setElement(msg, 'd', i); i++;
+ ArrayUInt16::setElement(msg, ' ', i); i++;
for (sint32 j = 0; j < name->size; ++j) {
- if (name->elements[j] == '/') msg->elements[i++] = '.';
- else msg->elements[i++] = name->elements[j];
+ if (name->elements[j] == '/') {
+ ArrayUInt16::setElement(msg, '.', i); i++;
+ } else {
+ ArrayUInt16::setElement(msg, name->elements[j], i); i++;
+ }
}
assert(i == size && "Array overflow");
@@ -694,10 +713,9 @@
uint32 size = utf8->size;
ArrayUInt16* tmp = (ArrayUInt16*)upcalls->ArrayOfChar->doNew(size, this);
llvm_gcroot(tmp, 0);
- uint16* buf = tmp->elements;
for (uint32 i = 0; i < size; i++) {
- buf[i] = utf8->elements[i];
+ ArrayUInt16::setElement(tmp, utf8->elements[i], i);
}
return hashStr.lookupOrCreate(const_cast<const ArrayUInt16*&>(tmp), this,
@@ -786,17 +804,17 @@
static char* findInformation(Jnjvm* vm, ArrayUInt8* manifest, const char* entry,
uint32 len) {
- uint8* ptr = manifest->elements;
- sint32 index = sys_strnstr((char*)ptr, entry);
+ llvm_gcroot(manifest, 0);
+ sint32 index = sys_strnstr((char*)ArrayUInt8::getElements(manifest), entry);
if (index != -1) {
index += len;
- sint32 end = sys_strnstr((char*)&(ptr[index]), "\n");
- if (end == -1) end = manifest->size;
+ sint32 end = sys_strnstr((char*)ArrayUInt8::getElements(manifest) + index, "\n");
+ if (end == -1) end = ArrayUInt8::getSize(manifest);
else end += index;
sint32 length = end - index - 1;
char* name = (char*)vm->allocator.Allocate(length + 1, "class name");
- memcpy(name, &(ptr[index]), length);
+ memcpy(name, ArrayUInt8::getElements(manifest) + index, length);
name[length] = 0;
return name;
} else {
@@ -806,13 +824,15 @@
void ClArgumentsInfo::extractClassFromJar(Jnjvm* vm, int argc, char** argv,
int i) {
+ ArrayUInt8* bytes = NULL;
+ llvm_gcroot(bytes, 0);
jarFile = argv[i];
vm->setClasspath(jarFile);
- ArrayUInt8* bytes = Reader::openFile(vm->bootstrapLoader, jarFile, true);
+ bytes = Reader::openFile(vm->bootstrapLoader, jarFile, true);
- if (!bytes) {
+ if (bytes == NULL) {
printf("Unable to access jarfile %s\n", jarFile);
return;
}
@@ -1266,7 +1286,7 @@
UserClassArray* array = vm->bootstrapLoader->upcalls->ArrayOfString;
args = (ArrayObject*)array->doNew(info.argc - 2, vm);
for (int i = 2; i < info.argc; ++i) {
- args->elements[i - 2] = (JavaObject*)vm->asciizToStr(info.argv[i]);
+ ArrayObject::setElement(args, (JavaObject*)vm->asciizToStr(info.argv[i]), i - 2);
}
vm->executeClass(info.className, args);
@@ -1394,10 +1414,9 @@
ArrayUInt16* Jnjvm::asciizToArray(const char* asciiz) {
uint32 size = strlen(asciiz);
ArrayUInt16* tmp = (ArrayUInt16*)upcalls->ArrayOfChar->doNew(size, this);
- uint16* buf = tmp->elements;
for (uint32 i = 0; i < size; i++) {
- buf[i] = asciiz[i];
+ ArrayUInt16::setElement(tmp, asciiz[i], i);
}
return tmp;
}
Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp Wed Jun 2 16:27:17 2010
@@ -569,47 +569,44 @@
llvm_gcroot(str, 0);
- UTF8* name = (UTF8*)alloca(sizeof(UTF8) + str->count * sizeof(uint16));
+ UTF8* name = (UTF8*)malloc(sizeof(UTF8) + str->count * sizeof(uint16));
- if (name) {
- name->size = str->count;
- if (str->value->elements[str->offset] != I_TAB) {
- for (sint32 i = 0; i < str->count; ++i) {
- uint16 cur = str->value->elements[str->offset + i];
- if (cur == '.') name->elements[i] = '/';
- else if (cur == '/') return 0;
- else name->elements[i] = cur;
- }
- } else {
- for (sint32 i = 0; i < str->count; ++i) {
- uint16 cur = str->value->elements[str->offset + i];
- if (cur == '.') name->elements[i] = '/';
- else if (cur == '/') return 0;
- else name->elements[i] = cur;
- }
+ name->size = str->count;
+ if (ArrayUInt16::getElement(str->value, str->offset) != I_TAB) {
+ for (sint32 i = 0; i < str->count; ++i) {
+ uint16 cur = ArrayUInt16::getElement(str->value, str->offset + i);
+ if (cur == '.') name->elements[i] = '/';
+ else if (cur == '/') return 0;
+ else name->elements[i] = cur;
+ }
+ } else {
+ for (sint32 i = 0; i < str->count; ++i) {
+ uint16 cur = ArrayUInt16::getElement(str->value, str->offset + i);
+ if (cur == '.') name->elements[i] = '/';
+ else if (cur == '/') return 0;
+ else name->elements[i] = cur;
}
-
- return loadClassFromUserUTF8(name, doResolve, doThrow, str);
}
-
- return 0;
+
+ UserCommonClass* cls = loadClassFromUserUTF8(name, doResolve, doThrow, str);
+ free(name);
+ return cls;
}
UserCommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str) {
llvm_gcroot(str, 0);
- UTF8* name = (UTF8*)alloca(sizeof(UTF8) + str->count * sizeof(uint16));
- if (name) {
- name->size = str->count;
- for (sint32 i = 0; i < str->count; ++i) {
- uint16 cur = str->value->elements[str->offset + i];
- if (cur == '.') name->elements[i] = '/';
- else name->elements[i] = cur;
- }
- return lookupClass(name);
- }
- return 0;
+ UTF8* name = (UTF8*)malloc(sizeof(UTF8) + str->count * sizeof(uint16));
+ name->size = str->count;
+ for (sint32 i = 0; i < str->count; ++i) {
+ uint16 cur = ArrayUInt16::getElement(str->value, str->offset + i);
+ if (cur == '.') name->elements[i] = '/';
+ else name->elements[i] = cur;
+ }
+ UserCommonClass* cls = lookupClass(name);
+ free(name);
+ return cls;
}
UserCommonClass* JnjvmClassLoader::lookupClass(const UTF8* utf8) {
Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.h?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.h Wed Jun 2 16:27:17 2010
@@ -48,10 +48,11 @@
{
bool operator()(const ArrayUInt16* s1, const ArrayUInt16* s2) const
{
- if (s1->size < s2->size) return true;
- else if (s1->size > s2->size) return false;
- else return memcmp((const char*)s1->elements, (const char*)s2->elements,
- s1->size * sizeof(uint16)) < 0;
+ if (ArrayUInt16::getSize(s1) < ArrayUInt16::getSize(s2)) return true;
+ else if (ArrayUInt16::getSize(s1) > ArrayUInt16::getSize(s2)) return false;
+ else return memcmp((const char*)ArrayUInt16::getElements(s1),
+ (const char*)ArrayUInt16::getElements(s2),
+ ArrayUInt16::getSize(s1) * sizeof(uint16)) < 0;
}
};
Modified: vmkit/trunk/lib/J3/VMCore/Reader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Reader.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Reader.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Reader.cpp Wed Jun 2 16:27:17 2010
@@ -28,14 +28,15 @@
ArrayUInt8* Reader::openFile(JnjvmBootstrapLoader* loader, const char* path,
bool temp) {
FILE* fp = fopen(path, "r");
- ArrayUInt8* res = 0;
+ ArrayUInt8* res = NULL;
+ llvm_gcroot(res, 0);
if (fp != 0) {
fseek(fp, 0, SeekEnd);
long nbb = ftell(fp);
fseek(fp, 0, SeekSet);
UserClassArray* array = loader->upcalls->ArrayOfByte;
res = (ArrayUInt8*)array->doNew((sint32)nbb, loader->allocator, temp);
- if (fread(res->elements, nbb, 1, fp) == 0) {
+ if (fread(ArrayUInt8::getElements(res), nbb, 1, fp) == 0) {
fprintf(stderr, "fread error\n");
abort();
}
@@ -46,17 +47,17 @@
ArrayUInt8* Reader::openZip(JnjvmBootstrapLoader* loader, ZipArchive* archive,
const char* filename) {
- ArrayUInt8* ret = 0;
+ ArrayUInt8* res = 0;
+ llvm_gcroot(res, 0);
ZipFile* file = archive->getFile(filename);
if (file != 0) {
UserClassArray* array = loader->upcalls->ArrayOfByte;
- ArrayUInt8* res =
- (ArrayUInt8*)array->doNew((sint32)file->ucsize, loader->allocator);
+ res = (ArrayUInt8*)array->doNew((sint32)file->ucsize, loader->allocator);
if (archive->readFile(res, file) != 0) {
- ret = res;
+ return res;
}
}
- return ret;
+ return NULL;
}
void Reader::seek(uint32 pos, int from) {
Modified: vmkit/trunk/lib/J3/VMCore/Reader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Reader.h?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Reader.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Reader.h Wed Jun 2 16:27:17 2010
@@ -84,11 +84,13 @@
const char* filename);
uint8 readU1() {
- return (*bytes)->elements[cursor++];
+ ++cursor;
+ return ArrayUInt8::getElement(*bytes, cursor - 1);
}
sint8 readS1() {
- return (*bytes)->elements[cursor++];
+ ++cursor;
+ return ArrayUInt8::getElement(*bytes, cursor - 1);
}
uint16 readU2() {
@@ -122,7 +124,7 @@
}
Reader(ArrayUInt8** array, uint32 start = 0, uint32 end = 0) {
- if (!end) end = (*array)->size;
+ if (!end) end = ArrayUInt8::getSize(*array);
this->bytes = array;
this->cursor = start;
this->min = start;
Modified: vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp Wed Jun 2 16:27:17 2010
@@ -91,9 +91,10 @@
cl->classLoader->getJavaClassLoaderPtr(), closure);
- for (sint32 i = 0; i < obj->size; i++) {
- if (obj->elements[i]) {
- mvm::Collector::markAndTrace(obj, obj->elements + i, closure);
+ for (sint32 i = 0; i < ArrayObject::getSize(obj); i++) {
+ if (ArrayObject::getElement(obj, i) != NULL) {
+ mvm::Collector::markAndTrace(
+ obj, ArrayObject::getElements(obj) + i, closure);
}
}
}
Modified: vmkit/trunk/lib/J3/VMCore/Zip.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Zip.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Zip.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Zip.cpp Wed Jun 2 16:27:17 2010
@@ -103,8 +103,8 @@
if (searchPos >= st) {
sint32 searchPtr = temp + (searchPos - st);
while (searchPtr > temp) {
- if ((*(reader.bytes))->elements[searchPtr] == 'P' &&
- !(memcmp(&((*(reader.bytes))->elements[searchPtr]), HDR_ENDCENTRAL, 4))) {
+ if (ArrayUInt8::getElement(*(reader.bytes), searchPtr) == 'P' &&
+ !(memcmp(ArrayUInt8::getElements(*(reader.bytes)) + searchPtr, HDR_ENDCENTRAL, 4))) {
sint32 offset = searchPtr + 4 + E_OFFSET_START_CENTRAL_DIRECTORY;
reader.cursor = offset;
this->ofscd = readEndianDep4(reader);
@@ -123,7 +123,7 @@
reader.cursor = temp;
while (true) {
- if (memcmp(&((*(reader.bytes))->elements[temp]), HDR_CENTRAL, 4)) return;
+ if (memcmp(ArrayUInt8::getElements(*(reader.bytes)) + temp, HDR_CENTRAL, 4)) return;
ZipFile* ptr = new(allocator, "ZipFile") ZipFile();
reader.cursor = temp + 4 + C_COMPRESSION_METHOD;
ptr->compressionMethod = readEndianDep2(reader);
@@ -147,7 +147,7 @@
ptr->filename = (char*)allocator.Allocate(ptr->filenameLength + 1,
"Zip file name");
- memcpy(ptr->filename, &((*(reader.bytes))->elements[temp]),
+ memcpy(ptr->filename, ArrayUInt8::getElements(*(reader.bytes)) + temp,
ptr->filenameLength);
ptr->filename[ptr->filenameLength] = 0;
@@ -161,16 +161,16 @@
}
sint32 ZipArchive::readFile(ArrayUInt8* array, const ZipFile* file) {
+ llvm_gcroot(array, 0);
uint32 bytesLeft = 0;
uint32 filenameLength = 0;
uint32 extraFieldLength = 0;
- char* ptr = (char*)array->elements;
uint32 temp = 0;
Reader reader(&bytes);
reader.cursor = file->rolh;
- if (!(memcmp(&((*(reader.bytes))->elements[file->rolh]), HDR_LOCAL, 4))) {
+ if (!(memcmp(ArrayUInt8::getElements(*(reader.bytes)) + file->rolh, HDR_LOCAL, 4))) {
reader.cursor += 4;
temp = reader.cursor;
reader.cursor += L_FILENAME_LENGTH;
@@ -181,14 +181,14 @@
temp + extraFieldLength + filenameLength + LOCAL_FILE_HEADER_SIZE;
if (file->compressionMethod == ZIP_STORE) {
- memcpy(ptr, &((*(reader.bytes))->elements[reader.cursor]), file->ucsize);
+ memcpy(ArrayUInt8::getElements(array), ArrayUInt8::getElements(*(reader.bytes)) + reader.cursor, file->ucsize);
return 1;
} else if (file->compressionMethod == ZIP_DEFLATE) {
z_stream stre;
sint32 err = 0;
bytesLeft = file->csize;
- stre.next_out = (Bytef*)ptr;
+ stre.next_out = (Bytef*)ArrayUInt8::getElements(array);
stre.avail_out = file->ucsize;
stre.zalloc = 0;
stre.zfree = 0;
@@ -201,7 +201,7 @@
while (bytesLeft) {
uint32 size = 0;
- stre.next_in = &((*(reader.bytes))->elements[reader.cursor]);
+ stre.next_in = ArrayUInt8::getElements(*(reader.bytes)) + reader.cursor;
if (bytesLeft > 1024) size = 1024;
else size = bytesLeft;
Modified: vmkit/trunk/mmtk/mmtk-j3/RuntimeHelpers.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/RuntimeHelpers.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/RuntimeHelpers.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/RuntimeHelpers.cpp Wed Jun 2 16:27:17 2010
@@ -14,7 +14,7 @@
using namespace j3;
extern "C" uint16_t MMTkCharAt(JavaString* str, uint32_t index) {
- return str->value->elements[index];
+ return ArrayUInt16::getElement(str->value, index);
}
extern "C" JavaObject* MMTkGetClass(JavaObject* obj) {
Modified: vmkit/trunk/mmtk/mmtk-j3/Strings.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Strings.cpp?rev=105346&r1=105345&r2=105346&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Strings.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Strings.cpp Wed Jun 2 16:27:17 2010
@@ -17,8 +17,9 @@
extern "C" void Java_org_j3_mmtk_Strings_write___3CI(JavaObject* str,
ArrayUInt16* msg,
sint32 len) {
- for (sint32 i = 0; i < len; ++i)
- fprintf(stderr, "%c", msg->elements[i]);
+ for (sint32 i = 0; i < len; ++i) {
+ fprintf(stderr, "%c", ArrayUInt16::getElement(msg, i));
+ }
}
extern "C" void Java_org_j3_mmtk_Strings_writeThreadId___3CI(JavaObject*str,
@@ -27,8 +28,9 @@
fprintf(stderr, "[%p] ", (void*)JavaThread::get());
- for (sint32 i = 0; i < len; ++i)
- fprintf(stderr, "%c", msg->elements[i]);
+ for (sint32 i = 0; i < len; ++i) {
+ fprintf(stderr, "%c", ArrayUInt16::getElement(msg, i));
+ }
}
@@ -41,7 +43,8 @@
sint32 n = (dstBegin + len <= dstEnd) ? len : (dstEnd - dstBegin);
for (sint32 i = 0; i < n; i++) {
- dst->elements[dstBegin + i] = str->value->elements[str->offset + i];
+ ArrayUInt16::setElement(dst,
+ ArrayUInt16::getElement(str->value, str->offset + i), dstBegin + i);
}
return n;
More information about the vmkit-commits
mailing list