X-Git-Url: https://deadsoftware.ru/gitweb?a=blobdiff_plain;f=generator.c;h=94bc1696a8f54f281e8868cfa02d7a51f1800cb0;hb=c4d4a265b71124ad0e8588601cfc1d66aca84b96;hp=244296228ae3335b5de1b12047c3d90a8c7777b3;hpb=d3438ae51da4c98b47441911495f10e686191abd;p=dsw-obn.git diff --git a/generator.c b/generator.c index 2442962..94bc169 100644 --- a/generator.c +++ b/generator.c @@ -5,22 +5,21 @@ #include #include +#include + #include "oberon.h" #include "generator.h" -static void printcontext(oberon_context_t * ctx, char * s) +// ======================================================================= +// INTERNAL FUNCTIONS +// ======================================================================= + +static void * +__OBERON_ALLOC__ (size_t bytes) { -/* - gen_context_t * gen_context = ctx -> gen_context; - gcc_jit_context * gcc_context = gen_context -> gcc_context; - gcc_jit_block * gcc_block = gen_context -> gcc_block; - - printf("%s:\n", s); - printf(" ctx = %p:\n", ctx); - printf(" gctx = %p:\n", gctx); - printf(" context = %p:\n", context); - printf(" block = %p:\n", block); -*/ + void * p = GC_MALLOC(bytes); + memset(p, 0, bytes); + return p; } // ======================================================================= @@ -57,14 +56,19 @@ oberon_generator_init_context(oberon_context_t * ctx) ctx -> gen_context = gen_context; gen_context -> gcc_context = gcc_context; - printcontext(ctx, "oberon_generator_init_context"); + gcc_jit_type * void_ptr_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_VOID_PTR); + gcc_jit_type * size_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_SIZE_T); + gcc_jit_type * alloc_ptr_type = gcc_jit_context_new_function_ptr_type( + gcc_context, NULL, void_ptr_type, 1, &size_type, 0 + ); + gen_context -> gcc_alloc = gcc_jit_context_new_global( + gcc_context, NULL, GCC_JIT_GLOBAL_EXPORTED, alloc_ptr_type, "__OBERON_ALLOC__" + ); } void oberon_generator_destroy_context(oberon_context_t * ctx) { - printcontext(ctx, "oberon_generator_destroy_context"); - gen_context_t * gen_context = ctx -> gen_context; gcc_jit_context * gcc_context = gen_context -> gcc_context; @@ -171,6 +175,46 @@ oberon_generator_init_record(oberon_context_t * ctx, oberon_type_t * type) //gcc_struct = gcc_jit_context_new_struct_type(gcc_context, NULL, "", num_fields, fields); } +static void +oberon_generator_get_full_name(char * name, int max_len, oberon_object_t * x) +{ + if(!x) + { + name[0] = 0; + return; + } + + int add_module_prefix; + switch(x -> class) + { + case OBERON_CLASS_FIELD: + case OBERON_CLASS_PARAM: + case OBERON_CLASS_VAR_PARAM: + /* В локальных областях префиксы излишни */ + add_module_prefix = 0; + break; + default: + add_module_prefix = 1; + break; + } + + char parent[256]; + oberon_generator_get_full_name(parent, 256, x -> parent); + + if(strlen(parent) > 0) + { + snprintf(name, max_len, "%s_%s", parent, x -> name); + } + else if(add_module_prefix) + { + snprintf(name, max_len, "%s_%s", x -> module -> name, x -> name); + } + else + { + snprintf(name, max_len, "%s", x -> name); + } +} + void oberon_generator_init_var(oberon_context_t * ctx, oberon_object_t * var) { @@ -183,7 +227,9 @@ oberon_generator_init_var(oberon_context_t * ctx, oberon_object_t * var) gcc_jit_context * gcc_context = gen_context -> gcc_context; gcc_jit_type * gcc_type = gen_type -> gcc_type; - const char * name = var -> name; + + char name[256]; + oberon_generator_get_full_name(name, 256, var); gcc_jit_lvalue * gcc_lvalue = NULL; gcc_jit_param * gcc_param = NULL; @@ -200,7 +246,7 @@ oberon_generator_init_var(oberon_context_t * ctx, oberon_object_t * var) else { gcc_lvalue = gcc_jit_context_new_global( - gcc_context, NULL, GCC_JIT_GLOBAL_INTERNAL, gcc_type, name + gcc_context, NULL, GCC_JIT_GLOBAL_EXPORTED, gcc_type, name ); } } @@ -244,7 +290,9 @@ oberon_generator_init_proc(oberon_context_t * ctx, oberon_object_t * proc) memset(gen_proc, 0, sizeof *gen_proc); proc -> gen_proc = gen_proc; - const char * name = proc -> name; + char name[256]; + oberon_generator_get_full_name(name, 256, proc); + gen_type_t * gen_result_type = proc -> type -> base -> gen_type; gcc_jit_type * result_type = gen_result_type -> gcc_type; @@ -274,17 +322,25 @@ oberon_generator_init_proc(oberon_context_t * ctx, oberon_object_t * proc) static gcc_jit_rvalue * rvalue_from_item(oberon_context_t * ctx, oberon_item_t * item); static gcc_jit_rvalue * rvalue_from_expr(oberon_context_t * ctx, oberon_expr_t * expr); +static int +oberon_generator_get_type_size(oberon_type_t * type) +{ + printf("TODO: oberon_generator_get_type_size\n"); + return 128; +} + void oberon_generate_begin_module(oberon_context_t * ctx) { - printcontext(ctx, "oberon_generate_begin_module"); - gen_context_t * gen_context = ctx -> gen_context; gcc_jit_context * gcc_context = gen_context -> gcc_context; + char name[256]; + snprintf(name, 256, "%s_BEGIN", ctx -> mod -> name); + gcc_jit_type * void_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_VOID); gcc_jit_function * func = gcc_jit_context_new_function( - gcc_context, NULL, GCC_JIT_FUNCTION_EXPORTED, void_type, "BEGIN", 0, NULL, 0 + gcc_context, NULL, GCC_JIT_FUNCTION_EXPORTED, void_type, name, 0, NULL, 0 ); gcc_jit_block * gcc_block = gcc_jit_function_new_block(func, NULL); @@ -294,8 +350,6 @@ oberon_generate_begin_module(oberon_context_t * ctx) void oberon_generate_end_module(oberon_context_t * ctx) { - printcontext(ctx, "oberon_generate_end_module"); - gen_context_t * gen_context = ctx -> gen_context; gcc_jit_block * gcc_block = gen_context -> block -> gcc_block; @@ -399,7 +453,7 @@ lvalue_from_item(oberon_context_t * ctx, oberon_item_t * item) } else { - oberon_error(ctx, "invalid lvalue expression"); + oberon_error(ctx, "lvalue_from_item: invalid mode %i", item -> mode); } return left; @@ -524,6 +578,30 @@ rvalue_from_item(oberon_context_t * ctx, oberon_item_t * item) gcc_jit_type * type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_VOID_PTR); right = gcc_jit_context_null(gcc_context, type); } + else if(item -> mode == MODE_NEWARR) + { + int type_size = oberon_generator_get_type_size(item -> type); + int array_size = type_size; + + int num = item -> num_args; + oberon_expr_t * arg = item -> args; + for(int i = 0; i < num; i++) + { + array_size *= arg -> item.integer; + arg = arg -> next; + } + + gcc_jit_type * size_type; + size_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_SIZE_T); + + gcc_jit_rvalue * fnarg; + fnarg = gcc_jit_context_new_rvalue_from_int(gcc_context, size_type, array_size); + + gcc_jit_type * result_type = item -> result -> gen_type -> gcc_type; + gcc_jit_rvalue * gcc_alloc = gcc_jit_lvalue_as_rvalue(gen_context -> gcc_alloc); + right = gcc_jit_context_new_call_through_ptr(gcc_context, NULL, gcc_alloc, 1, &fnarg); + right = gcc_jit_context_new_cast(gcc_context, NULL, right, result_type); + } else { oberon_error(ctx, "rvalue_from_item: invalid mode %i", item -> mode); @@ -661,7 +739,12 @@ oberon_generate_code(oberon_context_t * ctx) gcc_result = gcc_jit_context_compile(gcc_context); gen_context -> gcc_result = gcc_result; - ctx -> mod -> begin = gcc_jit_result_get_code(gcc_result, "BEGIN"); + + typedef void * (*TOberonAlloc)(size_t); + TOberonAlloc * fn_alloc_ptr = gcc_jit_result_get_global(gcc_result, "__OBERON_ALLOC__"); + *fn_alloc_ptr = __OBERON_ALLOC__; + +// ctx -> mod -> begin = gcc_jit_result_get_code(gcc_result, "BEGIN"); } void @@ -671,3 +754,21 @@ oberon_generator_dump(oberon_context_t * ctx, char * path) gcc_jit_context * gcc_context = gen_context -> gcc_context; gcc_jit_context_dump_to_file(gcc_context, path, 0); } + +void * +oberon_generator_get_procedure(oberon_context_t * ctx, const char * name) +{ + gen_context_t * gen_context = ctx -> gen_context; + gcc_jit_result * gcc_result = gen_context -> gcc_result; + + return gcc_jit_result_get_code(gcc_result, name); +} + +void * +oberon_generator_get_var(oberon_context_t * ctx, const char * name) +{ + gen_context_t * gen_context = ctx -> gen_context; + gcc_jit_result * gcc_result = gen_context -> gcc_result; + + return gcc_jit_result_get_global(gcc_result, name); +}