X-Git-Url: https://deadsoftware.ru/gitweb?p=dsw-obn.git;a=blobdiff_plain;f=src%2Fbackends%2Fjvm%2Fgenerator-jvm-abi.c;h=2889ae3c718437b3220ae308ba0e446a9fec55bc;hp=fa34f1dfd8190149b12569aca64b7bc29b767d64;hb=023ef0d8349acdfe751bba1b50749361682f72ff;hpb=6e0d9d632fdf070f9777fe90b9add849562acaf2 diff --git a/src/backends/jvm/generator-jvm-abi.c b/src/backends/jvm/generator-jvm-abi.c index fa34f1d..2889ae3 100644 --- a/src/backends/jvm/generator-jvm-abi.c +++ b/src/backends/jvm/generator-jvm-abi.c @@ -15,48 +15,50 @@ #include "generator-jvm-asm.h" #include "generator-jvm-basic.h" -/* - * --- Каждый модуль является объектом. - * Импортируемые модули представляются полями. - * Каждая глобальная переменная представляется не статическим полем. - * Каждая процедура представляется не статическим метеодом. - * Процедура инициализации модуля имеет название BEGIN. - * Процедура финализации модуля имеет название END. - * Это позволит сделать динамическую загрузку и выгрузку. - * +++ всем переменным и полям в дескриптор добавляется "[" - * Это позволит делать ссылки на переменные в VAR-параметрах. - * --- Каждая процедура снабжается параметром-фреймом. - * Это позволит реализовать локальные процедуры и средства рефлекции над стеком. - */ - void jvm_generate_ldst_prepare(gen_proc_t * p, gen_var_t * v) { - char * desc; - char * full_name; + char * desc = v -> type -> desc; + char * full_name = v -> full_name; switch(v -> storage) { case JVM_STORAGE_REGISTER: - break; case JVM_STORAGE_STATIC: - full_name = v -> full_name; - desc = v -> type -> desc; + case JVM_STORAGE_FIELD: + case JVM_STORAGE_PARAM: + break; + case JVM_STORAGE_REGISTER_VAR: + case JVM_STORAGE_PARAM_VAR: + jvm_generate(p, 0, 1, "aload %i", v -> reg); + jvm_generate(p, 0, 1, "iconst_0"); + break; + case JVM_STORAGE_STATIC_VAR: jvm_generate(p, 0, 1, "getstatic %s [%s", full_name, desc); jvm_generate(p, 0, 1, "iconst_0"); break; - case JVM_STORAGE_FIELD: - full_name = v -> full_name; - desc = v -> type -> desc; + case JVM_STORAGE_FIELD_VAR: jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc); jvm_generate(p, 0, 1, "iconst_0"); break; - case JVM_STORAGE_LOCAL: + case JVM_STORAGE_PARAM_VARPTR: jvm_generate(p, 0, 1, "aload %i", v -> reg); + jvm_generate(p, 0, 1, "iload %i", v -> reg + 1); + break; + case JVM_STORAGE_FRAME: + case JVM_STORAGE_FRAME_PARAM: + jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]); + break; + case JVM_STORAGE_FRAME_VAR: + case JVM_STORAGE_FRAME_PARAM_VAR: + jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]); + jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc); jvm_generate(p, 0, 1, "iconst_0"); break; - case JVM_STORAGE_VARPTR: - jvm_generate(p, 0, 1, "aload %i", v -> reg); - jvm_generate(p, 0, 1, "iload %i", v -> reg + 1); + case JVM_STORAGE_FRAME_PARAM_VARPTR: + jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]); + jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc); + jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]); + jvm_generate(p, 1, 1, "getfield %s$offset I", full_name); break; default: gen_error("jvm_abi_obn_generate_ldst_prepare: wat %i", v -> storage); @@ -67,19 +69,38 @@ void jvm_generate_load(gen_proc_t * p, gen_var_t * src) { char prefix = src -> type -> prefix; + char postfix = src -> type -> postfix; int cell_size = src -> type -> cell_size; + char * full_name = src -> full_name; + char * desc = src -> type -> desc; switch(src -> storage) { case JVM_STORAGE_REGISTER: + case JVM_STORAGE_PARAM: jvm_generate(p, 0, cell_size, "%cload %i", prefix, src -> reg); break; case JVM_STORAGE_STATIC: + jvm_generate(p, 0, cell_size, "getstatic %s %s", full_name, desc); + break; case JVM_STORAGE_FIELD: - case JVM_STORAGE_LOCAL: - case JVM_STORAGE_VARPTR: + jvm_generate(p, 0, cell_size, "getfield %s %s", full_name, desc); + break; + case JVM_STORAGE_REGISTER_VAR: + case JVM_STORAGE_STATIC_VAR: + case JVM_STORAGE_FIELD_VAR: + case JVM_STORAGE_PARAM_VAR: + case JVM_STORAGE_PARAM_VARPTR: + case JVM_STORAGE_FRAME_VAR: + case JVM_STORAGE_FRAME_PARAM_VAR: + case JVM_STORAGE_FRAME_PARAM_VARPTR: jvm_generate_ldst_prepare(p, src); - jvm_generate(p, 1 + 1, cell_size, "%caload", prefix); + jvm_generate(p, 1 + 1, cell_size, "%caload", postfix); + break; + case JVM_STORAGE_FRAME: + case JVM_STORAGE_FRAME_PARAM: + jvm_generate_ldst_prepare(p, src); + jvm_generate(p, 1, cell_size, "getfield %s %s", full_name, desc); break; default: gen_error("jvm_generate_load: unknow storage type %i", src -> storage); @@ -91,18 +112,36 @@ void jvm_generate_store(gen_proc_t * p, gen_var_t * dst) { char prefix = dst -> type -> prefix; + char postfix = dst -> type -> postfix; int cell_size = dst -> type -> cell_size; + char * full_name = dst -> full_name; + char * desc = dst -> type -> desc; switch(dst -> storage) { case JVM_STORAGE_REGISTER: + case JVM_STORAGE_PARAM: jvm_generate(p, cell_size, 0, "%cstore %i", prefix, dst -> reg); break; case JVM_STORAGE_STATIC: + jvm_generate(p, 0, cell_size, "putstatic %s %s", full_name, desc); + break; case JVM_STORAGE_FIELD: - case JVM_STORAGE_LOCAL: - case JVM_STORAGE_VARPTR: - jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", prefix); + jvm_generate(p, 0, cell_size, "putfield %s %s", full_name, desc); + break; + case JVM_STORAGE_REGISTER_VAR: + case JVM_STORAGE_STATIC_VAR: + case JVM_STORAGE_FIELD_VAR: + case JVM_STORAGE_PARAM_VAR: + case JVM_STORAGE_PARAM_VARPTR: + case JVM_STORAGE_FRAME_VAR: + case JVM_STORAGE_FRAME_PARAM_VAR: + case JVM_STORAGE_FRAME_PARAM_VARPTR: + jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix); + break; + case JVM_STORAGE_FRAME: + case JVM_STORAGE_FRAME_PARAM: + jvm_generate(p, 0, cell_size, "putfield %s %s", full_name, desc); break; default: gen_error("jvm_generate_store: unknow storage type %i", dst -> storage); @@ -110,108 +149,533 @@ jvm_generate_store(gen_proc_t * p, gen_var_t * dst) } } -void -jvm_generate_and_init_global_var(struct gen_class * class, gen_var_t * v, char * name, gen_type_t * t) +static gen_var_t * +jvm_new_var() { - assert(class -> p == NULL); - fprintf(class -> fp, ".field public static %s [%s\n\n", name, t -> desc); - - v -> storage = JVM_STORAGE_STATIC; - v -> full_name = new_string("%s/%s", class -> full_name, name); - v -> type = t; + gen_var_t * v = GC_MALLOC(sizeof *v); + memset(v, 0, sizeof *v); + return v; } -void -jvm_generate_and_init_field(struct gen_class * class, gen_var_t * v, char * name, gen_type_t * t) +gen_var_t * +jvm_create_class_var(struct gen_class * class, enum gen_storage storage, char * name, gen_type_t * t) { + gen_var_t * v = jvm_new_var(); + v -> storage = storage; + v -> name = new_string(name); + v -> type = t; + v -> class = class; + assert(class -> p == NULL); - fprintf(class -> fp, ".field public %s [%s\n\n", name, t -> desc); + switch(storage) + { + case JVM_STORAGE_STATIC: + case JVM_STORAGE_FIELD: + case JVM_STORAGE_STATIC_VAR: + case JVM_STORAGE_FIELD_VAR: + v -> full_name = new_string("%s/%s", class -> full_name, name); + break; + default: + gen_error("jvm_create_class_var: invalid storage %i", storage); + break; + } - v -> storage = JVM_STORAGE_FIELD; - v -> full_name = new_string("%s/%s", class -> full_name, name); - v -> type = t; + return v; } -void -jvm_generate_and_init_local_var(gen_proc_t * p, gen_var_t * v, gen_type_t * t) +gen_var_t * +jvm_create_function_var(gen_proc_t * p, enum gen_storage storage, char * name, gen_type_t * t) { - v -> storage = JVM_STORAGE_REGISTER; - v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide); + gen_var_t * v = jvm_new_var(); + v -> storage = storage; + v -> name = new_string(name); v -> type = t; + v -> p = p; + v -> level = p -> level; + + switch(storage) + { + case JVM_STORAGE_REGISTER: + case JVM_STORAGE_PARAM: + case JVM_STORAGE_PARAM_VAR: + v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide); + break; + case JVM_STORAGE_PARAM_VARPTR: + /* Содержит пару массив+индекс */ + v -> reg = jvm_alloc_register_untyped(p -> rf, true); + break; + case JVM_STORAGE_REGISTER_VAR: + /* Содержит массив */ + v -> reg = jvm_alloc_register_untyped(p -> rf, false); + break; + case JVM_STORAGE_FRAME: + case JVM_STORAGE_FRAME_VAR: + v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name); + break; + case JVM_STORAGE_FRAME_PARAM: + case JVM_STORAGE_FRAME_PARAM_VAR: + v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide); + v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name); + break; + case JVM_STORAGE_FRAME_PARAM_VARPTR: + /* Содержит пару массив+индекс */ + v -> reg = jvm_alloc_register_untyped(p -> rf, true); + v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name); + break; + default: + gen_error("jvm_create_class_var: invalid storage %i", storage); + break; + } + + return v; } -void -jvm_init_named_local_var(gen_proc_t * p, gen_var_t * v, gen_type_t * t) +gen_var_t * +jvm_create_function_temp_var(gen_proc_t * p, gen_type_t * t) { + gen_var_t * v = jvm_new_var(); v -> storage = JVM_STORAGE_REGISTER; v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide); + v -> name = new_string("$TEMP_%i$", v -> reg); v -> type = t; + v -> p = p; + v -> level = p -> level; + return v; } void -jvm_init_param(gen_proc_t * p, gen_var_t * v, gen_type_t * t) +jvm_generate_var(gen_var_t * v) { - v -> storage = JVM_STORAGE_LOCAL; - v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide); - v -> type = t; + enum gen_storage storage = v -> storage; + int reg = v -> reg; + char * name = v -> name; + char * desc = v -> type -> desc; + gen_proc_t * p = v -> p; + + switch(v -> storage) + { + case JVM_STORAGE_REGISTER: + case JVM_STORAGE_PARAM: + case JVM_STORAGE_PARAM_VAR: + case JVM_STORAGE_FRAME: + case JVM_STORAGE_FRAME_VAR: + case JVM_STORAGE_FRAME_PARAM: + case JVM_STORAGE_FRAME_PARAM_VAR: + jvm_generate(p, 0, 0, ".var %i is '%s' %s from start to end", reg, name, desc); + break; + case JVM_STORAGE_REGISTER_VAR: + jvm_generate(p, 0, 0, ".var %i is '%s' [%s from start to end", reg, name, desc); + break; + case JVM_STORAGE_PARAM_VARPTR: + case JVM_STORAGE_FRAME_PARAM_VARPTR: + jvm_generate(p, 0, 0, ".var %i is '%s' [%s from start to end", reg, name, desc); + jvm_generate(p, 0, 0, ".var %i is '%s$offset' I from start to end", reg + 1, name); + break; + case JVM_STORAGE_STATIC: + fprintf(v -> class -> fp, ".field public static '%s' %s\n\n", name, desc); + break; + case JVM_STORAGE_STATIC_VAR: + fprintf(v -> class -> fp, ".field public static '%s' [%s\n\n", name, desc); + break; + case JVM_STORAGE_FIELD: + fprintf(v -> class -> fp, ".field public '%s' %s\n\n", name, desc); + break; + case JVM_STORAGE_FIELD_VAR: + fprintf(v -> class -> fp, ".field public '%s' [%s\n\n", name, desc); + break; + default: + gen_error("jvm_generate_var: invalid storage %i", storage); + break; + } } -void -jvm_init_var_param(gen_proc_t * p, gen_var_t * v, gen_type_t * t) +static void +jvm_generate_param_initialization(gen_proc_t * p, gen_var_t * v) { - v -> storage = JVM_STORAGE_VARPTR; - v -> reg = jvm_alloc_register_untyped(p -> rf, true); - v -> type = t; + int old_reg = v -> reg; + int cell_size = v -> type -> cell_size; + char prefix = v -> type -> prefix; + char postfix = v -> type -> postfix; + char * name = v -> name; + char * desc = v -> type -> desc; + + v -> reg = jvm_alloc_register_untyped(p -> rf, false); + jvm_generate(p, 0, 0, ".var %i is $%s [%s from start to end", v -> reg, name, desc); + + jvm_generate(p, 0, 1, "iconst_1"); + jvm_generate(p, 1, 1, "multianewarray [%s 1", desc); + jvm_generate(p, 1, 2, "dup"); + jvm_generate(p, 1, 0, "astore %i", v -> reg); + + jvm_generate(p, 0, 1, "iconst_0"); + jvm_generate(p, 0, cell_size, "%cload %i", prefix, old_reg); + jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix); } void -jvm_generate_variable_initialization(gen_proc_t * p, gen_var_t * v) +jvm_generate_var_initialization(gen_proc_t * p, gen_var_t * v) { - if(v -> storage == JVM_STORAGE_STATIC) + if(v -> storage == JVM_STORAGE_REGISTER_VAR) + { + jvm_generate(p, 0, 1, "iconst_1"); + jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc); + jvm_generate(p, 1, 0, "astore %i", v -> reg); + } + else if(v -> storage == JVM_STORAGE_STATIC_VAR) { jvm_generate(p, 0, 1, "iconst_1"); jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc); jvm_generate(p, 1, 0, "putstatic %s [%s", v -> full_name, v -> type -> desc); } - else if(v -> storage == JVM_STORAGE_FIELD) + else if(v -> storage == JVM_STORAGE_FIELD_VAR) { jvm_generate(p, 0, 1, "iconst_1"); jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc); jvm_generate(p, 1, 0, "putfield %s [%s", v -> full_name, v -> type -> desc); } + else if(v -> storage == JVM_STORAGE_PARAM_VAR) + { + jvm_generate_param_initialization(p, v); + } + else if(v -> storage == JVM_STORAGE_FRAME_PARAM + || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR) + { + jvm_generate_ldst_prepare(p, v); + jvm_generate(p, 0, v -> type -> cell_size, "%cload %i", v -> type -> prefix, v -> reg); + jvm_generate_store(p, v); + } + else if(v -> storage == JVM_STORAGE_FRAME_PARAM_VARPTR) + { + jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]); + jvm_generate(p, 0, 1, "aload %i", v -> reg); + jvm_generate(p, 1, 0, "putfield %s [%s", v -> full_name, v -> type -> desc); + + jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]); + jvm_generate(p, 0, 1, "iload %i", v -> reg + 1); + jvm_generate(p, 1, 0, "putfield %s$offset I", v -> full_name); + } } -void -jvm_generate_named_local_var_initialization(gen_proc_t * p, gen_var_t * v, char * name) +/* +static void +jvm_generate_abstract_frame_class() { - jvm_generate(p, 0, 0, ".var %i is %s %s from start to end", v -> reg, name, v -> type -> desc); + FILE * fp; + char * cname; + struct gen_class * class; + + cname = "SYSTEM$FRAME"; + class = jvm_create_class(cname); + fp = class -> fp; + + fprintf(fp, ".source SYSTEM\n"); + fprintf(fp, ".class public abstract %s\n", cname); + fprintf(fp, ".super java/lang/Object\n\n"); + + fprintf(fp, ".field public $UP L%s;\n\n", cname); + + fprintf(fp, ".method ()V\n"); + fprintf(fp, " aload_0\n"); + fprintf(fp, " invokespecial java/lang/Object/()V\n"); + fprintf(fp, " return\n"); + fprintf(fp, ".end method\n\n"); + + jvm_destroy_class(class); +} +*/ + +static struct gen_class * +jvm_generate_frame_class(oberon_object_t * proc) +{ + FILE * fp; + char * cname; + char * abscname; + struct gen_class * class; + oberon_object_t * var; + + abscname = "SYSTEM$FRAME"; + cname = jvm_get_field_full_name_safe(proc); + cname = new_string("%s$FRAME", cname); + class = jvm_create_class(proc -> gen_proc -> class -> dir, cname); + fp = class -> fp; + + class -> full_name = cname; + + fprintf(fp, ".source %s\n", proc -> module -> name); + fprintf(fp, ".class public %s\n", cname); + fprintf(fp, ".super %s\n\n", abscname); + + var = proc -> scope -> list -> next; + while(var) + { + if(var -> class == OBERON_CLASS_VAR + || var -> class == OBERON_CLASS_PARAM + || var -> class == OBERON_CLASS_VAR_PARAM) + { + gen_var_t * v = var -> gen_var; + if(v -> storage == JVM_STORAGE_FRAME + || v -> storage == JVM_STORAGE_FRAME_PARAM) + { + fprintf(fp, "; LEVEL %i\n", v -> level); + fprintf(fp, ".field public '%s' %s\n\n", v -> name, v -> type -> desc); + } + else if(v -> storage == JVM_STORAGE_FRAME_VAR + || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR) + { + fprintf(fp, "; LEVEL %i\n", v -> level); + fprintf(fp, ".field public '%s' [%s\n\n", v -> name, v -> type -> desc); + } + else if(v -> storage == JVM_STORAGE_FRAME_PARAM_VARPTR) + { + fprintf(fp, "; LEVEL %i\n", v -> level); + fprintf(fp, ".field public '%s' [%s\n", v -> name, v -> type -> desc); + fprintf(fp, ".field public '%s$offset' I\n\n", v -> name); + } + } + var = var -> next; + } + + fprintf(fp, ".method ()V\n"); + fprintf(fp, " .limit stack 2\n"); + fprintf(fp, " aload_0\n"); + fprintf(fp, " invokespecial %s/()V\n", abscname); + + var = proc -> scope -> list -> next; + while(var) + { + if(var -> class == OBERON_CLASS_VAR + || var -> class == OBERON_CLASS_PARAM + || var -> class == OBERON_CLASS_VAR_PARAM) + { + gen_var_t * v = var -> gen_var; + if(v -> storage == JVM_STORAGE_FRAME_VAR + || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR) + { + fprintf(fp, " aload_0\n"); + fprintf(fp, " iconst_1\n"); + fprintf(fp, " multianewarray [%s 1\n", v -> type -> desc); + fprintf(fp, " putfield %s [%s\n", v -> full_name, v -> type -> desc); + } + } + var = var -> next; + } + + fprintf(fp, " return\n"); + fprintf(fp, ".end method\n\n"); + + jvm_destroy_class(class); + + return class; } void -jvm_generate_param_initialization(gen_proc_t * p, gen_var_t * v, char * name) +jvm_generate_procedure_frame(oberon_object_t * proc) { - int old_reg = v -> reg; - bool wide = v -> type -> wide; - int cell_size = v -> type -> cell_size; - char prefix = v -> type -> prefix; - char * desc = v -> type -> desc; + gen_proc_t * p; + gen_type_t * t; + gen_var_t * v; + struct gen_class * class; - jvm_generate(p, 0, 0, ".var %i is %s %s from start to end", old_reg, name, desc); - v -> reg = jvm_alloc_register_untyped(p -> rf, wide); + p = proc -> gen_proc; - jvm_generate(p, 0, 1, "iconst_1"); - jvm_generate(p, 1, 1, "multianewarray [%s 1", desc); +// jvm_generate_abstract_frame_class(); + + class = jvm_generate_frame_class(proc); + + t = GC_MALLOC(sizeof *t); + memset(t, 0, sizeof *t); + t -> class = class; + t -> wide = false; + t -> prefix = 'a'; + t -> postfix = 'a'; + t -> cell_size = 1; + t -> desc = new_string("L%s;", class -> full_name); + + v = jvm_create_function_var(p, JVM_STORAGE_REGISTER, "$FP$", t); + p -> frame_v = v; + p -> reg_frame[p -> level] = v -> reg; +} + +void +jvm_generate_frame_initialization(gen_proc_t * p) +{ + jvm_generate_var(p -> frame_v); + jvm_generate_ldst_prepare(p, p -> frame_v); + jvm_generate(p, 0, 1, "new %s", p -> frame_v -> type -> class -> full_name); jvm_generate(p, 1, 2, "dup"); - jvm_generate(p, 1, 0, "astore %i", v -> reg); + jvm_generate(p, 1, 0, "invokespecial %s/()V", p -> frame_v -> type -> class -> full_name); + jvm_generate_store(p, p -> frame_v); +} - jvm_generate(p, 0, 1, "iconst_0"); - jvm_generate(p, 0, cell_size, "%cload %i", prefix, old_reg); - jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", prefix); +char * +jvm_get_procedure_signature(oberon_type_t * ps) +{ + char * signature; + char * desc; + int num; + oberon_object_t * arg; + + signature = new_string("("); + + num = ps -> num_decl; + arg = ps -> decl; + for(int i = 0; i < num; i++) + { + desc = jvm_get_descriptor(arg -> type); + if(arg -> class == OBERON_CLASS_VAR_PARAM) + { + signature = new_string("%s[%sI", signature, desc); + } + else + { + signature = new_string("%s%s", signature, desc); + } + arg = arg -> next; + } + + desc = jvm_get_descriptor(ps -> base); + signature = new_string("%s)%s", signature, desc); + + return signature; +} + +static char * +jvm_get_frame_descriptor(oberon_object_t * proc) +{ + char * full_name = jvm_get_field_full_name_safe(proc); + return new_string("L%s$FRAME;", full_name); +} + +static char * +jvm_get_oberon_signature_static_links(oberon_object_t * parent) +{ + if(parent == NULL) + { + return ""; + } + + char * up = jvm_get_oberon_signature_static_links(parent -> parent); + char * desc = jvm_get_frame_descriptor(parent); + return new_string("%s%s", up, desc); +} + +char * +jvm_get_local_procedure_signature(oberon_object_t * proc) +{ + char * stlinks; + char * signature; + char * desc; + int num; + oberon_object_t * arg; + oberon_type_t * ps; + + ps = proc -> type; + + signature = new_string("("); + + if(proc -> local) + { + stlinks = jvm_get_oberon_signature_static_links(proc -> parent); + signature = new_string("%s%s", signature, stlinks); + } + + num = ps -> num_decl; + arg = ps -> decl; + for(int i = 0; i < num; i++) + { + desc = jvm_get_descriptor(arg -> type); + if(arg -> class == OBERON_CLASS_VAR_PARAM) + { + signature = new_string("%s[%sI", signature, desc); + } + else + { + signature = new_string("%s%s", signature, desc); + } + arg = arg -> next; + } + + desc = jvm_get_descriptor(ps -> base); + signature = new_string("%s)%s", signature, desc); + + return signature; +} + + +static void +jvm_generate_staticlinks_recursive(gen_proc_t * p, oberon_object_t * parent, int level) +{ + if(parent == NULL) + { + return; + } + + jvm_generate_staticlinks_recursive(p, parent -> parent, level - 1); + int reg = p -> reg_frame[level]; + char * desc = jvm_get_frame_descriptor(parent); + jvm_generate(p, 0, 0, ".var %i is SL$%i %s from start to end", reg, level, desc); +} + +void +jvm_generate_staticlinks(oberon_object_t * proc) +{ + gen_proc_t * p; + + p = proc -> gen_proc; + + jvm_generate_staticlinks_recursive(p, proc -> parent, p -> level); +} + +static void +jvm_create_staticlinks_recursive(gen_proc_t * p, oberon_object_t * parent, int level) +{ + if(parent == NULL) + { + return; + } + + jvm_create_staticlinks_recursive(p, parent -> parent, level - 1); + p -> reg_frame[level] = jvm_alloc_register_untyped(p -> rf, false); +} + +void +jvm_create_static_links(oberon_object_t * proc) +{ + gen_proc_t * p; + p = proc -> gen_proc; + + int max_frames = 0; + oberon_object_t * prc = proc; + while(prc) + { + max_frames += 1; + prc = prc -> parent; + } + + size_t sz = sizeof(*p -> reg_frame) * max_frames; + p -> max_frames = max_frames; + p -> reg_frame = GC_MALLOC(sz); + memset(p -> reg_frame, 0, sz); + + p -> level = max_frames - 1; + jvm_create_staticlinks_recursive(p, proc -> parent, p -> level); +} + +static void +jvm_generate_push_static_links_recursive(gen_proc_t * p, oberon_object_t * parent) +{ + if(parent == NULL) + { + return; + } + + jvm_generate_push_static_links_recursive(p, parent -> parent); + int level = parent -> gen_proc -> level; + jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[level]); } void -jvm_generate_var_param_initialization(gen_proc_t * p, gen_var_t * v, char * name) +jvm_generate_push_static_links(gen_proc_t * p, oberon_object_t * proc) { - jvm_generate(p, 0, 0, ".var %i is %s [%s from start to end", v -> reg, name, v -> type -> desc); - jvm_generate(p, 0, 0, ".var %i is __%s_offset I from start to end", v -> reg + 1, name); + jvm_generate_push_static_links_recursive(p, proc -> parent); }