diff --git a/compiler/src/jlang/extension/JLangNewArrayExt.java b/compiler/src/jlang/extension/JLangNewArrayExt.java index a55a578d..bea630fc 100644 --- a/compiler/src/jlang/extension/JLangNewArrayExt.java +++ b/compiler/src/jlang/extension/JLangNewArrayExt.java @@ -95,21 +95,19 @@ 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) { @@ -117,13 +115,11 @@ public static LLVMValueRef translateNew1DArray(LLVMTranslator v, LLVMValueRef le 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); } } diff --git a/compiler/src/jlang/structures/ObjectStruct.java b/compiler/src/jlang/structures/ObjectStruct.java index b32f3682..a786608e 100644 --- a/compiler/src/jlang/structures/ObjectStruct.java +++ b/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); diff --git a/compiler/src/jlang/structures/ObjectStruct_c.java b/compiler/src/jlang/structures/ObjectStruct_c.java index 780116f4..2ec3b224 100644 --- a/compiler/src/jlang/structures/ObjectStruct_c.java +++ b/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 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. diff --git a/runtime/native/class.cpp b/runtime/native/class.cpp index 5ac378b5..0805d74c 100644 --- a/runtime/native/class.cpp +++ b/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(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; diff --git a/runtime/native/class.h b/runtime/native/class.h index 18f8febd..c4d68bfc 100644 --- a/runtime/native/class.h +++ b/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); diff --git a/runtime/native/constants.cpp b/runtime/native/constants.cpp new file mode 100644 index 00000000..4d664eb0 --- /dev/null +++ b/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; +} \ No newline at end of file diff --git a/runtime/native/constants.h b/runtime/native/constants.h new file mode 100644 index 00000000..125845ef --- /dev/null +++ b/runtime/native/constants.h @@ -0,0 +1,5 @@ +#pragma once + +int getClassSize(); + +int getNumOfRuntimeArrayCdvMethods(); \ No newline at end of file diff --git a/runtime/native/main.cpp b/runtime/native/main.cpp index e3866f2e..708651b8 100644 --- a/runtime/native/main.cpp +++ b/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); diff --git a/runtime/src/jlang/runtime/Constants.java b/runtime/src/jlang/runtime/Constants.java new file mode 100644 index 00000000..aaec1f5a --- /dev/null +++ b/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() +}