wash/mie
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mie: tool: validate: remove functionality that was moved to internal subcommands

Browse Source
This commit is contained in:
max 🍓
2026-01-25 15:11:06 +00:00
parent 5873326138
commit a67e4b6688
1 changed files with 69 additions and 323 deletions
Download Patch File Download Diff File Expand all files Collapse all files

386
tool/cmd/validate.c
View File

@@ -43,248 +43,6 @@ enum {
ARG_FILEPATH, 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 : "<unknown>");
printf("OP: %s\n", op->op_info ? op->op_info->op_name : "<unknown>");
printf("NAME: %s\n", op->op_name ? op->op_name : "<unknown>");
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) static int validate_file(const char *path, const b_arglist *args)
{ {
b_file *file = NULL; 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_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_lex *lex = mie_lex_create(file);
struct mie_parser *parse = mie_parser_create(ctx, lex); 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; return -1;
} }
struct mie_walker *walker = mie_walker_begin( enum mie_walker_flags walk_flags
root, MIE_WALKER_F_INCLUDE_OPS | MIE_WALKER_F_PREORDER = MIE_WALKER_F_INCLUDE_OPS | MIE_WALKER_F_PREORDER
| MIE_WALKER_F_FORWARD | MIE_WALKER_F_RECURSIVE); | MIE_WALKER_F_FORWARD | MIE_WALKER_F_RECURSIVE;
struct mie_walker walker;
mie_walker_begin(&walker, root, walk_flags);
do { 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++) { for (size_t i = 0; i < item->i_depth; i++) {
fputs(" ", stdout); fputs(" ", stdout);
} }
printf("resolving %p %s... ", item->i_op, item->i_op->op_name); 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); bool ok = mie_ctx_resolve_op(ctx, item->i_op);
printf("%s\n", ok ? "OK" : "FAIL"); printf("%s\n", ok ? "OK" : "FAIL");
} while (mie_walker_step(walker) == MIE_SUCCESS); break;
default:
break;
}
} while (mie_walker_step(&walker) == MIE_SUCCESS);
mie_walker_end(&walker);
struct mie_pass *prefix_func_with_underscore = NULL; struct mie_pass *prefix_func_with_underscore = NULL;
if (mie_ctx_get_pass( enum mie_status status = mie_ctx_get_pass(
ctx, "prefix-func-with-underscore", NULL, ctx, "prefix-func-with-underscore", NULL,
&prefix_func_with_underscore) &prefix_func_with_underscore);
!= MIE_SUCCESS) { if (status != MIE_SUCCESS) {
printf("cannot load pass prefix-func-with-underscore\n"); printf("cannot load pass prefix-func-with-underscore\n");
return -1; 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); mie_pass_manager_add_pass(func_pm, prefix_func_with_underscore);
#if 0
mie_pass_manager_parse( mie_pass_manager_parse(
pm, "builtin.module(func.func(prefix-func-with-underscore))"); pm, "builtin.module(func.func(prefix-func-with-underscore))");
#endif
mie_pass_manager_run(pm, root); 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); mie_printer_print_op(&printer, root);
printf("\n"); 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 #if 0
while (1) { while (1) {