ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-03-03 12:57:29 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

finish using setters

Browse Source
This commit is contained in:
Joshua Warner 2014-06-25 20:17:27 -06:00 committed by Joshua Warner
parent 4367867be9
commit b0490b8233
14 changed files with 146 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
classpath/avian/ClassAddendum.java
View File

@ -21,6 +21,10 @@ public class ClassAddendum extends Addendum {
* extended by that class.
*/
public int declaredMethodCount;
// Either a byte[] or a Pair, apparently...
// TODO: make it monomorphic
public Object enclosingClass;
public Object enclosingMethod;
}

12
src/avian/machine.h
View File

@ -1539,7 +1539,7 @@ class GcJfield;
class Classpath {
public:
virtual object
virtual GcJclass*
makeJclass(Thread* t, GcClass* class_) = 0;
virtual GcString*
@ -1871,14 +1871,14 @@ mark(Thread* t, object o, unsigned offset)
}
inline void
set(Thread* t, object target, unsigned offset, object value)
setField(Thread* t, object target, unsigned offset, object value)
{
fieldAtOffset<object>(target, offset) = value;
mark(t, target, offset);
}
inline void
set(Thread* t, GcObject* target, unsigned offset, GcObject* value)
setField(Thread* t, GcObject* target, unsigned offset, GcObject* value)
{
fieldAtOffset<GcObject*>(target, offset) = value;
mark(t, reinterpret_cast<object>(target), offset);
@ -1887,7 +1887,7 @@ set(Thread* t, GcObject* target, unsigned offset, GcObject* value)
inline void
setObject(Thread* t, GcObject* target, unsigned offset, GcObject* value)
{
set(t, target, offset, value);
setField(t, target, offset, value);
}
inline void
@ -3612,7 +3612,7 @@ resolveClassInObject(Thread* t, GcClassLoader* loader, object container,
if (c) {
storeStoreMemoryBarrier();
set(t, container, classOffset, reinterpret_cast<object>(c));
setField(t, container, classOffset, reinterpret_cast<object>(c));
}
return c;
@ -3894,7 +3894,7 @@ getJClass(Thread* t, GcClass* c)
jclass = cast<GcJclass>(t, getClassRuntimeData(t, c)->jclass());
if (jclass == 0) {
jclass = cast<GcJclass>(t, t->m->classpath->makeJclass(t, c));
jclass = t->m->classpath->makeJclass(t, c);
storeStoreMemoryBarrier();

2
src/avian/util.h
View File

@ -48,7 +48,7 @@ hashMapInsertOrReplace(Thread* t, GcHashMap* map, object key, object value,
hashMapInsert(t, map, key, value, hash);
return true;
} else {
set(t, reinterpret_cast<object>(n), TripleSecond, value);
n->setSecond(t, value);
return false;
}
}

4
src/builtin.cpp
View File

@ -765,7 +765,7 @@ Avian_sun_misc_Unsafe_putObject
int64_t offset; memcpy(&offset, arguments + 2, 8);
uintptr_t value = arguments[4];
set(t, o, offset, reinterpret_cast<object>(value));
setField(t, o, offset, reinterpret_cast<object>(value));
}
extern "C" AVIAN_EXPORT void JNICALL
@ -777,7 +777,7 @@ Avian_sun_misc_Unsafe_putObjectVolatile
object value = reinterpret_cast<object>(arguments[4]);
storeStoreMemoryBarrier();
set(t, o, offset, reinterpret_cast<object>(value));
setField(t, o, offset, reinterpret_cast<object>(value));
storeLoadMemoryBarrier();
}

4
src/classpath-android.cpp
View File

@ -232,7 +232,7 @@ class MyClasspath : public Classpath {
: allocator(allocator), tzdata(0), mayInitClasses_(false)
{ }
virtual object
virtual GcJclass*
makeJclass(Thread* t, GcClass* class_)
{
PROTECT(t, class_);
@ -241,7 +241,7 @@ class MyClasspath : public Classpath {
setObjectClass(t, reinterpret_cast<object>(c), type(t, GcJclass::Type));
c->setVmClass(t, class_);
return reinterpret_cast<object>(c);
return c;
}
virtual GcString*

19
src/classpath-avian.cpp
View File

@ -26,10 +26,10 @@ class MyClasspath : public Classpath {
allocator(allocator)
{ }
virtual object
virtual GcJclass*
makeJclass(Thread* t, GcClass* class_)
{
return reinterpret_cast<object>(vm::makeJclass(t, class_));
return vm::makeJclass(t, class_);
}
virtual GcString*
@ -228,11 +228,11 @@ class MyClasspath : public Classpath {
};
void
enumerateThreads(Thread* t, Thread* x, object array, unsigned* index,
enumerateThreads(Thread* t, Thread* x, GcArray* array, unsigned* index,
unsigned limit)
{
if (*index < limit) {
set(t, array, ArrayBody + (*index * BytesPerWord), reinterpret_cast<object>(x->javaThread));
array->setBodyElement(t, *index, reinterpret_cast<object>(x->javaThread));
++ (*index);
if (x->peer) enumerateThreads(t, x->peer, array, index, limit);
@ -427,7 +427,7 @@ Avian_java_lang_reflect_Field_setObject
int offset = arguments[1];
object value = reinterpret_cast<object>(arguments[2]);
set(t, instance, offset, value);
setField(t, instance, offset, value);
}
extern "C" AVIAN_EXPORT int64_t JNICALL
@ -547,7 +547,7 @@ extern "C" AVIAN_EXPORT int64_t JNICALL
for (unsigned i = 0; i < t->m->propertyCount; ++i) {
GcString* s = makeString(t, "%s", t->m->properties[i]);
set(t, array, ArrayBody + (i * BytesPerWord), reinterpret_cast<object>(s));
reinterpret_cast<GcArray*>(array)->setBodyElement(t, i, reinterpret_cast<object>(s));
}
return reinterpret_cast<int64_t>(array);
@ -619,7 +619,8 @@ Avian_java_lang_Runtime_addShutdownHook
ACQUIRE(t, t->m->shutdownLock);
GcPair* p = makePair(t, hook, reinterpret_cast<object>(roots(t)->shutdownHooks()));
set(t, roots(t), RootsShutdownHooks, p);
// sequence point, for gc (don't recombine statements)
roots(t)->setShutdownHooks(t, p);
}
extern "C" AVIAN_EXPORT int64_t JNICALL
@ -643,7 +644,7 @@ Avian_java_lang_Throwable_resolveTrace
for (unsigned i = 0; i < length; ++i) {
GcStackTraceElement* ste = makeStackTraceElement(t, cast<GcTraceElement>(t, objectArrayBody(t, trace, i)));
set(t, array, ArrayBody + (i * BytesPerWord), reinterpret_cast<object>(ste));
reinterpret_cast<GcArray*>(array)->setBodyElement(t, i, reinterpret_cast<object>(ste));
}
return reinterpret_cast<int64_t>(array);
@ -714,7 +715,7 @@ Avian_java_lang_Thread_enumerate
unsigned count = min(t->m->liveCount, objectArrayLength(t, reinterpret_cast<object>(array)));
unsigned index = 0;
local::enumerateThreads(t, t->m->rootThread, reinterpret_cast<object>(array), &index, count);
local::enumerateThreads(t, t->m->rootThread, array, &index, count);
return count;
}

75
src/classpath-openjdk.cpp
View File

@ -325,7 +325,7 @@ getClassName(Thread* t, GcClass* c)
GcByteArray* name = makeByteArray(t, primitiveName(t, c));
set(t, c, ClassName, name);
c->setName(t, name);
} else {
abort(t);
}
@ -481,7 +481,7 @@ class MyClasspath : public Classpath {
this->bufferSize = sb.bufferSize;
}
virtual object
virtual GcJclass*
makeJclass(Thread* t, GcClass* class_)
{
PROTECT(t, class_);
@ -489,10 +489,10 @@ class MyClasspath : public Classpath {
GcString* name = makeClassNameString(t, getClassName(t, class_));
PROTECT(t, name);
object c = allocate(t, GcJclass::FixedSize, true);
setObjectClass(t, c, type(t, GcJclass::Type));
set(t, c, JclassName, reinterpret_cast<object>(name));
set(t, c, JclassVmClass, reinterpret_cast<object>(class_));
GcJclass* c = reinterpret_cast<GcJclass*>(allocate(t, GcJclass::FixedSize, true));
setObjectClass(t, reinterpret_cast<object>(c), type(t, GcJclass::Type));
c->setName(t, name);
c->setVmClass(t, class_);
return c;
}
@ -556,16 +556,14 @@ class MyClasspath : public Classpath {
setObjectClass(t, reinterpret_cast<object>(thread), type(t, GcThread::Type));
thread->priority() = NormalPriority;
// TODO: use set / write barrier?
thread->group() = group;
thread->setGroup(t, group);
// TODO: use set / write barrier?
thread->contextClassLoader() = roots(t)->appLoader();
thread->setContextClassLoader(t, roots(t)->appLoader());
PROTECT(t, thread);
GcJobject* blockerLock = makeJobject(t);
set(t, thread, ThreadBlockerLock, blockerLock);
thread->setBlockerLock(t, reinterpret_cast<object>(blockerLock));
const unsigned BufferSize = 256;
char buffer[BufferSize];
@ -574,7 +572,7 @@ class MyClasspath : public Classpath {
for (unsigned i = 0; i < length; ++i) {
name->body()[i] = buffer[i];
}
set(t, thread, ThreadName, name);
thread->setName(t, name);
return thread;
}
@ -710,7 +708,7 @@ class MyClasspath : public Classpath {
(t, roots(t)->bootLoader(), "java/lang/ThreadGroup",
"threadTerminated", "(Ljava/lang/Thread;)V");
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsThreadTerminated, method);
roots(t)->setThreadTerminated(t, reinterpret_cast<object>(method));
#ifdef AVIAN_OPENJDK_SRC
interceptFileOperations(t, true);
@ -723,7 +721,7 @@ class MyClasspath : public Classpath {
(t, type(t, GcClassLoader::Type), "assertionLock",
"Ljava/lang/Object;");
set(t, roots(t)->bootLoader(), assertionLock->offset(),
setField(t, roots(t)->bootLoader(), assertionLock->offset(),
roots(t)->bootLoader());
}
@ -768,7 +766,7 @@ class MyClasspath : public Classpath {
GcField* sclSet = resolveField
(t, type(t, GcClassLoader::Type), "sclSet", "Z");
set(t, type(t, GcClassLoader::Type)->staticTable(),
setField(t, type(t, GcClassLoader::Type)->staticTable(),
scl->offset(), roots(t)->appLoader());
fieldAtOffset<uint8_t>(type(t, GcClassLoader::Type)->staticTable(),
@ -783,8 +781,7 @@ class MyClasspath : public Classpath {
(t, roots(t)->bootLoader(), "sun/misc/Launcher",
"getLauncher", "()Lsun/misc/Launcher;", 0);
set(t, t->javaThread, ThreadContextClassLoader,
roots(t)->appLoader());
t->javaThread->setContextClassLoader(t, roots(t)->appLoader());
}
virtual const char*
@ -2292,8 +2289,8 @@ makeJmethod(Thread* t, GcMethod* vmMethod, int index)
if (annotationTable or parameterAnnotationTable or annotationDefault) {
GcClassRuntimeData* runtimeData = getClassRuntimeData(t, vmMethod->class_());
set(t, runtimeData, ClassRuntimeDataPool,
vmMethod->addendum()->pool());
runtimeData->setPool(t,
reinterpret_cast<object>(vmMethod->addendum()->pool()));
}
if (index == -1) {
@ -2361,8 +2358,8 @@ makeJconstructor(Thread* t, GcMethod* vmMethod, int index)
if (annotationTable or parameterAnnotationTable) {
GcClassRuntimeData* runtimeData = getClassRuntimeData(t, vmMethod->class_());
set(t, runtimeData, ClassRuntimeDataPool,
vmMethod->addendum()->pool());
runtimeData->setPool(t,
reinterpret_cast<object>(vmMethod->addendum()->pool()));
}
if (index == -1) {
@ -2440,8 +2437,8 @@ makeJfield(Thread* t, GcField* vmField, int index)
if (annotationTable) {
GcClassRuntimeData* runtimeData = getClassRuntimeData(t, vmField->class_());
set(t, runtimeData, ClassRuntimeDataPool,
vmField->addendum()->pool());
runtimeData->setPool(t,
reinterpret_cast<object>(vmField->addendum()->pool()));
}
if (index == -1) {
@ -3199,10 +3196,10 @@ EXPORT(JVM_IsNaN)(jdouble) { abort(); }
uint64_t
jvmFillInStackTrace(Thread* t, uintptr_t* arguments)
{
jobject throwable = reinterpret_cast<jobject>(arguments[0]);
GcThrowable* throwable = cast<GcThrowable>(t, *reinterpret_cast<jobject>(arguments[0]));
object trace = getTrace(t, 2);
set(t, *throwable, ThrowableTrace, trace);
throwable->setTrace(t, trace);
return 1;
}
@ -3337,7 +3334,7 @@ jvmSleep(Thread* t, uintptr_t* arguments)
if (t->javaThread->sleepLock() == 0) {
GcJobject* lock = makeJobject(t);
set(t, t->javaThread, ThreadSleepLock, lock);
t->javaThread->setSleepLock(t, reinterpret_cast<object>(lock));
}
acquire(t, t->javaThread->sleepLock());
@ -3452,10 +3449,10 @@ jvmDumpThreads(Thread* t, uintptr_t* arguments)
for (unsigned traceIndex = 0; traceIndex < traceLength; ++ traceIndex) {
object ste = reinterpret_cast<object>(makeStackTraceElement
(t, cast<GcTraceElement>(t, objectArrayBody(t, trace, traceIndex))));
set(t, array, ArrayBody + (traceIndex * BytesPerWord), ste);
setField(t, array, ArrayBody + (traceIndex * BytesPerWord), ste);
}
set(t, result, ArrayBody + (threadsIndex * BytesPerWord), array);
setField(t, result, ArrayBody + (threadsIndex * BytesPerWord), array);
}
}
@ -3497,7 +3494,7 @@ jvmGetClassContext(Thread* t, uintptr_t*)
t,
cast<GcMethod>(t, cast<GcTraceElement>(t, objectArrayBody(t, trace, i))->method())->class_()));
set(t, context, ArrayBody + (i * BytesPerWord), c);
setField(t, context, ArrayBody + (i * BytesPerWord), c);
}
return reinterpret_cast<uint64_t>(makeLocalReference(t, context));
@ -3716,7 +3713,7 @@ EXPORT(JVM_SetArrayElement)(Thread* t, jobject array, jint index,
break;
case 'L':
case '[':
set(t, *array, ArrayBody + (index * BytesPerWord), (value ? *value : 0));
setField(t, *array, ArrayBody + (index * BytesPerWord), (value ? *value : 0));
break;
default:
abort(t);
@ -4021,7 +4018,7 @@ jvmGetClassInterfaces(Thread* t, uintptr_t* arguments)
for (unsigned i = 0; i < table->length(); ++i) {
object c = reinterpret_cast<object>(getJClass(t, cast<GcClass>(t, table->body()[i])));
set(t, array, ArrayBody + (i * BytesPerWord), c);
setField(t, array, ArrayBody + (i * BytesPerWord), c);
}
return reinterpret_cast<uint64_t>(makeLocalReference(t, array));
@ -4111,7 +4108,7 @@ EXPORT(JVM_SetClassSigners)(Thread* t, jclass c, jobjectArray signers)
GcClassRuntimeData* runtimeData = getClassRuntimeData(t, (*c)->vmClass());
set(t, reinterpret_cast<object>(runtimeData), ClassRuntimeDataSigners, reinterpret_cast<object>(*signers));
runtimeData->setSigners(t, reinterpret_cast<object>(*signers));
}
uint64_t
@ -4297,7 +4294,7 @@ jvmGetClassDeclaredMethods(Thread* t, uintptr_t* arguments)
assertT(t, ai < objectArrayLength(t, array));
set(t, array, ArrayBody + ((ai++) * BytesPerWord), method);
setField(t, array, ArrayBody + ((ai++) * BytesPerWord), method);
}
}
@ -4342,7 +4339,7 @@ jvmGetClassDeclaredFields(Thread* t, uintptr_t* arguments)
assertT(t, ai < objectArrayLength(t, array));
set(t, array, ArrayBody + ((ai++) * BytesPerWord), field);
setField(t, array, ArrayBody + ((ai++) * BytesPerWord), field);
}
}
assertT(t, ai == objectArrayLength(t, array));
@ -4395,7 +4392,7 @@ jvmGetClassDeclaredConstructors(Thread* t, uintptr_t* arguments)
assertT(t, ai < objectArrayLength(t, array));
set(t, array, ArrayBody + ((ai++) * BytesPerWord), method);
setField(t, array, ArrayBody + ((ai++) * BytesPerWord), method);
}
}
@ -5142,7 +5139,7 @@ getInputArgumentArray(Thread* t, uintptr_t*)
for (unsigned i = 0; i < t->m->argumentCount; ++i) {
GcString* argument = makeString(t, t->m->arguments[i]);
set(t, array, ArrayBody + (i * BytesPerWord), reinterpret_cast<object>(argument));
setField(t, array, ArrayBody + (i * BytesPerWord), reinterpret_cast<object>(argument));
}
return reinterpret_cast<uintptr_t>(makeLocalReference(t, array));
@ -5273,7 +5270,7 @@ getEnclosingMethodInfo(Thread* t, uintptr_t* arguments)
enclosingClass = reinterpret_cast<object>(getJClass
(t, resolveClass(t, class_->loader(), cast<GcByteArray>(t, enclosingClass))));
set(t, array, ArrayBody, enclosingClass);
setField(t, array, ArrayBody, enclosingClass);
GcPair* enclosingMethod = cast<GcPair>(t, addendum->enclosingMethod());
@ -5284,13 +5281,13 @@ getEnclosingMethodInfo(Thread* t, uintptr_t* arguments)
(t, enclosingMethod->first(), 0,
cast<GcByteArray>(t, enclosingMethod->first())->length() - 1);
set(t, array, ArrayBody + BytesPerWord, reinterpret_cast<object>(name));
setField(t, array, ArrayBody + BytesPerWord, reinterpret_cast<object>(name));
GcString* spec = t->m->classpath->makeString
(t, enclosingMethod->second(), 0,
cast<GcByteArray>(t, enclosingMethod->second())->length() - 1);
set(t, array, ArrayBody + (2 * BytesPerWord), reinterpret_cast<object>(spec));
setField(t, array, ArrayBody + (2 * BytesPerWord), reinterpret_cast<object>(spec));
}
return reinterpret_cast<uintptr_t>(makeLocalReference(t, array));

12
src/compile.cpp
View File

@ -2560,7 +2560,7 @@ void
setMaybeNull(MyThread* t, object o, unsigned offset, object value)
{
if (LIKELY(o)) {
set(t, o, offset, value);
setField(t, o, offset, value);
} else {
throwNew(t, GcNullPointerException::Type);
}
@ -2813,7 +2813,7 @@ setStaticObjectFieldValueFromReference(MyThread* t, GcPair* pair, object value)
ACQUIRE_FIELD_FOR_WRITE(t, field);
set(t, reinterpret_cast<object>(field->class_()->staticTable()), field->offset(),
setField(t, reinterpret_cast<object>(field->class_()->staticTable()), field->offset(),
value);
}
@ -2829,7 +2829,7 @@ setObjectFieldValueFromReference(MyThread* t, GcPair* pair, object instance,
ACQUIRE_FIELD_FOR_WRITE(t, field);
set(t, instance, field->offset(), value);
setField(t, instance, field->offset(), value);
}
void
@ -6800,7 +6800,7 @@ finish(MyThread* t, FixedAllocator* allocator, Context* context)
initArray(t, reinterpret_cast<GcArray*>(pool), context->objectPoolCount + 1);
mark(t, pool, 0);
set(t, pool, ArrayBody, compileRoots(t)->objectPools());
setField(t, pool, ArrayBody, compileRoots(t)->objectPools());
compileRoots(t)->setObjectPools(t, pool);
unsigned i = 1;
@ -6809,7 +6809,7 @@ finish(MyThread* t, FixedAllocator* allocator, Context* context)
p->address = reinterpret_cast<uintptr_t>(pool) + offset;
set(t, pool, offset, p->target);
setField(t, pool, offset, p->target);
}
}
@ -8097,7 +8097,7 @@ invoke(Thread* thread, GcMethod* method, ArgumentList* arguments)
class SignalHandler: public SignalRegistrar::Handler {
public:
typedef GcThrowable*& (GcRoots::*ExceptionGetter)();
typedef GcThrowable* (GcRoots::*ExceptionGetter)();
SignalHandler(Gc::Type type, ExceptionGetter exc, unsigned fixedSize):
m(0), type(type), exc(exc), fixedSize(fixedSize) { }

6
src/interpret.cpp
View File

@ -844,7 +844,7 @@ interpret3(Thread* t, const int base)
if (LIKELY(index >= 0 and
static_cast<uintptr_t>(index) < objectArrayLength(t, array)))
{
set(t, array, ArrayBody + (index * BytesPerWord), value);
setField(t, array, ArrayBody + (index * BytesPerWord), value);
} else {
exception = makeThrowable
(t, GcArrayIndexOutOfBoundsException::Type, "%d not in [0,%d)",
@ -2498,7 +2498,7 @@ interpret3(Thread* t, const int base)
object value = popObject(t);
object o = popObject(t);
if (LIKELY(o)) {
set(t, o, field->offset(), value);
setField(t, o, field->offset(), value);
} else {
exception = makeThrowable(t, GcNullPointerException::Type);
}
@ -2560,7 +2560,7 @@ interpret3(Thread* t, const int base)
} break;
case ObjectField: {
set(t, reinterpret_cast<object>(table), field->offset(), popObject(t));
setField(t, reinterpret_cast<object>(table), field->offset(), popObject(t));
} break;
default: abort(t);

28
src/jnienv.cpp
View File

@ -396,8 +396,8 @@ throwNew(Thread* t, uintptr_t* arguments)
PROTECT(t, trace);
t->exception = cast<GcThrowable>(t, make(t, (*c)->vmClass()));
set(t, t->exception, ThrowableMessage, m);
set(t, reinterpret_cast<object>(t->exception), ThrowableTrace, trace);
t->exception->setMessage(t, m);
t->exception->setTrace(t, trace);
return 1;
}
@ -551,7 +551,7 @@ methodID(Thread* t, GcMethod* method)
GcVector* v = vectorAppend(
t, roots(t)->jNIMethodTable(), reinterpret_cast<object>(method));
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsJNIMethodTable, v);
roots(t)->setJNIMethodTable(t, v);
storeStoreMemoryBarrier();
@ -1505,7 +1505,7 @@ fieldID(Thread* t, GcField* field)
GcVector* v = vectorAppend(
t, roots(t)->jNIFieldTable(), reinterpret_cast<object>(field));
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsJNIFieldTable, v);
roots(t)->setJNIFieldTable(t, v);
storeStoreMemoryBarrier();
@ -1758,7 +1758,7 @@ setObjectField(Thread* t, uintptr_t* arguments)
PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field);
set(t, *o, field->offset(), (v ? *v : 0));
setField(t, *o, field->offset(), (v ? *v : 0));
return 1;
}
@ -2229,7 +2229,7 @@ setStaticObjectField(Thread* t, uintptr_t* arguments)
PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field);
set(t, reinterpret_cast<object>(c->vmClass()->staticTable()), field->offset(),
setField(t, reinterpret_cast<object>(c->vmClass()->staticTable()), field->offset(),
(v ? *v : 0));
return 1;
@ -2576,7 +2576,7 @@ newObjectArray(Thread* t, uintptr_t* arguments)
object a = makeObjectArray(t, (*class_)->vmClass(), length);
object value = (init ? *init : 0);
for (jsize i = 0; i < length; ++i) {
set(t, reinterpret_cast<object>(a), ArrayBody + (i * BytesPerWord), value);
reinterpret_cast<GcArray*>(a)->setBodyElement(t, i, value);
}
return reinterpret_cast<uint64_t>(makeLocalReference(t, reinterpret_cast<object>(a)));
}
@ -2605,7 +2605,7 @@ SetObjectArrayElement(Thread* t, jobjectArray array, jsize index,
{
ENTER(t, Thread::ActiveState);
set(t, reinterpret_cast<object>(*array), ArrayBody + (index * BytesPerWord), (value ? *value : 0));
setField(t, reinterpret_cast<object>(*array), ArrayBody + (index * BytesPerWord), (value ? *value : 0));
}
uint64_t
@ -3541,23 +3541,23 @@ boot(Thread* t, uintptr_t*)
{
GcThrowable* throwable = makeThrowable(t, GcNullPointerException::Type);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsNullPointerException, throwable);
roots(t)->setNullPointerException(t, throwable);
throwable = makeThrowable(t, GcArithmeticException::Type);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsArithmeticException, throwable);
roots(t)->setArithmeticException(t, throwable);
throwable = makeThrowable(t, GcArrayIndexOutOfBoundsException::Type);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsArrayIndexOutOfBoundsException, throwable);
roots(t)->setArrayIndexOutOfBoundsException(t, throwable);
throwable = makeThrowable(t, GcOutOfMemoryError::Type);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsOutOfMemoryError, throwable);
roots(t)->setOutOfMemoryError(t, throwable);
throwable = makeThrowable(t, GcThrowable::Type);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsShutdownInProgress, throwable);
roots(t)->setShutdownInProgress(t, throwable);
t->m->classpath->preBoot(t);
@ -3567,7 +3567,7 @@ boot(Thread* t, uintptr_t*)
GcThread* jthread = t->m->classpath->makeThread(t, t);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsFinalizerThread, jthread);
roots(t)->setFinalizerThread(t, jthread);
roots(t)->finalizerThread()->daemon() = true;

24
src/machine.cpp
View File

@ -1223,7 +1223,7 @@ getClassAddendum(Thread* t, GcClass* class_, GcSingleton* pool)
PROTECT(t, class_);
addendum = makeClassAddendum(t, pool, 0, 0, 0, 0, -1, 0, 0);
set(t,
setField(t,
reinterpret_cast<object>(class_),
ClassAddendum,
reinterpret_cast<object>(addendum));
@ -2824,23 +2824,23 @@ boot(Thread* t)
#include "type-initializations.cpp"
GcClass* arrayClass = type(t, GcArray::Type);
set(t, m->types, 0, arrayClass);
setField(t, m->types, 0, arrayClass);
GcClass* rootsClass = type(t, GcRoots::Type);
set(t, m->roots, 0, rootsClass);
setField(t, m->roots, 0, rootsClass);
GcClass* loaderClass = type(t, GcSystemClassLoader::Type);
set(t, roots(t)->bootLoader(), 0, loaderClass);
set(t, roots(t)->appLoader(), 0, loaderClass);
setField(t, roots(t)->bootLoader(), 0, loaderClass);
setField(t, roots(t)->appLoader(), 0, loaderClass);
GcClass* objectClass = type(t, GcJobject::Type);
GcClass* classClass = type(t, GcClass::Type);
set(t, classClass, 0, classClass);
setField(t, classClass, 0, classClass);
classClass->setSuper(t, objectClass);
GcClass* intArrayClass = type(t, GcIntArray::Type);
set(t, intArrayClass, 0, classClass);
setField(t, intArrayClass, 0, classClass);
intArrayClass->setSuper(t, objectClass);
m->unsafe = false;
@ -4810,19 +4810,19 @@ makeObjectArray(Thread* t, GcClass* elementClass, unsigned count)
}
static GcByteArray* getFieldName(Thread* t, object obj) {
return reinterpret_cast<GcByteArray*&>(cast<GcField>(t, obj)->name());
return reinterpret_cast<GcByteArray*>(cast<GcField>(t, obj)->name());
}
static GcByteArray* getFieldSpec(Thread* t, object obj) {
return reinterpret_cast<GcByteArray*&>(cast<GcField>(t, obj)->spec());
return reinterpret_cast<GcByteArray*>(cast<GcField>(t, obj)->spec());
}
static GcByteArray* getMethodName(Thread* t, object obj) {
return reinterpret_cast<GcByteArray*&>(cast<GcMethod>(t, obj)->name());
return reinterpret_cast<GcByteArray*>(cast<GcMethod>(t, obj)->name());
}
static GcByteArray* getMethodSpec(Thread* t, object obj) {
return reinterpret_cast<GcByteArray*&>(cast<GcMethod>(t, obj)->spec());
return reinterpret_cast<GcByteArray*>(cast<GcMethod>(t, obj)->spec());
}
object
@ -5400,7 +5400,7 @@ populateMultiArray(Thread* t, object array, int32_t* counts,
(counts[index + 1] * class_->arrayElementSize(), BytesPerWord));
a->length() = counts[index + 1];
setObjectClass(t, reinterpret_cast<object>(a), class_);
set(t, array, ArrayBody + (i * BytesPerWord), reinterpret_cast<object>(a));
setField(t, array, ArrayBody + (i * BytesPerWord), reinterpret_cast<object>(a));
populateMultiArray(t, reinterpret_cast<object>(a), counts, index + 1, dimensions);
}

12
src/process.cpp
View File

@ -205,17 +205,17 @@ resolveNativeMethod(Thread* t, GcMethod* method, const char* prefix,
return 0;
}
object
GcNative*
resolveNativeMethod(Thread* t, GcMethod* method)
{
void* p = resolveNativeMethod(t, method, "Avian_", 6, 3);
if (p) {
return reinterpret_cast<object>(makeNative(t, p, true));
return makeNative(t, p, true);
}
p = resolveNativeMethod(t, method, "Java_", 5, -1);
if (p) {
return reinterpret_cast<object>(makeNative(t, p, false));
return makeNative(t, p, false);
}
return 0;
@ -235,7 +235,7 @@ resolveNative(Thread* t, GcMethod* method)
initClass(t, method->class_());
if (getMethodRuntimeData(t, method)->native() == 0) {
object native = resolveNativeMethod(t, method);
GcNative* native = resolveNativeMethod(t, method);
if (UNLIKELY(native == 0)) {
throwNew(t, GcUnsatisfiedLinkError::Type, "%s.%s%s",
method->class_()->name()->body().begin(),
@ -251,8 +251,8 @@ resolveNative(Thread* t, GcMethod* method)
// populated once the object it points to has been populated:
storeStoreMemoryBarrier();
set(t, reinterpret_cast<object>(runtimeData), MethodRuntimeDataNative, native);
}
runtimeData->setNative(t, native);
}
}
int

56
src/tools/bootimage-generator/main.cpp
View File

@ -659,8 +659,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
o = reinterpret_cast<object>(resolveClass
(t, roots(t)->bootLoader(), cast<GcReference>(t, o)->name()));
set(t, reinterpret_cast<object>(addendum->pool()),
SingletonBody + (index * BytesPerWord), o);
addendum->pool()->setBodyElement(t, index, reinterpret_cast<uintptr_t>(o));
}
}
}
@ -1290,7 +1289,7 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
{
GcThrowable* throwable = cast<GcThrowable>(t, make(t, type(t, GcOutOfMemoryError::Type)));
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsOutOfMemoryError, throwable);
roots(t)->setOutOfMemoryError(t, throwable);
Zone zone(t->m->system, t->m->heap, 64 * 1024);
@ -1332,7 +1331,7 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
{ classPoolMap = makeHashMap(t, 0, 0);
PROTECT(t, classPoolMap);
set(t, roots(t), RootsPoolMap, classPoolMap);
roots(t)->setPoolMap(t, classPoolMap);
typeMaps = makeHashMap(t, 0, 0);
PROTECT(t, typeMaps);
@ -1494,40 +1493,49 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
// these roots will not be used when the bootimage is loaded, so
// there's no need to preserve them:
set(t, roots(t), RootsPoolMap, 0);
roots(t)->setPoolMap(t, 0);
GcWeakHashMap* map = makeWeakHashMap(t, 0, 0);
// sequence point, for gc (don't recombine statements)
set(t, roots(t), RootsByteArrayMap, map);
roots(t)->setByteArrayMap(t, map->as<GcHashMap>(t));
// name all primitive classes so we don't try to update immutable
// references at runtime:
{ object name = reinterpret_cast<object>(makeByteArray(t, "void"));
set(t, reinterpret_cast<object>(type(t, GcJvoid::Type)), ClassName, name);
{ GcByteArray* name = makeByteArray(t, "void");
// sequence point, for gc (don't recombine statements)
type(t, GcJvoid::Type)->setName(t, name);
name = reinterpret_cast<object>(makeByteArray(t, "boolean"));
set(t, reinterpret_cast<object>(type(t, GcJboolean::Type)), ClassName, name);
name = makeByteArray(t, "boolean");
// sequence point, for gc (don't recombine statements)
type(t, GcJboolean::Type)->setName(t, name);
name = reinterpret_cast<object>(makeByteArray(t, "byte"));
set(t, reinterpret_cast<object>(type(t, GcJbyte::Type)), ClassName, name);
name = makeByteArray(t, "byte");
// sequence point, for gc (don't recombine statements)
type(t, GcJbyte::Type)->setName(t, name);
name = reinterpret_cast<object>(makeByteArray(t, "short"));
set(t, reinterpret_cast<object>(type(t, GcJshort::Type)), ClassName, name);
name = makeByteArray(t, "short");
// sequence point, for gc (don't recombine statements)
type(t, GcJshort::Type)->setName(t, name);
name = reinterpret_cast<object>(makeByteArray(t, "char"));
set(t, reinterpret_cast<object>(type(t, GcJchar::Type)), ClassName, name);
name = makeByteArray(t, "char");
// sequence point, for gc (don't recombine statements)
type(t, GcJchar::Type)->setName(t, name);
name = reinterpret_cast<object>(makeByteArray(t, "int"));
set(t, reinterpret_cast<object>(type(t, GcJint::Type)), ClassName, name);
name = makeByteArray(t, "int");
// sequence point, for gc (don't recombine statements)
type(t, GcJint::Type)->setName(t, name);
name = reinterpret_cast<object>(makeByteArray(t, "float"));
set(t, reinterpret_cast<object>(type(t, GcJfloat::Type)), ClassName, name);
name = makeByteArray(t, "float");
// sequence point, for gc (don't recombine statements)
type(t, GcJfloat::Type)->setName(t, name);
name = reinterpret_cast<object>(makeByteArray(t, "long"));
set(t, reinterpret_cast<object>(type(t, GcJlong::Type)), ClassName, name);
name = makeByteArray(t, "long");
// sequence point, for gc (don't recombine statements)
type(t, GcJlong::Type)->setName(t, name);
name = reinterpret_cast<object>(makeByteArray(t, "double"));
set(t, reinterpret_cast<object>(type(t, GcJdouble::Type)), ClassName, name);
name = makeByteArray(t, "double");
// sequence point, for gc (don't recombine statements)
type(t, GcJdouble::Type)->setName(t, name);
}
// resolve primitive array classes in case they are needed at

24
src/tools/type-generator/main.cpp
View File

@ -1024,7 +1024,7 @@ void writeClassAccessors(Output* out, Module& module, Class* cl)
out->write(cppFieldType(module, f));
out->write(" value) { ");
if(isFieldGcMarkable(module, f)) {
out->write("set(t, reinterpret_cast<object>(this), ");
out->write("setField(t, reinterpret_cast<object>(this), ");
out->write(capitalize(cl->name));
out->write(capitalize(f.name));
out->write(", reinterpret_cast<object>(value));");
@ -1052,7 +1052,7 @@ void writeClassAccessors(Output* out, Module& module, Class* cl)
out->write(" ");
out->write(cppFieldType(module, f));
if(!f.polyfill) {
if(!f.polyfill && !isFieldGcMarkable(module, f)) {
out->write("&");
}
out->write(" ");
@ -1076,21 +1076,21 @@ void writeClassAccessors(Output* out, Module& module, Class* cl)
if(cl->arrayField) {
Field& f = *cl->arrayField;
out->write(" avian::util::Slice<");
// if(f.typeName != "maybe_object" && isFieldGcMarkable(module, f)) {
// out->write("const ");
// }
if(isFieldGcVisible(module, f)) {
out->write("const ");
}
out->write(cppFieldType(module, f));
out->write("> ");
out->write(obfuscate(f.name));
out->write("() { return avian::util::Slice<");
// if(f.typeName != "maybe_object" && isFieldGcMarkable(module, f)) {
// out->write("const ");
// }
if(isFieldGcVisible(module, f)) {
out->write("const ");
}
out->write(cppFieldType(module, f));
out->write("> (&field_at<");
// if(f.typeName != "maybe_object" && isFieldGcMarkable(module, f)) {
// out->write("const ");
// }
if(isFieldGcVisible(module, f)) {
out->write("const ");
}
out->write(cppFieldType(module, f));
out->write(">(");
out->write(capitalize(cl->name));
@ -1105,7 +1105,7 @@ void writeClassAccessors(Output* out, Module& module, Class* cl)
out->write(cppFieldType(module, f));
out->write(" value) { ");
if(isFieldGcMarkable(module, f)) {
out->write("set(t, reinterpret_cast<object>(this), ");
out->write("setField(t, reinterpret_cast<object>(this), ");
out->write(capitalize(cl->name));
out->write(capitalize(f.name));
out->write(" + index * (");