[vmkit-commits] [vmkit] r55587 - in /vmkit/branches/isolate/lib/JnJVM/Isolate: IsolateCommonClass.cpp IsolateCommonClass.h

[Nicolas Geoffray]

Author: geoffray
Date: Sun Aug 31 04:53:46 2008
New Revision: 55587

URL: http://llvm.org/viewvc/llvm-project?rev=55587&view=rev
Log:
Implement UserConstantPool::loadClass ::resolveMethod and ::resolveField.


Modified:
    vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp
    vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h

Modified: vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp?rev=55587&r1=55586&r2=55587&view=diff

==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp Sun Aug 31 04:53:46 2008
@@ -35,7 +35,7 @@
   classLoader = JCL;
   delegatee = 0;
   staticInstance = 0;
-  ctpInfo = new(JCL->allocator, cl->ctpInfo->ctpSize) UserConstantPool(this);
+  ctpInfo = 0;
 }
 
 UserClassArray::UserClassArray(JnjvmClassLoader* JCL, const UTF8* name) {
@@ -82,11 +82,15 @@
             def->readClass();
             def->status = classRead;
             status = classRead;
-            def->release();
-            release();
+            cl->ctpInfo = 
+              new(classLoader->allocator, def->ctpInfo->ctpSize) UserConstantPool(cl);
             cl->loadParents();
-            acquire();
-            def->acquire();
+            if (cl->super)
+              def->super = cl->super->classDef;
+            for (std::vector<UserClass*>::iterator i = interfaces.begin(),
+                 e = interfaces.end(); i != e; ++i) {
+              def->interfaces.push_back((Class*)((*i)->classDef));
+            }
             def->status = prepared;
             status = prepared;
             def->classLoader->TheModule->resolveVirtualClass(def);
@@ -100,6 +104,8 @@
             classDef->release();
           }
         } else {
+          cl->ctpInfo = 
+            new(classLoader->allocator, def->ctpInfo->ctpSize) UserConstantPool(cl);
           release();
           status = classRead,
           cl->loadParents();
@@ -128,27 +134,58 @@
   return 0;
 }
 
+
+UserCommonClass* UserConstantPool::isClassLoaded(uint32 entry) {
+  JavaConstantPool* ctpInfo = getSharedPool();
+  if (! ((entry > 0) && (entry < ctpInfo->ctpSize) && 
+        ctpInfo->typeAt(entry) == JavaConstantPool::ConstantClass)) {
+    JavaThread::get()->isolate->classFormatError(
+              "bad constant pool number for class at entry %d", entry);
+  }
+  return (UserCommonClass*)ctpRes[entry];
+}
+
 UserCommonClass* UserConstantPool::loadClass(uint32 index) {
-  fprintf(stderr, "implement me");
-  abort();
-  return 0;
+  UserCommonClass* temp = isClassLoaded(index);
+  if (!temp) {
+    JavaConstantPool* ctpInfo = getSharedPool();
+    JnjvmClassLoader* loader = getClass()->classLoader;
+    const UTF8* name = ctpInfo->UTF8At(ctpInfo->ctpDef[index]);
+    if (name->elements[0] == AssessorDesc::I_TAB) {
+      temp = loader->constructArray(name);
+      temp->resolveClass();
+    } else {
+      // Put into ctpRes because there is only one representation of the class
+      temp = loader->loadName(name, true, false);
+    }
+    ctpRes[index] = temp;
+    ctpInfo->ctpRes[index] = getClass()->classDef;
+  }
+  return temp;
 }
 
 void UserConstantPool::resolveMethod(uint32 index, UserCommonClass*& cl,
                                      const UTF8*& utf8, Signdef*& sign) {
-  fprintf(stderr, "implement me");
-  abort();
+  JavaConstantPool* ctpInfo = getSharedPool();
+  sint32 entry = ctpInfo->ctpDef[index];
+  sint32 ntIndex = entry & 0xFFFF;
+  sign = (Signdef*)ctpInfo->ctpRes[ntIndex];
+  assert(sign && "No cached signature after JITting");
+  utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[ntIndex] >> 16);
+  cl = loadClass(entry >> 16);
+  assert(cl && cl->isResolved() && "No resolved class when resolving method");
 }
   
 void UserConstantPool::resolveField(uint32 index, UserCommonClass*& cl,
                                     const UTF8*& utf8, Typedef*& sign) {
-  fprintf(stderr, "implement me");
-  abort();
-}
-
-const UTF8* UserConstantPool::UTF8AtForString(uint32 entry) {
-  fprintf(stderr, "implement me");
-  abort();
+  JavaConstantPool* ctpInfo = getSharedPool();
+  sint32 entry = ctpInfo->ctpDef[index];
+  sint32 ntIndex = entry & 0xFFFF;
+  sign = (Typedef*)ctpInfo->ctpRes[ntIndex];
+  assert(sign && "No cached Typedef after JITting");
+  utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[ntIndex] >> 16);
+  cl = loadClass(entry >> 16);
+  assert(cl && cl->isResolved() && "No resolved class when resolving field");
 }
 
 void* UserConstantPool::operator new(size_t sz, JavaAllocator* alloc,

Modified: vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h?rev=55587&r1=55586&r2=55587&view=diff

==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h Sun Aug 31 04:53:46 2008
@@ -16,6 +16,8 @@
 
 #include "mvm/Object.h"
 
+#include "JavaConstantPool.h"
+
 namespace jnjvm {
 
 class ArrayUInt8;
@@ -112,6 +114,10 @@
   bool isReady() {
     return status >= inClinit;
   }
+  
+  bool isResolved() {
+    return status >= resolved;
+  }
 
   uint8 getAccess() {
     return classDef->access;
@@ -386,10 +392,20 @@
   ///
   void resolveField(uint32 index, UserCommonClass*& cl, const UTF8*& utf8,
                     Typedef*& sign);
+  
+  UserClass* getClass() {
+    return (UserClass*)ctpRes[0];
+  }
+
+  JavaConstantPool* getSharedPool() {
+    return ((Class*)(getClass()->classDef))->ctpInfo;
+  }
 
   /// UTF8At - Get the UTF8 referenced from this string entry.
   ///
-  const UTF8* UTF8AtForString(uint32 entry);
+  const UTF8* UTF8AtForString(uint32 entry) {
+    return getSharedPool()->UTF8AtForString(entry);
+  }
 
   /// loadClass - Loads the class and returns it. This is called just in time, 
   /// ie when the class will be used and not yet resolved.
@@ -403,6 +419,9 @@
   UserConstantPool(UserClass* cl) {
     ctpRes[0] = cl;
   }
+
+  UserCommonClass* isClassLoaded(uint32 entry);
+
 };
 
 } // end namespace jnjvm