ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-01-07 13:38:47 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

rename cast -> fieldAtOffset

Browse Source
This commit is contained in:
Joshua Warner 2013-02-10 17:38:51 -07:00
parent 2a1834e48a
commit 5dd770d7ea
13 changed files with 175 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/bootimage.cpp
View File

@ -740,7 +740,7 @@ targetSize(Thread* t, object typeMaps, object p)
if (map->targetArrayElementSizeInBytes) { if (map->targetArrayElementSizeInBytes) {
return map->targetFixedSizeInWords return map->targetFixedSizeInWords
+ ceilingDivide(map->targetArrayElementSizeInBytes + ceilingDivide(map->targetArrayElementSizeInBytes
* cast<uintptr_t> * fieldAtOffset<uintptr_t>
(p, (map->buildFixedSizeInWords - 1) * BytesPerWord), (p, (map->buildFixedSizeInWords - 1) * BytesPerWord),
TargetBytesPerWord); TargetBytesPerWord);
} else { } else {
@ -888,7 +888,7 @@ nonObjectsEqual(TypeMap* map, uint8_t* src, uint8_t* dst)
if (map->targetArrayElementSizeInBytes) { if (map->targetArrayElementSizeInBytes) {
unsigned fixedSize = map->buildFixedSizeInWords * BytesPerWord; unsigned fixedSize = map->buildFixedSizeInWords * BytesPerWord;
unsigned count = cast<uintptr_t>(src, fixedSize - BytesPerWord); unsigned count = fieldAtOffset<uintptr_t>(src, fixedSize - BytesPerWord);
for (unsigned i = 0; i < count; ++i) { for (unsigned i = 0; i < count; ++i) {
if (not nonObjectsEqual if (not nonObjectsEqual
@ -919,7 +919,7 @@ copy(Thread* t, object typeMaps, object p, uint8_t* dst)
if (map->targetArrayElementSizeInBytes) { if (map->targetArrayElementSizeInBytes) {
unsigned fixedSize = map->buildFixedSizeInWords * BytesPerWord; unsigned fixedSize = map->buildFixedSizeInWords * BytesPerWord;
unsigned count = cast<uintptr_t>(p, fixedSize - BytesPerWord); unsigned count = fieldAtOffset<uintptr_t>(p, fixedSize - BytesPerWord);
for (unsigned i = 0; i < count; ++i) { for (unsigned i = 0; i < count; ++i) {
copy(t, src + fixedSize + (i * map->buildArrayElementSizeInBytes), copy(t, src + fixedSize + (i * map->buildArrayElementSizeInBytes),

6
src/builtin.cpp
View File

@ -365,7 +365,7 @@ Avian_sun_misc_Unsafe_setMemory
ACQUIRE(t, t->m->referenceLock); ACQUIRE(t, t->m->referenceLock);
if (base) { if (base) {
memset(&cast<int8_t>(base, offset), value, count); memset(&fieldAtOffset<int8_t>(base, offset), value, count);
} else { } else {
memset(reinterpret_cast<int8_t*>(offset), value, count); memset(reinterpret_cast<int8_t*>(offset), value, count);
} }
@ -528,11 +528,11 @@ Avian_sun_misc_Unsafe_copyMemory
ACQUIRE(t, t->m->referenceLock); ACQUIRE(t, t->m->referenceLock);
void* src = srcBase void* src = srcBase
? &cast<uint8_t>(srcBase, srcOffset) ? &fieldAtOffset<uint8_t>(srcBase, srcOffset)
: reinterpret_cast<uint8_t*>(srcOffset); : reinterpret_cast<uint8_t*>(srcOffset);
void* dst = dstBase void* dst = dstBase
? &cast<uint8_t>(dstBase, dstOffset) ? &fieldAtOffset<uint8_t>(dstBase, dstOffset)
: reinterpret_cast<uint8_t*>(dstOffset); : reinterpret_cast<uint8_t*>(dstOffset);
memcpy(dst, src, count); memcpy(dst, src, count);

38
src/classpath-avian.cpp
View File

@ -250,21 +250,21 @@ Avian_java_lang_reflect_Field_getPrimitive
switch (code) { switch (code) {
case ByteField: case ByteField:
return cast<int8_t>(instance, offset); return fieldAtOffset<int8_t>(instance, offset);
case BooleanField: case BooleanField:
return cast<uint8_t>(instance, offset); return fieldAtOffset<uint8_t>(instance, offset);
case CharField: case CharField:
return cast<uint16_t>(instance, offset); return fieldAtOffset<uint16_t>(instance, offset);
case ShortField: case ShortField:
return cast<int16_t>(instance, offset); return fieldAtOffset<int16_t>(instance, offset);
case IntField: case IntField:
return cast<int32_t>(instance, offset); return fieldAtOffset<int32_t>(instance, offset);
case LongField: case LongField:
return cast<int64_t>(instance, offset); return fieldAtOffset<int64_t>(instance, offset);
case FloatField: case FloatField:
return cast<uint32_t>(instance, offset); return fieldAtOffset<uint32_t>(instance, offset);
case DoubleField: case DoubleField:
return cast<uint64_t>(instance, offset); return fieldAtOffset<uint64_t>(instance, offset);
default: default:
abort(t); abort(t);
} }
@ -277,7 +277,7 @@ Avian_java_lang_reflect_Field_getObject
object instance = reinterpret_cast<object>(arguments[0]); object instance = reinterpret_cast<object>(arguments[0]);
int offset = arguments[1]; int offset = arguments[1];
return reinterpret_cast<int64_t>(cast<object>(instance, offset)); return reinterpret_cast<int64_t>(fieldAtOffset<object>(instance, offset));
} }
extern "C" JNIEXPORT void JNICALL extern "C" JNIEXPORT void JNICALL
@ -291,28 +291,28 @@ Avian_java_lang_reflect_Field_setPrimitive
switch (code) { switch (code) {
case ByteField: case ByteField:
cast<int8_t>(instance, offset) = static_cast<int8_t>(value); fieldAtOffset<int8_t>(instance, offset) = static_cast<int8_t>(value);
break; break;
case BooleanField: case BooleanField:
cast<uint8_t>(instance, offset) = static_cast<uint8_t>(value); fieldAtOffset<uint8_t>(instance, offset) = static_cast<uint8_t>(value);
break; break;
case CharField: case CharField:
cast<uint16_t>(instance, offset) = static_cast<uint16_t>(value); fieldAtOffset<uint16_t>(instance, offset) = static_cast<uint16_t>(value);
break; break;
case ShortField: case ShortField:
cast<int16_t>(instance, offset) = static_cast<int16_t>(value); fieldAtOffset<int16_t>(instance, offset) = static_cast<int16_t>(value);
break; break;
case IntField: case IntField:
cast<int32_t>(instance, offset) = static_cast<int32_t>(value); fieldAtOffset<int32_t>(instance, offset) = static_cast<int32_t>(value);
break; break;
case LongField: case LongField:
cast<int64_t>(instance, offset) = static_cast<int64_t>(value); fieldAtOffset<int64_t>(instance, offset) = static_cast<int64_t>(value);
break; break;
case FloatField: case FloatField:
cast<uint32_t>(instance, offset) = static_cast<uint32_t>(value); fieldAtOffset<uint32_t>(instance, offset) = static_cast<uint32_t>(value);
break; break;
case DoubleField: case DoubleField:
cast<uint64_t>(instance, offset) = static_cast<uint64_t>(value); fieldAtOffset<uint64_t>(instance, offset) = static_cast<uint64_t>(value);
break; break;
default: default:
abort(t); abort(t);
@ -379,7 +379,7 @@ Avian_java_lang_reflect_Array_getLength
unsigned elementSize = classArrayElementSize(t, objectClass(t, array)); unsigned elementSize = classArrayElementSize(t, objectClass(t, array));
if (LIKELY(elementSize)) { if (LIKELY(elementSize)) {
return cast<uintptr_t>(array, BytesPerWord); return fieldAtOffset<uintptr_t>(array, BytesPerWord);
} else { } else {
throwNew(t, Machine::IllegalArgumentExceptionType); throwNew(t, Machine::IllegalArgumentExceptionType);
} }
@ -666,7 +666,7 @@ Avian_avian_Atomic_compareAndSwapObject
uintptr_t update = arguments[4]; uintptr_t update = arguments[4];
bool success = atomicCompareAndSwap bool success = atomicCompareAndSwap
(&cast<uintptr_t>(target, offset), expect, update); (&fieldAtOffset<uintptr_t>(target, offset), expect, update);
if (success) { if (success) {
mark(t, target, offset); mark(t, target, offset);

8
src/classpath-common.h
View File

@ -77,14 +77,14 @@ arrayCopy(Thread* t, object src, int32_t srcOffset, object dst,
unsigned elementSize = classArrayElementSize(t, objectClass(t, src)); unsigned elementSize = classArrayElementSize(t, objectClass(t, src));
if (LIKELY(elementSize)) { if (LIKELY(elementSize)) {
intptr_t sl = cast<uintptr_t>(src, BytesPerWord); intptr_t sl = fieldAtOffset<uintptr_t>(src, BytesPerWord);
intptr_t dl = cast<uintptr_t>(dst, BytesPerWord); intptr_t dl = fieldAtOffset<uintptr_t>(dst, BytesPerWord);
if (LIKELY(length > 0)) { if (LIKELY(length > 0)) {
if (LIKELY(srcOffset >= 0 and srcOffset + length <= sl and if (LIKELY(srcOffset >= 0 and srcOffset + length <= sl and
dstOffset >= 0 and dstOffset + length <= dl)) dstOffset >= 0 and dstOffset + length <= dl))
{ {
uint8_t* sbody = &cast<uint8_t>(src, ArrayBody); uint8_t* sbody = &fieldAtOffset<uint8_t>(src, ArrayBody);
uint8_t* dbody = &cast<uint8_t>(dst, ArrayBody); uint8_t* dbody = &fieldAtOffset<uint8_t>(dst, ArrayBody);
if (src == dst) { if (src == dst) {
memmove(dbody + (dstOffset * elementSize), memmove(dbody + (dstOffset * elementSize),
sbody + (srcOffset * elementSize), sbody + (srcOffset * elementSize),

122
src/classpath-openjdk.cpp
View File

@ -709,7 +709,7 @@ class MyClasspath : public Classpath {
set(t, classStaticTable(t, type(t, Machine::ClassLoaderType)), set(t, classStaticTable(t, type(t, Machine::ClassLoaderType)),
fieldOffset(t, scl), root(t, Machine::AppLoader)); fieldOffset(t, scl), root(t, Machine::AppLoader));
cast<uint8_t>(classStaticTable(t, type(t, Machine::ClassLoaderType)), fieldAtOffset<uint8_t>(classStaticTable(t, type(t, Machine::ClassLoaderType)),
fieldOffset(t, sclSet)) = true; fieldOffset(t, sclSet)) = true;
} }
@ -950,7 +950,7 @@ getFileAttributes
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath); MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
object file = reinterpret_cast<object>(arguments[1]); object file = reinterpret_cast<object>(arguments[1]);
object path = cast<object>(file, cp->filePathField); object path = fieldAtOffset<object>(file, cp->filePathField);
THREAD_RUNTIME_ARRAY(t, char, p, stringLength(t, path) + 1); THREAD_RUNTIME_ARRAY(t, char, p, stringLength(t, path) + 1);
stringChars(t, path, RUNTIME_ARRAY_BODY(p)); stringChars(t, path, RUNTIME_ARRAY_BODY(p));
@ -999,7 +999,7 @@ checkFileAccess
object file = reinterpret_cast<object>(arguments[1]); object file = reinterpret_cast<object>(arguments[1]);
unsigned mask = arguments[2]; unsigned mask = arguments[2];
object path = cast<object>(file, cp->filePathField); object path = fieldAtOffset<object>(file, cp->filePathField);
THREAD_RUNTIME_ARRAY(t, char, p, stringLength(t, path) + 1); THREAD_RUNTIME_ARRAY(t, char, p, stringLength(t, path) + 1);
stringChars(t, path, RUNTIME_ARRAY_BODY(p)); stringChars(t, path, RUNTIME_ARRAY_BODY(p));
@ -1045,7 +1045,7 @@ getFileLength
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath); MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
object file = reinterpret_cast<object>(arguments[1]); object file = reinterpret_cast<object>(arguments[1]);
object path = cast<object>(file, cp->filePathField); object path = fieldAtOffset<object>(file, cp->filePathField);
THREAD_RUNTIME_ARRAY(t, char, p, stringLength(t, path) + 1); THREAD_RUNTIME_ARRAY(t, char, p, stringLength(t, path) + 1);
stringChars(t, path, RUNTIME_ARRAY_BODY(p)); stringChars(t, path, RUNTIME_ARRAY_BODY(p));
@ -1131,8 +1131,8 @@ openFile(Thread* t, object method, uintptr_t* arguments)
set(t, root(t, Machine::VirtualFiles), ArrayBody + (index * BytesPerWord), set(t, root(t, Machine::VirtualFiles), ArrayBody + (index * BytesPerWord),
region); region);
cast<int32_t> fieldAtOffset<int32_t>
(cast<object> (fieldAtOffset<object>
(this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField) (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField)
= index + VirtualFileBase; = index + VirtualFileBase;
} else { } else {
@ -1150,8 +1150,8 @@ readByteFromFile(Thread* t, object method, uintptr_t* arguments)
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath); MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
int fd = cast<int32_t> int fd = fieldAtOffset<int32_t>
(cast<object> (fieldAtOffset<object>
(this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField); (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField);
if (fd >= VirtualFileBase) { if (fd >= VirtualFileBase) {
@ -1191,8 +1191,8 @@ readBytesFromFile(Thread* t, object method, uintptr_t* arguments)
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath); MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
int fd = cast<int32_t> int fd = fieldAtOffset<int32_t>
(cast<object> (fieldAtOffset<object>
(this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField); (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField);
if (fd >= VirtualFileBase) { if (fd >= VirtualFileBase) {
@ -1243,8 +1243,8 @@ skipBytesInFile(Thread* t, object method, uintptr_t* arguments)
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath); MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
int fd = cast<int32_t> int fd = fieldAtOffset<int32_t>
(cast<object> (fieldAtOffset<object>
(this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField); (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField);
if (fd >= VirtualFileBase) { if (fd >= VirtualFileBase) {
@ -1284,8 +1284,8 @@ availableBytesInFile(Thread* t, object method, uintptr_t* arguments)
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath); MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
int fd = cast<int32_t> int fd = fieldAtOffset<int32_t>
(cast<object> (fieldAtOffset<object>
(this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField); (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField);
if (fd >= VirtualFileBase) { if (fd >= VirtualFileBase) {
@ -1317,8 +1317,8 @@ closeFile(Thread* t, object method, uintptr_t* arguments)
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath); MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
int fd = cast<int32_t> int fd = fieldAtOffset<int32_t>
(cast<object> (fieldAtOffset<object>
(this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField); (this_, cp->fileInputStreamFdField), cp->fileDescriptorFdField);
if (fd >= VirtualFileBase) { if (fd >= VirtualFileBase) {
@ -1623,15 +1623,15 @@ initializeZipEntryFields(Thread* t, object method, uintptr_t* arguments)
set(t, this_, cp->zipEntryNameField, name); set(t, this_, cp->zipEntryNameField, name);
cast<int64_t>(this_, cp->zipEntryTimeField) fieldAtOffset<int64_t>(this_, cp->zipEntryTimeField)
= fileTime(entry->start); = fileTime(entry->start);
cast<int64_t>(this_, cp->zipEntryCrcField) fieldAtOffset<int64_t>(this_, cp->zipEntryCrcField)
= fileCRC(entry->start); = fileCRC(entry->start);
cast<int64_t>(this_, cp->zipEntrySizeField) fieldAtOffset<int64_t>(this_, cp->zipEntrySizeField)
= uncompressedSize(entry->start); = uncompressedSize(entry->start);
cast<int64_t>(this_, cp->zipEntryCsizeField) fieldAtOffset<int64_t>(this_, cp->zipEntryCsizeField)
= compressedSize(entry->start); = compressedSize(entry->start);
cast<int64_t>(this_, cp->zipEntryMethodField) fieldAtOffset<int64_t>(this_, cp->zipEntryMethodField)
= compressionMethod(entry->start); = compressionMethod(entry->start);
} else { } else {
t->m->processor->invoke t->m->processor->invoke
@ -1771,7 +1771,7 @@ getJarFileMetaInfEntryNames(Thread* t, object method, uintptr_t* arguments)
MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath); MyClasspath* cp = static_cast<MyClasspath*>(t->m->classpath);
int64_t peer = cast<int64_t>(this_, cp->zipFileJzfileField); int64_t peer = fieldAtOffset<int64_t>(this_, cp->zipFileJzfileField);
ZipFile* file = reinterpret_cast<ZipFile*>(peer); ZipFile* file = reinterpret_cast<ZipFile*>(peer);
if (file->region) { if (file->region) {
return 0; return 0;
@ -2839,7 +2839,7 @@ Avian_sun_misc_Unsafe_getObject
object o = reinterpret_cast<object>(arguments[1]); object o = reinterpret_cast<object>(arguments[1]);
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
return cast<uintptr_t>(o, offset); return fieldAtOffset<uintptr_t>(o, offset);
} }
extern "C" JNIEXPORT void JNICALL extern "C" JNIEXPORT void JNICALL
@ -2860,7 +2860,7 @@ Avian_sun_misc_Unsafe_getShort__Ljava_lang_Object_2J
object o = reinterpret_cast<object>(arguments[1]); object o = reinterpret_cast<object>(arguments[1]);
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
return cast<int16_t>(o, offset); return fieldAtOffset<int16_t>(o, offset);
} }
extern "C" JNIEXPORT int64_t JNICALL extern "C" JNIEXPORT int64_t JNICALL
@ -2870,7 +2870,7 @@ Avian_sun_misc_Unsafe_getInt__Ljava_lang_Object_2J
object o = reinterpret_cast<object>(arguments[1]); object o = reinterpret_cast<object>(arguments[1]);
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
return cast<int32_t>(o, offset); return fieldAtOffset<int32_t>(o, offset);
} }
extern "C" JNIEXPORT int64_t JNICALL extern "C" JNIEXPORT int64_t JNICALL
@ -2880,7 +2880,7 @@ Avian_sun_misc_Unsafe_getFloat__Ljava_lang_Object_2J
object o = reinterpret_cast<object>(arguments[1]); object o = reinterpret_cast<object>(arguments[1]);
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
return cast<int32_t>(o, offset); return fieldAtOffset<int32_t>(o, offset);
} }
extern "C" JNIEXPORT int64_t JNICALL extern "C" JNIEXPORT int64_t JNICALL
@ -2890,7 +2890,7 @@ Avian_sun_misc_Unsafe_getIntVolatile
object o = reinterpret_cast<object>(arguments[1]); object o = reinterpret_cast<object>(arguments[1]);
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
int32_t result = cast<int32_t>(o, offset); int32_t result = fieldAtOffset<int32_t>(o, offset);
loadMemoryBarrier(); loadMemoryBarrier();
return result; return result;
} }
@ -2902,7 +2902,7 @@ Avian_sun_misc_Unsafe_getLong__Ljava_lang_Object_2J
object o = reinterpret_cast<object>(arguments[1]); object o = reinterpret_cast<object>(arguments[1]);
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
return cast<int64_t>(o, offset); return fieldAtOffset<int64_t>(o, offset);
} }
extern "C" JNIEXPORT int64_t JNICALL extern "C" JNIEXPORT int64_t JNICALL
@ -2928,7 +2928,7 @@ Avian_sun_misc_Unsafe_getLongVolatile
acquire(t, field); acquire(t, field);
} }
int64_t result = cast<int64_t>(o, offset); int64_t result = fieldAtOffset<int64_t>(o, offset);
if (BytesPerWord < 8) { if (BytesPerWord < 8) {
release(t, field); release(t, field);
@ -2947,7 +2947,7 @@ Avian_sun_misc_Unsafe_putByte__Ljava_lang_Object_2JB
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
int8_t value = arguments[4]; int8_t value = arguments[4];
cast<int8_t>(o, offset) = value; fieldAtOffset<int8_t>(o, offset) = value;
} }
extern "C" JNIEXPORT void JNICALL extern "C" JNIEXPORT void JNICALL
@ -2958,7 +2958,7 @@ Avian_sun_misc_Unsafe_putShort__Ljava_lang_Object_2JS
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
int16_t value = arguments[4]; int16_t value = arguments[4];
cast<int16_t>(o, offset) = value; fieldAtOffset<int16_t>(o, offset) = value;
} }
extern "C" JNIEXPORT void JNICALL extern "C" JNIEXPORT void JNICALL
@ -2969,7 +2969,7 @@ Avian_sun_misc_Unsafe_putInt__Ljava_lang_Object_2JI
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
int32_t value = arguments[4]; int32_t value = arguments[4];
cast<int32_t>(o, offset) = value; fieldAtOffset<int32_t>(o, offset) = value;
} }
extern "C" JNIEXPORT void JNICALL extern "C" JNIEXPORT void JNICALL
@ -2980,7 +2980,7 @@ Avian_sun_misc_Unsafe_putFloat__Ljava_lang_Object_2JF
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
int32_t value = arguments[4]; int32_t value = arguments[4];
cast<int32_t>(o, offset) = value; fieldAtOffset<int32_t>(o, offset) = value;
} }
extern "C" JNIEXPORT int64_t JNICALL extern "C" JNIEXPORT int64_t JNICALL
@ -2990,7 +2990,7 @@ Avian_sun_misc_Unsafe_getByte__Ljava_lang_Object_2J
object o = reinterpret_cast<object>(arguments[1]); object o = reinterpret_cast<object>(arguments[1]);
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
return cast<int8_t>(o, offset); return fieldAtOffset<int8_t>(o, offset);
} }
extern "C" JNIEXPORT int64_t JNICALL extern "C" JNIEXPORT int64_t JNICALL
@ -3009,7 +3009,7 @@ Avian_sun_misc_Unsafe_putBoolean__Ljava_lang_Object_2JZ
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
uint8_t value = arguments[4]; uint8_t value = arguments[4];
cast<uint8_t>(o, offset) = value; fieldAtOffset<uint8_t>(o, offset) = value;
} }
extern "C" JNIEXPORT void JNICALL extern "C" JNIEXPORT void JNICALL
@ -3020,7 +3020,7 @@ Avian_sun_misc_Unsafe_putLong__Ljava_lang_Object_2JJ
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
int64_t value; memcpy(&value, arguments + 4, 8); int64_t value; memcpy(&value, arguments + 4, 8);
cast<int64_t>(o, offset) = value; fieldAtOffset<int64_t>(o, offset) = value;
} }
extern "C" JNIEXPORT int64_t JNICALL extern "C" JNIEXPORT int64_t JNICALL
@ -3030,7 +3030,7 @@ Avian_sun_misc_Unsafe_getObjectVolatile
object o = reinterpret_cast<object>(arguments[1]); object o = reinterpret_cast<object>(arguments[1]);
int64_t offset; memcpy(&offset, arguments + 2, 8); int64_t offset; memcpy(&offset, arguments + 2, 8);
uintptr_t value = cast<uintptr_t>(o, offset); uintptr_t value = fieldAtOffset<uintptr_t>(o, offset);
loadMemoryBarrier(); loadMemoryBarrier();
return value; return value;
} }
@ -3065,7 +3065,7 @@ Avian_sun_misc_Unsafe_compareAndSwapInt
uint32_t update = arguments[5]; uint32_t update = arguments[5];
return atomicCompareAndSwap32 return atomicCompareAndSwap32
(&cast<uint32_t>(target, offset), expect, update); (&fieldAtOffset<uint32_t>(target, offset), expect, update);
} }
extern "C" JNIEXPORT int64_t JNICALL extern "C" JNIEXPORT int64_t JNICALL
@ -3078,7 +3078,7 @@ Avian_sun_misc_Unsafe_compareAndSwapObject
uintptr_t update = arguments[5]; uintptr_t update = arguments[5];
bool success = atomicCompareAndSwap bool success = atomicCompareAndSwap
(&cast<uintptr_t>(target, offset), expect, update); (&fieldAtOffset<uintptr_t>(target, offset), expect, update);
if (success) { if (success) {
mark(t, target, offset); mark(t, target, offset);
@ -3098,11 +3098,11 @@ Avian_sun_misc_Unsafe_compareAndSwapLong
#ifdef AVIAN_HAS_CAS64 #ifdef AVIAN_HAS_CAS64
return atomicCompareAndSwap64 return atomicCompareAndSwap64
(&cast<uint64_t>(target, offset), expect, update); (&fieldAtOffset<uint64_t>(target, offset), expect, update);
#else #else
ACQUIRE_FIELD_FOR_WRITE(t, local::fieldForOffset(t, target, offset)); ACQUIRE_FIELD_FOR_WRITE(t, local::fieldForOffset(t, target, offset));
if (cast<uint64_t>(target, offset) == expect) { if (fieldAtOffset<uint64_t>(target, offset) == expect) {
cast<uint64_t>(target, offset) = update; fieldAtOffset<uint64_t>(target, offset) = update;
return true; return true;
} else { } else {
return false; return false;
@ -3999,7 +3999,7 @@ EXPORT(JVM_GetArrayLength)(Thread* t, jobject array)
{ {
ENTER(t, Thread::ActiveState); ENTER(t, Thread::ActiveState);
return cast<uintptr_t>(*array, BytesPerWord); return fieldAtOffset<uintptr_t>(*array, BytesPerWord);
} }
uint64_t uint64_t
@ -4012,40 +4012,40 @@ jvmGetArrayElement(Thread* t, uintptr_t* arguments)
case 'Z': case 'Z':
return reinterpret_cast<intptr_t> return reinterpret_cast<intptr_t>
(makeLocalReference (makeLocalReference
(t, makeBoolean(t, cast<int8_t>(*array, ArrayBody + index)))); (t, makeBoolean(t, fieldAtOffset<int8_t>(*array, ArrayBody + index))));
case 'B': case 'B':
return reinterpret_cast<intptr_t> return reinterpret_cast<intptr_t>
(makeLocalReference (makeLocalReference
(t, makeByte(t, cast<int8_t>(*array, ArrayBody + index)))); (t, makeByte(t, fieldAtOffset<int8_t>(*array, ArrayBody + index))));
case 'C': case 'C':
return reinterpret_cast<intptr_t> return reinterpret_cast<intptr_t>
(makeLocalReference (makeLocalReference
(t, makeChar(t, cast<int16_t>(*array, ArrayBody + (index * 2))))); (t, makeChar(t, fieldAtOffset<int16_t>(*array, ArrayBody + (index * 2)))));
case 'S': case 'S':
return reinterpret_cast<intptr_t> return reinterpret_cast<intptr_t>
(makeLocalReference (makeLocalReference
(t, makeShort(t, cast<int16_t>(*array, ArrayBody + (index * 2))))); (t, makeShort(t, fieldAtOffset<int16_t>(*array, ArrayBody + (index * 2)))));
case 'I': case 'I':
return reinterpret_cast<intptr_t> return reinterpret_cast<intptr_t>
(makeLocalReference (makeLocalReference
(t, makeInt(t, cast<int32_t>(*array, ArrayBody + (index * 4))))); (t, makeInt(t, fieldAtOffset<int32_t>(*array, ArrayBody + (index * 4)))));
case 'F': case 'F':
return reinterpret_cast<intptr_t> return reinterpret_cast<intptr_t>
(makeLocalReference (makeLocalReference
(t, makeFloat(t, cast<int32_t>(*array, ArrayBody + (index * 4))))); (t, makeFloat(t, fieldAtOffset<int32_t>(*array, ArrayBody + (index * 4)))));
case 'J': case 'J':
return reinterpret_cast<intptr_t> return reinterpret_cast<intptr_t>
(makeLocalReference (makeLocalReference
(t, makeLong(t, cast<int64_t>(*array, ArrayBody + (index * 8))))); (t, makeLong(t, fieldAtOffset<int64_t>(*array, ArrayBody + (index * 8)))));
case 'D': case 'D':
return reinterpret_cast<intptr_t> return reinterpret_cast<intptr_t>
(makeLocalReference (makeLocalReference
(t, makeDouble(t, cast<int64_t>(*array, ArrayBody + (index * 8))))); (t, makeDouble(t, fieldAtOffset<int64_t>(*array, ArrayBody + (index * 8)))));
case 'L': case 'L':
case '[': case '[':
return reinterpret_cast<intptr_t> return reinterpret_cast<intptr_t>
(makeLocalReference (makeLocalReference
(t, cast<object>(*array, ArrayBody + (index * BytesPerWord)))); (t, fieldAtOffset<object>(*array, ArrayBody + (index * BytesPerWord))));
default: default:
abort(t); abort(t);
} }
@ -4071,28 +4071,28 @@ EXPORT(JVM_SetArrayElement)(Thread* t, jobject array, jint index,
switch (byteArrayBody(t, className(t, objectClass(t, *array)), 1)) { switch (byteArrayBody(t, className(t, objectClass(t, *array)), 1)) {
case 'Z': case 'Z':
cast<int8_t>(*array, ArrayBody + index) = booleanValue(t, *value); fieldAtOffset<int8_t>(*array, ArrayBody + index) = booleanValue(t, *value);
break; break;
case 'B': case 'B':
cast<int8_t>(*array, ArrayBody + index) = byteValue(t, *value); fieldAtOffset<int8_t>(*array, ArrayBody + index) = byteValue(t, *value);
break; break;
case 'C': case 'C':
cast<int16_t>(*array, ArrayBody + (index * 2)) = charValue(t, *value); fieldAtOffset<int16_t>(*array, ArrayBody + (index * 2)) = charValue(t, *value);
break; break;
case 'S': case 'S':
cast<int16_t>(*array, ArrayBody + (index * 2)) = shortValue(t, *value); fieldAtOffset<int16_t>(*array, ArrayBody + (index * 2)) = shortValue(t, *value);
break; break;
case 'I': case 'I':
cast<int32_t>(*array, ArrayBody + (index * 4)) = intValue(t, *value); fieldAtOffset<int32_t>(*array, ArrayBody + (index * 4)) = intValue(t, *value);
break; break;
case 'F': case 'F':
cast<int32_t>(*array, ArrayBody + (index * 4)) = floatValue(t, *value); fieldAtOffset<int32_t>(*array, ArrayBody + (index * 4)) = floatValue(t, *value);
break; break;
case 'J': case 'J':
cast<int64_t>(*array, ArrayBody + (index * 8)) = longValue(t, *value); fieldAtOffset<int64_t>(*array, ArrayBody + (index * 8)) = longValue(t, *value);
break; break;
case 'D': case 'D':
cast<int64_t>(*array, ArrayBody + (index * 8)) = doubleValue(t, *value); fieldAtOffset<int64_t>(*array, ArrayBody + (index * 8)) = doubleValue(t, *value);
break; break;
case 'L': case 'L':
case '[': case '[':
@ -5059,7 +5059,7 @@ jvmConstantPoolGetUTF8At(Thread* t, uintptr_t* arguments)
return reinterpret_cast<uint64_t> return reinterpret_cast<uint64_t>
(makeLocalReference (makeLocalReference
(t, t->m->classpath->makeString (t, t->m->classpath->makeString
(t, array, 0, cast<uintptr_t>(array, BytesPerWord) - 1))); (t, array, 0, fieldAtOffset<uintptr_t>(array, BytesPerWord) - 1)));
} }
extern "C" JNIEXPORT jstring JNICALL extern "C" JNIEXPORT jstring JNICALL

2
src/common.h
View File

@ -476,7 +476,7 @@ getBits(T* map, unsigned bitsPerRecord, unsigned index)
template <class T> template <class T>
inline T& inline T&
cast(void* p, unsigned offset) fieldAtOffset(void* p, unsigned offset)
{ {
return *reinterpret_cast<T*>(static_cast<uint8_t*>(p) + offset); return *reinterpret_cast<T*>(static_cast<uint8_t*>(p) + offset);
} }

24
src/compile.cpp
View File

@ -3047,22 +3047,22 @@ getFieldValue(Thread* t, object target, object field)
switch (fieldCode(t, field)) { switch (fieldCode(t, field)) {
case ByteField: case ByteField:
case BooleanField: case BooleanField:
return cast<int8_t>(target, fieldOffset(t, field)); return fieldAtOffset<int8_t>(target, fieldOffset(t, field));
case CharField: case CharField:
case ShortField: case ShortField:
return cast<int16_t>(target, fieldOffset(t, field)); return fieldAtOffset<int16_t>(target, fieldOffset(t, field));
case FloatField: case FloatField:
case IntField: case IntField:
return cast<int32_t>(target, fieldOffset(t, field)); return fieldAtOffset<int32_t>(target, fieldOffset(t, field));
case DoubleField: case DoubleField:
case LongField: case LongField:
return cast<int64_t>(target, fieldOffset(t, field)); return fieldAtOffset<int64_t>(target, fieldOffset(t, field));
case ObjectField: case ObjectField:
return cast<intptr_t>(target, fieldOffset(t, field)); return fieldAtOffset<intptr_t>(target, fieldOffset(t, field));
default: default:
abort(t); abort(t);
@ -3105,7 +3105,7 @@ setStaticLongFieldValueFromReference(MyThread* t, object pair, uint64_t value)
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<int64_t> fieldAtOffset<int64_t>
(classStaticTable(t, fieldClass(t, field)), fieldOffset(t, field)) = value; (classStaticTable(t, fieldClass(t, field)), fieldOffset(t, field)) = value;
} }
@ -3120,7 +3120,7 @@ setLongFieldValueFromReference(MyThread* t, object pair, object instance,
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<int64_t>(instance, fieldOffset(t, field)) = value; fieldAtOffset<int64_t>(instance, fieldOffset(t, field)) = value;
} }
void void
@ -3160,17 +3160,17 @@ setFieldValue(MyThread* t, object target, object field, uint32_t value)
switch (fieldCode(t, field)) { switch (fieldCode(t, field)) {
case ByteField: case ByteField:
case BooleanField: case BooleanField:
cast<int8_t>(target, fieldOffset(t, field)) = value; fieldAtOffset<int8_t>(target, fieldOffset(t, field)) = value;
break; break;
case CharField: case CharField:
case ShortField: case ShortField:
cast<int16_t>(target, fieldOffset(t, field)) = value; fieldAtOffset<int16_t>(target, fieldOffset(t, field)) = value;
break; break;
case FloatField: case FloatField:
case IntField: case IntField:
cast<int32_t>(target, fieldOffset(t, field)) = value; fieldAtOffset<int32_t>(target, fieldOffset(t, field)) = value;
break; break;
default: default:
@ -8498,11 +8498,11 @@ class ArgumentList {
case 'J': case 'J':
case 'D': case 'D':
addLong(cast<int64_t>(objectArrayBody(t, arguments, index++), 8)); addLong(fieldAtOffset<int64_t>(objectArrayBody(t, arguments, index++), 8));
break; break;
default: default:
addInt(cast<int32_t>(objectArrayBody(t, arguments, index++), addInt(fieldAtOffset<int32_t>(objectArrayBody(t, arguments, index++),
BytesPerWord)); BytesPerWord));
break; break;
} }

12
src/heap.cpp
View File

@ -80,13 +80,13 @@ markBitAtomic(uintptr_t* map, unsigned i)
inline void* inline void*
get(void* o, unsigned offsetInWords) get(void* o, unsigned offsetInWords)
{ {
return maskAlignedPointer(cast<void*>(o, offsetInWords * BytesPerWord)); return maskAlignedPointer(fieldAtOffset<void*>(o, offsetInWords * BytesPerWord));
} }
inline void** inline void**
getp(void* o, unsigned offsetInWords) getp(void* o, unsigned offsetInWords)
{ {
return &cast<void*>(o, offsetInWords * BytesPerWord); return &fieldAtOffset<void*>(o, offsetInWords * BytesPerWord);
} }
inline void inline void
@ -862,21 +862,21 @@ inline void*
follow(Context* c UNUSED, void* o) follow(Context* c UNUSED, void* o)
{ {
assert(c, wasCollected(c, o)); assert(c, wasCollected(c, o));
return cast<void*>(o, 0); return fieldAtOffset<void*>(o, 0);
} }
inline void*& inline void*&
parent(Context* c UNUSED, void* o) parent(Context* c UNUSED, void* o)
{ {
assert(c, wasCollected(c, o)); assert(c, wasCollected(c, o));
return cast<void*>(o, BytesPerWord); return fieldAtOffset<void*>(o, BytesPerWord);
} }
inline uintptr_t* inline uintptr_t*
bitset(Context* c UNUSED, void* o) bitset(Context* c UNUSED, void* o)
{ {
assert(c, wasCollected(c, o)); assert(c, wasCollected(c, o));
return &cast<uintptr_t>(o, BytesPerWord * 2); return &fieldAtOffset<uintptr_t>(o, BytesPerWord * 2);
} }
void void
@ -1059,7 +1059,7 @@ copy(Context* c, void* o)
} }
// leave a pointer to the copy in the original // leave a pointer to the copy in the original
cast<void*>(o, 0) = r; fieldAtOffset<void*>(o, 0) = r;
return r; return r;
} }

2
src/heapwalk.cpp
View File

@ -228,7 +228,7 @@ inline object
get(object o, unsigned offsetInWords) get(object o, unsigned offsetInWords)
{ {
return static_cast<object> return static_cast<object>
(mask(cast<void*>(o, offsetInWords * BytesPerWord))); (mask(fieldAtOffset<void*>(o, offsetInWords * BytesPerWord)));
} }
unsigned unsigned

32
src/interpret.cpp
View File

@ -733,26 +733,26 @@ pushField(Thread* t, object target, object field)
switch (fieldCode(t, field)) { switch (fieldCode(t, field)) {
case ByteField: case ByteField:
case BooleanField: case BooleanField:
pushInt(t, cast<int8_t>(target, fieldOffset(t, field))); pushInt(t, fieldAtOffset<int8_t>(target, fieldOffset(t, field)));
break; break;
case CharField: case CharField:
case ShortField: case ShortField:
pushInt(t, cast<int16_t>(target, fieldOffset(t, field))); pushInt(t, fieldAtOffset<int16_t>(target, fieldOffset(t, field)));
break; break;
case FloatField: case FloatField:
case IntField: case IntField:
pushInt(t, cast<int32_t>(target, fieldOffset(t, field))); pushInt(t, fieldAtOffset<int32_t>(target, fieldOffset(t, field)));
break; break;
case DoubleField: case DoubleField:
case LongField: case LongField:
pushLong(t, cast<int64_t>(target, fieldOffset(t, field))); pushLong(t, fieldAtOffset<int64_t>(target, fieldOffset(t, field)));
break; break;
case ObjectField: case ObjectField:
pushObject(t, cast<object>(target, fieldOffset(t, field))); pushObject(t, fieldAtOffset<object>(target, fieldOffset(t, field)));
break; break;
default: default:
@ -902,7 +902,7 @@ interpret3(Thread* t, const int base)
case arraylength: { case arraylength: {
object array = popObject(t); object array = popObject(t);
if (LIKELY(array)) { if (LIKELY(array)) {
pushInt(t, cast<uintptr_t>(array, BytesPerWord)); pushInt(t, fieldAtOffset<uintptr_t>(array, BytesPerWord));
} else { } else {
exception = makeThrowable(t, Machine::NullPointerExceptionType); exception = makeThrowable(t, Machine::NullPointerExceptionType);
goto throw_; goto throw_;
@ -2436,17 +2436,17 @@ interpret3(Thread* t, const int base)
switch (fieldCode(t, field)) { switch (fieldCode(t, field)) {
case ByteField: case ByteField:
case BooleanField: case BooleanField:
cast<int8_t>(o, fieldOffset(t, field)) = value; fieldAtOffset<int8_t>(o, fieldOffset(t, field)) = value;
break; break;
case CharField: case CharField:
case ShortField: case ShortField:
cast<int16_t>(o, fieldOffset(t, field)) = value; fieldAtOffset<int16_t>(o, fieldOffset(t, field)) = value;
break; break;
case FloatField: case FloatField:
case IntField: case IntField:
cast<int32_t>(o, fieldOffset(t, field)) = value; fieldAtOffset<int32_t>(o, fieldOffset(t, field)) = value;
break; break;
} }
} else { } else {
@ -2459,7 +2459,7 @@ interpret3(Thread* t, const int base)
int64_t value = popLong(t); int64_t value = popLong(t);
object o = popObject(t); object o = popObject(t);
if (LIKELY(o)) { if (LIKELY(o)) {
cast<int64_t>(o, fieldOffset(t, field)) = value; fieldAtOffset<int64_t>(o, fieldOffset(t, field)) = value;
} else { } else {
exception = makeThrowable(t, Machine::NullPointerExceptionType); exception = makeThrowable(t, Machine::NullPointerExceptionType);
} }
@ -2510,24 +2510,24 @@ interpret3(Thread* t, const int base)
switch (fieldCode(t, field)) { switch (fieldCode(t, field)) {
case ByteField: case ByteField:
case BooleanField: case BooleanField:
cast<int8_t>(table, fieldOffset(t, field)) = value; fieldAtOffset<int8_t>(table, fieldOffset(t, field)) = value;
break; break;
case CharField: case CharField:
case ShortField: case ShortField:
cast<int16_t>(table, fieldOffset(t, field)) = value; fieldAtOffset<int16_t>(table, fieldOffset(t, field)) = value;
break; break;
case FloatField: case FloatField:
case IntField: case IntField:
cast<int32_t>(table, fieldOffset(t, field)) = value; fieldAtOffset<int32_t>(table, fieldOffset(t, field)) = value;
break; break;
} }
} break; } break;
case DoubleField: case DoubleField:
case LongField: { case LongField: {
cast<int64_t>(table, fieldOffset(t, field)) = popLong(t); fieldAtOffset<int64_t>(table, fieldOffset(t, field)) = popLong(t);
} break; } break;
case ObjectField: { case ObjectField: {
@ -2850,11 +2850,11 @@ pushArguments(Thread* t, object this_, const char* spec, object a)
case 'J': case 'J':
case 'D': case 'D':
pushLong(t, cast<int64_t>(objectArrayBody(t, a, index++), 8)); pushLong(t, fieldAtOffset<int64_t>(objectArrayBody(t, a, index++), 8));
break; break;
default: default:
pushInt(t, cast<int32_t>(objectArrayBody(t, a, index++), pushInt(t, fieldAtOffset<int32_t>(objectArrayBody(t, a, index++),
BytesPerWord)); BytesPerWord));
break; break;
} }

72
src/jnienv.cpp
View File

@ -232,7 +232,7 @@ GetArrayLength(Thread* t, jarray array)
{ {
ENTER(t, Thread::ActiveState); ENTER(t, Thread::ActiveState);
return cast<uintptr_t>(*array, BytesPerWord); return fieldAtOffset<uintptr_t>(*array, BytesPerWord);
} }
uint64_t uint64_t
@ -271,7 +271,7 @@ newStringUTF(Thread* t, uintptr_t* arguments)
return reinterpret_cast<uint64_t> return reinterpret_cast<uint64_t>
(makeLocalReference (makeLocalReference
(t, t->m->classpath->makeString (t, t->m->classpath->makeString
(t, array, 0, cast<uintptr_t>(array, BytesPerWord) - 1))); (t, array, 0, fieldAtOffset<uintptr_t>(array, BytesPerWord) - 1)));
} }
jstring JNICALL jstring JNICALL
@ -1532,7 +1532,7 @@ getObjectField(Thread* t, uintptr_t* arguments)
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return reinterpret_cast<uintptr_t> return reinterpret_cast<uintptr_t>
(makeLocalReference(t, cast<object>(*o, fieldOffset(t, field)))); (makeLocalReference(t, fieldAtOffset<object>(*o, fieldOffset(t, field))));
} }
jobject JNICALL jobject JNICALL
@ -1553,7 +1553,7 @@ getBooleanField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jboolean>(*o, fieldOffset(t, field)); return fieldAtOffset<jboolean>(*o, fieldOffset(t, field));
} }
jboolean JNICALL jboolean JNICALL
@ -1574,7 +1574,7 @@ getByteField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jbyte>(*o, fieldOffset(t, field)); return fieldAtOffset<jbyte>(*o, fieldOffset(t, field));
} }
jbyte JNICALL jbyte JNICALL
@ -1595,7 +1595,7 @@ getCharField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jchar>(*o, fieldOffset(t, field)); return fieldAtOffset<jchar>(*o, fieldOffset(t, field));
} }
jchar JNICALL jchar JNICALL
@ -1616,7 +1616,7 @@ getShortField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jshort>(*o, fieldOffset(t, field)); return fieldAtOffset<jshort>(*o, fieldOffset(t, field));
} }
jshort JNICALL jshort JNICALL
@ -1637,7 +1637,7 @@ getIntField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jint>(*o, fieldOffset(t, field)); return fieldAtOffset<jint>(*o, fieldOffset(t, field));
} }
jint JNICALL jint JNICALL
@ -1658,7 +1658,7 @@ getLongField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jlong>(*o, fieldOffset(t, field)); return fieldAtOffset<jlong>(*o, fieldOffset(t, field));
} }
jlong JNICALL jlong JNICALL
@ -1679,7 +1679,7 @@ getFloatField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return floatToBits(cast<jfloat>(*o, fieldOffset(t, field))); return floatToBits(fieldAtOffset<jfloat>(*o, fieldOffset(t, field)));
} }
jfloat JNICALL jfloat JNICALL
@ -1700,7 +1700,7 @@ getDoubleField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return doubleToBits(cast<jdouble>(*o, fieldOffset(t, field))); return doubleToBits(fieldAtOffset<jdouble>(*o, fieldOffset(t, field)));
} }
jdouble JNICALL jdouble JNICALL
@ -1747,7 +1747,7 @@ setBooleanField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jboolean>(*o, fieldOffset(t, field)) = v; fieldAtOffset<jboolean>(*o, fieldOffset(t, field)) = v;
return 1; return 1;
} }
@ -1772,7 +1772,7 @@ setByteField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jbyte>(*o, fieldOffset(t, field)) = v; fieldAtOffset<jbyte>(*o, fieldOffset(t, field)) = v;
return 1; return 1;
} }
@ -1797,7 +1797,7 @@ setCharField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jchar>(*o, fieldOffset(t, field)) = v; fieldAtOffset<jchar>(*o, fieldOffset(t, field)) = v;
return 1; return 1;
} }
@ -1822,7 +1822,7 @@ setShortField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jshort>(*o, fieldOffset(t, field)) = v; fieldAtOffset<jshort>(*o, fieldOffset(t, field)) = v;
return 1; return 1;
} }
@ -1847,7 +1847,7 @@ setIntField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jint>(*o, fieldOffset(t, field)) = v; fieldAtOffset<jint>(*o, fieldOffset(t, field)) = v;
return 1; return 1;
} }
@ -1872,7 +1872,7 @@ setLongField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jlong>(*o, fieldOffset(t, field)) = v; fieldAtOffset<jlong>(*o, fieldOffset(t, field)) = v;
return 1; return 1;
} }
@ -1898,7 +1898,7 @@ setFloatField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jfloat>(*o, fieldOffset(t, field)) = v; fieldAtOffset<jfloat>(*o, fieldOffset(t, field)) = v;
return 1; return 1;
} }
@ -1923,7 +1923,7 @@ setDoubleField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jdouble>(*o, fieldOffset(t, field)) = v; fieldAtOffset<jdouble>(*o, fieldOffset(t, field)) = v;
return 1; return 1;
} }
@ -1965,7 +1965,7 @@ getStaticObjectField(Thread* t, uintptr_t* arguments)
return reinterpret_cast<uintptr_t> return reinterpret_cast<uintptr_t>
(makeLocalReference (makeLocalReference
(t, cast<object> (t, fieldAtOffset<object>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)))); (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field))));
} }
@ -1990,7 +1990,7 @@ getStaticBooleanField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jboolean> return fieldAtOffset<jboolean>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)); (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field));
} }
@ -2015,7 +2015,7 @@ getStaticByteField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jbyte> return fieldAtOffset<jbyte>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)); (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field));
} }
@ -2040,7 +2040,7 @@ getStaticCharField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jchar> return fieldAtOffset<jchar>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)); (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field));
} }
@ -2065,7 +2065,7 @@ getStaticShortField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jshort> return fieldAtOffset<jshort>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)); (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field));
} }
@ -2090,7 +2090,7 @@ getStaticIntField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jint> return fieldAtOffset<jint>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)); (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field));
} }
@ -2115,7 +2115,7 @@ getStaticLongField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return cast<jlong> return fieldAtOffset<jlong>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)); (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field));
} }
@ -2141,7 +2141,7 @@ getStaticFloatField(Thread* t, uintptr_t* arguments)
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return floatToBits return floatToBits
(cast<jfloat> (fieldAtOffset<jfloat>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field))); (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)));
} }
@ -2167,7 +2167,7 @@ getStaticDoubleField(Thread* t, uintptr_t* arguments)
ACQUIRE_FIELD_FOR_READ(t, field); ACQUIRE_FIELD_FOR_READ(t, field);
return doubleToBits return doubleToBits
(cast<jdouble> (fieldAtOffset<jdouble>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field))); (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)));
} }
@ -2222,7 +2222,7 @@ setStaticBooleanField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jboolean> fieldAtOffset<jboolean>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v; (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v;
return 1; return 1;
@ -2251,7 +2251,7 @@ setStaticByteField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jbyte> fieldAtOffset<jbyte>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v; (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v;
return 1; return 1;
@ -2280,7 +2280,7 @@ setStaticCharField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jchar> fieldAtOffset<jchar>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v; (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v;
return 1; return 1;
@ -2309,7 +2309,7 @@ setStaticShortField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jshort> fieldAtOffset<jshort>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v; (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v;
return 1; return 1;
@ -2338,7 +2338,7 @@ setStaticIntField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jint> fieldAtOffset<jint>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v; (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v;
return 1; return 1;
@ -2367,7 +2367,7 @@ setStaticLongField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jlong> fieldAtOffset<jlong>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v; (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v;
return 1; return 1;
@ -2397,7 +2397,7 @@ setStaticFloatField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jfloat> fieldAtOffset<jfloat>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v; (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v;
return 1; return 1;
@ -2426,7 +2426,7 @@ setStaticDoubleField(Thread* t, uintptr_t* arguments)
PROTECT(t, field); PROTECT(t, field);
ACQUIRE_FIELD_FOR_WRITE(t, field); ACQUIRE_FIELD_FOR_WRITE(t, field);
cast<jdouble> fieldAtOffset<jdouble>
(classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v; (classStaticTable(t, jclassVmClass(t, *c)), fieldOffset(t, field)) = v;
return 1; return 1;

6
src/machine.cpp
View File

@ -924,7 +924,7 @@ parsePoolEntry(Thread* t, Stream& s, uint32_t* index, object pool, unsigned i)
object value = parseUtf8(t, singletonObject(t, pool, si)); object value = parseUtf8(t, singletonObject(t, pool, si));
value = t->m->classpath->makeString value = t->m->classpath->makeString
(t, value, 0, cast<uintptr_t>(value, BytesPerWord) - 1); (t, value, 0, fieldAtOffset<uintptr_t>(value, BytesPerWord) - 1);
value = intern(t, value); value = intern(t, value);
set(t, pool, SingletonBody + (i * BytesPerWord), value); set(t, pool, SingletonBody + (i * BytesPerWord), value);
@ -3466,7 +3466,7 @@ allocate3(Thread* t, Allocator* allocator, Machine::AllocationType type,
object o = reinterpret_cast<object>(t->backupHeap + t->backupHeapIndex); object o = reinterpret_cast<object>(t->backupHeap + t->backupHeapIndex);
t->backupHeapIndex += ceilingDivide(sizeInBytes, BytesPerWord); t->backupHeapIndex += ceilingDivide(sizeInBytes, BytesPerWord);
cast<object>(o, 0) = 0; fieldAtOffset<object>(o, 0) = 0;
return o; return o;
} else if (UNLIKELY(t->flags & Thread::TracingFlag)) { } else if (UNLIKELY(t->flags & Thread::TracingFlag)) {
expect(t, t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord) expect(t, t->heapIndex + ceilingDivide(sizeInBytes, BytesPerWord)
@ -4670,7 +4670,7 @@ walk(Thread* t, Heap::Walker* w, object o, unsigned start)
unsigned arrayElementSize = classArrayElementSize(t, class_); unsigned arrayElementSize = classArrayElementSize(t, class_);
unsigned arrayLength unsigned arrayLength
= (arrayElementSize ? = (arrayElementSize ?
cast<uintptr_t>(o, fixedSize - BytesPerWord) : 0); fieldAtOffset<uintptr_t>(o, fixedSize - BytesPerWord) : 0);
THREAD_RUNTIME_ARRAY(t, uint32_t, mask, intArrayLength(t, objectMask)); THREAD_RUNTIME_ARRAY(t, uint32_t, mask, intArrayLength(t, objectMask));
memcpy(RUNTIME_ARRAY_BODY(mask), &intArrayBody(t, objectMask, 0), memcpy(RUNTIME_ARRAY_BODY(mask), &intArrayBody(t, objectMask, 0),

20
src/machine.h
View File

@ -1611,7 +1611,7 @@ typedef uint64_t (JNICALL *FastNativeFunction)(Thread*, object, uintptr_t*);
inline object inline object
objectClass(Thread*, object o) objectClass(Thread*, object o)
{ {
return maskAlignedPointer(cast<object>(o, 0)); return maskAlignedPointer(fieldAtOffset<object>(o, 0));
} }
inline unsigned inline unsigned
@ -1883,18 +1883,18 @@ mark(Thread* t, object o, unsigned offset)
inline void inline void
set(Thread* t, object target, unsigned offset, object value) set(Thread* t, object target, unsigned offset, object value)
{ {
cast<object>(target, offset) = value; fieldAtOffset<object>(target, offset) = value;
mark(t, target, offset); mark(t, target, offset);
} }
inline void inline void
setObjectClass(Thread*, object o, object value) setObjectClass(Thread*, object o, object value)
{ {
cast<object>(o, 0) fieldAtOffset<object>(o, 0)
= reinterpret_cast<object> = reinterpret_cast<object>
(reinterpret_cast<intptr_alias_t>(value) (reinterpret_cast<intptr_alias_t>(value)
| (reinterpret_cast<intptr_alias_t> | (reinterpret_cast<intptr_alias_t>
(cast<object>(o, 0)) & (~PointerMask))); (fieldAtOffset<object>(o, 0)) & (~PointerMask)));
} }
inline const char* inline const char*
@ -2151,7 +2151,7 @@ baseSize(Thread* t, object o, object class_)
return ceilingDivide(classFixedSize(t, class_), BytesPerWord) return ceilingDivide(classFixedSize(t, class_), BytesPerWord)
+ ceilingDivide(classArrayElementSize(t, class_) + ceilingDivide(classArrayElementSize(t, class_)
* cast<uintptr_t>(o, classFixedSize(t, class_) - BytesPerWord), * fieldAtOffset<uintptr_t>(o, classFixedSize(t, class_) - BytesPerWord),
BytesPerWord); BytesPerWord);
} }
@ -2290,7 +2290,7 @@ inline uintptr_t&
extendedWord(Thread* t UNUSED, object o, unsigned baseSize) extendedWord(Thread* t UNUSED, object o, unsigned baseSize)
{ {
assert(t, objectExtended(t, o)); assert(t, objectExtended(t, o));
return cast<uintptr_t>(o, baseSize * BytesPerWord); return fieldAtOffset<uintptr_t>(o, baseSize * BytesPerWord);
} }
inline unsigned inline unsigned
@ -2792,7 +2792,7 @@ objectArrayLength(Thread* t UNUSED, object array)
{ {
assert(t, classFixedSize(t, objectClass(t, array)) == BytesPerWord * 2); assert(t, classFixedSize(t, objectClass(t, array)) == BytesPerWord * 2);
assert(t, classArrayElementSize(t, objectClass(t, array)) == BytesPerWord); assert(t, classArrayElementSize(t, objectClass(t, array)) == BytesPerWord);
return cast<uintptr_t>(array, BytesPerWord); return fieldAtOffset<uintptr_t>(array, BytesPerWord);
} }
inline object& inline object&
@ -2803,7 +2803,7 @@ objectArrayBody(Thread* t UNUSED, object array, unsigned index)
assert(t, classObjectMask(t, objectClass(t, array)) assert(t, classObjectMask(t, objectClass(t, array))
== classObjectMask(t, arrayBody == classObjectMask(t, arrayBody
(t, t->m->types, Machine::ArrayType))); (t, t->m->types, Machine::ArrayType)));
return cast<object>(array, ArrayBody + (index * BytesPerWord)); return fieldAtOffset<object>(array, ArrayBody + (index * BytesPerWord));
} }
unsigned unsigned
@ -2839,7 +2839,7 @@ inline bool
atomicCompareAndSwapObject(Thread* t, object target, unsigned offset, atomicCompareAndSwapObject(Thread* t, object target, unsigned offset,
object old, object new_) object old, object new_)
{ {
if (atomicCompareAndSwap(&cast<uintptr_t>(target, offset), if (atomicCompareAndSwap(&fieldAtOffset<uintptr_t>(target, offset),
reinterpret_cast<uintptr_t>(old), reinterpret_cast<uintptr_t>(old),
reinterpret_cast<uintptr_t>(new_))) reinterpret_cast<uintptr_t>(new_)))
{ {
@ -3473,7 +3473,7 @@ inline object
resolveClassInObject(Thread* t, object loader, object container, resolveClassInObject(Thread* t, object loader, object container,
unsigned classOffset, bool throw_ = true) unsigned classOffset, bool throw_ = true)
{ {
object o = cast<object>(container, classOffset); object o = fieldAtOffset<object>(container, classOffset);
loadMemoryBarrier(); loadMemoryBarrier();