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

mie: update bluelib api usage

Browse Source
This commit is contained in:
max 🍓
2025-11-06 10:38:50 +00:00
parent 7c1e7e21a9
commit 5bf893651e
19 changed files with 226 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
mie/CMakeLists.txt
View File

@@ -11,5 +11,5 @@ else ()
endif ()
target_include_directories(mie PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/)
target_link_libraries(mie Bluelib::Core Bluelib::Object)
target_link_libraries(mie Bluelib::Core Bluelib::Ds)
target_compile_definitions(mie PRIVATE MIE_EXPORT=1 MIE_STATIC=${IVY_STATIC})

30
mie/ctx.c
View File

@@ -1,6 +1,6 @@
#include <blue/object/hashmap.h>
#include <blue/object/list.h>
#include <blue/object/string.h>
#include <blue/ds/hashmap.h>
#include <blue/ds/list.h>
#include <blue/ds/string.h>
#include <mie/ctx.h>
#include <mie/ir/const.h>
#include <stdlib.h>
@@ -62,23 +62,25 @@ void mie_ctx_destroy(struct mie_ctx *ctx)
ctx->ctx_true = NULL;
ctx->ctx_false = NULL;
b_btree_iterator it = {};
b_btree_iterator_begin(&ctx->ctx_int_cache, &it);
while (b_btree_iterator_is_valid(&it)) {
b_btree_node *node = b_btree_first(&ctx->ctx_int_cache);
while (node) {
struct ctx_int_cache_entry *entry
= b_unbox(struct ctx_int_cache_entry, it.node, i_node);
b_btree_iterator_erase(&it);
= b_unbox(struct ctx_int_cache_entry, node, i_node);
b_btree_node *next = b_btree_next(node);
b_btree_delete(&ctx->ctx_int_cache, node);
b_btree_iterator it2 = {};
b_btree_iterator_begin(&entry->i_values, &it2);
while (b_btree_iterator_is_valid(&it2)) {
b_btree_node *node2 = b_btree_first(&entry->i_values);
while (node2) {
struct ctx_int_value_cache_entry *value = b_unbox(
struct ctx_int_value_cache_entry, it2.node, i_node);
b_btree_iterator_erase(&it2);
struct ctx_int_value_cache_entry, node2, i_node);
b_btree_node *next2 = b_btree_next(node2);
b_btree_delete(&entry->i_values, node2);
free(value);
node2 = next2;
}
free(entry);
node = next;
}
const size_t nr_types = sizeof ctx->ctx_types / sizeof ctx->ctx_types[0];
@@ -93,7 +95,7 @@ void mie_ctx_destroy(struct mie_ctx *ctx)
mie_value_destroy(ctx->ctx_null);
}
b_hashmap_release(ctx->ctx_sel_cache);
b_hashmap_unref(ctx->ctx_sel_cache);
free(ctx);
}

5
mie/include/mie/ctx.h
View File

@@ -2,6 +2,7 @@
#define MIE_CTX_H_
#include <blue/core/btree.h>
#include <blue/ds/hashmap.h>
#include <mie/type.h>
struct mie_ctx {
@@ -9,8 +10,8 @@ struct mie_ctx {
struct mie_value *ctx_null;
struct mie_type *ctx_types[__MIE_TYPE_COUNT];
b_btree ctx_int_cache;
struct b_hashmap *ctx_sel_cache;
struct b_hashmap *ctx_string_cache;
b_hashmap *ctx_sel_cache;
b_hashmap *ctx_string_cache;
};
extern struct mie_ctx *mie_ctx_create(void);

5
mie/include/mie/ir/const.h
View File

@@ -1,6 +1,7 @@
#ifndef MIE_CONST_H_
#define MIE_CONST_H_
#include <blue/ds/list.h>
#include <mie/ir/value.h>
#include <mie/type.h>
@@ -13,8 +14,6 @@
#define MIE_SELECTOR(p) ((struct mie_selector *)(p))
#define MIE_ARRAY(p) ((struct mie_array *)(p))
struct b_list;
struct mie_const {
struct mie_value c_base;
struct mie_type *c_type;
@@ -47,7 +46,7 @@ struct mie_selector {
struct mie_array {
struct mie_const a_base;
struct b_list *a_values;
b_list *a_values;
};
extern void mie_const_init(struct mie_const *c, struct mie_type *type);

4
mie/include/mie/ir/convert.h
View File

@@ -2,8 +2,8 @@
#define MIE_CONVERT_H_
#include <blue/core/stringstream.h>
#include <blue/object/bitbuffer.h>
#include <blue/object/string.h>
#include <blue/ds/bitbuffer.h>
#include <blue/ds/string.h>
#include <mie/misc.h>
#include <stdio.h>

6
mie/include/mie/ir/module.h
View File

@@ -4,11 +4,11 @@
#define MIE_MODULE(p) ((struct mie_module *)(p))
#include <blue/core/queue.h>
#include <blue/ds/hashmap.h>
#include <mie/ir/value.h>
#include <mie/name.h>
struct mie_func;
struct b_hashmap;
struct mie_module {
struct mie_value m_base;
@@ -17,8 +17,8 @@ struct mie_module {
b_queue m_types;
b_queue m_func;
struct b_hashmap *m_data;
struct b_hashmap *m_data_strings;
b_hashmap *m_data;
b_hashmap *m_data_strings;
};
extern struct mie_module *mie_module_create(void);

13
mie/include/mie/select/graph.h
View File

@@ -31,20 +31,9 @@ struct mie_select_graph {
};
struct mie_select_use_iterator {
b_queue_iterator it_base;
b_queue_entry *it_ptr;
};
#define mie_select_use_foreach(it, q) b_queue_foreach (&(it)->it_base, q)
static inline struct mie_select_use *mie_select_use_iterator_unbox(
struct mie_select_use_iterator *it)
{
return b_unbox(struct mie_select_use, it->it_base.entry, u_entry);
}
MIE_API void mie_select_use_iterator_next(struct mie_select_use_iterator *it);
MIE_API bool mie_select_use_iterator_is_valid(
const struct mie_select_use_iterator *it);
MIE_API struct mie_select_graph *mie_select_graph_create(struct mie_ctx *ctx);
MIE_API void mie_select_graph_destroy(struct mie_select_graph *graph);

4
mie/include/mie/select/node.h
View File

@@ -61,13 +61,13 @@ struct mie_select_node {
};
struct mie_select_node_iterator {
b_queue_iterator it_base;
b_queue_entry *it_ptr;
};
static inline struct mie_select_node *mie_select_node_iterator_unbox(
struct mie_select_node_iterator *it)
{
return b_unbox(struct mie_select_node, it->it_base.entry, n_entry);
return b_unbox(struct mie_select_node, it->it_ptr, n_entry);
}
MIE_API void mie_select_node_iterator_next(struct mie_select_node_iterator *it);

25
mie/ir/block.c
View File

@@ -70,19 +70,26 @@ static void cleanup(struct mie_value *value)
{
struct mie_block *block = MIE_BLOCK(value);
b_queue_iterator it;
b_queue_iterator_begin(&block->b_phi, &it);
while (b_queue_iterator_is_valid(&it)) {
struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry);
b_queue_iterator_erase(&it);
b_queue_entry *entry = b_queue_first(&block->b_phi);
b_queue_entry *next = NULL;
while (entry) {
struct mie_value *v = b_unbox(struct mie_value, entry, v_entry);
next = b_queue_next(entry);
b_queue_delete(&block->b_phi, entry);
mie_value_destroy(v);
entry = next;
}
b_queue_iterator_begin(&block->b_instr, &it);
while (b_queue_iterator_is_valid(&it)) {
struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry);
b_queue_iterator_erase(&it);
entry = b_queue_first(&block->b_instr);
while (entry) {
struct mie_value *v = b_unbox(struct mie_value, entry, v_entry);
next = b_queue_next(entry);
b_queue_delete(&block->b_instr, entry);
mie_value_destroy(v);
entry = next;
}
if (block->b_terminator) {

20
mie/ir/builder.c
View File

@@ -1,4 +1,4 @@
#include <blue/object/string.h>
#include <blue/ds/string.h>
#include <mie/ctx.h>
#include <mie/ir/alloca.h>
#include <mie/ir/block.h>
@@ -52,15 +52,16 @@ struct mie_record *mie_builder_put_record(
return NULL;
}
b_queue_iterator it = {};
b_queue_foreach (&it, &builder->b_module->m_records) {
struct mie_value *rec
= b_unbox(struct mie_value, it.entry, v_entry);
b_queue_entry *entry = b_queue_first(&builder->b_module->m_records);
while (entry) {
struct mie_value *rec = b_unbox(struct mie_value, entry, v_entry);
if (!strcmp(rec->v_name.n_str, name)) {
/* TODO what to do about `val` here? */
return MIE_RECORD(rec);
}
entry = b_queue_next(entry);
}
struct mie_record *rec = mie_record_create(val);
@@ -77,14 +78,15 @@ struct mie_record *mie_builder_get_record(
return NULL;
}
b_queue_iterator it = {};
b_queue_foreach (&it, &builder->b_module->m_records) {
struct mie_value *rec
= b_unbox(struct mie_value, it.entry, v_entry);
b_queue_entry *entry = b_queue_first(&builder->b_module->m_records);
while (entry) {
struct mie_value *rec = b_unbox(struct mie_value, entry, v_entry);
if (!strcmp(rec->v_name.n_str, name)) {
return MIE_RECORD(rec);
}
entry = b_queue_next(entry);
}
return NULL;

85
mie/ir/convert/text-write.c
View File

@@ -1,7 +1,7 @@
#include "convert.h"
#include <blue/object/hashmap.h>
#include <blue/object/list.h>
#include <blue/ds/hashmap.h>
#include <blue/ds/list.h>
#include <inttypes.h>
#include <mie/ir/alloca.h>
#include <mie/ir/arg.h>
@@ -32,7 +32,8 @@ b_status write_char(struct mie_ir_converter *converter, char c)
switch (converter->c_dest_medium) {
case MIE_IR_CONVERTER_STRINGSTREAM:
return b_stringstream_add(converter->c_dest.stringstream, s);
return b_stream_write_string(
converter->c_dest.stringstream, s, NULL);
case MIE_IR_CONVERTER_STRING:
b_string_append_cstr(converter->c_dest.string, s);
return B_SUCCESS;
@@ -52,7 +53,8 @@ b_status write_string(struct mie_ir_converter *converter, const char *s)
switch (converter->c_dest_medium) {
case MIE_IR_CONVERTER_STRINGSTREAM:
return b_stringstream_add(converter->c_dest.stringstream, s);
return b_stream_write_string(
converter->c_dest.stringstream, s, NULL);
case MIE_IR_CONVERTER_STRING:
b_string_append_cstr(converter->c_dest.string, s);
return B_SUCCESS;
@@ -79,7 +81,8 @@ b_status write_string_f(struct mie_ir_converter *converter, const char *format,
switch (converter->c_dest_medium) {
case MIE_IR_CONVERTER_STRINGSTREAM:
vsnprintf(buf, sizeof buf, format, arg);
status = b_stringstream_add(converter->c_dest.stringstream, buf);
status = b_stream_write_string(
converter->c_dest.stringstream, buf, NULL);
break;
case MIE_IR_CONVERTER_STRING:
vsnprintf(buf, sizeof buf, format, arg);
@@ -147,23 +150,26 @@ static b_status write_operand_const(
break;
case MIE_TYPE_ARRAY: {
struct mie_array *array = MIE_ARRAY(value);
b_list_iterator it;
b_list_iterator_begin(array->a_values, &it);
b_iterator *it = b_list_begin(array->a_values);
write_char(converter, '{');
while (b_list_iterator_is_valid(&it)) {
if (it.i > 0) {
size_t i = 0;
b_foreach(void *, item, it)
{
if (i > 0) {
write_char(converter, ',');
}
write_string(converter, "\n ");
struct mie_value *child = it.item;
struct mie_value *child = item;
write_operand_const(converter, child, F_INCLUDE_TYPE);
b_list_iterator_next(&it);
i++;
}
b_iterator_unref(it);
if (!b_list_empty(array->a_values)) {
write_char(converter, '\n');
}
@@ -292,39 +298,43 @@ static b_status write_module(
struct mie_module *mod = MIE_MODULE(value);
b_status status = B_SUCCESS;
b_queue_iterator it;
b_queue_foreach (&it, &mod->m_records) {
b_queue_entry *entry = b_queue_first(&mod->m_records);
while (entry) {
struct mie_value *record
= b_unbox(struct mie_value, it.entry, v_entry);
= b_unbox(struct mie_value, entry, v_entry);
status = write_value_to_text(converter, record);
if (!B_OK(status)) {
return status;
}
entry = b_queue_next(entry);
}
if (!b_queue_empty(&mod->m_records)) {
write_char(converter, '\n');
}
b_queue_foreach (&it, &mod->m_types) {
struct mie_value *type
= b_unbox(struct mie_value, it.entry, v_entry);
entry = b_queue_first(&mod->m_types);
while (entry) {
struct mie_value *type = b_unbox(struct mie_value, entry, v_entry);
status = write_value_to_text(converter, type);
if (!B_OK(status)) {
return status;
}
entry = b_queue_next(entry);
}
if (!b_queue_empty(&mod->m_types)) {
write_char(converter, '\n');
}
b_hashmap_iterator it2;
b_hashmap_foreach(&it2, mod->m_data)
b_iterator *it = b_iterator_begin(mod->m_data);
b_foreach_ptr(b_hashmap_item, item, it)
{
struct mie_value *data = it2.value->value_data;
struct mie_value *data = item->value.value_data;
status = write_value_to_text(converter, data);
if (!B_OK(status)) {
@@ -332,18 +342,20 @@ static b_status write_module(
}
}
b_iterator_unref(it);
if (!b_hashmap_is_empty(mod->m_data)) {
write_char(converter, '\n');
}
unsigned long i = 0;
b_queue_foreach (&it, &mod->m_func) {
entry = b_queue_first(&mod->m_func);
while (entry) {
if (i > 0) {
write_char(converter, '\n');
}
struct mie_value *func
= b_unbox(struct mie_value, it.entry, v_entry);
struct mie_value *func = b_unbox(struct mie_value, entry, v_entry);
status = write_value_to_text(converter, func);
if (!B_OK(status)) {
@@ -351,6 +363,7 @@ static b_status write_module(
}
i++;
entry = b_queue_next(entry);
}
return B_SUCCESS;
@@ -390,10 +403,10 @@ static b_status write_func_definition(
converter, "define %s @%s(", type_name, func->f_base.v_name.n_str);
unsigned int i = 0;
b_queue_iterator it;
b_queue_foreach (&it, &func->f_args) {
struct b_queue_entry *entry = b_queue_first(&func->f_args);
while (entry) {
struct mie_arg *arg = (struct mie_arg *)b_unbox(
struct mie_value, it.entry, v_entry);
struct mie_value, entry, v_entry);
if (i > 0) {
write_string(converter, ", ");
@@ -405,6 +418,7 @@ static b_status write_func_definition(
converter, "%s %%%s", type_name,
arg->arg_base.v_name.n_str);
i++;
entry = b_queue_next(entry);
}
write_string_f(converter, ")");
@@ -425,10 +439,12 @@ static b_status write_func_definition(
write_string_f(converter, " {\n");
b_queue_foreach (&it, &func->f_blocks) {
entry = b_queue_first(&func->f_blocks);
while (entry) {
struct mie_value *block
= b_unbox(struct mie_value, it.entry, v_entry);
= b_unbox(struct mie_value, entry, v_entry);
write_value_to_text(converter, block);
entry = b_queue_next(entry);
}
write_string_f(converter, "}\n");
@@ -442,17 +458,20 @@ static b_status write_block_definition(
struct mie_block *block = MIE_BLOCK(value);
write_string_f(converter, "%s:\n", block->b_base.v_name.n_str);
b_queue_iterator it;
b_queue_foreach (&it, &block->b_phi) {
b_queue_entry *entry = b_queue_first(&block->b_phi);
while (entry) {
struct mie_value *instr
= b_unbox(struct mie_value, it.entry, v_entry);
= b_unbox(struct mie_value, entry, v_entry);
write_value_to_text(converter, instr);
entry = b_queue_next(entry);
}
b_queue_foreach (&it, &block->b_instr) {
entry = b_queue_first(&block->b_instr);
while (entry) {
struct mie_value *instr
= b_unbox(struct mie_value, it.entry, v_entry);
= b_unbox(struct mie_value, entry, v_entry);
write_value_to_text(converter, instr);
entry = b_queue_next(entry);
}
if (block->b_terminator) {

2
mie/ir/data.c
View File

@@ -1,4 +1,4 @@
#include <blue/object/string.h>
#include <blue/ds/string.h>
#include <mie/ctx.h>
#include <mie/ir/data.h>
#include <mie/type.h>

27
mie/ir/func.c
View File

@@ -1,5 +1,5 @@
#include <blue/core/hash.h>
#include <blue/object/string.h>
#include <blue/ds/string.h>
#include <mie/ir/arg.h>
#include <mie/ir/block.h>
#include <mie/ir/func.h>
@@ -118,19 +118,26 @@ static void cleanup(struct mie_value *value)
{
struct mie_func *func = MIE_FUNC(value);
b_queue_iterator it;
b_queue_iterator_begin(&func->f_args, &it);
while (b_queue_iterator_is_valid(&it)) {
struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry);
b_queue_iterator_erase(&it);
b_queue_entry *entry = b_queue_first(&func->f_args);
b_queue_entry *next = NULL;
while (entry) {
struct mie_value *v = b_unbox(struct mie_value, entry, v_entry);
next = b_queue_next(entry);
b_queue_delete(&func->f_args, entry);
mie_value_destroy(v);
entry = next;
}
b_queue_iterator_begin(&func->f_blocks, &it);
while (b_queue_iterator_is_valid(&it)) {
struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry);
b_queue_iterator_erase(&it);
entry = b_queue_first(&func->f_blocks);
while (entry) {
struct mie_value *v = b_unbox(struct mie_value, entry, v_entry);
next = b_queue_next(entry);
b_queue_delete(&func->f_blocks, entry);
mie_value_destroy(v);
entry = next;
}
mie_name_map_destroy(func->f_names);

38
mie/ir/module.c
View File

@@ -1,4 +1,4 @@
#include <blue/object/hashmap.h>
#include <blue/ds/hashmap.h>
#include <mie/ir/const.h>
#include <mie/ir/data.h>
#include <mie/ir/func.h>
@@ -116,30 +116,36 @@ static void cleanup(struct mie_value *value)
{
struct mie_module *module = MIE_MODULE(value);
b_queue_iterator it;
b_queue_iterator_begin(&module->m_records, &it);
while (b_queue_iterator_is_valid(&it)) {
struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry);
b_queue_iterator_erase(&it);
b_queue_entry *entry = b_queue_first(&module->m_records);
b_queue_entry *next = NULL;
while (entry) {
struct mie_value *v = b_unbox(struct mie_value, entry, v_entry);
next = b_queue_next(entry);
b_queue_delete(&module->m_records, entry);
mie_value_destroy(v);
entry = next;
}
b_queue_iterator_begin(&module->m_types, &it);
while (b_queue_iterator_is_valid(&it)) {
struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry);
b_queue_iterator_erase(&it);
entry = b_queue_first(&module->m_types);
while (entry) {
struct mie_value *v = b_unbox(struct mie_value, entry, v_entry);
next = b_queue_next(entry);
b_queue_delete(&module->m_types, entry);
mie_value_destroy(v);
entry = next;
}
b_queue_iterator_begin(&module->m_func, &it);
while (b_queue_iterator_is_valid(&it)) {
struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry);
b_queue_iterator_erase(&it);
entry = b_queue_first(&module->m_func);
while (entry) {
struct mie_value *v = b_unbox(struct mie_value, entry, v_entry);
next = b_queue_next(entry);
b_queue_delete(&module->m_func, entry);
mie_value_destroy(v);
entry = next;
}
b_hashmap_release(module->m_data_strings);
b_hashmap_release(module->m_data);
b_hashmap_unref(module->m_data_strings);
b_hashmap_unref(module->m_data);
}
const struct mie_value_type module_value_type = {

35
mie/name.c
View File

@@ -1,5 +1,5 @@
#include <blue/core/rope.h>
#include <blue/object/string.h>
#include <blue/ds/string.h>
#include <mie/name.h>
#include <stdlib.h>
#include <string.h>
@@ -25,11 +25,12 @@ static struct mie_name_bucket *create_bucket(void)
static void destroy_bucket(struct mie_name_bucket *bucket)
{
b_queue_iterator it;
b_queue_iterator_begin(&bucket->b_names, &it);
b_queue_entry *entry = b_queue_first(&bucket->b_names);
while (b_queue_iterator_is_valid(&it)) {
b_queue_iterator_erase(&it);
while (entry) {
b_queue_entry *next = b_queue_next(entry);
b_queue_delete(&bucket->b_names, entry);
entry = next;
}
free(bucket);
@@ -48,19 +49,20 @@ struct mie_name_map *mie_name_map_create(void)
void mie_name_map_destroy(struct mie_name_map *map)
{
b_btree_iterator it;
b_btree_iterator_begin(&map->m_entries, &it);
b_btree_node *node = b_btree_first(&map->m_entries);
while (b_btree_iterator_is_valid(&it)) {
while (node) {
struct mie_name_map_entry *entry
= b_unbox(struct mie_name_map_entry, it.node, e_node);
b_btree_iterator_erase(&it);
= b_unbox(struct mie_name_map_entry, node, e_node);
b_btree_node *next = b_btree_next(node);
b_btree_delete(&map->m_entries, node);
if (entry->e_type == MIE_NAME_MAP_E_BUCKET) {
struct mie_name_bucket *bucket
= (struct mie_name_bucket *)entry;
destroy_bucket(bucket);
}
node = next;
}
free(map);
@@ -69,14 +71,17 @@ void mie_name_map_destroy(struct mie_name_map *map)
static b_status put_name_in_bucket(
struct mie_name_bucket *bucket, struct mie_name *name)
{
b_queue_iterator it;
b_queue_foreach (&it, &bucket->b_names) {
b_queue_entry *entry = b_queue_first(&bucket->b_names);
while (entry) {
struct mie_name *cur = (struct mie_name *)b_unbox(
struct mie_name_map_entry, it.entry, e_entry);
struct mie_name_map_entry, entry, e_entry);
if (!strcmp(cur->n_str, name->n_str)) {
return B_ERR_NAME_EXISTS;
}
entry = b_queue_next(entry);
}
b_queue_push_back(&bucket->b_names, &name->n_base.e_entry);
@@ -181,7 +186,7 @@ struct mie_name *mie_name_map_put(
b_rope_to_cstr(&unique_name, str, sizeof str);
entry->n_str = str;
entry->n_base.e_hash = b_hash_string(str);
entry->n_base.e_hash = b_hash_cstr(str);
b_status status = put_name(map, entry);
if (B_OK(status)) {

44
mie/select/builder.c
View File

@@ -1,6 +1,6 @@
#include "builder.h"
#include <blue/object/hashmap.h>
#include <blue/ds/hashmap.h>
#include <mie/ctx.h>
#include <mie/ir/const.h>
#include <mie/ir/data.h>
@@ -51,7 +51,7 @@ struct mie_select_builder *mie_select_builder_create(
out->b_mem_access = b_hashmap_create(NULL, NULL);
if (!out->b_mem_access) {
b_hashmap_release(out->b_nodes);
b_hashmap_unref(out->b_nodes);
mie_select_graph_destroy(out->b_graph);
free(out);
return NULL;
@@ -63,11 +63,11 @@ struct mie_select_builder *mie_select_builder_create(
void mie_select_builder_destroy(struct mie_select_builder *builder)
{
if (builder->b_nodes) {
b_hashmap_release(builder->b_nodes);
b_hashmap_unref(builder->b_nodes);
}
if (builder->b_mem_access) {
b_hashmap_release(builder->b_mem_access);
b_hashmap_unref(builder->b_mem_access);
}
if (builder->b_graph) {
@@ -96,12 +96,14 @@ const struct mie_target *mie_select_builder_get_target(
static void clear_node_map(struct mie_select_builder *builder)
{
b_hashmap_iterator it;
b_hashmap_iterator_begin(builder->b_nodes, &it);
while (b_hashmap_iterator_is_valid(&it)) {
free(it.value->value_data);
b_hashmap_iterator_erase(&it);
b_iterator *it = b_iterator_begin(builder->b_nodes);
while (b_iterator_is_valid(it)) {
b_hashmap_item *item = b_iterator_get_value(it).v_ptr;
free(item->value.value_data);
b_iterator_erase(it);
}
b_iterator_unref(it);
}
struct mie_select_graph *mie_select_builder_finish(struct mie_select_builder *builder)
@@ -142,28 +144,30 @@ enum mie_status mie_select_builder_get_const(
struct mie_type *ctype = mie_ctx_get_int_type(builder->b_ctx, 32);
struct mie_select_node *node = NULL;
b_queue_iterator it;
b_queue_foreach (&it, &builder->b_graph->g_nodes) {
node = b_unbox(struct mie_select_node, it.entry, n_entry);
b_queue_entry *entry = b_queue_first(&builder->b_graph->g_nodes);
while (entry) {
node = b_unbox(struct mie_select_node, entry, n_entry);
if (node->n_target != builtin) {
continue;
goto skip;
}
if (node->n_opcode != MIE_SELECT_OP_CONSTANT) {
continue;
goto skip;
}
if (!(node->n_flags & MIE_SELECT_NODE_F_IVALUE)) {
continue;
goto skip;
}
if (node->n_value.i != value) {
continue;
goto skip;
}
mie_select_node_get_value(node, ctype, 0, out);
return MIE_SUCCESS;
skip:
entry = b_queue_next(entry);
}
enum mie_status status = mie_select_graph_get_node(
@@ -368,15 +372,17 @@ struct mie_select_node *mie_select_builder_find_node_with_ivalue(
struct mie_select_builder *builder, const struct mie_target *target,
unsigned int opcode, long long val)
{
b_queue_iterator it;
b_queue_foreach (&it, &builder->b_graph->g_nodes) {
b_queue_entry *entry = b_queue_first(&builder->b_graph->g_nodes);
while (entry) {
struct mie_select_node *node
= b_unbox(struct mie_select_node, it.entry, n_entry);
= b_unbox(struct mie_select_node, entry, n_entry);
if (node->n_target == target && node->n_opcode == opcode
&& node->n_value.i == val) {
return node;
}
entry = b_queue_next(entry);
}
return NULL;

22
mie/select/dump.c
View File

@@ -245,11 +245,12 @@ static void node_links_dump_dot(struct mie_select_node *node, b_stream *out)
void mie_select_graph_dump_text(struct mie_select_graph *graph)
{
b_queue_iterator it;
b_queue_foreach (&it, &graph->g_nodes) {
b_queue_entry *entry = b_queue_first(&graph->g_nodes);
while (entry) {
struct mie_select_node *node
= b_unbox(struct mie_select_node, it.entry, n_entry);
= b_unbox(struct mie_select_node, entry, n_entry);
node_dump_text(node);
entry = b_queue_next(entry);
}
}
@@ -263,22 +264,25 @@ void mie_select_graph_dump_dot(struct mie_select_graph *graph)
b_stream_write_string(tmpstream, "\tnode [shape=Mrecord];\n", NULL);
b_stream_write_string(tmpstream, "\trankdir=\"BT\";\n", NULL);
b_queue_iterator it;
b_queue_foreach (&it, &graph->g_nodes) {
b_queue_entry *entry = b_queue_first(&graph->g_nodes);
while (entry) {
struct mie_select_node *node
= b_unbox(struct mie_select_node, it.entry, n_entry);
= b_unbox(struct mie_select_node, entry, n_entry);
node_dump_dot(node, tmpstream);
entry = b_queue_next(entry);
}
b_queue_foreach (&it, &graph->g_nodes) {
entry = b_queue_first(&graph->g_nodes);
while (entry) {
struct mie_select_node *node
= b_unbox(struct mie_select_node, it.entry, n_entry);
= b_unbox(struct mie_select_node, entry, n_entry);
node_links_dump_dot(node, tmpstream);
entry = b_queue_next(entry);
}
b_stream_write_string(tmpstream, "}\n", NULL);
b_stream_close(tmpstream);
b_stream_unref(tmpstream);
system("open graph.dot");

11
mie/select/graph.c
View File

@@ -42,12 +42,12 @@ struct mie_select_graph *mie_select_graph_create(struct mie_ctx *ctx)
void mie_select_graph_destroy(struct mie_select_graph *graph)
{
b_queue_iterator it;
b_queue_iterator_begin(&graph->g_nodes, &it);
while (b_queue_iterator_is_valid(&it)) {
b_queue_entry *entry = b_queue_first(&graph->g_nodes);
while (entry) {
struct mie_select_node *node
= b_unbox(struct mie_select_node, it.entry, n_entry);
b_queue_iterator_erase(&it);
= b_unbox(struct mie_select_node, entry, n_entry);
b_queue_entry *next = b_queue_next(entry);
b_queue_delete(&graph->g_nodes, entry);
#if 0
if (node->n_value) {
@@ -56,6 +56,7 @@ void mie_select_graph_destroy(struct mie_select_graph *graph)
#endif
free(node);
entry = next;
}
free(graph);

21
mie/select/node.c
View File

@@ -22,6 +22,7 @@ const struct select_node_type *select_type_for_node(enum mie_select_opcode node)
return node_types[node];
}
#if 0
void mie_select_node_iterator_next(struct mie_select_node_iterator *it)
{
b_queue_iterator_next(&it->it_base);
@@ -31,6 +32,7 @@ bool mie_select_node_iterator_is_valid(const struct mie_select_node_iterator *it
{
return b_queue_iterator_is_valid(&it->it_base);
}
#endif
struct mie_select_node *mie_select_node_create(
const struct mie_target *target, unsigned int op,
@@ -101,13 +103,16 @@ enum mie_status mie_select_node_set_operands(
enum mie_status mie_select_node_clear_operands(struct mie_select_node *node)
{
struct mie_select_use_iterator it;
mie_select_use_foreach(&it, &node->n_use)
{
struct mie_select_use *use = mie_select_use_iterator_unbox(&it);
b_queue_entry *entry = b_queue_first(&node->n_use);
while (entry) {
struct mie_select_use *use
= b_unbox(struct mie_select_use, entry, u_entry);
if (use->u_value.v_node == node) {
memset(&use->u_value, 0x0, sizeof use->u_value);
}
entry = b_queue_next(entry);
}
if (node->n_operands) {
@@ -158,12 +163,12 @@ enum mie_status mie_select_node_set_description(
{
va_list arg;
va_start(arg, format);
b_stringstream str;
b_stringstream_begin_dynamic(&str);
b_stringstream_addvf(&str, format, arg);
b_stringstream *str = b_stringstream_create();
b_stream_write_vfmt(str, NULL, format, arg);
va_end(arg);
node->n_description = b_stringstream_end(&str);
node->n_description = b_stringstream_steal(str);
b_stringstream_unref(str);
return node->n_description ? MIE_SUCCESS : MIE_ERR_NO_MEMORY;
}