From a67e4b6688e3dcff812862f207e4f5effde47f34 Mon Sep 17 00:00:00 2001 From: Max Wash Date: Sun, 25 Jan 2026 15:11:06 +0000 Subject: [PATCH] mie: tool: validate: remove functionality that was moved to internal subcommands --- tool/cmd/validate.c | 392 ++++++++------------------------------------ 1 file changed, 69 insertions(+), 323 deletions(-) diff --git a/tool/cmd/validate.c b/tool/cmd/validate.c index 7def32b..1966e30 100644 --- a/tool/cmd/validate.c +++ b/tool/cmd/validate.c @@ -43,248 +43,6 @@ enum { ARG_FILEPATH, }; -static int trait_ref_print(const struct mie_trait *trait, void *arg) -{ - fputc(' ', stdout); - mie_trait_print(trait, b_stdout); - - return 0; -} - -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.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; - arg_type = arg->arg_unresolved.reg_type; - } - - if (arg_flags & MIE_REGISTER_F_MACHINE) { - b_printf(" [bold,red]MR"); - } else { - b_printf(" [bold,magenta]VR"); - } - - printf(":("); - mie_printer_print_type(printer, arg_type); - b_printf(")%s[reset]", arg_name); -} - -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"); - (op->op_flags & MIE_OP_F_ARG_RESOLVED) && printf(" ARG_RESOLVED"); - printf("\n"); - printf("DIALECT: %s\n", - op->op_dialect ? op->op_dialect->d_name : ""); - printf("OP: %s\n", op->op_info ? op->op_info->op_name : ""); - printf("NAME: %s\n", op->op_name ? op->op_name : ""); - printf("TRAITS:"); - 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_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)); - printf("SUCCESSORS:"); - for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_successors); i++) { - const struct mie_op_successor *s = &op->op_successors.items[i]; - if (MIE_TEST_FLAGS(s->s_flags, MIE_OP_F_SUCCESSOR_RESOLVED)) { - printf(" ^%s", s->s_block->b_name.n_str); - } else { - printf(" ^%s?", s->s_block_name); - } - - printf(":("); - - for (size_t i = 0; i < MIE_VECTOR_COUNT(s->s_args); i++) { - const struct mie_op_arg *arg = &s->s_args.items[i]; - op_arg_dump(&printer, arg); - } - - printf(" )"); - } - printf("\n"); - - printf("ARGS:"); - for (size_t i = 0; i < op->op_args.count; i++) { - const struct mie_op_arg *arg = &op->op_args.items[i]; - op_arg_dump(&printer, arg); - } - printf("\n"); - - printf("RESULT:"); - for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) { - const struct mie_register *reg = &op->op_result.items[i]; - printf(" %s:(", - (reg->reg_flags & MIE_REGISTER_F_MACHINE) ? "MR" : "VR"); - mie_printer_print_type(&printer, reg->reg_type); - printf(")%s", reg->reg_name.n_str); - } - printf("\n"); -} - -static void mie_op_definition_print(const struct mie_op_definition *op) -{ - char id_str[MIE_ID_STRING_MAX]; - mie_id_to_string(&op->op_id, id_str, sizeof id_str); - b_printf( - " [bold,red]Op:[reset]%-20s [dark_grey]{%s}[reset]\n", - op->op_name, id_str); -} - -static void mie_type_definition_print(const struct mie_type_definition *type) -{ - char id_str[MIE_ID_STRING_MAX]; - mie_id_to_string(&type->ty_id, id_str, sizeof id_str); - b_printf( - " [bold,blue]Ty:[reset]%-20s [dark_grey]{%s}[reset]\n", - type->ty_name, id_str); -} - -static void mie_trait_definition_print(const struct mie_trait_definition *trait) -{ - char id_str[MIE_ID_STRING_MAX]; - mie_id_to_string(&trait->tr_id, id_str, sizeof id_str); - b_printf( - " [bold,yellow]Tr:[reset]%-20s [dark_grey]{%s}[reset]\n", - 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]; - mie_id_to_string(&dialect->d_id, id_str, sizeof id_str); - b_printf( - "[bold,green]D:[reset]%-20s [dark_grey]{%s}[reset]\n", - dialect->d_name, id_str); - - b_btree_node *node = b_btree_first(&dialect->d_ops.map_entries); - while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); - struct mie_op_definition *op - = b_unbox(struct mie_op_definition, id, op_id); - - mie_op_definition_print(op); - node = b_btree_next(node); - } - - node = b_btree_first(&dialect->d_types.map_entries); - while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); - struct mie_type_definition *type - = b_unbox(struct mie_type_definition, id, ty_id); - - mie_type_definition_print(type); - node = b_btree_next(node); - } - - node = b_btree_first(&dialect->d_traits.map_entries); - while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); - struct mie_trait_definition *trait - = b_unbox(struct mie_trait_definition, id, tr_id); - - 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); - struct mie_dialect *dialect - = b_unbox(struct mie_dialect, id, d_id); - - 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) { b_file *file = NULL; @@ -310,75 +68,6 @@ static int validate_file(const char *path, const b_arglist *args) mie_builtin_passes_register(ctx); - mie_ctx_print(ctx); - - 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, "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( - ctx, storage_type_parts, - sizeof storage_type_parts / sizeof *storage_type_parts); - - const struct mie_type *func_in_parts[] = {i32, str}; - const struct mie_type *func_out_parts[] = {index}; - struct mie_type *func_type = mie_ctx_get_function_type( - ctx, func_in_parts, sizeof func_in_parts / sizeof *func_in_parts, - func_out_parts, sizeof func_out_parts / sizeof *func_out_parts); - - /* make sure storage/function type caching is working */ - assert(storage_type - == mie_ctx_get_storage_type( - ctx, storage_type_parts, - sizeof storage_type_parts / sizeof *storage_type_parts)); - assert(func_type - == mie_ctx_get_function_type( - ctx, func_in_parts, - 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, - i32->ty_def->ty_parent->d_name, i32->ty_def->ty_name); - mie_id_to_string(&str->ty_id, id_str, sizeof id_str); - printf("str type: {%s} %s (instance of %s.%s)\n", id_str, str->ty_name, - str->ty_def->ty_parent->d_name, str->ty_def->ty_name); - mie_id_to_string(&index->ty_id, id_str, sizeof id_str); - printf("index type: {%s} %s (instance of %s.%s)\n", id_str, index->ty_name, - 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_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_printer_print_type(&printer, func_type); - printf("\n"); - - printf("i32 value: "); - mie_printer_print_attribute(&printer, i32_value); - printf("\n"); - - printf("index value: "); - mie_printer_print_attribute(&printer, index_value); - printf("\n"); - - printf("str value: "); - mie_printer_print_attribute(&printer, str_value); - printf("\n"); - struct mie_lex *lex = mie_lex_create(file); struct mie_parser *parse = mie_parser_create(ctx, lex); @@ -391,26 +80,44 @@ static int validate_file(const char *path, const b_arglist *args) return -1; } - 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); + enum mie_walker_flags walk_flags + = MIE_WALKER_F_INCLUDE_OPS | MIE_WALKER_F_PREORDER + | MIE_WALKER_F_FORWARD | MIE_WALKER_F_RECURSIVE; + struct mie_walker walker; + mie_walker_begin(&walker, root, walk_flags); do { - const struct mie_walker_item *item = mie_walker_get(walker); + const struct mie_walk_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); + switch (item->i_type) { + case MIE_WALK_ITEM_REGION: + printf("looking at region %p...\n", item->i_region); + continue; + case MIE_WALK_ITEM_BLOCK: + printf("looking at block %p %s...\n", item->i_block, + item->i_block->b_name.n_str); + continue; + case MIE_WALK_ITEM_OP: + + 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"); + break; + default: + break; + } + } while (mie_walker_step(&walker) == MIE_SUCCESS); + mie_walker_end(&walker); 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) { + enum mie_status status = mie_ctx_get_pass( + ctx, "prefix-func-with-underscore", NULL, + &prefix_func_with_underscore); + if (status != MIE_SUCCESS) { printf("cannot load pass prefix-func-with-underscore\n"); return -1; } @@ -424,13 +131,52 @@ static int validate_file(const char *path, const b_arglist *args) mie_pass_manager_add_pass(func_pm, prefix_func_with_underscore); +#if 0 mie_pass_manager_parse( pm, "builtin.module(func.func(prefix-func-with-underscore))"); +#endif mie_pass_manager_run(pm, root); + struct mie_printer printer; + mie_printer_init(&printer, ctx, b_stdout, MIE_PRINT_F_ABBREVIATED); mie_printer_print_op(&printer, root); printf("\n"); + struct mie_op *func = mie_op_get_first_child_op(root); + walk_flags = MIE_WALKER_F_INCLUDE_OPS | MIE_WALKER_F_PREORDER + | MIE_WALKER_F_FORWARD; + mie_walker_begin(&walker, func, walk_flags); + + do { + const struct mie_walk_item *item = mie_walker_get(&walker); + for (size_t i = 0; i < item->i_depth; i++) { + fputs(" ", stdout); + } + + switch (item->i_type) { + case MIE_WALK_ITEM_REGION: + printf("looking at region %p...\n", item->i_region); + break; + case MIE_WALK_ITEM_BLOCK: + printf("looking at block %p %s...\n", item->i_block, + item->i_block->b_name.n_str); + break; + case MIE_WALK_ITEM_OP: + if (item->i_op->op_flags & MIE_OP_F_OP_RESOLVED) { + printf("looking at %p %s.%s...\n", item->i_op, + item->i_op->op_dialect->d_name, + item->i_op->op_info->op_name); + } else { + printf("looking at %p %s...\n", item->i_op, + item->i_op->op_name); + } + break; + default: + break; + } + } while (mie_walker_step(&walker) == MIE_SUCCESS); + mie_walker_end(&walker); + #if 0 while (1) {