X-Git-Url: https://deadsoftware.ru/gitweb?a=blobdiff_plain;f=src%2Fbackends%2Fjvm%2Fgenerator-jvm.c;h=d609ed8de96c216a30ac4ec9bceda90ec230583e;hb=ee7fd939ac99201466900fb3983aa90b980da5c3;hp=dc79ea11cd0cbb656036a37d67d9a512c46517ae;hpb=961fbb99dcba21ccb737db16c0cdb28d757a2de7;p=dsw-obn.git diff --git a/src/backends/jvm/generator-jvm.c b/src/backends/jvm/generator-jvm.c index dc79ea1..d609ed8 100644 --- a/src/backends/jvm/generator-jvm.c +++ b/src/backends/jvm/generator-jvm.c @@ -128,6 +128,19 @@ jvm_generate(gen_proc_t * p, unsigned get, unsigned push, char * format, ...) va_end(ptr); } +static void +jvm_generate_comment(gen_proc_t * p, char * format, ...) +{ + va_list ptr; + va_start(ptr, format); + + fprintf(p -> class -> fp, " ;;;; "); + vfprintf(p -> class -> fp, format, ptr); + fprintf(p -> class -> fp, "\n"); + + va_end(ptr); +} + static void jvm_generate_push_int(gen_proc_t * p, int64_t i) { @@ -153,7 +166,61 @@ jvm_generate_push_int(gen_proc_t * p, int64_t i) } else { - jvm_generate(p, 0, 2, "ldc2 %li", i); + jvm_generate(p, 0, 2, "ldc2_w %li", i); + } +} + +static void +jvm_generate_push_int_size(gen_proc_t * p, int64_t i, int size) +{ + int pushed_cell = 1; + + if(i == -1) + { + jvm_generate(p, 0, 1, "iconst_m1"); + } + else if(i >= 0 && i <= 5) + { + jvm_generate(p, 0, 1, "iconst_%li", i); + } + else if(i >= -128 && i <= 127) + { + jvm_generate(p, 0, 1, "bipush %li", i); + } + else if(i >= -32768 && i <= 32767) + { + jvm_generate(p, 0, 1, "sipush %li", i); + } + else if(i >= -2147483648 && i <= 2147483647) + { + jvm_generate(p, 0, 1, "ldc %li", i); + } + else + { + pushed_cell = 2; + jvm_generate(p, 0, 2, "ldc2_w %li", i); + } + + assert(size <= 8); + if(size > 4 && pushed_cell == 1) + { + jvm_generate(p, pushed_cell, 2, "i2l"); + } + else if(size <= 4) + { + if(pushed_cell > 1) + { + jvm_generate(p, 2, 1, "l2i"); + } + + if(size == 2) + { + jvm_generate(p, 1, 1, "i2s"); + } + else if(size == 1) + { + jvm_generate(p, 1, 1, "i2b"); + } } } @@ -191,7 +258,7 @@ jvm_generate_push_float(gen_proc_t * p, double f, int size) } else { - jvm_generate(p, 0, 2, "ldc2 %lf", f); + jvm_generate(p, 0, 2, "ldc2_w %lf", f); } } } @@ -610,10 +677,21 @@ jvm_generate_copy_array(gen_proc_t * p, oberon_type_t * arr) } } +static void +jvm_generate_push_procedure_pointer(gen_proc_t * p, oberon_object_t * proc) +{ + char * full_name = jvm_get_field_full_name_safe(proc); + char * desc = jvm_get_descriptor(proc -> type); + jvm_generate(p, 0, 1, "getstatic %s/pointer %s", full_name, desc); +} + // ========================================== // ========================================== // ========================================== +static void +push_item(gen_proc_t * p, oberon_item_t * item); + void oberon_generator_init_context(oberon_context_t * ctx) { @@ -644,7 +722,7 @@ oberon_generate_procedure_class(oberon_type_t * proc) fprintf(fp, ".class public abstract %s\n", cname); fprintf(fp, ".super java/lang/Object\n\n"); - fprintf(fp, ".method public ()V\n"); + fprintf(fp, ".method ()V\n"); fprintf(fp, " aload_0\n"); fprintf(fp, " invokespecial java/lang/Object/()V\n"); fprintf(fp, " return\n"); @@ -658,6 +736,92 @@ oberon_generate_procedure_class(oberon_type_t * proc) jvm_destroy_class(class); } +static void +oberon_generate_procedure_pointer_class(oberon_object_t * proc) +{ + FILE * fp; + char * cname; + char * abscname; + char * absdesc; + char * signature; + struct gen_class * class; + + cname = jvm_get_field_full_name_safe(proc); + class = jvm_create_class(cname); + abscname = jvm_get_class_full_name(proc -> type); + absdesc = jvm_get_descriptor(proc -> type); + fp = class -> fp; + + fprintf(fp, ".source %s\n", proc -> module -> name); + fprintf(fp, ".class public %s\n", cname); + fprintf(fp, ".super %s\n\n", abscname); + + fprintf(fp, ".field public static pointer %s\n\n", absdesc); + + fprintf(fp, ".method ()V\n"); + fprintf(fp, " aload_0\n"); + fprintf(fp, " invokespecial %s/()V\n", abscname); + fprintf(fp, " return\n"); + fprintf(fp, ".end method\n\n"); + + fprintf(fp, ".method static ()V\n"); + fprintf(fp, " .limit stack 2\n"); + fprintf(fp, " new %s\n", cname); + fprintf(fp, " dup\n"); + fprintf(fp, " invokespecial %s/()V\n", cname); + fprintf(fp, " putstatic %s/pointer %s\n", cname, absdesc); + fprintf(fp, " return\n"); + fprintf(fp, ".end method\n\n"); + + signature = jvm_get_procedure_signature(proc -> type); + + gen_proc_t * p; + gen_var_t * this_v; + + p = jvm_create_proc(class); + jvm_generate_function_header(p, "public", "invoke", signature); + + this_v = oberon_generator_new_var(); + jvm_generate_and_init_local_var(this_v, p, false); + + gen_var_t * v; + int use_size = 0; + int num = proc -> type -> num_decl; + oberon_object_t * arg = proc -> type -> decl; + for(int i = 0; i < num; i++) + { + v = oberon_generator_new_var(); + bool wide = jvm_is_wide_type(arg -> type); + char * desc = jvm_get_descriptor(arg -> type); + jvm_generate_and_init_named_local_var(v, p, wide, arg -> name, desc); + + jvm_generate_load(p, arg -> type, v); + + use_size += (wide) ? (2) : (1); + + arg = arg -> next; + } + + char * full_name = jvm_get_field_full_name(proc); + int cell_size = jvm_cell_size_for_type(proc -> type -> base); + + jvm_generate(p, use_size, cell_size, "invokestatic %s%s", full_name, signature); + + if(proc -> type -> base -> class == OBERON_TYPE_VOID) + { + jvm_generate(p, 0, 0, "return"); + } + else + { + char prefix = jvm_get_prefix(proc -> type -> base); + jvm_generate(p, cell_size, 0, "%creturn", prefix); + } + + jvm_generate_function_end(p); + + jvm_destroy_class(class); +} + static void oberon_generate_record_class(gen_module_t * m, oberon_type_t * rec) { @@ -673,7 +837,16 @@ oberon_generate_record_class(gen_module_t * m, oberon_type_t * rec) fprintf(class -> fp, ".source %s\n", rec -> module -> name); fprintf(class -> fp, ".class public %s\n", cname); - fprintf(class -> fp, ".super java/lang/Object\n\n"); + + if(rec -> base == NULL) + { + fprintf(class -> fp, ".super java/lang/Object\n\n"); + } + else + { + class -> base = rec -> base -> gen_type -> class; + fprintf(class -> fp, ".super %s\n\n", class -> base -> full_name); + } rec -> gen_type -> class = class; } @@ -692,6 +865,7 @@ oberon_generator_init_type(oberon_context_t * ctx, oberon_type_t * type) case OBERON_TYPE_BOOLEAN: case OBERON_TYPE_ARRAY: case OBERON_TYPE_REAL: + case OBERON_TYPE_CHAR: break; case OBERON_TYPE_RECORD: ; @@ -733,7 +907,14 @@ oberon_generator_init_record(oberon_context_t * ctx, oberon_type_t * rec) jvm_generate_function_header(p, "public", "", "()V"); jvm_alloc_register_untyped(p -> rf, false); jvm_generate(p, 0, 1, "aload_0"); - jvm_generate(p, 1, 0, "invokespecial java/lang/Object/()V"); + if(class -> base) + { + jvm_generate(p, 1, 0, "invokespecial %s/()V", class -> base -> full_name); + } + else + { + jvm_generate(p, 1, 0, "invokespecial java/lang/Object/()V"); + } num = rec -> num_decl; field = rec -> decl; for(int i = 0; i < num; i++) @@ -846,6 +1027,8 @@ oberon_generator_init_proc(oberon_context_t * ctx, oberon_object_t * proc) { gen_error("generator: local procedures not implemented"); } + + oberon_generate_procedure_pointer_class(proc); } void @@ -900,6 +1083,7 @@ oberon_generate_begin_module(oberon_context_t * ctx) jvm_generate_store(p, x -> type, x -> gen_var); } } + x = x -> next; } } @@ -1045,24 +1229,39 @@ oberon_generate_end_proc(oberon_context_t * ctx) } static void -jvm_generate_call_proc(gen_proc_t * p, oberon_expr_t * desig) +jvm_generate_call_proc(gen_proc_t * p, oberon_item_t * desig) { - assert(desig -> is_item); - assert(desig -> item.mode == MODE_CALL); - - oberon_object_t * proc; - char * fullname; - char * signature; + assert(desig -> var == NULL); + assert(desig -> mode == MODE_CALL); - proc = desig -> item.var; - fullname = jvm_get_field_full_name(proc); - signature = jvm_get_procedure_signature(proc -> type); + char * signature = NULL; + + bool direct_call = false; + if(desig -> parent -> mode == MODE_VAR) + { + if(desig -> parent -> var -> class == OBERON_CLASS_PROC) + { + direct_call = true; + } + } + + printf("direct_call == %i\n", direct_call); + + oberon_type_t * procsig; + procsig = desig -> parent -> result; + signature = jvm_get_procedure_signature(procsig); + + if(direct_call == false) + { + /* Загружаем указатель на процедуру */ + push_item(p, desig -> parent); + } int args_cells = 0; - int result_cells = jvm_cell_size_for_type(proc -> type -> base); + int result_cells = jvm_cell_size_for_type(procsig -> base); - int num = desig -> item.num_args; - oberon_expr_t * arg = desig -> item.args; + int num = desig -> num_args; + oberon_expr_t * arg = desig -> args; for(int i = 0; i < num; i++) { args_cells += jvm_cell_size_for_type(arg -> result); @@ -1070,13 +1269,23 @@ jvm_generate_call_proc(gen_proc_t * p, oberon_expr_t * desig) arg = arg -> next; } - jvm_generate(p, args_cells, result_cells, "invokestatic %s%s", fullname, signature); + if(direct_call) + { + char * full_name = jvm_get_field_full_name(desig -> parent -> var); + jvm_generate(p, args_cells, result_cells, "invokestatic %s%s", full_name, signature); + } + else + { + char * cname = jvm_get_class_full_name(procsig); + jvm_generate(p, 1 + args_cells, result_cells, "invokevirtual %s/invoke%s", cname, signature); + } } void oberon_generate_call_proc(oberon_context_t * ctx, oberon_expr_t * desig) { - jvm_generate_call_proc(ctx -> gen_context -> current_m -> class -> p, desig); + assert(desig -> is_item); + jvm_generate_call_proc(ctx -> mod -> gen_mod -> class -> p, (oberon_item_t *) desig); } void @@ -1117,38 +1326,75 @@ jvm_generate_expr_new_pointer(gen_proc_t * p, oberon_type_t * type, int num, obe jvm_generate_new(p, type -> base, num); } +static void +jvm_generate_cast_type(gen_proc_t * p, oberon_type_t * from, oberon_type_t * to) +{ + if(to -> class == OBERON_TYPE_RECORD || to -> class == OBERON_TYPE_POINTER) + { + char * full_name = jvm_get_class_full_name(to); + jvm_generate(p, 1, 1, "checkcast %s", full_name); + } + else + { + char prefix = jvm_get_prefix(from); + char postfix = jvm_get_postfix(to); + int from_cell_size = jvm_cell_size_for_type(from); + int to_cell_size = jvm_cell_size_for_type(to); + + jvm_generate_comment(p, "cast type class from %i(%i) to %i(%i)", from -> class, from -> size, to -> class, to -> size); + + if(prefix == postfix) + { + return; + } + + jvm_generate(p, from_cell_size, to_cell_size, "%c2%c", prefix, postfix); + } +} + static void push_item(gen_proc_t * p, oberon_item_t * item) { switch(item -> mode) { case MODE_VAR: - jvm_generate_load(p, item -> result, item -> var -> gen_var); + if(item -> var -> class == OBERON_CLASS_PROC) + { + jvm_generate_push_procedure_pointer(p, item -> var); + } + else + { + jvm_generate_load(p, item -> result, item -> var -> gen_var); + } break; case MODE_INTEGER: - jvm_generate_push_int(p, item -> integer); + case MODE_CHAR: + jvm_generate_push_int_size(p, item -> integer, item -> result -> size); break; case MODE_BOOLEAN: - jvm_generate_push_int(p, item -> boolean); + jvm_generate_push_int_size(p, item -> boolean, item -> result -> size); break; case MODE_CALL: - jvm_generate_call_proc(p, (oberon_expr_t *) item); + jvm_generate_call_proc(p, item); break; case MODE_INDEX: ; char postfix = jvm_get_postfix(item -> result); int cell_size = jvm_cell_size_for_postfix(postfix); - push_item(p, item -> parent); + assert(item -> parent -> is_item); + push_item(p, (oberon_item_t *) item -> parent); push_expr(p, item -> args); jvm_generate(p, 1 + 1, cell_size, "%caload", postfix); break; case MODE_FIELD: - push_item(p, item -> parent); + assert(item -> parent -> is_item); + push_item(p, (oberon_item_t *) item -> parent); jvm_generate_load(p, item -> result, item -> var -> gen_var); break; case MODE_DEREF: /* Все объекты в jvm представляются как указатели */ - push_item(p, item -> parent); + assert(item -> parent -> is_item); + push_item(p, (oberon_item_t *) item -> parent); break; case MODE_NIL: jvm_generate(p, 0, 1, "aconst_null"); @@ -1338,6 +1584,10 @@ push_operator(gen_proc_t * p, oberon_oper_t * oper) int op = oper -> op; switch(op) { + case OP_CAST: + push_expr(p, oper -> left); + jvm_generate_cast_type(p, oper -> left -> result, oper -> result); + break; case OP_UNARY_MINUS: case OP_BITWISE_NOT: case OP_LOGIC_NOT: @@ -1421,13 +1671,15 @@ store_expr(gen_proc_t * p, oberon_expr_t * dst, oberon_expr_t * src) ; char postfix = jvm_get_postfix(src -> result); int cell_size = jvm_cell_size_for_postfix(postfix); - push_item(p, item -> parent); + assert(item -> parent -> is_item); + push_item(p, (oberon_item_t *) item -> parent); push_expr(p, item -> args); push_expr(p, src); jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix); break; case MODE_FIELD: - push_item(p, item -> parent); + assert(item -> parent -> is_item); + push_item(p, (oberon_item_t *) item -> parent); push_expr(p, src); jvm_generate_store(p, src -> result, item -> var -> gen_var); break;