From c3449e207b5e1e85ecea55975163a4dc6b986962 Mon Sep 17 00:00:00 2001 From: DeaDDooMER Date: Mon, 24 Jul 2017 22:03:31 +0300 Subject: [PATCH] =?utf8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5=D0=BD?= =?utf8?q?=D1=8B=20=D1=82=D0=B8=D0=BF=D1=8B=20INTEGER=20=D0=B8=20BOOLEAN?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- generator.c | 225 ++++++++++++++++++++++++++++++++++++ generator.h | 11 ++ make.sh | 2 +- oberon.c | 263 +++++++++++++++++++++++++++---------------- oberon.h | 35 +++++- run.sh | 8 ++ test.c | 6 +- test_gcc_jit/make.sh | 5 - test_gcc_jit/s1 | Bin 10792 -> 0 bytes test_gcc_jit/s1.c | 22 ---- 10 files changed, 445 insertions(+), 132 deletions(-) create mode 100644 generator.c create mode 100644 generator.h create mode 100755 run.sh delete mode 100755 test_gcc_jit/make.sh delete mode 100755 test_gcc_jit/s1 delete mode 100644 test_gcc_jit/s1.c diff --git a/generator.c b/generator.c new file mode 100644 index 0000000..c633e54 --- /dev/null +++ b/generator.c @@ -0,0 +1,225 @@ +#include +#include +#include +#include +#include +#include + +#include "oberon.h" +#include "generator.h" + +#include + +/* + * oberon_var_t -> gvar == gcc_jit_lvalue; + * oberon_type_t -> gtype == gcc_jit_type; + * oberon_context_t -> gctx == gen_context_t; + */ + +typedef struct +{ + gcc_jit_context * gcc_context; + gcc_jit_block * gcc_block; + gcc_jit_result * gcc_result; +} gen_context_t; + +static void printcontext(oberon_context_t * ctx, char * s) +{ +/* + 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); +*/ +} + +// ======================================================================= +// ALLOC +// ======================================================================= + +void +oberon_generator_init_context(oberon_context_t * ctx) +{ + gen_context_t * gen_context = malloc(sizeof *gen_context); + memset(gen_context, 0, sizeof *gen_context); + + gcc_jit_context * gcc_context; + gcc_context = gcc_jit_context_acquire(); + + ctx -> gen_context = gen_context; + gen_context -> gcc_context = gcc_context; + + printcontext(ctx, "oberon_generator_init_context"); +} + +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; + + gcc_jit_context_release(gcc_context); +} + +void +oberon_generator_init_type(oberon_context_t * ctx, oberon_type_t * type) +{ + printcontext(ctx, "oberon_generator_init_type"); + + gen_context_t * gen_context = ctx -> gen_context; + gcc_jit_context * gcc_context = gen_context -> gcc_context; + + gcc_jit_type * gen_type; + if(type -> class == OBERON_TYPE_INTEGER) + { + gen_type = gcc_jit_context_get_int_type(gcc_context, type -> size, 1); + } + else if(type -> class == OBERON_TYPE_BOOLEAN) + { + gen_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_BOOL); + } + else + { + oberon_error(ctx, "oberon_generator_init_type: invalid type class %i", type -> class); + } + + type -> gen_type = gen_type; +} + +void +oberon_generator_init_var(oberon_context_t * ctx, oberon_var_t * var) +{ + printcontext(ctx, "oberon_generator_init_var"); + + gen_context_t * gen_context = ctx -> gen_context; + gcc_jit_context * gcc_context = gen_context -> gcc_context; + gcc_jit_type * gen_type = var -> type -> gen_type; + const char * name = var -> name; + + gcc_jit_lvalue * gen_var; + gen_var = gcc_jit_context_new_global(gcc_context, NULL, GCC_JIT_GLOBAL_INTERNAL, gen_type, name); + + var -> gen_var = gen_var; +} + +// ======================================================================= +// GENERATOR +// ======================================================================= + +static gcc_jit_rvalue * +oberon_generate_rvalue_from_item(oberon_context_t * ctx, oberon_item_t * item) +{ + printcontext(ctx, "oberon_generate_rvalue_from_item"); + + gen_context_t * gen_context = ctx -> gen_context; + gcc_jit_context * gcc_context = gen_context -> gcc_context; + + gcc_jit_rvalue * right; + if(item -> mode == MODE_VAR) + { + gcc_jit_lvalue * gen_var = item -> var -> gen_var; + right = gcc_jit_lvalue_as_rvalue(gen_var); + printf("PUSH (var) %s\n", item -> var -> name); + } + else if(item -> mode == MODE_INTEGER) + { + gcc_jit_type * int_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_INT); + right = gcc_jit_context_new_rvalue_from_int(gcc_context, int_type, item -> integer); + printf("PUSH (int) %i\n", item -> integer); + } + else if(item -> mode == MODE_BOOLEAN) + { + gcc_jit_type * bool_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_BOOL); + if(item -> boolean) + { + right = gcc_jit_context_one(gcc_context, bool_type); + } + else + { + right = gcc_jit_context_zero(gcc_context, bool_type); + } + printf("PUSH (bool) %i\n", item -> boolean); + } + else + { + oberon_error(ctx, "oberon_generate_push: invalid mode %i", item -> mode); + } + + return right; +} + +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; + + 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_jit_block * gcc_block = gcc_jit_function_new_block(func, NULL); + + gen_context -> gcc_block = gcc_block; +} + +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 -> gcc_block; + + gcc_jit_block_end_with_void_return(gcc_block, NULL); + + gen_context -> gcc_block = NULL; +} + +void +oberon_generate_assign(oberon_context_t * ctx, oberon_item_t * src, oberon_item_t * dst) +{ + printcontext(ctx, "oberon_generate_assign"); + + gen_context_t * gen_context = ctx -> gen_context; + gcc_jit_block * gcc_block = gen_context -> gcc_block; + + gcc_jit_lvalue * left; + gcc_jit_rvalue * right; + + right = oberon_generate_rvalue_from_item(ctx, src); + + if(dst -> mode == MODE_VAR) + { + printf("STORE %s\n", dst -> var -> name); + left = dst -> var -> gen_var; + } + else + { + oberon_error(ctx, "oberon_generate_assign: invalid assignment"); + } + + gcc_jit_block_add_assignment(gcc_block, NULL, left, right); +} + +void +oberon_generate_code(oberon_context_t * ctx) +{ + gen_context_t * gen_context = ctx -> gen_context; + gcc_jit_context * gcc_context = gen_context -> gcc_context; + + gcc_jit_result * gcc_result; + 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"); +} diff --git a/generator.h b/generator.h new file mode 100644 index 0000000..e9dbd53 --- /dev/null +++ b/generator.h @@ -0,0 +1,11 @@ +void oberon_generator_init_context(oberon_context_t * ctx); +void oberon_generator_destroy_context(oberon_context_t * ctx); +void oberon_generator_init_type(oberon_context_t * ctx, oberon_type_t * type); +void oberon_generator_init_var(oberon_context_t * ctx, oberon_var_t * var); + +void oberon_generate_begin_module(oberon_context_t * ctx); +void oberon_generate_end_module(oberon_context_t * ctx); + +void oberon_generate_assign(oberon_context_t * ctx, oberon_item_t * src, oberon_item_t * dst); + +void oberon_generate_code(oberon_context_t * ctx); diff --git a/make.sh b/make.sh index fe43cd6..286e5ff 100755 --- a/make.sh +++ b/make.sh @@ -2,4 +2,4 @@ set -e -cc -g -Wall -Werror -std=c11 *.c +cc -g -Wall -Werror -std=c11 -lgccjit *.c diff --git a/oberon.c b/oberon.c index e411c6c..4dfc604 100644 --- a/oberon.c +++ b/oberon.c @@ -3,7 +3,9 @@ #include #include #include + #include "oberon.h" +#include "generator.h" enum { EOF_ = 0, @@ -16,26 +18,18 @@ enum { COLON, BEGIN, ASSIGN, - INTEGER -}; - -enum { - MODE_VAR, - MODE_INTEGER, + INTEGER, + TRUE, + FALSE, + LPAREN, + RPAREN }; -typedef struct -{ - int mode; - int integer; - oberon_var_t * var; -} oberon_item_t; - // ======================================================================= // UTILS // ======================================================================= -static void +void oberon_error(oberon_context_t * ctx, const char * fmt, ...) { va_list ptr; @@ -55,22 +49,37 @@ oberon_item_to_type_class(oberon_context_t * ctx, oberon_item_t * item) { int class; - if(item -> mode == MODE_INTEGER) + switch(item -> mode) { - class = OBERON_TYPE_INTEGER; - } - else if(item -> mode == MODE_VAR) - { - class = item -> var -> type -> class; - } - else - { - oberon_error(ctx, "oberon_item_to_type_class: wat"); + case MODE_INTEGER: + class = OBERON_TYPE_INTEGER; + break; + case MODE_BOOLEAN: + class = OBERON_TYPE_BOOLEAN; + break; + case MODE_VAR: + class = item -> var -> type -> class; + break; + default: + oberon_error(ctx, "oberon_item_to_type_class: wat"); + break; } return class; } +static void +oberon_autocast_to(oberon_context_t * ctx, oberon_item_t * from, oberon_item_t * to) +{ + int from_class = oberon_item_to_type_class(ctx, from); + int to_class = oberon_item_to_type_class(ctx, to); + + if(from_class != to_class) + { + oberon_error(ctx, "oberon_autocast_to: types not matched %i -> %i", from_class, to_class); + } +} + // ======================================================================= // TABLE // ======================================================================= @@ -117,20 +126,11 @@ oberon_define_var(oberon_context_t * ctx, char * name, oberon_type_t * type) memset(newvar, 0, sizeof *newvar); newvar -> name = name; newvar -> type = type; + oberon_generator_init_var(ctx, newvar); x -> next = newvar; } -// ======================================================================= -// GENERATOR -// ======================================================================= - -static void -oberon_generate_assign(oberon_context_t * ctx, void * src, void * dst, int size) -{ - printf("G: %p := %p (%i);\n", dst, src, size); -} - // ======================================================================= // SCANER // ======================================================================= @@ -164,9 +164,9 @@ oberon_read_ident(oberon_context_t * ctx) c = ctx -> code[i]; } - char * ident = malloc(len + 2); + char * ident = malloc(len + 1); memcpy(ident, &ctx->code[ctx->code_index], len); - ident[len + 1] = 0; + ident[len] = 0; ctx -> code_index = i; ctx -> c = ctx -> code[i]; @@ -189,6 +189,14 @@ oberon_read_ident(oberon_context_t * ctx) { ctx -> token = BEGIN; } + else if(strcmp(ident, "TRUE") == 0) + { + ctx -> token = TRUE; + } + else if(strcmp(ident, "FALSE") == 0) + { + ctx -> token = FALSE; + } } static void @@ -225,6 +233,46 @@ oberon_skip_space(oberon_context_t * ctx) } } +static void +oberon_read_symbol(oberon_context_t * ctx) +{ + int c = ctx -> c; + switch(c) + { + case 0: + ctx -> token = EOF_; + break; + case ';': + ctx -> token = SEMICOLON; + oberon_get_char(ctx); + break; + case ':': + ctx -> token = COLON; + oberon_get_char(ctx); + if(ctx -> c == '=') + { + ctx -> token = ASSIGN; + oberon_get_char(ctx); + } + break; + case '.': + ctx -> token = DOT; + oberon_get_char(ctx); + break; + case '(': + ctx -> token = LPAREN; + oberon_get_char(ctx); + break; + case ')': + ctx -> token = RPAREN; + oberon_get_char(ctx); + break; + default: + oberon_error(ctx, "invalid char"); + break; + } +} + static void oberon_read_token(oberon_context_t * ctx) { @@ -241,26 +289,73 @@ oberon_read_token(oberon_context_t * ctx) } else { - switch(c) - { - case 0: ctx -> token = EOF_; break; - case ';': ctx -> token = SEMICOLON; oberon_get_char(ctx); break; - case ':': - /****************************************************/ - ctx -> token = COLON; oberon_get_char(ctx); - if(ctx -> c == '=') - { - ctx -> token = ASSIGN; - oberon_get_char(ctx); - } - break; - /****************************************************/ - case '.': ctx -> token = DOT; oberon_get_char(ctx); break; - default: oberon_error(ctx, "invalid char"); - } + oberon_read_symbol(ctx); } } +// ======================================================================= +// EXPR +// ======================================================================= + +static void oberon_expect_token(oberon_context_t * ctx, int token); +static oberon_item_t * oberon_expr(oberon_context_t * ctx); +static void oberon_assert_token(oberon_context_t * ctx, int token); +static char * oberon_assert_ident(oberon_context_t * ctx); + +static oberon_item_t * +oberon_factor(oberon_context_t * ctx) +{ + char * name; + oberon_var_t * var; + + oberon_item_t * item = malloc(sizeof *item); + memset(item, 0, sizeof *item); + + switch(ctx -> token) + { + case IDENT: + name = oberon_assert_ident(ctx); + var = oberon_find_var(ctx, name); + if(var == NULL) + { + oberon_error(ctx, "undefined variable %s", name); + } + item -> mode = MODE_VAR; + item -> var = var; + break; + case INTEGER: + item -> mode = MODE_INTEGER; + item -> integer = ctx -> integer; + oberon_assert_token(ctx, INTEGER); + break; + case TRUE: + item -> mode = MODE_BOOLEAN; + item -> boolean = 1; + oberon_assert_token(ctx, TRUE); + break; + case FALSE: + item -> mode = MODE_BOOLEAN; + item -> boolean = 0; + oberon_assert_token(ctx, FALSE); + break; + case LPAREN: + oberon_assert_token(ctx, LPAREN); + item = oberon_expr(ctx); + oberon_assert_token(ctx, RPAREN); + break; + default: + oberon_error(ctx, "invalid expression"); + } + + return item; +} + +static oberon_item_t * +oberon_expr(oberon_context_t * ctx) +{ + return oberon_factor(ctx); +} + // ======================================================================= // PARSER // ======================================================================= @@ -284,9 +379,8 @@ oberon_assert_token(oberon_context_t * ctx, int token) static char * oberon_assert_ident(oberon_context_t * ctx) { - char * ident; oberon_expect_token(ctx, IDENT); - ident = ctx -> string; + char * ident = ctx -> string; oberon_read_token(ctx); return ident; } @@ -328,37 +422,6 @@ oberon_decl_seq(oberon_context_t * ctx) } } -static oberon_item_t * -oberon_expr(oberon_context_t * ctx) -{ - oberon_item_t * item = malloc(sizeof *item); - memset(item, 0, sizeof *item); - - if(ctx -> token == IDENT) - { - char * name = oberon_assert_ident(ctx); - oberon_var_t * var = oberon_find_var(ctx, name); - if(var == NULL) - { - oberon_error(ctx, "undefined variable"); - } - item -> mode = MODE_VAR; - item -> var = var; - } - else if(ctx -> token == INTEGER) - { - item -> mode = MODE_INTEGER; - item -> integer = ctx -> integer; - oberon_assert_token(ctx, INTEGER); - } - else - { - oberon_error(ctx, "invalid expression"); - } - - return item; -} - static void oberon_assign(oberon_context_t * ctx, oberon_item_t * src, oberon_item_t * dst) { @@ -367,16 +430,9 @@ oberon_assign(oberon_context_t * ctx, oberon_item_t * src, oberon_item_t * dst) oberon_error(ctx, "invalid assignment"); } - int src_class = oberon_item_to_type_class(ctx, src); - int dst_class = oberon_item_to_type_class(ctx, dst); - - if(src_class != dst_class) - { - oberon_error(ctx, "types not matched"); - } + oberon_autocast_to(ctx, src, dst); - // TODO: code generation - oberon_generate_assign(ctx, 0, 0, 4); + oberon_generate_assign(ctx, src, dst); } static void @@ -406,7 +462,7 @@ oberon_statement_seq(oberon_context_t * ctx) } static void -oberon_parse_it(oberon_context_t * ctx) +oberon_parse_module(oberon_context_t * ctx) { char *name1, *name2; oberon_read_token(ctx); @@ -421,7 +477,9 @@ oberon_parse_it(oberon_context_t * ctx) if(ctx -> token == BEGIN) { oberon_assert_token(ctx, BEGIN); + oberon_generate_begin_module(ctx); oberon_statement_seq(ctx); + oberon_generate_end_module(ctx); } oberon_assert_token(ctx, END); @@ -447,10 +505,18 @@ oberon_create_context() oberon_type_t * types = malloc(sizeof *types); memset(types, 0, sizeof *types); + oberon_generator_init_context(ctx); ctx -> types = types; return ctx; } +void +oberon_destroy_context(oberon_context_t * ctx) +{ + oberon_generator_destroy_context(ctx); + free(ctx); +} + oberon_module_t * oberon_compile_module(oberon_context_t * ctx, const char * code) { @@ -462,7 +528,9 @@ oberon_compile_module(oberon_context_t * ctx, const char * code) ctx -> mod -> vars = vars; oberon_init_scaner(ctx, code); - oberon_parse_it(ctx); + oberon_parse_module(ctx); + + oberon_generate_code(ctx); return mod; } @@ -484,6 +552,7 @@ oberon_register_global_type(oberon_context_t * ctx, oberon_type_t * type) oberon_type_t * newtype = malloc(sizeof *newtype); memcpy(newtype, type, sizeof *newtype); newtype -> next = NULL; + oberon_generator_init_type(ctx, newtype); x -> next = newtype; } diff --git a/oberon.h b/oberon.h index 7fee329..ec742c6 100644 --- a/oberon.h +++ b/oberon.h @@ -1,22 +1,24 @@ #ifndef EMBEDED_OBERON_SCRIPT_H #define EMBEDED_OBERON_SCRIPT_H -enum { - OBERON_TYPE_INTEGER, - OBERON_TYPE_BOOLEAN, -}; - typedef struct oberon_var_s oberon_var_t; typedef struct oberon_type_s oberon_type_t; typedef struct oberon_module_s oberon_module_t; typedef struct oberon_context_s oberon_context_t; +enum { + OBERON_TYPE_INTEGER, + OBERON_TYPE_BOOLEAN, +}; + struct oberon_type_s { char * name; int class; int size; oberon_type_t * next; + + void * gen_type; }; struct oberon_var_s @@ -24,12 +26,16 @@ struct oberon_var_s char * name; oberon_type_t * type; oberon_var_t * next; + + void * gen_var; }; struct oberon_module_s { char * name; oberon_var_t * vars; + + void (* begin)(); }; struct oberon_context_s @@ -43,12 +49,29 @@ struct oberon_context_s int integer; oberon_module_t * mod; - oberon_type_t * types; + + void * gen_context; +}; + +enum { + MODE_VAR, + MODE_INTEGER, + MODE_BOOLEAN }; +typedef struct +{ + int mode; + int integer; + int boolean; + oberon_var_t * var; +} oberon_item_t; + oberon_context_t * oberon_create_context(); +void oberon_destroy_context(oberon_context_t * ctx); void oberon_register_global_type(oberon_context_t * ctx, oberon_type_t * type); oberon_module_t * oberon_compile_module(oberon_context_t * ctx, const char * code); +void oberon_error(oberon_context_t * ctx, const char * fmt, ...); #endif // EMBEDED_OBERON_SCRIPT_H diff --git a/run.sh b/run.sh new file mode 100755 index 0000000..58023d2 --- /dev/null +++ b/run.sh @@ -0,0 +1,8 @@ +#!/bin/sh + +set -e + +export PATH="/usr/lib/gcc/x86_64-pc-linux-gnu/7.1.1:${PATH}" +export LIBRARY_PATH="/usr/lib/gcc/x86_64-pc-linux-gnu/7.1.1:${LIBRARY_PATH}" + +exec ./a.out diff --git a/test.c b/test.c index 2247eac..7149026 100644 --- a/test.c +++ b/test.c @@ -7,10 +7,13 @@ static oberon_type_t boolean = { "BOOLEAN", OBERON_TYPE_BOOLEAN, sizeof(int) }; static const char source[] = "MODULE Test;" "VAR" + " k : INTEGER;" " i : INTEGER;" " b : BOOLEAN;" "BEGIN" - " i := 10;" + " k := 10;" + " i := k;" + " b := TRUE;" "END Test." ; @@ -24,5 +27,6 @@ main(int argc, char ** argv) oberon_register_global_type(ctx, &integer); oberon_register_global_type(ctx, &boolean); mod = oberon_compile_module(ctx, source); + oberon_destroy_context(ctx); return 0; } diff --git a/test_gcc_jit/make.sh b/test_gcc_jit/make.sh deleted file mode 100755 index 03ddd5b..0000000 --- a/test_gcc_jit/make.sh +++ /dev/null @@ -1,5 +0,0 @@ -#!/bin/sh - -set -e - -gcc -g -Wall -Werror -std=c11 -lgccjit s1.c -o s1 diff --git a/test_gcc_jit/s1 b/test_gcc_jit/s1 deleted file mode 100755 index 143c368728b240a28050c4037cf43e46b59c26f4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10792 zcmeHNeQ;Y>mA_At<)=876+3C1hNVhrz@@chyQ!UM(_%=-$%S}&gA^4O z69Hj}YsCiP2hxI{Axnrl9Mjj7Yo@x=^Md;Di+LO%<}oD0^bHOym~sn=QhkfbP^?35 zR2484A}q_vj@l}MQUu-WFp6?J4AmaCBa!Sv$}XhznVwS(W6J%bzR_<&`J3<C|>p(3^^3@FquyOZO*2#?-QmuIbAH6Wjk52O;e!AM46c`7HsRF zZ6?$AS8^q530|`DRg*Cfj^K!>ETZPzloK{F;v&^gK?X}0rH8rJu z&-VyiI4AY?oXkr4UBY%HKKQT7AaUZdH&LBWoVc(hp*@#){<6KM=AmuTgJApF%^Og+ zsI1+UsGh&@ezf?xmJT4=o|Dr5pFs?fjdWb|A!-P!s-EBThbj>aRk-@Ti-~IG+=Uhx zCaNQ^B|d^*_4I}Fmlqafy+1m+XiJ{r?~3mptNtRsD?TxPbYr14439^9iM}&ly);&R zb^LmAtS3%f@?I#yOX8tF+Ts3Ra{c4g*T<``Zmqr;Us(OC#F3L);?{qv{0q&|d-lZN z8{ZSZFK(VZwpiz%F?G_Pnnew3Nn7u|jg}|9TW&`che7k8(>JRd_BW7%O3n3!xDMr{fBe$If_y}Rq0wOXogHll z^jWdx>f7FW({2AbJQ#Y|Gu-aaqGDB+0sR`vEl@EO3_a=@3U+_YI}!{Z z^$i7kKH8E9_C4%R1Y<{9w+D?pSCNR;64#HfY5^}W;y1APnm_)`jq(6h*V|Mm#6 zIz0ux*N6}4he_w(iSO1o6aG5!Vf{UX|AqJ-{S(Ch2l0LS&(H|pCE{cHIC9@*;*G!@ z@j@dZ5r~q3CWRe=Tgk#Bg?j?;Ai<~I35C6ZLuBLEc0ia4JVzzEmI5{tD3Y*J3U=Uq zBm}h?lpG9vnS@Sl6vAxaHzagv6A&H@e3&X-t?dRm5~xy1x0Z$QNZ^AcY|#D=YR3X^ zC$;Ofhao%>xCgoKtx|X@V3Kfy6rK*`NbN=`d@V3TLPVpnJsv2NT2!`eE^vul_iK45 zoDwTWNqW5X^B~>6C#jSAFA4fAu|hvU{O72|ycSD-)jYHu1<%LdyJ}RbQ-SB>J30@La(qPF0H8?BFI7$1Er)S;>q%TPf!ruoN~rHakmYJdx z95P8&veLpdXOfu#_yf6V(bB!<&2{7Ve$4D+O!wq*bs= zxirLNDLu8>Iq3`cPKJBYg3amve(AZK+^T%IbHY!^gBwOBEoJyFl|#q>TJ zBQ$lNRVoW}rig5Dc#9Pqe;$x09*7#nmKBlWAv`sjZblrEFoE+umE=qX>9+?MnIqP=#X(&(qjd9L(>=%dxB zSCzaMUoyT2s4w)2RU+0@A1B@_&TiE25_(g7HSRg~)~ib1E7sJ`S?deE;wpU3n(40< zJx%fMCFkSh&nqZiTAI9qcMFYWUctKxH_p2WH~u$`fReo8jZ1L6(-CF8wBRnlm$E62 z4-{5;yLieq@3ikA{EQ3lQ8@3nAj)(Hat*r%I<}=m?Vz+BKTRy1FB>@dH&hHwx|C+| z)99wdHIJVM{=ezh7p0$7h)oS}jj5TRuS=EACF|-Wa1FaE_qzIt(s#G>*Aid4&i^F+ zEM0Fp2C5U|K&R-GC=jCb81OK5Z|-&2E%hCp`aBN2+5JtY)L;6XCYJGY|1$V7<=@?& z&jJtEH$?Hz0$=4>EBai|(YFW}i|+@Y(*GfF8i!dm4wk~d3mU?@a^F8auJrky_XeeZ z7C7niI#jUuozmyvh4o(mPVIE-|6J-fc~8>y5#p$H$u8TKY!)n{7;7?DwylzBPn&6c z{w;j7%}mjp%okJ1yqU3!rLvi<92Du|^i1BetxRO_)>{#GG*gn-RA#bNN*+QGWS0(! zY$-WynVHJ;^dXqkN%AhMK~=_hra8JZzJ0_Txoaz~(9A|H#2H)fy(_+bY`C#R-naom zEM<-)l!wIDoxcn;b6?b{3pvAZ-=e9T zH@CjJ*lVKizQ;3+`b#Li9+glEWQyE+Zl&O(n}y zB9b{&fIo*Kl$9m>5$)xQg$BVy8OAY528x@>+ae+x9HIMA5s`PAky24!XGW|kwLGRW zuw}`yaMp=q!8{x%r*mo4T7)lT5m|xb3|FHff)zWBRfxt~smdhml7&euZzbjm*&_4F zRH|g{X9>6J7V{V?ehmN5l)jjFBx~sV1yxBXV&ui~tX>wm&yNX;h{5R($Nvx?I9x<1_n0ejL~`#GLG zqwMFEvLBTC&i363-wleLUCn;ZYsiv00+F6^NG*4d-+d^dvp;S>$ESJK(bdY5+s}GT z_o1B55?SUrc2?ON%AVR!I^2E*iwD4vD%*3sJE!dXlp@#9_T2vuDf=O%$8qs|6MKB6 zYxT1|9lFq%Q2Qu_Ra_KS74kW&Q@V8hR8dfGZzy|1*>n5ZKBO3?pK#gpcW*}7Kj@k; zwqt*vcG>fJ_sgn7eD2HoYFJnlPbqsuW=?7~6m^JOpJk>`Lyelq^T+!DA3an^n;cTh z*^Ys4f~mLX{X$IHzs!n?^87PA2ZoNr)N)^pF9}3)>$A+1;yrn$Dz%}n;#2*9Xnz)V zG}K%_$CLbjS?ARJ@%rL=c^-cQTT)?r{=boVY7`RdInrW(*w61#P;Xz`_b9_2HdK`D zn7-(;=QyxO*)LZ=yL|-=`Qr9-ycJW1To3E3;b2j`4vw(C8sac)?_NJ_&(sTs`Fa<5 zRlnP>TbJT!H%5M*RQ6Hsm~!sced99rKc)>B(yI=sLj(jT`DzPGR~PlkC1TIe P+};X1R>Lj>mni-d4RO-u diff --git a/test_gcc_jit/s1.c b/test_gcc_jit/s1.c deleted file mode 100644 index f83910e..0000000 --- a/test_gcc_jit/s1.c +++ /dev/null @@ -1,22 +0,0 @@ -#include - -gcc_jit_context * ctxt; - -int -main(int argc, char **argv) -{ - ctxt = gcc_jit_context_acquire(); - - cc_jit_type * void_type = gcc_jit_context_get_type(ctxt, GCC_JIT_TYPE_VOID); - - gcc_jit_function * func = gcc_jit_context_new_function( - ctxt, NULL, GCC_JIT_FUNCTION_EXPORTED, void_type, "BEGIN", 0, NULL, 0 - ); - - gcc_jit_block * block = gcc_jit_function_new_block (func, NULL); - - - - gcc_jit_context_release(ctxt); - return 0; -} -- 2.29.2