bilbo/jvm
1
0
Fork 0
Code Pull Requests Activity

class_resolver: resolve static fields from superclasses

Browse Source
This commit is contained in:
Zack Buhman 2025-01-11 16:25:10 -06:00
parent ec525bbfbc
commit a9b40c9521
7 changed files with 285 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -10,7 +10,7 @@ CFLAGS += -Wall -Werror -Wfatal-errors -Wno-error=unused-variable -fstack-protec
CFLAGS += -I$(MAKEFILE_PATH)/
CFLAGS += -I$(MAKEFILE_PATH)/c
CFLAGS += -DDEBUG
CFLAGS += -DDEBUG_PRINT
#CFLAGS += -DDEBUG_PRINT
LDFLAGS = -lm
OPT ?= -O0
DEPFLAGS = -MMD -MP

285
c/class_resolver.c
View File

@ -20,9 +20,7 @@
static int field_info_field_size(struct class_file * class_file, struct field_info * field_info)
{
struct constant * field_descriptor_constant = &class_file->constant_pool[field_info->descriptor_index - 1];
#ifdef DEBUG
assert(field_descriptor_constant->tag == CONSTANT_Utf8);
#endif
return field_size(field_descriptor_constant->utf8.bytes[0]);
}
@ -86,6 +84,7 @@ static int add_superclass_instance_fields(int class_hash_table_length,
struct field_entry * field_entry = malloc_class_arena((sizeof (struct field_entry)));
field_entry->instance_index = instance_index;
field_entry->field_info = field_info;
field_entry->class_entry = class_entry;
struct constant * name_constant = &class_entry->class_file->constant_pool[field_info->name_index - 1];
assert(name_constant->tag == CONSTANT_Utf8);
@ -126,6 +125,7 @@ static int32_t class_resolver_create_fields_hash_table(int class_hash_table_leng
struct field_entry * field_entry = malloc_class_arena((sizeof (struct field_entry)));
field_entry->static_index = static_index;
field_entry->field_info = field_info;
field_entry->class_entry = class_entry;
static_index += field_info_field_size(class_entry->class_file, field_info);
struct constant * name_constant = &class_entry->class_file->constant_pool[field_info->name_index - 1];
@ -332,49 +332,83 @@ struct field_entry * class_resolver_lookup_field(int fields_hash_table_length,
int field_name_length)
{
debugf("class_resolver_lookup_field: ");
for (int i = 0; i < field_name_length; i++) { debugc(field_name[i]); }
debug_print__string(field_name, field_name_length);
debugc('\n');
struct hash_table_entry * e = hash_table_find(fields_hash_table_length,
fields_hash_table,
field_name,
field_name_length);
assert(e != nullptr);
debugf("%p\n", e->value);
if (e == nullptr)
return nullptr;
else
return (struct field_entry *)e->value;
}
struct field_entry * class_resolver_lookup_field_from_fieldref_index(int fields_hash_table_length,
struct hash_table_entry * fields_hash_table,
struct field_entry * resolve_field_entry_from_superclasses(int class_hash_table_length,
struct hash_table_entry * class_hash_table,
struct class_entry * class_entry,
int fieldref_index)
struct constant * field_name_constant)
{
if (class_entry->attribute_entry[fieldref_index - 1].field_entry != nullptr) {
debugf("class_resolver_lookup_field_from_fieldref_index %d: [cached]\n", fieldref_index);
return class_entry->attribute_entry[fieldref_index - 1].field_entry;
}
struct constant * fieldref_constant = &class_entry->class_file->constant_pool[fieldref_index - 1];
#ifdef DEBUG
assert(fieldref_constant->tag == CONSTANT_Fieldref);
#endif
struct constant * nameandtype_constant = &class_entry->class_file->constant_pool[fieldref_constant->fieldref.name_and_type_index - 1];
#ifdef DEBUG
assert(nameandtype_constant->tag == CONSTANT_NameAndType);
#endif
struct constant * field_name_constant = &class_entry->class_file->constant_pool[nameandtype_constant->nameandtype.name_index - 1];
#ifdef DEBUG
assert(field_name_constant->tag == CONSTANT_Utf8);
#endif
struct field_entry * field_entry = class_resolver_lookup_field(fields_hash_table_length,
fields_hash_table,
while (true) {
struct field_entry * field_entry = class_resolver_lookup_field(class_entry->fields.length,
class_entry->fields.entry,
field_name_constant->utf8.bytes,
field_name_constant->utf8.length);
if (field_entry != nullptr)
return field_entry;
if (class_entry->class_file->super_class == 0)
break;
struct constant * class_constant = &class_entry->class_file->constant_pool[class_entry->class_file->super_class - 1];
assert(class_constant->tag == CONSTANT_Class);
struct constant * class_name_constant = &class_entry->class_file->constant_pool[class_constant->class.name_index - 1];
assert(class_name_constant->tag == CONSTANT_Utf8);
// lookup the field from the superclass
class_entry = class_resolver_lookup_class_from_class_index(class_hash_table_length,
class_hash_table,
class_entry,
class_entry->class_file->super_class);
assert(class_entry != nullptr);
}
return nullptr;
}
struct field_entry * class_resolver_lookup_field_from_fieldref_index(int class_hash_table_length,
struct hash_table_entry * class_hash_table,
struct class_entry * origin_class_entry,
int fieldref_index)
{
if (origin_class_entry->attribute_entry[fieldref_index - 1].field_entry != nullptr) {
debugf("class_resolver_lookup_field_from_fieldref_index %d: [cached]\n", fieldref_index);
return origin_class_entry->attribute_entry[fieldref_index - 1].field_entry;
}
struct constant * fieldref_constant = &origin_class_entry->class_file->constant_pool[fieldref_index - 1];
assert(fieldref_constant->tag == CONSTANT_Fieldref);
struct constant * nameandtype_constant = &origin_class_entry->class_file->constant_pool[fieldref_constant->fieldref.name_and_type_index - 1];
assert(nameandtype_constant->tag == CONSTANT_NameAndType);
struct constant * field_name_constant = &origin_class_entry->class_file->constant_pool[nameandtype_constant->nameandtype.name_index - 1];
assert(field_name_constant->tag == CONSTANT_Utf8);
struct class_entry * field_class_entry = class_resolver_lookup_class_from_class_index(class_hash_table_length,
class_hash_table,
origin_class_entry,
fieldref_constant->fieldref.class_index);
assert(field_class_entry != nullptr);
struct field_entry * field_entry = resolve_field_entry_from_superclasses(class_hash_table_length,
class_hash_table,
field_class_entry,
field_name_constant);
assert(field_entry != nullptr);
// cache the result
class_entry->attribute_entry[fieldref_index - 1].field_entry = field_entry;
origin_class_entry->attribute_entry[fieldref_index - 1].field_entry = field_entry;
return field_entry;
}
@ -404,60 +438,67 @@ struct method_info * class_resolver_lookup_method(int methods_hash_table_length,
return (struct method_info *)e->value;
}
struct method_entry class_resolver_lookup_method_from_interfacemethodref_index(int class_hash_table_length,
struct hash_table_entry * class_hash_table,
int32_t interfacemethodref_index,
struct class_entry * objectref_class_entry,
struct class_entry * origin_class_entry)
static struct Code_attribute * resolve_code_attribute(struct class_entry * class_entry,
struct method_info * method_info)
{
struct constant * interfacemethodref_constant = &origin_class_entry->class_file->constant_pool[interfacemethodref_index - 1];
assert(interfacemethodref_constant->tag == CONSTANT_InterfaceMethodref || interfacemethodref_constant->tag == CONSTANT_Methodref);
struct constant * nameandtype_constant = &origin_class_entry->class_file->constant_pool[interfacemethodref_constant->interfacemethodref.name_and_type_index - 1];
assert(nameandtype_constant->tag == CONSTANT_NameAndType);
struct constant * method_name_constant = &origin_class_entry->class_file->constant_pool[nameandtype_constant->nameandtype.name_index - 1];
assert(method_name_constant->tag == CONSTANT_Utf8);
struct constant * method_descriptor_constant = &origin_class_entry->class_file->constant_pool[nameandtype_constant->nameandtype.descriptor_index - 1];
assert(method_descriptor_constant->tag == CONSTANT_Utf8);
struct class_entry * class_entry = objectref_class_entry;
while (true) {
struct method_info * method_info = class_resolver_lookup_method(class_entry->methods.length,
class_entry->methods.entry,
method_name_constant->utf8.bytes,
method_name_constant->utf8.length,
method_descriptor_constant->utf8.bytes,
method_descriptor_constant->utf8.length);
if (method_info != nullptr) {
debugf("method resolved:\n");
debugf(" class: ");
debug_print__class_file__class_name(class_entry->class_file);
debugf("\n method: ");
debug_print__method_info__method_name(class_entry->class_file, method_info);
debugc('\n');
if ((method_info->access_flags & METHOD_ACC_NATIVE) != 0) {
return nullptr;
}
int code_index = find_code_name_index(class_entry->class_file);
assert(code_index != 0);
struct attribute_info * attribute = find_attribute(code_index,
method_info->attributes_count,
method_info->attributes);
if ((method_info->access_flags & METHOD_ACC_NATIVE) != 0) {
return (struct method_entry){
.class_entry = class_entry,
.method_info = method_info,
.code_attribute = nullptr,
};
} else {
assert(attribute != nullptr);
return (struct method_entry){
.class_entry = class_entry,
.method_info = method_info,
.code_attribute = attribute->code,
};
return attribute->code;
}
static void resolve_method_entry(struct class_entry * class_entry,
struct constant * method_name_constant,
struct constant * method_descriptor_constant,
struct method_entry * method_entry)
{
struct method_info * method_info = class_resolver_lookup_method(class_entry->methods.length,
class_entry->methods.entry,
method_name_constant->utf8.bytes,
method_name_constant->utf8.length,
method_descriptor_constant->utf8.bytes,
method_descriptor_constant->utf8.length);
if (method_info == nullptr)
return;
method_entry->class_entry = class_entry;
method_entry->method_info = method_info;
method_entry->code_attribute = resolve_code_attribute(class_entry, method_info);
debugf("method resolved:\n");
debugf(" class: ");
debug_print__class_file__class_name(class_entry->class_file);
debugf("\n method: ");
debug_print__method_info__method_name(class_entry->class_file, method_info);
debugc('\n');
}
static void resolve_method_entry_from_superclasses(int class_hash_table_length,
struct hash_table_entry * class_hash_table,
struct class_entry * class_entry,
struct constant * method_name_constant,
struct constant * method_descriptor_constant,
struct method_entry * method_entry)
{
assert(method_entry != nullptr);
method_entry->method_info = nullptr;
while (true) {
resolve_method_entry(class_entry,
method_name_constant,
method_descriptor_constant,
method_entry);
if (method_entry->method_info != nullptr)
break;
if (class_entry->class_file->super_class == 0)
break;
@ -465,8 +506,6 @@ struct method_entry class_resolver_lookup_method_from_interfacemethodref_index(i
assert(class_constant->tag == CONSTANT_Class);
struct constant * class_name_constant = &class_entry->class_file->constant_pool[class_constant->class.name_index - 1];
assert(class_name_constant->tag == CONSTANT_Utf8);
debug_print__constant__utf8_string(class_name_constant);
debugf("\n");
// lookup the method from the superclass
class_entry = class_resolver_lookup_class_from_class_index(class_hash_table_length,
@ -475,19 +514,44 @@ struct method_entry class_resolver_lookup_method_from_interfacemethodref_index(i
class_entry->class_file->super_class);
assert(class_entry != nullptr);
}
print__class_file__class_name(objectref_class_entry->class_file);
printc('\n');
assert(!"interfacemethodref method does not exist");
}
struct method_entry * class_resolver_lookup_method_from_methodref_index(int class_hash_table_length,
struct method_entry class_resolver_lookup_method_from_objectref_class(int class_hash_table_length,
struct hash_table_entry * class_hash_table,
int32_t methodref_index,
struct class_entry * objectref_class_entry,
struct class_entry * origin_class_entry)
{
struct constant * methodref_constant = &origin_class_entry->class_file->constant_pool[methodref_index - 1];
assert(methodref_constant->tag == CONSTANT_InterfaceMethodref || methodref_constant->tag == CONSTANT_Methodref);
struct constant * nameandtype_constant = &origin_class_entry->class_file->constant_pool[methodref_constant->methodref.name_and_type_index - 1];
assert(nameandtype_constant->tag == CONSTANT_NameAndType);
struct constant * method_name_constant = &origin_class_entry->class_file->constant_pool[nameandtype_constant->nameandtype.name_index - 1];
assert(method_name_constant->tag == CONSTANT_Utf8);
struct constant * method_descriptor_constant = &origin_class_entry->class_file->constant_pool[nameandtype_constant->nameandtype.descriptor_index - 1];
assert(method_descriptor_constant->tag == CONSTANT_Utf8);
struct class_entry * class_entry = objectref_class_entry;
struct method_entry method_entry;
resolve_method_entry_from_superclasses(class_hash_table_length,
class_hash_table,
class_entry,
method_name_constant,
method_descriptor_constant,
&method_entry);
return method_entry;
}
struct method_entry * class_resolver_lookup_method_from_origin_class(int class_hash_table_length,
struct hash_table_entry * class_hash_table,
int32_t methodref_index,
struct class_entry * origin_class_entry)
{
if (origin_class_entry->attribute_entry[methodref_index - 1].method_entry != nullptr) {
debugf("class_resolver_lookup_method_from_methodref_index %d: [cached]\n", methodref_index);
debugf("class_resolver_lookup_method_from_origin_class %d: [cached]\n", methodref_index);
return origin_class_entry->attribute_entry[methodref_index - 1].method_entry;
}
@ -505,61 +569,20 @@ struct method_entry * class_resolver_lookup_method_from_methodref_index(int clas
origin_class_entry,
methodref_constant->methodref.class_index);
while (true) {
struct method_info * method_info = class_resolver_lookup_method(class_entry->methods.length,
class_entry->methods.entry,
method_name_constant->utf8.bytes,
method_name_constant->utf8.length,
method_descriptor_constant->utf8.bytes,
method_descriptor_constant->utf8.length);
if (method_info != nullptr) {
// cache the result
debugf("method resolved:\n");
debugf(" class: ");
debug_print__class_file__class_name(class_entry->class_file);
debugf("\n method: ");
debug_print__method_info__method_name(class_entry->class_file, method_info);
debugc('\n');
struct method_entry * method_entry = malloc_class_arena((sizeof (struct method_entry)));
method_entry->class_entry = class_entry;
method_entry->method_info = method_info;
int code_index = find_code_name_index(class_entry->class_file);
assert(code_index != 0);
struct attribute_info * attribute = find_attribute(code_index,
method_info->attributes_count,
method_info->attributes);
if ((method_info->access_flags & METHOD_ACC_NATIVE) != 0) {
assert(attribute == nullptr);
method_entry->code_attribute = nullptr;
} else {
assert(attribute != nullptr);
method_entry->code_attribute = attribute->code;
}
origin_class_entry->attribute_entry[methodref_index - 1].method_entry = method_entry;
return method_entry;
}
if (class_entry->class_file->super_class == 0)
break;
struct constant * class_constant = &class_entry->class_file->constant_pool[class_entry->class_file->super_class - 1];
assert(class_constant->tag == CONSTANT_Class);
struct constant * class_name_constant = &class_entry->class_file->constant_pool[class_constant->class.name_index - 1];
assert(class_name_constant->tag == CONSTANT_Utf8);
debug_print__constant__utf8_string(class_name_constant);
debugf("\n");
// lookup the method from the superclass
class_entry = class_resolver_lookup_class_from_class_index(class_hash_table_length,
resolve_method_entry_from_superclasses(class_hash_table_length,
class_hash_table,
class_entry,
class_entry->class_file->super_class);
assert(class_entry != nullptr);
}
method_name_constant,
method_descriptor_constant,
method_entry);
assert(!"methodref method does not exist");
assert(method_entry->method_info != nullptr);
origin_class_entry->attribute_entry[methodref_index - 1].method_entry = method_entry;
return method_entry;
}
struct method_entry class_resolver_lookup_method_from_method_name_method_descriptor(struct class_entry * class_entry,

9
c/class_resolver.h
View File

@ -26,6 +26,7 @@ union attribute_entry {
};
struct field_entry {
struct class_entry * class_entry;
struct field_info * field_info;
union {
int32_t instance_index;
@ -63,15 +64,17 @@ struct class_entry * class_resolver_lookup_class_from_class_index(int class_hash
struct hash_table_entry * class_hash_table,
struct class_entry * class_entry,
int32_t class_index);
struct method_entry class_resolver_lookup_method_from_interfacemethodref_index(int class_hash_table_length,
struct method_entry class_resolver_lookup_method_from_objectref_class(int class_hash_table_length,
struct hash_table_entry * class_hash_table,
int32_t interfacemethodref_index,
int32_t methodref_index,
struct class_entry * objectref_class_entry,
struct class_entry * origin_class_entry);
struct method_entry * class_resolver_lookup_method_from_methodref_index(int class_hash_table_length,
struct method_entry * class_resolver_lookup_method_from_origin_class(int class_hash_table_length,
struct hash_table_entry * class_hash_table,
int32_t methodref_index,
struct class_entry * origin_class_entry);
struct method_entry class_resolver_lookup_method_from_method_name_method_descriptor(struct class_entry * class_entry,
const uint8_t * method_name,
int method_name_length,

69
c/execute.c
View File

@ -734,20 +734,19 @@ void op_fsub(struct vm * vm)
void op_getfield(struct vm * vm, uint32_t index)
{
struct class_entry * class_entry;
struct field_entry * field_entry;
struct constant * field_descriptor_constant;
class_entry_field_entry_from_constant_index(vm, index,
&class_entry,
&field_entry,
&field_descriptor_constant);
debugf("getfield instance_index %d\n", field_entry->instance_index);
struct objectref * objectref = operand_stack_pop_ref(vm->current_frame);
if (objectref == nullptr)
return vm_exception(vm, vm_instance_create(vm, "java/lang/NullPointerException"));
struct constant * field_descriptor_constant;
struct field_entry * field_entry = field_entry_from_constant_index(vm->class_hash_table.length,
vm->class_hash_table.entry,
vm->current_frame->class_entry,
index,
&field_descriptor_constant);
debugf("getfield instance_index %d\n", field_entry->instance_index);
switch (field_descriptor_constant->utf8.bytes[0]) {
case 'B': [[fallthrough]];
case 'C': [[fallthrough]];
@ -778,18 +777,19 @@ void op_getfield(struct vm * vm, uint32_t index)
void op_getstatic(struct vm * vm, uint32_t index)
{
struct class_entry * class_entry;
struct field_entry * field_entry;
struct constant * field_descriptor_constant;
class_entry_field_entry_from_constant_index(vm, index,
&class_entry,
&field_entry,
struct field_entry * field_entry = field_entry_from_constant_index(vm->class_hash_table.length,
vm->class_hash_table.entry,
vm->current_frame->class_entry,
index,
&field_descriptor_constant);
/* On successful resolution of the field, the class or interface that
declared the resolved field is initialized if that class or interface has
not already been initialized (§5.5). */
struct class_entry * class_entry = field_entry->class_entry;
if (!vm_initialize_class(vm, class_entry))
return;
@ -1184,13 +1184,12 @@ void op_invokeinterface(struct vm * vm, uint32_t index, uint32_t count)
struct objectref * objectref = operand_stack_peek_ref(vm->current_frame, count);
if (objectref == nullptr)
return vm_exception(vm, vm_instance_create(vm, "java/lang/NullPointerException"));
struct class_entry * class_entry = objectref->class_entry;
struct method_entry method_entry =
class_resolver_lookup_method_from_interfacemethodref_index(vm->class_hash_table.length,
class_resolver_lookup_method_from_objectref_class(vm->class_hash_table.length,
vm->class_hash_table.entry,
index,
class_entry,
objectref->class_entry,
vm->current_frame->class_entry);
vm_special_method_call(vm, method_entry.class_entry, &method_entry);
@ -1200,9 +1199,9 @@ void op_invokespecial(struct vm * vm, uint32_t index)
{
struct class_entry * origin_class_entry = vm->current_frame->class_entry;
struct constant * interfacemethodref_constant = &origin_class_entry->class_file->constant_pool[index - 1];
assert(interfacemethodref_constant->tag == CONSTANT_Methodref);
struct constant * nameandtype_constant = &origin_class_entry->class_file->constant_pool[interfacemethodref_constant->interfacemethodref.name_and_type_index - 1];
struct constant * methodref_constant = &origin_class_entry->class_file->constant_pool[index - 1];
assert(methodref_constant->tag == CONSTANT_Methodref);
struct constant * nameandtype_constant = &origin_class_entry->class_file->constant_pool[methodref_constant->methodref.name_and_type_index - 1];
assert(nameandtype_constant->tag == CONSTANT_NameAndType);
struct constant * method_descriptor_constant = &origin_class_entry->class_file->constant_pool[nameandtype_constant->nameandtype.descriptor_index - 1];
assert(method_descriptor_constant->tag == CONSTANT_Utf8);
@ -1216,7 +1215,7 @@ void op_invokespecial(struct vm * vm, uint32_t index)
return vm_exception(vm, vm_instance_create(vm, "java/lang/NullPointerException"));
struct method_entry * method_entry =
class_resolver_lookup_method_from_methodref_index(vm->class_hash_table.length,
class_resolver_lookup_method_from_origin_class(vm->class_hash_table.length,
vm->class_hash_table.entry,
index,
vm->current_frame->class_entry);
@ -1227,7 +1226,7 @@ void op_invokespecial(struct vm * vm, uint32_t index)
void op_invokestatic(struct vm * vm, uint32_t index)
{
struct method_entry * method_entry =
class_resolver_lookup_method_from_methodref_index(vm->class_hash_table.length,
class_resolver_lookup_method_from_origin_class(vm->class_hash_table.length,
vm->class_hash_table.entry,
index,
vm->current_frame->class_entry);
@ -1257,13 +1256,12 @@ void op_invokevirtual(struct vm * vm, uint32_t index)
struct objectref * objectref = operand_stack_peek_ref(vm->current_frame, nargs + 1);
if (objectref == nullptr)
return vm_exception(vm, vm_instance_create(vm, "java/lang/NullPointerException"));
struct class_entry * class_entry = objectref->class_entry;
struct method_entry method_entry =
class_resolver_lookup_method_from_interfacemethodref_index(vm->class_hash_table.length,
class_resolver_lookup_method_from_objectref_class(vm->class_hash_table.length,
vm->class_hash_table.entry,
index,
class_entry,
objectref->class_entry,
vm->current_frame->class_entry);
vm_special_method_call(vm, method_entry.class_entry, &method_entry);
@ -1893,13 +1891,11 @@ void op_pop2(struct vm * vm)
void op_putfield(struct vm * vm, uint32_t index)
{
struct class_entry * class_entry;
struct field_entry * field_entry;
struct constant * field_descriptor_constant;
class_entry_field_entry_from_constant_index(vm,
struct field_entry * field_entry = field_entry_from_constant_index(vm->class_hash_table.length,
vm->class_hash_table.entry,
vm->current_frame->class_entry,
index,
&class_entry,
&field_entry,
&field_descriptor_constant);
/* The type of a value stored by a putfield instruction must be compatible
@ -1948,12 +1944,11 @@ void op_putfield(struct vm * vm, uint32_t index)
void op_putstatic(struct vm * vm, uint32_t index)
{
struct class_entry * class_entry;
struct field_entry * field_entry;
struct constant * field_descriptor_constant;
class_entry_field_entry_from_constant_index(vm, index,
&class_entry,
&field_entry,
struct field_entry * field_entry = field_entry_from_constant_index(vm->class_hash_table.length,
vm->class_hash_table.entry,
vm->current_frame->class_entry,
index,
&field_descriptor_constant);
/* The type of a value stored by a putstatic instruction must be compatible
@ -1968,6 +1963,8 @@ void op_putstatic(struct vm * vm, uint32_t index)
the resolved field is initialized if that class or interface has not
already been initialized (§5.5). */
struct class_entry * class_entry = field_entry->class_entry;
if (!vm_initialize_class(vm, class_entry))
return;

41
c/execute_helper.h
View File

@ -3,39 +3,24 @@ struct objectref * class_resolver_lookup_string(struct vm * vm,
struct class_entry * class_entry,
const int string_index);
static inline void class_entry_field_entry_from_constant_index(struct vm * vm,
static inline struct field_entry * field_entry_from_constant_index(int class_hash_table_length,
struct hash_table_entry * class_hash_table,
struct class_entry * origin_class_entry,
int32_t index,
struct class_entry ** class_entry,
struct field_entry ** field_entry,
struct constant ** field_descriptor_constant)
{
struct constant * fieldref_constant = &vm->current_frame->class_entry->class_file->constant_pool[index - 1];
#ifdef DEBUG
assert(fieldref_constant->tag == CONSTANT_Fieldref);
#endif
*class_entry = class_resolver_lookup_class_from_class_index(vm->class_hash_table.length,
vm->class_hash_table.entry,
vm->current_frame->class_entry,
fieldref_constant->fieldref.class_index);
assert(*class_entry != nullptr);
int fields_hash_table_length = (*class_entry)->fields.length;
struct hash_table_entry * fields_hash_table = (*class_entry)->fields.entry;
*field_entry = class_resolver_lookup_field_from_fieldref_index(fields_hash_table_length,
fields_hash_table,
vm->current_frame->class_entry,
struct field_entry * field_entry = class_resolver_lookup_field_from_fieldref_index(class_hash_table_length,
class_hash_table,
origin_class_entry,
index);
assert(*field_entry != nullptr);
assert(field_entry != nullptr);
struct constant * nameandtype_constant = &vm->current_frame->class_entry->class_file->constant_pool[fieldref_constant->fieldref.name_and_type_index - 1];
#ifdef DEBUG
struct constant * fieldref_constant = &origin_class_entry->class_file->constant_pool[index - 1];
assert(fieldref_constant->tag == CONSTANT_Fieldref);
struct constant * nameandtype_constant = &origin_class_entry->class_file->constant_pool[fieldref_constant->fieldref.name_and_type_index - 1];
assert(nameandtype_constant->tag == CONSTANT_NameAndType);
#endif
*field_descriptor_constant = &vm->current_frame->class_entry->class_file->constant_pool[nameandtype_constant->nameandtype.descriptor_index - 1];
#ifdef DEBUG
*field_descriptor_constant = &origin_class_entry->class_file->constant_pool[nameandtype_constant->nameandtype.descriptor_index - 1];
assert((*field_descriptor_constant)->tag == CONSTANT_Utf8);
#endif
return field_entry;
}

9
c/frame.c
View File

@ -110,14 +110,11 @@ bool vm_initialize_class(struct vm * vm, struct class_entry * class_entry)
struct constant * name_constant = &class_file->constant_pool[field_info->name_index - 1];
assert(name_constant->tag == CONSTANT_Utf8);
int fields_hash_table_length = class_entry->fields.length;
struct hash_table_entry * fields_hash_table = class_entry->fields.entry;
struct field_entry * field_entry = class_resolver_lookup_field(fields_hash_table_length,
fields_hash_table,
struct field_entry * field_entry = class_resolver_lookup_field(class_entry->fields.length,
class_entry->fields.entry,
name_constant->utf8.bytes,
name_constant->utf8.length);
assert(field_info != nullptr);
assert(field_entry != nullptr);
class_entry->static_fields[field_entry->static_index] = constantvalue->integer.bytes;
debugf(" constantvalue: %d\n", constantvalue->integer.bytes);
break;

48
classes/p/InheritanceTest.java → classes/test/TestInheritance.java
View File

@ -1,10 +1,14 @@
package p;
package test;
class A {
int egg;
static int baz = 3;
static int bleh = 4;
public A() {
egg = -1;
}
public int foo(int a) {
return a + baz;
}
@ -19,14 +23,7 @@ class B extends A {
}
}
class InheritanceTest {
static int test() {
B b = new B();
b.egg = 2;
//return b.bar(b.foo(4, 3));
return B.baz * A.baz;
}
class TestInheritance {
static void static_test() {
System.out.println("A:");
@ -35,10 +32,36 @@ class InheritanceTest {
System.out.println("B:");
System.out.println(B.baz);
System.out.println(B.bleh);
B.bleh = 33;
B.baz = 99;
System.out.println("A:");
System.out.println(A.baz);
System.out.println(A.bleh);
System.out.println("B:");
System.out.println(B.baz);
System.out.println(B.bleh);
/*
static_test:
A:
3
4
B:
5
4
A:
3
33
B:
99
33
*/
}
static int instance_test() {
B b = new B();
System.out.println(b.egg);
b.egg = 1;
b.horse = 2;
@ -61,6 +84,13 @@ class InheritanceTest {
}
public static void main() {
System.out.println("static_test:");
static_test();
/*
System.out.println("instance_test:");
System.out.println(instance_test());
System.out.println("method_test:");
method_test();
*/
}
}