1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
#include "xmlvm.h"
#include "org_xmlvm_runtime_XMLVMArray.h"
//XMLVM_BEGIN_NATIVE_IMPLEMENTATION
#include "java_lang_Class.h"
typedef struct {
short sizeOfBaseType;
short useAtomicMalloc;
} TYPE_INFO;
org_xmlvm_runtime_XMLVMArray* __NEW_XMLVMArray(JAVA_OBJECT type, JAVA_INT length, JAVA_OBJECT data)
{
org_xmlvm_runtime_XMLVMArray* array = __NEW_org_xmlvm_runtime_XMLVMArray();
org_xmlvm_runtime_XMLVMArray___INIT____java_lang_Class_int_java_lang_Object(array, type, length, data);
return array;
}
/**
* This function determines two pieces of information of a type: the size of the type in byte
* and whether or not an atomic malloc() should be used. For arrays of primitive type it is possible
* to use an atomic malloc() offered by the GC. In this case the GC knows that the memory region cannot
* contain any pointers and can therefore skip scanning the memory region.
*/
TYPE_INFO XMLVMArray_getTypeInfo(JAVA_OBJECT type)
{
TYPE_INFO info;
info.useAtomicMalloc = 1;
if (type == __CLASS_byte || type == __CLASS_boolean) {
info.sizeOfBaseType = sizeof(JAVA_ARRAY_BYTE);
} else if (type == __CLASS_char || type == __CLASS_short) {
info.sizeOfBaseType = sizeof(JAVA_ARRAY_SHORT);
} else if (type == __CLASS_int) {
info.sizeOfBaseType = sizeof(JAVA_ARRAY_INT);
} else if (type == __CLASS_float) {
info.sizeOfBaseType = sizeof(JAVA_ARRAY_FLOAT);
} else if (type == __CLASS_double) {
info.sizeOfBaseType = sizeof(JAVA_ARRAY_DOUBLE);
} else if (type == __CLASS_long) {
info.sizeOfBaseType = sizeof(JAVA_ARRAY_LONG);
} else {
info.sizeOfBaseType = sizeof(void*);
// For arrays of object references we need to use the regular malloc() as the
// GC needs to scan this memory region.
info.useAtomicMalloc = 0;
}
return info;
}
static org_xmlvm_runtime_XMLVMArray* XMLVMArray_createMultiDimensionsWithCount(JAVA_OBJECT type, JAVA_ARRAY_INT* dim, int count)
{
JAVA_ARRAY_INT dimensions = *dim;
org_xmlvm_runtime_XMLVMArray* slice;
int i;
dim++;
count--;
if (count == 0) {
return XMLVMArray_createSingleDimension(type, dimensions);
}
slice = XMLVMArray_createSingleDimension(type, dimensions);
JAVA_ARRAY_OBJECT* sliceData = (JAVA_ARRAY_OBJECT*) slice->fields.org_xmlvm_runtime_XMLVMArray.array_;
// Get base type
java_lang_Class* typeClass = (java_lang_Class*) type;
__TIB_DEFINITION_TEMPLATE* typeTIB = (__TIB_DEFINITION_TEMPLATE*) typeClass->fields.java_lang_Class.tib_;
JAVA_OBJECT baseType = typeTIB->baseType;
for (i = 0; i < dimensions; i++) {
//TODO should 'type' be baseType of this type?
sliceData[i] = XMLVMArray_createMultiDimensionsWithCount(baseType, dim, count);
}
return slice;
}
JAVA_OBJECT org_xmlvm_runtime_XMLVMArray_getClass__(JAVA_OBJECT me)
{
org_xmlvm_runtime_XMLVMArray* thiz = me;
return thiz->fields.org_xmlvm_runtime_XMLVMArray.type_;
}
//XMLVM_END_NATIVE_IMPLEMENTATION
void org_xmlvm_runtime_XMLVMArray_initNativeLayer__()
{
//XMLVM_BEGIN_NATIVE[org_xmlvm_runtime_XMLVMArray_initNativeLayer__]
__TIB_org_xmlvm_runtime_XMLVMArray.vtable[XMLVM_VTABLE_IDX_java_lang_Object_getClass__] =
(VTABLE_PTR) org_xmlvm_runtime_XMLVMArray_getClass__;
//XMLVM_END_NATIVE
}
JAVA_OBJECT org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int(JAVA_OBJECT n1, JAVA_INT n2)
{
//XMLVM_BEGIN_NATIVE[org_xmlvm_runtime_XMLVMArray_createSingleDimension___java_lang_Class_int]
JAVA_OBJECT type = n1;
JAVA_INT size = n2;
TYPE_INFO info = XMLVMArray_getTypeInfo(type);
int mem_size = info.sizeOfBaseType * size;
JAVA_OBJECT data = info.useAtomicMalloc ? XMLVM_ATOMIC_MALLOC(mem_size) : XMLVM_MALLOC(mem_size);
XMLVM_BZERO(data, mem_size);
return org_xmlvm_runtime_XMLVMArray_createSingleDimensionWithData___java_lang_Class_int_java_lang_Object(type, size, data);
//XMLVM_END_NATIVE
}
JAVA_OBJECT org_xmlvm_runtime_XMLVMArray_createSingleDimensionWithData___java_lang_Class_int_java_lang_Object(JAVA_OBJECT n1, JAVA_INT n2, JAVA_OBJECT n3)
{
//XMLVM_BEGIN_NATIVE[org_xmlvm_runtime_XMLVMArray_createSingleDimensionWithData___java_lang_Class_int_java_lang_Object]
org_xmlvm_runtime_XMLVMArray* array = __NEW_org_xmlvm_runtime_XMLVMArray();
java_lang_Class* baseType = n1;
__TIB_DEFINITION_TEMPLATE* baseTIB = baseType->fields.java_lang_Class.tib_;
JAVA_OBJECT arrayType = baseTIB->arrayType;
if (arrayType == JAVA_NULL) {
XMLVM_INTERNAL_ERROR();
}
org_xmlvm_runtime_XMLVMArray___INIT____java_lang_Class_int_java_lang_Object(array, arrayType, n2, n3);
return array;
//XMLVM_END_NATIVE
}
JAVA_OBJECT org_xmlvm_runtime_XMLVMArray_createMultiDimensions___java_lang_Class_org_xmlvm_runtime_XMLVMArray(JAVA_OBJECT n1, JAVA_OBJECT n2)
{
//XMLVM_BEGIN_NATIVE[org_xmlvm_runtime_XMLVMArray_createMultiDimensions___java_lang_Class_org_xmlvm_runtime_XMLVMArray]
org_xmlvm_runtime_XMLVMArray* dimArray = (org_xmlvm_runtime_XMLVMArray*) n2;
if (dimArray->fields.org_xmlvm_runtime_XMLVMArray.type_ != __CLASS_int_1ARRAY) {
XMLVM_INTERNAL_ERROR();
}
int count = dimArray->fields.org_xmlvm_runtime_XMLVMArray.length_;
JAVA_ARRAY_INT* data = (JAVA_ARRAY_INT*) dimArray->fields.org_xmlvm_runtime_XMLVMArray.array_;
int i;
java_lang_Class* arrayType = n1;
for (i = 0; i < count - 1; i++) {
__TIB_DEFINITION_TEMPLATE* arrayTIB = arrayType->fields.java_lang_Class.tib_;
arrayType = arrayTIB->arrayType;
if (arrayType == JAVA_NULL) {
XMLVM_INTERNAL_ERROR();
}
}
return XMLVMArray_createMultiDimensionsWithCount(arrayType, data, count);
//XMLVM_END_NATIVE
}
void org_xmlvm_runtime_XMLVMArray_fillArray___org_xmlvm_runtime_XMLVMArray_java_lang_Object(JAVA_OBJECT n1, JAVA_OBJECT n2)
{
//XMLVM_BEGIN_NATIVE[org_xmlvm_runtime_XMLVMArray_fillArray___org_xmlvm_runtime_XMLVMArray_java_lang_Object]
org_xmlvm_runtime_XMLVMArray* array = (org_xmlvm_runtime_XMLVMArray*) n1;
java_lang_Class* arrayType = array->fields.org_xmlvm_runtime_XMLVMArray.type_;
__TIB_DEFINITION_TEMPLATE* arrayTIB = arrayType->fields.java_lang_Class.tib_;
TYPE_INFO info = XMLVMArray_getTypeInfo(arrayTIB->baseType);
int n = info.sizeOfBaseType * array->fields.org_xmlvm_runtime_XMLVMArray.length_;
XMLVM_MEMCPY(array->fields.org_xmlvm_runtime_XMLVMArray.array_, n2, n);
//XMLVM_END_NATIVE
}
JAVA_OBJECT org_xmlvm_runtime_XMLVMArray_clone__(JAVA_OBJECT me)
{
//XMLVM_BEGIN_NATIVE[org_xmlvm_runtime_XMLVMArray_clone__]
org_xmlvm_runtime_XMLVMArray* thiz = (org_xmlvm_runtime_XMLVMArray*) me;
JAVA_OBJECT type = thiz->fields.org_xmlvm_runtime_XMLVMArray.type_;
JAVA_INT length = thiz->fields.org_xmlvm_runtime_XMLVMArray.length_;
JAVA_OBJECT data = thiz->fields.org_xmlvm_runtime_XMLVMArray.array_;
TYPE_INFO info = XMLVMArray_getTypeInfo(type);
int sizeOfArrayInBytes = info.sizeOfBaseType * length;
JAVA_OBJECT copyData = info.useAtomicMalloc ? XMLVM_ATOMIC_MALLOC(sizeOfArrayInBytes) : XMLVM_MALLOC(sizeOfArrayInBytes);
XMLVM_MEMCPY(copyData, data, sizeOfArrayInBytes);
return XMLVMArray_createSingleDimensionWithData(type, length, copyData);
//XMLVM_END_NATIVE
}
void xmlvm_init_native_org_xmlvm_runtime_XMLVMArray()
{
//XMLVM_BEGIN_NATIVE_IMPLEMENTATION_INIT
//XMLVM_END_NATIVE_IMPLEMENTATION_INIT
#ifdef XMLVM_VTABLE_IDX_org_xmlvm_runtime_XMLVMArray_clone__
__TIB_org_xmlvm_runtime_XMLVMArray.vtable[XMLVM_VTABLE_IDX_org_xmlvm_runtime_XMLVMArray_clone__] =
(VTABLE_PTR) org_xmlvm_runtime_XMLVMArray_clone__;
#endif
}
|
