diff --git a/tool/cmd/validate.c b/tool/cmd/validate.c index 6e214ea..7def32b 100644 --- a/tool/cmd/validate.c +++ b/tool/cmd/validate.c @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -16,15 +17,20 @@ #include #include #include +#include #include #include #include #include #include +#include #include #include -#include +#include #include +#include +#include +#include #include #include #include @@ -45,16 +51,16 @@ static int trait_ref_print(const struct mie_trait *trait, void *arg) return 0; } -static void mie_op_arg_print(const struct mie_op_arg *arg) +static void op_arg_dump(struct mie_printer *printer, const struct mie_op_arg *arg) { enum mie_register_flags arg_flags = 0; const char *arg_name = NULL; const struct mie_type *arg_type = NULL; if (MIE_TEST_FLAGS(arg->arg_flags, MIE_OP_F_ARG_RESOLVED)) { - arg_flags = arg->arg_value->reg_flags; - arg_name = arg->arg_value->reg_name.n_str; - arg_type = arg->arg_value->reg_type; + arg_flags = arg->arg_value.u_reg->reg_flags; + arg_name = arg->arg_value.u_reg->reg_name.n_str; + arg_type = arg->arg_value.u_reg->reg_type; } else { arg_flags = arg->arg_unresolved.reg_flags; arg_name = arg->arg_unresolved.reg_name; @@ -68,13 +74,15 @@ static void mie_op_arg_print(const struct mie_op_arg *arg) } printf(":("); - mie_type_print(arg_type, b_stdout); + mie_printer_print_type(printer, arg_type); b_printf(")%s[reset]", arg_name); } -static void mie_op_print(const struct mie_op *op) +static void op_dump(const struct mie_op *op) { b_stringstream *tmp = b_stringstream_create(); + struct mie_printer printer; + mie_printer_init(&printer, NULL, b_stdout, MIE_PRINT_F_GENERIC); printf("FLAGS:"); (op->op_flags & MIE_OP_F_OP_RESOLVED) && printf(" OP_RESOLVED"); @@ -88,11 +96,14 @@ static void mie_op_print(const struct mie_op *op) mie_trait_table_iterate(&op->op_info->op_traits, trait_ref_print, NULL); printf("\n"); printf("ATTRIBUTES:"); +#if 0 for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_attrib); i++) { printf(" (%s = ", op->op_attrib.items[i].attrib_name); - mie_value_print(op->op_attrib.items[i].attrib_value, b_stdout); + mie_printer_print_value( + &printer, op->op_attrib.items[i].attrib_value); printf(")"); } +#endif printf("\n"); printf("REGIONS: %zu\n", MIE_VECTOR_COUNT(op->op_regions)); @@ -109,7 +120,7 @@ static void mie_op_print(const struct mie_op *op) for (size_t i = 0; i < MIE_VECTOR_COUNT(s->s_args); i++) { const struct mie_op_arg *arg = &s->s_args.items[i]; - mie_op_arg_print(arg); + op_arg_dump(&printer, arg); } printf(" )"); @@ -119,7 +130,7 @@ static void mie_op_print(const struct mie_op *op) printf("ARGS:"); for (size_t i = 0; i < op->op_args.count; i++) { const struct mie_op_arg *arg = &op->op_args.items[i]; - mie_op_arg_print(arg); + op_arg_dump(&printer, arg); } printf("\n"); @@ -128,7 +139,7 @@ static void mie_op_print(const struct mie_op *op) const struct mie_register *reg = &op->op_result.items[i]; printf(" %s:(", (reg->reg_flags & MIE_REGISTER_F_MACHINE) ? "MR" : "VR"); - mie_type_print(reg->reg_type, b_stdout); + mie_printer_print_type(&printer, reg->reg_type); printf(")%s", reg->reg_name.n_str); } printf("\n"); @@ -161,6 +172,35 @@ static void mie_trait_definition_print(const struct mie_trait_definition *trait) trait->tr_name, id_str); } +static void mie_attribute_definition_print( + const struct mie_attribute_definition *attribute) +{ + char id_str[MIE_ID_STRING_MAX]; + mie_id_to_string(&attribute->a_id, id_str, sizeof id_str); + b_printf( + " [bold,magenta]At:[reset]%-20s [dark_grey]{%s}[reset]\n", + attribute->a_name, id_str); +} + +static void mie_interface_definition_print( + const struct mie_interface_definition *interface) +{ + char id_str[MIE_ID_STRING_MAX]; + mie_id_to_string(&interface->if_id, id_str, sizeof id_str); + b_printf( + " [bold,cyan]If:[reset]%-20s [dark_grey]{%s}[reset]\n", + interface->if_name, id_str); +} + +static void mie_pass_definition_print(const struct mie_pass_definition *interface) +{ + char id_str[MIE_ID_STRING_MAX]; + mie_id_to_string(&interface->p_id, id_str, sizeof id_str); + b_printf( + " [bold,cyan]Ps:[reset]%-20s [dark_grey]{%s}[reset]\n", + interface->p_name, id_str); +} + static void mie_dialect_print(const struct mie_dialect *dialect) { char id_str[MIE_ID_STRING_MAX]; @@ -198,10 +238,31 @@ static void mie_dialect_print(const struct mie_dialect *dialect) mie_trait_definition_print(trait); node = b_btree_next(node); } + + node = b_btree_first(&dialect->d_attributes.map_entries); + while (node) { + mie_id *id = b_unbox(mie_id, node, e_node); + struct mie_attribute_definition *attribute + = b_unbox(struct mie_attribute_definition, id, a_id); + + mie_attribute_definition_print(attribute); + node = b_btree_next(node); + } + + node = b_btree_first(&dialect->d_interfaces.map_entries); + while (node) { + mie_id *id = b_unbox(mie_id, node, e_node); + struct mie_interface_definition *interface = b_unbox( + struct mie_interface_definition, id, if_id); + + mie_interface_definition_print(interface); + node = b_btree_next(node); + } } static void mie_ctx_print(const struct mie_ctx *ctx) { + printf("Dialects:\n"); b_btree_node *node = b_btree_first(&ctx->ctx_dialects.map_entries); while (node) { mie_id *id = b_unbox(mie_id, node, e_node); @@ -211,6 +272,17 @@ static void mie_ctx_print(const struct mie_ctx *ctx) mie_dialect_print(dialect); node = b_btree_next(node); } + + printf("\nPasses:\n"); + node = b_btree_first(&ctx->ctx_passes.map_entries); + while (node) { + mie_id *id = b_unbox(mie_id, node, e_node); + struct mie_pass_definition *pass + = b_unbox(struct mie_pass_definition, id, p_id); + + mie_pass_definition_print(pass); + node = b_btree_next(node); + } } static int validate_file(const char *path, const b_arglist *args) @@ -236,14 +308,19 @@ static int validate_file(const char *path, const b_arglist *args) mie_scf_dialect_create(ctx); mie_index_dialect_create(ctx); + mie_builtin_passes_register(ctx); + mie_ctx_print(ctx); - struct mie_type *i32 = mie_arith_int_get_type(ctx, 32); + struct mie_type *i32 = mie_ctx_get_int_type(ctx, 32); struct mie_type *str = mie_ctx_get_type(ctx, "builtin", "string"); - struct mie_type *index = mie_ctx_get_type(ctx, "index", "index"); - struct mie_value *i32_value = mie_ctx_get_int(ctx, 1024, 32); - struct mie_value *index_value = mie_ctx_get_index(ctx, 25000); - struct mie_value *str_value = mie_ctx_get_string(ctx, "Hello, world!"); + struct mie_type *index = mie_ctx_get_type(ctx, "builtin", "index"); + struct mie_attribute *i32_value = mie_ctx_get_int(ctx, 1024, 32); + struct mie_attribute *index_value = mie_ctx_get_index(ctx, 25000); + struct mie_attribute *str_value + = mie_ctx_get_string(ctx, "Hello, world!"); + + printf("%zu\n", sizeof(struct mie_op)); const struct mie_type *storage_type_parts[] = {i32, str, index}; struct mie_type *storage_type = mie_ctx_get_storage_type( @@ -267,6 +344,9 @@ static int validate_file(const char *path, const b_arglist *args) sizeof func_in_parts / sizeof *func_in_parts, func_out_parts, sizeof func_out_parts / sizeof *func_out_parts)); + struct mie_printer printer; + mie_printer_init(&printer, ctx, b_stdout, MIE_PRINT_F_ABBREVIATED); + char id_str[MIE_ID_STRING_MAX]; mie_id_to_string(&i32->ty_id, id_str, sizeof id_str); printf("i32 type: {%s} %s (instance of %s.%s)\n", id_str, i32->ty_name, @@ -279,24 +359,24 @@ static int validate_file(const char *path, const b_arglist *args) index->ty_def->ty_parent->d_name, index->ty_def->ty_name); mie_id_to_string(&storage_type->ty_id, id_str, sizeof id_str); printf("storage type: {%s} ", id_str); - mie_type_print(storage_type, b_stdout); + mie_printer_print_type(&printer, storage_type); printf("\n"); mie_id_to_string(&func_type->ty_id, id_str, sizeof id_str); printf("function type: {%s} ", id_str); - mie_type_print(func_type, b_stdout); + mie_printer_print_type(&printer, func_type); printf("\n"); printf("i32 value: "); - mie_value_print(i32_value, b_stdout); + mie_printer_print_attribute(&printer, i32_value); printf("\n"); printf("index value: "); - mie_value_print(index_value, b_stdout); + mie_printer_print_attribute(&printer, index_value); printf("\n"); printf("str value: "); - mie_value_print(str_value, b_stdout); + mie_printer_print_attribute(&printer, str_value); printf("\n"); struct mie_lex *lex = mie_lex_create(file); @@ -304,19 +384,52 @@ static int validate_file(const char *path, const b_arglist *args) struct mie_name_map *names = mie_name_map_create(NULL); - struct mie_op op = {}; + struct mie_op *root = mie_op_create(); - if (!mie_parser_parse_op(parse, names, &op)) { + if (!mie_parser_parse_op(parse, NULL, root)) { printf("parse failed\n"); return -1; } - if (!mie_ctx_resolve_op(ctx, &op)) { - printf("op resolve failed\n"); + struct mie_walker *walker = mie_walker_begin( + root, MIE_WALKER_F_INCLUDE_OPS | MIE_WALKER_F_PREORDER + | MIE_WALKER_F_FORWARD | MIE_WALKER_F_RECURSIVE); + + do { + const struct mie_walker_item *item = mie_walker_get(walker); + for (size_t i = 0; i < item->i_depth; i++) { + fputs(" ", stdout); + } + + printf("resolving %p %s... ", item->i_op, item->i_op->op_name); + bool ok = mie_ctx_resolve_op(ctx, item->i_op); + printf("%s\n", ok ? "OK" : "FAIL"); + } while (mie_walker_step(walker) == MIE_SUCCESS); + + struct mie_pass *prefix_func_with_underscore = NULL; + if (mie_ctx_get_pass( + ctx, "prefix-func-with-underscore", NULL, + &prefix_func_with_underscore) + != MIE_SUCCESS) { + printf("cannot load pass prefix-func-with-underscore\n"); return -1; } - mie_op_print(&op); + struct mie_pass_manager *pm = mie_pass_manager_create(ctx); + struct mie_pass_manager *module_pm = mie_pass_manager_nest(pm); + mie_pass_manager_filter_op(module_pm, "builtin", "module"); + + struct mie_pass_manager *func_pm = mie_pass_manager_nest(pm); + mie_pass_manager_filter_op(module_pm, "func", "func"); + + mie_pass_manager_add_pass(func_pm, prefix_func_with_underscore); + + mie_pass_manager_parse( + pm, "builtin.module(func.func(prefix-func-with-underscore))"); + mie_pass_manager_run(pm, root); + + mie_printer_print_op(&printer, root); + printf("\n"); #if 0