use constants to determine classSize/cdvSize and fix wrong copy size …

…in initArrayClass

compiler/src/jlang/extension/JLangNewArrayExt.java

@@ -95,35 +95,31 @@ public static LLVMValueRef translateNewArray(LLVMTranslator v, LLVMValueRef[] le
                 v.utils.toLL(arrType),
                 v.utils.i8Ptr(),
                 v.utils.ptrTypeRef(v.utils.i32()),
-                v.utils.i32(),
                 v.utils.i32()
         );
         LLVMValueRef createArray = v.utils.getFunction(Constants.CREATE_ARRAY, createArrayType);
         LLVMValueRef name = v.utils.buildGlobalCStr(v.mangler.userVisibleEntityName(type));
         LLVMValueRef arrSize = LLVMConstInt(v.utils.i32(), len.length, 0);
         LLVMValueRef arrLen = v.utils.buildArrayAlloca("arr.len", v.utils.i32(), arrSize);
-        LLVMValueRef numOfCdvMethods = LLVMConstInt(v.utils.i32(), v.cdvMethods(arrType).size(), 0);
 
         for (int i = 0; i < len.length; i++) {
             LLVMValueRef gep = v.utils.buildGEP(arrLen, i);
             LLVMBuildStore(v.builder, len[i], gep);
         }
 
-        return v.utils.buildFunCall(createArray, name, arrLen, arrSize, numOfCdvMethods);
+        return v.utils.buildFunCall(createArray, name, arrLen, arrSize);
     }
 
     public static LLVMValueRef translateNew1DArray(LLVMTranslator v, LLVMValueRef len, ArrayType type) {
         ClassType arrType = v.ts.ArrayObject();
         LLVMTypeRef create1DArrayType = v.utils.functionType(
                 v.utils.toLL(arrType),
                 v.utils.i8Ptr(),
-                v.utils.i32(),
                 v.utils.i32()
         );
         LLVMValueRef create1DArray = v.utils.getFunction(Constants.CREATE_1D_ARRAY, create1DArrayType);
         LLVMValueRef name = v.utils.buildGlobalCStr(v.mangler.userVisibleEntityName(type));
-        LLVMValueRef numOfCdvMethods = LLVMConstInt(v.utils.i32(), v.cdvMethods(arrType).size(), 0);
 
-        return v.utils.buildFunCall(create1DArray, name, len, numOfCdvMethods);
+        return v.utils.buildFunCall(create1DArray, name, len);
     }
 }

compiler/src/jlang/structures/ObjectStruct.java

@@ -28,6 +28,9 @@ public interface ObjectStruct {
     /** Returns the size (in bytes) of the given class. */
     LLVMValueRef sizeOf(ReferenceType rt);
 
+    /** Returns the size (in bytes) of the given class. */
+    int sizeOfObj(ReferenceType rt);
+
     /** Returns a pointer to the dispatch dispatch vector. */
     LLVMValueRef buildDispatchVectorElementPtr(LLVMValueRef instance, ReferenceType rt);
 

compiler/src/jlang/structures/ObjectStruct_c.java

@@ -113,6 +113,18 @@ public LLVMValueRef sizeOf(ReferenceType rt) {
         return LLVMSizeOf(structTypeRefNonOpaque(rt));
     }
 
+    @Override
+    public int sizeOfObj(ReferenceType rt) {
+        List<FieldInstance> instances = getOrComputeInstanceFields(rt);
+        int size = 0;
+        size += v.utils.llvmPtrSize(); // DV
+        size += v.utils.llvmPtrSize(); // Sync_Var
+        for (FieldInstance inst : instances) {
+            size += v.utils.sizeOfType(inst.type());
+        }
+        return size;
+    }
+
     @Override
     public LLVMValueRef buildDispatchVectorElementPtr(LLVMValueRef instance, ReferenceType rt) {
         structTypeRefNonOpaque(rt); // Ensure non-opaque type.

runtime/native/class.cpp

@@ -18,6 +18,7 @@
 #include "rep.h"
 #include "object_array.h"
 #include "array.h"
+#include "constants.h"
 
 #define MEMCPY(a,b,c) memcpy((void *) a, (void *) b, c)
 static constexpr bool kDebug = false;
@@ -204,15 +205,29 @@ const jclass initArrayClass(const char* name) {
     printf("WARNING: class size not yet initialized\n");
     jclass_size = sizeof(JClassRep);
   }
+
+  // create base array class and its info.
   jclass globalArrayKlass = getArrayKlass();
   jclass newKlazz = (jclass)malloc(jclass_size);
-  memcpy(newKlazz, globalArrayKlass, sizeof(JClassRep));
+  memcpy(newKlazz, globalArrayKlass, jclass_size);
   JavaClassInfo* newInfo = (JavaClassInfo*)malloc(sizeof(JavaClassInfo));
   memcpy(newInfo, GetJavaClassInfo(globalArrayKlass), sizeof(JavaClassInfo));
+
+  // init and set name.
   int nameLen = strlen(name) + 1; //add the '\0' terminator
   char* newName = (char*)malloc(nameLen);
   memcpy(newName, name, nameLen);
   newInfo->name = newName;
+
+  // init and set cdv/
+  int numOfCdv = getNumOfRuntimeArrayCdvMethods();
+  DispatchVector* runtimeArrayCdv = getRuntimeArrayCdv();
+  int runtimeArrayCdvSize = sizeof(DispatchVector) + numOfCdv * sizeof(void*);
+  DispatchVector* newCdv = (DispatchVector*)malloc(runtimeArrayCdvSize);
+  memcpy(newCdv, runtimeArrayCdv, runtimeArrayCdvSize);
+  newCdv->SetClassPtr(new JClassRep*(Unwrap(newKlazz)));
+  newInfo->cdv = (void*)newCdv;
+
   RegisterJavaClass(newKlazz, newInfo);
   return newKlazz;
 }
@@ -229,18 +244,8 @@ const void RegisterPrimitiveClasses() {
   if (registeringClass) return;
 
   jclass globalArrayKlass = getArrayKlass();
-
-  jclass ClassClass = NULL;
-  try {
-    ClassClass = cnames.at(std::string("java.lang.Class"));
-  } catch (const std::out_of_range& oor) {
-    registeringClass = true;
-    ClassClass = LoadJavaClassFromLib("java.lang.Class");
-    registeringClass = false;
-  }
-  const JavaClassInfo* cinfo = GetJavaClassInfo(ClassClass);
-  classSize = cinfo->obj_size;
-
+  classSize = getClassSize();
+
   REGISTER_PRIM_CLASS(int)
 
   REGISTER_PRIM_CLASS(byte)
@@ -372,6 +377,12 @@ const jclass GetJavaClassFromName(const char* name) {
   }
 }
 
+DispatchVector* GetJavaCdvFromName(const char* name) {
+  jclass clazz = GetJavaClassFromName(name);
+  const JavaClassInfo* info = GetJavaClassInfo(clazz);
+  return (DispatchVector*)info->cdv;
+}
+
 /**
  * Returns the class inside the given array class's array.
  * If the given class is not an array class, this function
@@ -393,27 +404,12 @@ jclass GetComponentClass(jclass cls) {
   return NULL;
 }
 
-static int _numOfRuntimeArrayCdvMethods = 0;
-DispatchVector* initArrayDispatchVector(const char* name) {
-  DispatchVector* runtimeArrayCdv = getRuntimeArrayCdv();
-  const JavaClassInfo* runtimeArrayInfo = GetJavaClassInfo(runtimeArrayCdv->Class()->Wrap());
-  int runtimeArrayCdvSize = sizeof(DispatchVector) + _numOfRuntimeArrayCdvMethods * sizeof(void*);
-  DispatchVector* newCdv = (DispatchVector*)malloc(runtimeArrayCdvSize);
-  memcpy(newCdv, runtimeArrayCdv, runtimeArrayCdvSize);
-  JClassRep** newClassPtr = new JClassRep*(Unwrap(initArrayClass(name)));
-  newCdv->SetClassPtr(newClassPtr);
-  const JavaClassInfo* info = GetJavaClassInfo((*newClassPtr)->Wrap());
-  // TODO: temporary bad solution
-  const_cast<JavaClassInfo*>(info)->cdv = (void*)newCdv;
-  return newCdv;
-}
-
 /**
  * Helper function to initialize an array in runtime. 
  */
 JArrayRep* initArrayHelper(const char* arrType, int* len, int depth) {
   const char* componentName = getComponentName(arrType);
-  DispatchVector* cdv = initArrayDispatchVector(arrType);
+  DispatchVector* cdv = GetJavaCdvFromName(arrType);
 
   jclass primComponent = primitiveComponentNameToClass(componentName);
   int elementSize;
@@ -439,21 +435,15 @@ JArrayRep* initArrayHelper(const char* arrType, int* len, int depth) {
   return arr;
 }
 
-jarray createArray(const char* arrType, int* len, int sizeOfLen, int numOfCdvMethods) {
-  if (_numOfRuntimeArrayCdvMethods == 0) {
-    _numOfRuntimeArrayCdvMethods = numOfCdvMethods;
-  }
+jarray createArray(const char* arrType, int* len, int sizeOfLen) {
   JArrayRep* arr = initArrayHelper(arrType, len, sizeOfLen);
   return arr->Wrap();
 }
 
 // TODO: Or pass length as a pointer and discard 1D array special case
-jarray create1DArray(const char* arrType, int len, int numOfCdvMethods) {
-  if (_numOfRuntimeArrayCdvMethods == 0) {
-    _numOfRuntimeArrayCdvMethods = numOfCdvMethods;
-  }
+jarray create1DArray(const char* arrType, int len) {
   const char* componentName = getComponentName(arrType);
-  DispatchVector* cdv = initArrayDispatchVector(arrType);
+  DispatchVector* cdv = GetJavaCdvFromName(arrType);
 
   jclass primComponent = primitiveComponentNameToClass(componentName);
   int elementSize;

runtime/native/class.h

@@ -84,14 +84,16 @@ struct JavaClassInfo {
 void
 RegisterJavaClass(jclass cls, const JavaClassInfo* data);
 
-jarray createArray(const char* arrType, int* len, int sizeOfLen, int numOfCdvMethods);
+jarray createArray(const char* arrType, int* len, int sizeOfLen);
 
-jarray create1DArray(const char* arrType, int len, int numOfCdvMethods);
+jarray create1DArray(const char* arrType, int len);
 
 void InternStringLit(jstring str);
 
 } // extern "C"
 
+const void RegisterPrimitiveClasses();
+
 const JavaClassInfo*
 GetJavaClassInfo(jclass cls);
 

runtime/native/constants.cpp

@@ -0,0 +1,28 @@
+#include "constants.h"
+
+extern "C" {
+  extern void Polyglot_jlang_runtime_Constants_load_class();
+  extern int Polyglot_jlang_runtime_Constants_classSize;
+  extern int Polyglot_jlang_runtime_Constants_numOfRuntimeCdvArrayMethods;
+}
+
+static int __classSize = 0;
+static int __numOfRuntimeCdvArrayMethods = 0;
+
+inline void init() {
+    if (__classSize == 0 && __numOfRuntimeCdvArrayMethods == 0) {
+        Polyglot_jlang_runtime_Constants_load_class();
+        __classSize = Polyglot_jlang_runtime_Constants_classSize;
+        __numOfRuntimeCdvArrayMethods = Polyglot_jlang_runtime_Constants_numOfRuntimeCdvArrayMethods;
+    }
+}
+
+int getClassSize() {
+    init();
+    return __classSize;
+}
+
+int getNumOfRuntimeArrayCdvMethods() {
+    init();
+    return __numOfRuntimeCdvArrayMethods;
+}

runtime/native/constants.h

@@ -0,0 +1,5 @@
+#pragma once
+
+int getClassSize();
+
+int getNumOfRuntimeArrayCdvMethods();

runtime/native/main.cpp

@@ -9,6 +9,7 @@
 #include "gc.h"
 #include "rep.h"
 #include "stack_trace.h"
+#include "class.h"
 
 extern "C" {
 
@@ -47,6 +48,8 @@ int main(int argc, char** argv) {
     sigaction(SIGBUS, &sa, 0);
     sigaction(SIGFPE, &sa, 0);
 
+    RegisterPrimitiveClasses();
+
     // Ignore the 0th argument, which is the name of the program.
     --argc, ++argv;
     jarray args = Polyglot_jlang_runtime_Factory_ObjectArray__I(argc);

runtime/src/jlang/runtime/Constants.java

@@ -0,0 +1,7 @@
+package jlang.runtime;
+
+public class Constants {
+    // TODO: auto-generate
+    public static final int classSize = 168; // = v.obj.sizeOfObj(v.ts.Class())
+    public static final int numOfRuntimeCdvArrayMethods = 11; // = v.cdvMethods(v.ts.ArrayObject()).size()
+}