[vmkit-commits] [vmkit] r180427 - Annotations: support for properties of type arrays, class, byte
Peter Senna Tschudin
peter.senna at gmail.com
Thu Apr 25 10:10:34 PDT 2013
Author: peter.senna
Date: Thu Apr 25 12:08:46 2013
New Revision: 180427
URL: http://llvm.org/viewvc/llvm-project?rev=180427&view=rev
Log:
Annotations: support for properties of type arrays, class, byte
Status
Primitive properties in Annotations - OK
Array properties in Annotations - String[] only
Enumeration - None
Nested Annotation - None
(cherry picked from commit 0f648baaf3e70c44bf8105fbb44b033e03758b09)
Modified:
vmkit/trunk/lib/j3/VMCore/JavaClass.cpp
vmkit/trunk/lib/j3/VMCore/JavaClass.h
Modified: vmkit/trunk/lib/j3/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaClass.cpp?rev=180427&r1=180426&r2=180427&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaClass.cpp Thu Apr 25 12:08:46 2013
@@ -17,7 +17,7 @@
#include "ClasspathReflect.h"
#include "JavaArray.h"
#include "JavaClass.h"
-#include "j3/JavaCompiler.h"
+#include "JavaCompiler.h"
#include "JavaString.h"
#include "JavaConstantPool.h"
#include "JavaObject.h"
@@ -604,9 +604,6 @@ void JavaField::InitStaticField(float va
}
void JavaField::InitStaticField(Jnjvm* vm) {
- JavaString* obj = 0;
- llvm_gcroot(obj, 0);
-
const Typedef* type = getSignature();
JavaAttribute* attribute = lookupAttribute(JavaAttribute::constantAttribute);
@@ -629,8 +626,7 @@ void JavaField::InitStaticField(Jnjvm* v
}
} else if (type->isReference()) {
const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[idx]);
- obj = ctpInfo->resolveString(utf8, idx);
- InitStaticField(obj);
+ InitStaticField((JavaObject*)ctpInfo->resolveString(utf8, idx));
} else {
fprintf(stderr, "I haven't verified your class file and it's malformed:"
" unknown constant %s!\n",
@@ -1037,12 +1033,9 @@ ArrayObject* JavaMethod::getParameterTyp
}
JavaObject* JavaMethod::getReturnType(JnjvmClassLoader* loader) {
- JavaObject* obj = 0;
- llvm_gcroot(obj, 0);
Jnjvm* vm = JavaThread::get()->getJVM();
Typedef* ret = getSignature()->getReturnType();
- obj = getClassType(vm, loader, ret);
- return obj;
+ return getClassType(vm, loader, ret);
}
ArrayObject* JavaMethod::getExceptionTypes(JnjvmClassLoader* loader) {
@@ -1090,11 +1083,10 @@ JavaObject* CommonClass::setDelegatee(Ja
UserCommonClass* UserCommonClass::resolvedImplClass(Jnjvm* vm,
JavaObject* clazz,
bool doClinit) {
- JavaObjectClass* jcl = 0;
+
llvm_gcroot(clazz, 0);
- llvm_gcroot(jcl, 0);
- UserCommonClass* cl = JavaObjectClass::getClass(jcl = (JavaObjectClass*)clazz);
+ UserCommonClass* cl = JavaObjectClass::getClass((JavaObjectClass*)clazz);
assert(cl && "No class in Class object");
if (cl->isClass()) {
cl->asClass()->resolveClass();
@@ -1758,24 +1750,26 @@ void AnnotationReader::readElementValue(
}
}
-JavaObject* AnnotationReader::createElementValue() {
+JavaObject* AnnotationReader::createElementValue(uint8* outTag) {
uint8 tag = reader.readU1();
+ if (outTag)
+ *outTag = tag;
JavaObject* res = 0;
JavaObject* tmp = 0;
- ArrayObject* arrayObj = 0;
+ JavaString* str = 0;
llvm_gcroot(res, 0);
llvm_gcroot(tmp, 0);
- llvm_gcroot(arrayObj, 0);
+ llvm_gcroot(str, 0);
- Jnjvm* vm = JavaThread::get()->getJVM();
- Classpath* upcalls = JavaThread::get()->getJVM()->upcalls;
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ Classpath* upcalls = vm->upcalls;
ddprintf("value:");
if (tag == 'B') {
uint32 val = cl->ctpInfo->IntegerAt(reader.readU2());
ddprintf("B=%d", val);
- res = upcalls->boolClass->doNew(vm);
- upcalls->boolValue->setInstanceInt8Field(res, val);
+ res = upcalls->byteClass->doNew(vm);
+ upcalls->byteValue->setInstanceInt8Field(res, val);
} else if (tag == 'C') {
uint32 val = cl->ctpInfo->IntegerAt(reader.readU2());
@@ -1830,26 +1824,49 @@ JavaObject* AnnotationReader::createElem
ddprintf("%s", PrintBuffer(n).cString());
const UTF8* m = cl->ctpInfo->UTF8At(reader.readU2());
ddprintf("%s", PrintBuffer(m).cString());
- fprintf(stderr, "Annotation not supported for %c type\n", tag);
+ fprintf(stderr, "Annotation not supported for %c (enumerations) type\n", tag);
abort();
} else if (tag == 'c') {
ddprintf("class=");
const UTF8* m = cl->ctpInfo->UTF8At(reader.readU2());
+
ddprintf("%s", PrintBuffer(m).cString());
+ JnjvmClassLoader* JCL = this->cl->classLoader;
+
+ m = m->extract(JCL->hashUTF8, 1,m->size-1);
+
+ UserCommonClass* cl = JCL->loadClassFromUserUTF8(m,true,false, NULL);
+
+ if (cl != NULL && !cl->isPrimitive()) {
+ if (cl->asClass()) {
+ cl->asClass()->initialiseClass(vm);
+ }
+ res = cl->getClassDelegatee(vm);
+ } else {
+ str = JavaString::internalToJava(m, vm);
+ vm->classNotFoundException(str);
+ }
+
} else if (tag == '[') {
uint16 numValues = reader.readU2();
- UserClassArray* array = upcalls->annotationArrayClass;
- res = array->doNew(numValues, vm);
- ddprintf("Tableau de %d elements\n", numValues);
- for (uint32 i = 0; i < numValues; ++i) {
- tmp = createElementValue();
- arrayObj = (ArrayObject *)res;
- ArrayObject::setElement(arrayObj, tmp, i);
+ uint8 arrayTag = 0;
+ if (numValues > 0) {
+ tmp = createElementValue(&arrayTag);
+ res = createArrayByTag(arrayTag, numValues);
+ ArrayObject::setElement((ArrayObject *)res, tmp, 0);
+ for (uint32 i = 1; i < numValues; ++i) {
+ tmp = createElementValue();
+ ArrayObject::setElement((ArrayObject *)res, tmp, i);
+ }
+ }
+ else {
+ fprintf(stderr, "Empty array not implemented %c type\n", tag);
+ abort();
}
- ddprintf("Fin du Tableau");
+
} else {
// Element_value Annotation not implemented
fprintf(stderr, "Annotation not supported for %c type\n", tag);
@@ -1860,7 +1877,73 @@ JavaObject* AnnotationReader::createElem
return res;
}
-JavaObject* AnnotationReader::createAnnotationMapValues() {
+JavaObject* AnnotationReader::createArrayByTag(uint8 tag, uint16 numValues) {
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+ UserClassArray* array = 0;
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ Classpath* upcalls = vm->upcalls;
+ ddprintf("value:");
+
+ if (tag == 'B') {
+ array = upcalls->ArrayOfByte;
+ res = array->doNew(numValues, vm);
+ } else if (tag == 'C') {
+ array = upcalls->ArrayOfChar;
+ res = array->doNew(numValues, vm);
+
+ } else if (tag == 'D') {
+ array = upcalls->ArrayOfDouble;
+ res = array->doNew(numValues, vm);
+
+ } else if (tag == 'F') {
+ array = upcalls->ArrayOfFloat;
+ res = array->doNew(numValues, vm);
+
+ } else if (tag == 'J') {
+ array = upcalls->ArrayOfLong;
+ res = array->doNew(numValues, vm);
+
+ } else if (tag == 'S') {
+ array = upcalls->ArrayOfShort;
+ res = array->doNew(numValues, vm);
+
+ } else if (tag == 'I') {
+ array = upcalls->ArrayOfInt;
+ res = array->doNew(numValues, vm);
+
+ } else if (tag == 'Z') {
+ array = upcalls->ArrayOfBool;
+ res = array->doNew(numValues, vm);
+
+ } else if (tag == 's') {
+ array = upcalls->ArrayOfString;
+ res = array->doNew(numValues, vm);
+
+ } else if (tag == 'e') {
+ fprintf(stderr, "Annotation not supported for %c (enumerations) type\n", tag);
+ abort();
+
+ } else if (tag == 'c') {
+ //array = upcalls->constructorArrayClass;
+ //res = array->doNew(numValues, vm);
+ fprintf(stderr, "Annotation not supported for %c (enumerations) type\n", tag);
+ abort();
+
+ } else if (tag == '[') {
+ fprintf(stderr, "Annotation not supported for %c (enumerations) type\n", tag);
+ abort();
+
+ } else {
+ // Element_value Annotation not implemented
+ fprintf(stderr, "Annotation not supported for %c type\n", tag);
+ abort();
+ }
+
+ return res;
+}
+
+JavaObject* AnnotationReader::createAnnotationMapValues(JavaObject* type) {
std::pair<JavaObject*, JavaObject*> pair;
JavaObject* tmp = 0;
JavaString* str = 0;
@@ -1868,6 +1951,9 @@ JavaObject* AnnotationReader::createAnno
llvm_gcroot(tmp, 0);
llvm_gcroot(str, 0);
llvm_gcroot(newHashMap, 0);
+ llvm_gcroot(type, 0);
+
+ const UTF8* key = 0;
Jnjvm * vm = JavaThread::get()->getJVM();
Classpath* upcalls = vm->upcalls;
@@ -1879,14 +1965,18 @@ JavaObject* AnnotationReader::createAnno
dprintf("numPairs:%d\n", numPairs);
for (uint16 j = 0; j < numPairs; ++j) {
uint16 nameIndex = reader.readU2();
- const UTF8* key = cl->ctpInfo->UTF8At(nameIndex);
+ key = cl->ctpInfo->UTF8At(nameIndex);
dprintf("keyAn:%s|", PrintBuffer(key).cString());
tmp = createElementValue();
- str = JavaString::internalToJava(key, JavaThread::get()->getJVM());
+ str = JavaString::internalToJava(key, vm);
upcalls->putHashMap->invokeJavaObjectVirtual(vm, HashMap, newHashMap, &str, &tmp);
}
+ // annotationType
+ str = vm->asciizToStr("annotationType");
+ upcalls->putHashMap->invokeJavaObjectVirtual(vm, HashMap, newHashMap, &str, &type);
+
return newHashMap;
}
Modified: vmkit/trunk/lib/j3/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaClass.h?rev=180427&r1=180426&r2=180427&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaClass.h Thu Apr 25 12:08:46 2013
@@ -78,12 +78,14 @@ public:
// createAnnotation - search for a specific annotation in annotation
// attributes.
//
- JavaObject* createAnnotationMapValues();
+ JavaObject* createAnnotationMapValues(JavaObject* type);
// createElementValue - create the Java type associated withe the value
// of the current annotation key.
//
- JavaObject* createElementValue();
+ JavaObject* createElementValue(uint8* outTag = 0);
+
+ JavaObject* createArrayByTag(uint8 tag, uint16 numValues);
};
/// Attribute - This class represents JVM attributes to Java class, methods and
More information about the vmkit-commits
mailing list