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

mie: remove all legacy ir and select code

Browse Source
This commit is contained in:
max 🍓
2025-12-21 13:51:26 +00:00
parent 6573360656
commit f9a2cf3b8e
63 changed files with 12 additions and 5319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
mie/ir/arg.c
View File

@@ -1,30 +0,0 @@
#include <mie/ir/arg.h>
#include <stdlib.h>
#include <string.h>
struct mie_arg *mie_arg_create(struct mie_type *type)
{
struct mie_arg *out = malloc(sizeof *out);
if (!out) {
return NULL;
}
memset(out, 0x0, sizeof *out);
mie_value_init(&out->arg_base, MIE_VALUE_ARG);
out->arg_type = type;
return out;
}
static struct mie_type *get_type(struct mie_value *v, struct mie_ctx *ctx)
{
struct mie_arg *arg = MIE_ARG(v);
return arg->arg_type;
}
const struct mie_value_type arg_value_type = {
.t_id = MIE_VALUE_ARG,
.t_get_type = get_type,
};

104
mie/ir/block.c
View File

@@ -1,104 +0,0 @@
#include <mie/ctx.h>
#include <mie/ir/block.h>
#include <mie/ir/func.h>
#include <mie/ir/instr.h>
#include <mie/type.h>
#include <stdlib.h>
struct mie_block *mie_block_create(struct mie_func *parent, const char *name)
{
struct mie_block *out = malloc(sizeof *out);
if (!out) {
return NULL;
}
memset(out, 0x0, sizeof *out);
mie_value_init(&out->b_base, MIE_VALUE_BLOCK);
struct mie_value *block = MIE_VALUE(out);
if (parent) {
block = mie_func_generate_value_name(parent, block, name);
if (!block) {
free(out);
return NULL;
}
b_queue_push_back(&parent->f_blocks, &block->v_entry);
out->b_parent = parent;
}
return out;
}
bool mie_block_add_instr(struct mie_block *block, struct mie_instr *instr)
{
switch (instr->i_type) {
case MIE_INSTR_PHI:
if (!b_queue_empty(&block->b_instr) || block->b_terminator) {
return false;
}
b_queue_push_back(&block->b_phi, &instr->i_base.v_entry);
return true;
case MIE_INSTR_RET:
case MIE_INSTR_BR:
case MIE_INSTR_SWITCH:
if (block->b_terminator) {
return false;
}
block->b_terminator = instr;
return true;
default:
if (block->b_terminator) {
return false;
}
b_queue_push_back(&block->b_instr, &instr->i_base.v_entry);
return true;
}
}
static struct mie_type *get_type(struct mie_value *v, struct mie_ctx *ctx)
{
return mie_ctx_get_type(ctx, MIE_TYPE_LABEL);
}
static void cleanup(struct mie_value *value)
{
struct mie_block *block = MIE_BLOCK(value);
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;
}
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) {
mie_value_destroy(MIE_VALUE(block->b_terminator));
}
}
const struct mie_value_type block_value_type = {
.t_id = MIE_VALUE_BLOCK,
.t_get_type = get_type,
.t_cleanup = cleanup,
};

834
mie/ir/builder.c
View File

@@ -1,834 +0,0 @@
#include <blue/ds/string.h>
#include <mie/ctx.h>
#include <mie/ir/alloca.h>
#include <mie/ir/block.h>
#include <mie/ir/branch.h>
#include <mie/ir/builder.h>
#include <mie/ir/data.h>
#include <mie/ir/func.h>
#include <mie/ir/module.h>
#include <mie/ir/msg.h>
#include <mie/ir/op.h>
#include <mie/ir/phi.h>
#include <mie/ir/ptr.h>
#include <mie/ir/record.h>
#include <mie/type.h>
#include <stdlib.h>
#include <string.h>
struct mie_builder *mie_builder_create(struct mie_ctx *ctx, struct mie_module *mod)
{
struct mie_builder *out = malloc(sizeof *out);
if (!out) {
return NULL;
}
memset(out, 0x0, sizeof *out);
out->b_ctx = ctx;
out->b_module = mod;
return out;
}
void mie_builder_destroy(struct mie_builder *builder)
{
free(builder);
}
struct mie_func *mie_builder_get_current_func(struct mie_builder *builder)
{
struct mie_block *block = builder->b_current_block;
if (!block) {
return NULL;
}
return block->b_parent;
}
struct mie_record *mie_builder_put_record(
struct mie_builder *builder, struct mie_const *val, const char *name)
{
if (!builder->b_module) {
return NULL;
}
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);
rec->r_base.v_name.n_str = b_strdup(name);
b_queue_push_back(&builder->b_module->m_records, &rec->r_base.v_entry);
return rec;
}
struct mie_record *mie_builder_get_record(
struct mie_builder *builder, const char *name)
{
if (!builder->b_module) {
return NULL;
}
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;
}
#if 0
void mie_builder_put_data(struct mie_builder *builder, struct mie_data *data)
{
if (!builder->b_module) {
return;
}
const char *data_name = data->d_base.v_name.n_str;
struct mie_data *v = mie_module_get_data(builder->b_module, data_name);
if (v) {
return;
}
mie_module_put_data(builder->b_module, data);
}
#endif
#if 0
void mie_builder_put_type(struct mie_builder *builder, struct mie_type *type)
{
if (!builder->b_module) {
return;
}
const char *type_name = type->t_base.v_name.n_str;
struct mie_data *v = mie_module_get_data(builder->b_module, type_name);
if (v) {
return;
}
mie_module_put_data(builder->b_module, MIE_VALUE);
}
#endif
void mie_builder_set_insert_point(
struct mie_builder *builder, struct mie_block *block)
{
builder->b_current_block = block;
}
struct mie_value *mie_builder_get_data_ptr(
struct mie_builder *builder, const char *data_ident)
{
if (!builder->b_module) {
return NULL;
}
struct mie_data *data = mie_module_get_data(builder->b_module, data_ident);
if (!data) {
struct mie_type *id
= mie_ctx_get_type(builder->b_ctx, MIE_TYPE_ID);
data = mie_data_create_extern_global(id, data_ident);
if (!data) {
return NULL;
}
mie_module_put_data(builder->b_module, data, data_ident);
}
return MIE_VALUE(data);
}
struct mie_value *mie_builder_get_string_ptr(
struct mie_builder *builder, const char *s)
{
if (!builder->b_module) {
return NULL;
}
struct mie_data *data = mie_module_get_string_ptr(builder->b_module, s);
if (!data) {
struct mie_type *str
= mie_ctx_get_type(builder->b_ctx, MIE_TYPE_STR);
struct mie_value *value = mie_ctx_get_string(builder->b_ctx, s);
data = mie_data_create_const((struct mie_const *)value);
if (!data) {
return NULL;
}
mie_module_put_data(builder->b_module, data, ".str");
}
return MIE_VALUE(data);
}
struct mie_value *mie_builder_ret(struct mie_builder *builder, struct mie_value *val)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_ret *ret = malloc(sizeof *ret);
if (!ret) {
return NULL;
}
mie_instr_init(&ret->r_base, MIE_INSTR_RET);
ret->r_val = val;
if (!mie_block_add_instr(builder->b_current_block, &ret->r_base)) {
free(ret);
return NULL;
}
return MIE_VALUE(ret);
}
struct mie_value *mie_builder_add(
struct mie_builder *builder, struct mie_value *left,
struct mie_value *right, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_binary_op *add = malloc(sizeof *add);
if (!add) {
return NULL;
}
memset(add, 0x0, sizeof *add);
mie_instr_init(&add->op_base, MIE_INSTR_ADD);
add->op_left = left;
add->op_right = right;
add->op_type = mie_value_get_type(left, builder->b_ctx);
if (!mie_block_add_instr(builder->b_current_block, &add->op_base)) {
free(add);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(add), name);
return MIE_VALUE(add);
}
struct mie_value *mie_builder_sub(
struct mie_builder *builder, struct mie_value *left,
struct mie_value *right, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_binary_op *sub = malloc(sizeof *sub);
if (!sub) {
return NULL;
}
memset(sub, 0x0, sizeof *sub);
mie_instr_init(&sub->op_base, MIE_INSTR_SUB);
sub->op_left = left;
sub->op_right = right;
sub->op_type = mie_value_get_type(left, builder->b_ctx);
if (!mie_block_add_instr(builder->b_current_block, &sub->op_base)) {
free(sub);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(sub), name);
return MIE_VALUE(sub);
}
struct mie_value *mie_builder_mul(
struct mie_builder *builder, struct mie_value *left,
struct mie_value *right, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_binary_op *mul = malloc(sizeof *mul);
if (!mul) {
return NULL;
}
memset(mul, 0x0, sizeof *mul);
mie_instr_init(&mul->op_base, MIE_INSTR_MUL);
mul->op_left = left;
mul->op_right = right;
mul->op_type = mie_value_get_type(left, builder->b_ctx);
if (!mie_block_add_instr(builder->b_current_block, &mul->op_base)) {
free(mul);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(mul), name);
return MIE_VALUE(mul);
}
struct mie_value *mie_builder_div(
struct mie_builder *builder, struct mie_value *left,
struct mie_value *right, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_binary_op *div = malloc(sizeof *div);
if (!div) {
return NULL;
}
memset(div, 0x0, sizeof *div);
mie_instr_init(&div->op_base, MIE_INSTR_DIV);
div->op_left = left;
div->op_right = right;
div->op_type = mie_value_get_type(left, builder->b_ctx);
if (!mie_block_add_instr(builder->b_current_block, &div->op_base)) {
free(div);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(div), name);
return MIE_VALUE(div);
}
struct mie_value *mie_builder_load(
struct mie_builder *builder, struct mie_type *type,
struct mie_value *src, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_load *load = malloc(sizeof *load);
if (!load) {
return NULL;
}
mie_instr_init(&load->l_base, MIE_INSTR_LOAD);
load->l_src = src;
load->l_type = type;
if (!mie_block_add_instr(builder->b_current_block, &load->l_base)) {
free(load);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(load), name);
return MIE_VALUE(load);
}
struct mie_value *mie_builder_store(
struct mie_builder *builder, struct mie_value *val, struct mie_value *dest)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_store *store = malloc(sizeof *store);
if (!store) {
return NULL;
}
mie_instr_init(&store->s_base, MIE_INSTR_STORE);
store->s_val = val;
store->s_dest = dest;
if (!mie_block_add_instr(builder->b_current_block, &store->s_base)) {
free(store);
return NULL;
}
return MIE_VALUE(store);
}
struct mie_value *mie_builder_alloca(
struct mie_builder *builder, struct mie_type *type, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_alloca *alloca = malloc(sizeof *alloca);
if (!alloca) {
return NULL;
}
mie_instr_init(&alloca->a_base, MIE_INSTR_ALLOCA);
alloca->a_type = type;
if (!mie_block_add_instr(builder->b_current_block, &alloca->a_base)) {
free(alloca);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(alloca), name);
return MIE_VALUE(alloca);
}
struct mie_value *mie_builder_switch(
struct mie_builder *builder, struct mie_value *cond,
struct mie_switch_branch *branches, size_t nr_branches,
struct mie_block *default_block)
{
return NULL;
}
struct mie_value *mie_builder_br(struct mie_builder *builder, struct mie_block *dest)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_branch *br = malloc(sizeof *br);
if (!br) {
return NULL;
}
memset(br, 0x0, sizeof *br);
mie_instr_init(&br->b_base, MIE_INSTR_BR);
br->b_dest = dest;
if (!mie_block_add_instr(builder->b_current_block, &br->b_base)) {
free(br);
return NULL;
}
return MIE_VALUE(br);
}
struct mie_value *mie_builder_br_if(
struct mie_builder *builder, struct mie_value *cond,
struct mie_block *if_true, struct mie_block *if_false)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_branch_if *br = malloc(sizeof *br);
if (!br) {
return NULL;
}
memset(br, 0x0, sizeof *br);
mie_instr_init(&br->b_base, MIE_INSTR_BR_IF);
br->b_cond = cond;
br->b_true_block = if_true;
br->b_false_block = if_false;
if (!mie_block_add_instr(builder->b_current_block, &br->b_base)) {
free(br);
return NULL;
}
return MIE_VALUE(br);
}
struct mie_value *mie_builder_msg(
struct mie_builder *builder, struct mie_type *ret_type,
struct mie_value *recipient, struct mie_value *selector,
struct mie_value **args, size_t nr_args, enum mie_builder_flags flags,
const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
if ((flags & MIE_BUILDER_IGNORE_RESULT) && name) {
return NULL;
}
struct mie_msg *msg = malloc(sizeof *msg);
if (!msg) {
return NULL;
}
memset(msg, 0x0, sizeof *msg);
mie_instr_init(&msg->msg_base, MIE_INSTR_MSG);
msg->msg_ret_type = ret_type;
msg->msg_recipient = recipient;
msg->msg_selector = selector;
msg->msg_nr_args = nr_args;
msg->msg_args = calloc(nr_args, sizeof(struct mie_value *));
memcpy(msg->msg_args, args, nr_args * sizeof(struct mie_value *));
if (!mie_block_add_instr(builder->b_current_block, &msg->msg_base)) {
free(msg);
return NULL;
}
if (!(flags & MIE_BUILDER_IGNORE_RESULT)) {
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(msg), name);
}
return MIE_VALUE(msg);
}
struct mie_value *mie_builder_cmp_eq(
struct mie_builder *builder, struct mie_value *left,
struct mie_value *right, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_binary_op *sub = malloc(sizeof *sub);
if (!sub) {
return NULL;
}
memset(sub, 0x0, sizeof *sub);
mie_instr_init(&sub->op_base, MIE_INSTR_CMP_EQ);
sub->op_left = left;
sub->op_right = right;
sub->op_type = mie_ctx_get_int_type(builder->b_ctx, 1);
if (!mie_block_add_instr(builder->b_current_block, &sub->op_base)) {
free(sub);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(sub), name);
return MIE_VALUE(sub);
}
struct mie_value *mie_builder_cmp_neq(
struct mie_builder *builder, struct mie_value *left,
struct mie_value *right, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_binary_op *sub = malloc(sizeof *sub);
if (!sub) {
return NULL;
}
memset(sub, 0x0, sizeof *sub);
mie_instr_init(&sub->op_base, MIE_INSTR_CMP_NEQ);
sub->op_left = left;
sub->op_right = right;
sub->op_type = mie_ctx_get_int_type(builder->b_ctx, 1);
if (!mie_block_add_instr(builder->b_current_block, &sub->op_base)) {
free(sub);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(sub), name);
return MIE_VALUE(sub);
}
struct mie_value *mie_builder_cmp_lt(
struct mie_builder *builder, struct mie_value *left,
struct mie_value *right, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_binary_op *sub = malloc(sizeof *sub);
if (!sub) {
return NULL;
}
memset(sub, 0x0, sizeof *sub);
mie_instr_init(&sub->op_base, MIE_INSTR_CMP_LT);
sub->op_left = left;
sub->op_right = right;
sub->op_type = mie_ctx_get_int_type(builder->b_ctx, 1);
if (!mie_block_add_instr(builder->b_current_block, &sub->op_base)) {
free(sub);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(sub), name);
return MIE_VALUE(sub);
}
struct mie_value *mie_builder_cmp_gt(
struct mie_builder *builder, struct mie_value *left,
struct mie_value *right, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_binary_op *sub = malloc(sizeof *sub);
if (!sub) {
return NULL;
}
memset(sub, 0x0, sizeof *sub);
mie_instr_init(&sub->op_base, MIE_INSTR_CMP_GT);
sub->op_left = left;
sub->op_right = right;
sub->op_type = mie_ctx_get_int_type(builder->b_ctx, 1);
if (!mie_block_add_instr(builder->b_current_block, &sub->op_base)) {
free(sub);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(sub), name);
return MIE_VALUE(sub);
}
struct mie_value *mie_builder_cmp_leq(
struct mie_builder *builder, struct mie_value *left,
struct mie_value *right, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_binary_op *sub = malloc(sizeof *sub);
if (!sub) {
return NULL;
}
memset(sub, 0x0, sizeof *sub);
mie_instr_init(&sub->op_base, MIE_INSTR_CMP_LEQ);
sub->op_left = left;
sub->op_right = right;
sub->op_type = mie_ctx_get_int_type(builder->b_ctx, 1);
if (!mie_block_add_instr(builder->b_current_block, &sub->op_base)) {
free(sub);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(sub), name);
return MIE_VALUE(sub);
}
struct mie_value *mie_builder_cmp_geq(
struct mie_builder *builder, struct mie_value *left,
struct mie_value *right, const char *name)
{
if (!builder->b_current_block) {
return NULL;
}
if (builder->b_current_block->b_terminator) {
return NULL;
}
struct mie_binary_op *sub = malloc(sizeof *sub);
if (!sub) {
return NULL;
}
memset(sub, 0x0, sizeof *sub);
mie_instr_init(&sub->op_base, MIE_INSTR_CMP_GEQ);
sub->op_left = left;
sub->op_right = right;
sub->op_type = mie_ctx_get_int_type(builder->b_ctx, 1);
if (!mie_block_add_instr(builder->b_current_block, &sub->op_base)) {
free(sub);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(sub), name);
return MIE_VALUE(sub);
}
struct mie_value *mie_builder_getelementptr(
struct mie_builder *builder, struct mie_type *container_type,
struct mie_value *container, struct mie_value *index, const char *name)
{
return NULL;
}
struct mie_value *mie_builder_setelementptr(
struct mie_builder *builder, struct mie_type *container_type,
struct mie_value *container, struct mie_value *index)
{
return NULL;
}
struct mie_value *mie_builder_phi(
struct mie_builder *builder, struct mie_type *type,
struct mie_phi_edge *edges, unsigned int nr_edges, const char *name)
{
struct mie_block *block = builder->b_current_block;
if (!block) {
return NULL;
}
if (block->b_terminator || !b_queue_empty(&block->b_instr)) {
return NULL;
}
struct mie_phi *phi = malloc(sizeof *phi);
if (!phi) {
return NULL;
}
memset(phi, 0x0, sizeof *phi);
mie_instr_init(&phi->p_base, MIE_INSTR_PHI);
phi->p_type = type;
phi->p_nr_edges = nr_edges;
phi->p_edges = calloc(nr_edges, sizeof(struct mie_phi_edge));
if (!phi->p_edges) {
free(phi);
return NULL;
}
memcpy(phi->p_edges, edges, nr_edges * sizeof(struct mie_phi_edge));
if (!mie_block_add_instr(builder->b_current_block, &phi->p_base)) {
free(phi);
free(phi->p_edges);
return NULL;
}
mie_func_generate_value_name(
builder->b_current_block->b_parent, MIE_VALUE(phi), name);
return MIE_VALUE(phi);
}

22
mie/ir/const.c
View File

@@ -1,22 +0,0 @@
#include <mie/ir/const.h>
#include <stdlib.h>
#include <string.h>
void mie_const_init(struct mie_const *c, struct mie_type *type)
{
memset(c, 0x0, sizeof *c);
mie_value_init(&c->c_base, MIE_VALUE_CONST);
c->c_type = type;
}
static struct mie_type *get_type(struct mie_value *v, struct mie_ctx *ctx)
{
struct mie_const *c = MIE_CONST(v);
return c->c_type;
}
const struct mie_value_type const_value_type = {
.t_id = MIE_VALUE_CONST,
.t_get_type = get_type,
};

7
mie/ir/convert/bitcode-read.c
View File

@@ -1,7 +0,0 @@
#include "convert.h"
b_status read_value_from_bitcode(
struct mie_ir_converter *converter, struct mie_value **out)
{
return B_ERR_NOT_SUPPORTED;
}

7
mie/ir/convert/bitcode-write.c
View File

@@ -1,7 +0,0 @@
#include "convert.h"
b_status write_value_to_bitcode(
struct mie_ir_converter *converter, struct mie_value *value)
{
return B_ERR_NOT_SUPPORTED;
}

217
mie/ir/convert/convert.c
View File

@@ -1,217 +0,0 @@
#include "convert.h"
#include <mie/ir/convert.h>
#include <mie/ir/value.h>
#include <stdlib.h>
#include <string.h>
struct mie_ir_converter *mie_ir_converter_create(
struct mie_ctx *ctx, enum mie_ir_format src, enum mie_ir_format dest)
{
if (src == dest) {
return NULL;
}
struct mie_ir_converter *out = malloc(sizeof *out);
if (!out) {
return NULL;
}
memset(out, 0x0, sizeof *out);
out->c_ctx = ctx;
out->c_src_format = src;
out->c_dest_format = dest;
return out;
}
void mie_ir_converter_destroy(struct mie_ir_converter *converter)
{
free(converter);
}
b_status mie_ir_converter_set_src_value(
struct mie_ir_converter *converter, struct mie_value *value)
{
if (converter->c_src_format != MIE_IR_MEM) {
return B_ERR_INVALID_ARGUMENT;
}
converter->c_src_medium = MIE_IR_CONVERTER_MIE_VALUE;
converter->c_src.value = value;
return B_SUCCESS;
}
b_status mie_ir_converter_set_src_bitbuffer(
struct mie_ir_converter *converter, b_bitbuffer *bitbuffer)
{
if (converter->c_src_format != MIE_IR_BITCODE) {
return B_ERR_INVALID_ARGUMENT;
}
converter->c_src_medium = MIE_IR_CONVERTER_BITBUFFER;
converter->c_src.bitbuffer = bitbuffer;
return B_SUCCESS;
}
b_status mie_ir_converter_set_src_stringstream(
struct mie_ir_converter *converter, b_stringstream *stringstream)
{
if (converter->c_src_format != MIE_IR_TEXT) {
return B_ERR_INVALID_ARGUMENT;
}
converter->c_src_medium = MIE_IR_CONVERTER_STRINGSTREAM;
converter->c_src.stringstream = stringstream;
return B_SUCCESS;
}
b_status mie_ir_converter_set_src_string(
struct mie_ir_converter *converter, b_string *string)
{
if (converter->c_src_format != MIE_IR_TEXT) {
return B_ERR_INVALID_ARGUMENT;
}
converter->c_src_medium = MIE_IR_CONVERTER_STRING;
converter->c_src.string = string;
return B_SUCCESS;
}
b_status mie_ir_converter_set_src_file(struct mie_ir_converter *converter, FILE *file)
{
if (converter->c_src_format != MIE_IR_TEXT) {
return B_ERR_INVALID_ARGUMENT;
}
converter->c_src_medium = MIE_IR_CONVERTER_FILE;
converter->c_src.file = file;
return B_SUCCESS;
}
b_status mie_ir_converter_set_dest_value(
struct mie_ir_converter *converter, struct mie_value **value)
{
if (converter->c_dest_format != MIE_IR_MEM) {
return B_ERR_INVALID_ARGUMENT;
}
converter->c_dest_medium = MIE_IR_CONVERTER_MIE_VALUE;
converter->c_dest.value = value;
return B_SUCCESS;
}
b_status mie_ir_converter_set_dest_bitbuffer(
struct mie_ir_converter *converter, b_bitbuffer *bitbuffer)
{
if (converter->c_dest_format != MIE_IR_BITCODE) {
return B_ERR_INVALID_ARGUMENT;
}
converter->c_dest_medium = MIE_IR_CONVERTER_BITBUFFER;
converter->c_dest.bitbuffer = bitbuffer;
return B_SUCCESS;
}
b_status mie_ir_converter_set_dest_stringstream(
struct mie_ir_converter *converter, b_stringstream *stringstream)
{
if (converter->c_dest_format != MIE_IR_TEXT) {
return B_ERR_INVALID_ARGUMENT;
}
converter->c_dest_medium = MIE_IR_CONVERTER_STRINGSTREAM;
converter->c_dest.stringstream = stringstream;
return B_SUCCESS;
}
b_status mie_ir_converter_set_dest_string(
struct mie_ir_converter *converter, b_string *string)
{
if (converter->c_dest_format != MIE_IR_TEXT) {
return B_ERR_INVALID_ARGUMENT;
}
converter->c_dest_medium = MIE_IR_CONVERTER_STRING;
converter->c_dest.string = string;
return B_SUCCESS;
}
b_status mie_ir_converter_set_dest_file(
struct mie_ir_converter *converter, FILE *file)
{
if (converter->c_dest_format != MIE_IR_TEXT) {
return B_ERR_INVALID_ARGUMENT;
}
converter->c_dest_medium = MIE_IR_CONVERTER_FILE;
converter->c_dest.file = file;
return B_SUCCESS;
}
static b_status read_value_from_medium(
struct mie_ir_converter *converter, struct mie_value **value)
{
switch (converter->c_src_format) {
case MIE_IR_MEM:
*value = converter->c_src.value;
return B_SUCCESS;
case MIE_IR_TEXT:
return read_value_from_text(converter, value);
case MIE_IR_BITCODE:
return read_value_from_bitcode(converter, value);
default:
return B_ERR_NOT_SUPPORTED;
}
}
static b_status write_value_to_medium(
struct mie_ir_converter *converter, struct mie_value *value)
{
switch (converter->c_dest_format) {
case MIE_IR_MEM:
*converter->c_dest.value = value;
return B_SUCCESS;
case MIE_IR_TEXT:
return write_value_to_text(converter, value);
case MIE_IR_BITCODE:
return write_value_to_bitcode(converter, value);
default:
return B_ERR_NOT_SUPPORTED;
}
}
b_status mie_ir_converter_process(struct mie_ir_converter *converter)
{
b_status status = B_SUCCESS;
struct mie_value *value = NULL;
status = read_value_from_medium(converter, &value);
if (!B_OK(status)) {
return status;
}
if (!value) {
return B_ERR_BAD_FORMAT;
}
status = write_value_to_medium(converter, value);
if (converter->c_src_format != MIE_IR_MEM) {
mie_value_destroy(value);
}
return status;
}

19
mie/ir/convert/convert.h
View File

@@ -1,19 +0,0 @@
#ifndef _MIE_CONVERT_H_
#define _MIE_CONVERT_H_
#include <mie/ir/convert.h>
extern b_status write_char(struct mie_ir_converter *converter, char c);
extern b_status write_string(struct mie_ir_converter *converter, const char *s);
extern b_status read_value_from_text(
struct mie_ir_converter *converter, struct mie_value **out);
extern b_status read_value_from_bitcode(
struct mie_ir_converter *converter, struct mie_value **out);
extern b_status write_value_to_text(
struct mie_ir_converter *converter, struct mie_value *value);
extern b_status write_value_to_bitcode(
struct mie_ir_converter *converter, struct mie_value *value);
#endif

0
mie/ir/convert/lex.c
View File

0
mie/ir/convert/lex.h
View File

0
mie/ir/convert/parse.c
View File

0
mie/ir/convert/parse.h
View File

7
mie/ir/convert/text-read.c
View File

@@ -1,7 +0,0 @@
#include "convert.h"
b_status read_value_from_text(
struct mie_ir_converter *converter, struct mie_value **out)
{
return B_ERR_NOT_SUPPORTED;
}

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

@@ -1,747 +0,0 @@
#include "convert.h"
#include <blue/ds/hashmap.h>
#include <blue/ds/list.h>
#include <inttypes.h>
#include <mie/ir/alloca.h>
#include <mie/ir/arg.h>
#include <mie/ir/block.h>
#include <mie/ir/branch.h>
#include <mie/ir/const.h>
#include <mie/ir/data.h>
#include <mie/ir/func.h>
#include <mie/ir/instr.h>
#include <mie/ir/module.h>
#include <mie/ir/msg.h>
#include <mie/ir/op.h>
#include <mie/ir/phi.h>
#include <mie/ir/ptr.h>
#include <mie/ir/record.h>
#include <mie/ir/value.h>
#include <mie/type.h>
#include <stdarg.h>
#define F_INCLUDE_TYPE 0x01u
typedef b_status (*write_function)(struct mie_ir_converter *, struct mie_value *);
b_status write_char(struct mie_ir_converter *converter, char c)
{
long result = 0;
char s[] = {c, '\0'};
switch (converter->c_dest_medium) {
case MIE_IR_CONVERTER_STRINGSTREAM:
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;
case MIE_IR_CONVERTER_FILE:
result = fputc(c, converter->c_dest.file);
return result == EOF ? B_ERR_IO_FAILURE : B_SUCCESS;
default:
return B_ERR_NOT_SUPPORTED;
}
return B_SUCCESS;
}
b_status write_string(struct mie_ir_converter *converter, const char *s)
{
long result = 0;
switch (converter->c_dest_medium) {
case MIE_IR_CONVERTER_STRINGSTREAM:
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;
case MIE_IR_CONVERTER_FILE:
result = fputs(s, converter->c_dest.file);
return result == EOF ? B_ERR_IO_FAILURE : B_SUCCESS;
default:
return B_ERR_NOT_SUPPORTED;
}
return B_SUCCESS;
}
b_status write_string_f(struct mie_ir_converter *converter, const char *format, ...)
{
long result = 0;
char buf[512];
va_list arg;
va_start(arg, format);
b_status status = B_SUCCESS;
switch (converter->c_dest_medium) {
case MIE_IR_CONVERTER_STRINGSTREAM:
vsnprintf(buf, sizeof buf, format, arg);
status = b_stream_write_string(
converter->c_dest.stringstream, buf, NULL);
break;
case MIE_IR_CONVERTER_STRING:
vsnprintf(buf, sizeof buf, format, arg);
b_string_append_cstr(converter->c_dest.string, buf);
status = B_SUCCESS;
break;
case MIE_IR_CONVERTER_FILE:
result = vfprintf(converter->c_dest.file, format, arg);
status = (result == EOF ? B_ERR_IO_FAILURE : B_SUCCESS);
break;
default:
status = B_ERR_NOT_SUPPORTED;
break;
}
va_end(arg);
return status;
}
static b_status write_operand_const(
struct mie_ir_converter *converter, struct mie_value *value, int flags)
{
struct mie_const *c = MIE_CONST(value);
if (flags & F_INCLUDE_TYPE) {
char type_name[64];
mie_type_to_string(c->c_type, type_name, sizeof type_name);
write_string_f(converter, "%s", type_name);
if (type_name[0] != 0) {
write_char(converter, ' ');
}
}
switch (c->c_type->t_id) {
case MIE_TYPE_INT: {
struct mie_int *v = MIE_INT(c);
write_string_f(converter, "#%" PRId64, v->i_value);
break;
}
case MIE_TYPE_PTR:
case MIE_TYPE_ID:
write_string_f(converter, "%%%s", value->v_name.n_str);
break;
case MIE_TYPE_STR: {
struct mie_string *v = MIE_STRING(c);
write_string_f(converter, "\"%s\"", v->s_value);
break;
}
case MIE_TYPE_ATOM: {
struct mie_atom *v = MIE_ATOM(c);
write_string_f(converter, "\"%s\"", v->a_value);
break;
}
case MIE_TYPE_SELECTOR: {
struct mie_selector *v = MIE_SELECTOR(c);
write_string_f(converter, "@%s", v->sel_value);
break;
}
case MIE_TYPE_CLASS:
write_string_f(converter, "@%s", value->v_name.n_str);
break;
case MIE_TYPE_ARRAY: {
struct mie_array *array = MIE_ARRAY(value);
b_iterator *it = b_list_begin(array->a_values);
write_char(converter, '{');
size_t i = 0;
b_foreach(void *, item, it)
{
if (i > 0) {
write_char(converter, ',');
}
write_string(converter, "\n ");
struct mie_value *child = item;
write_operand_const(converter, child, F_INCLUDE_TYPE);
i++;
}
b_iterator_unref(it);
if (!b_list_empty(array->a_values)) {
write_char(converter, '\n');
}
write_char(converter, '}');
break;
}
default:
break;
}
return B_SUCCESS;
}
static b_status write_operand_instr(
struct mie_ir_converter *converter, struct mie_value *value, int flags)
{
struct mie_instr *instr = MIE_INSTR(value);
if (flags & F_INCLUDE_TYPE) {
char type_name[64];
struct mie_type *type
= mie_value_get_type(value, converter->c_ctx);
mie_type_to_string(type, type_name, sizeof type_name);
write_string_f(converter, "%s ", type_name);
}
write_string_f(converter, "%%%s", value->v_name.n_str);
return B_SUCCESS;
}
static b_status write_operand_block(
struct mie_ir_converter *converter, struct mie_value *value, int flags)
{
struct mie_block *block = MIE_BLOCK(value);
if (flags & F_INCLUDE_TYPE) {
char type_name[64];
struct mie_type *type
= mie_value_get_type(value, converter->c_ctx);
mie_type_to_string(type, type_name, sizeof type_name);
write_string_f(converter, "%s ", type_name);
}
write_string_f(converter, "%%%s", value->v_name.n_str);
return B_SUCCESS;
}
static b_status write_operand_data(
struct mie_ir_converter *converter, struct mie_value *value, int flags)
{
struct mie_const *c = MIE_CONST(value);
if (flags & F_INCLUDE_TYPE) {
write_string(converter, "ptr ");
}
write_string_f(converter, "@%s", value->v_name.n_str);
return B_SUCCESS;
}
static b_status write_operand_arg(
struct mie_ir_converter *converter, struct mie_value *value, int flags)
{
struct mie_arg *arg = MIE_ARG(value);
if (flags & F_INCLUDE_TYPE) {
char type_name[64];
mie_type_to_string(arg->arg_type, type_name, sizeof type_name);
write_string_f(converter, "%s ", type_name);
}
write_string_f(converter, "%%%s", value->v_name.n_str);
return B_SUCCESS;
}
static b_status write_operand_func(
struct mie_ir_converter *converter, struct mie_value *value, int flags)
{
struct mie_func *func = MIE_FUNC(value);
if (flags & F_INCLUDE_TYPE) {
write_string(converter, "ptr ");
}
write_string_f(converter, "@%s", value->v_name.n_str);
return B_SUCCESS;
}
static b_status write_operand(
struct mie_ir_converter *converter, struct mie_value *value, int flags)
{
if (!value) {
write_string(converter, "<NULL VALUE PTR>");
return B_SUCCESS;
}
switch (value->v_type->t_id) {
case MIE_VALUE_NONE:
write_string(converter, "null");
return B_SUCCESS;
case MIE_VALUE_CONST:
return write_operand_const(converter, value, flags);
case MIE_VALUE_INSTR:
return write_operand_instr(converter, value, flags);
case MIE_VALUE_BLOCK:
return write_operand_block(converter, value, flags);
case MIE_VALUE_DATA:
return write_operand_data(converter, value, flags);
case MIE_VALUE_FUNC:
return write_operand_func(converter, value, flags);
case MIE_VALUE_ARG:
return write_operand_arg(converter, value, flags);
default:
write_string_f(converter, "<unknown-value:%d>", value->v_type->t_id);
return B_SUCCESS;
}
}
static b_status write_module(
struct mie_ir_converter *converter, struct mie_value *value)
{
struct mie_module *mod = MIE_MODULE(value);
b_status status = B_SUCCESS;
b_queue_entry *entry = b_queue_first(&mod->m_records);
while (entry) {
struct mie_value *record
= 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');
}
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_iterator *it = b_iterator_begin(mod->m_data);
b_foreach_ptr(b_hashmap_item, item, it)
{
struct mie_value *data = item->value.value_data;
status = write_value_to_text(converter, data);
if (!B_OK(status)) {
return status;
}
}
b_iterator_unref(it);
if (!b_hashmap_is_empty(mod->m_data)) {
write_char(converter, '\n');
}
unsigned long i = 0;
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, entry, v_entry);
status = write_value_to_text(converter, func);
if (!B_OK(status)) {
return status;
}
i++;
entry = b_queue_next(entry);
}
return B_SUCCESS;
}
static b_status write_type_definition(
struct mie_ir_converter *converter, struct mie_value *value)
{
return B_SUCCESS;
}
static b_status write_record(
struct mie_ir_converter *converter, struct mie_value *value)
{
struct mie_record *rec = MIE_RECORD(value);
write_string_f(converter, "record %s", rec->r_base.v_name.n_str);
if (rec->r_value) {
write_string(converter, " = ");
write_operand_const(
converter, MIE_VALUE(rec->r_value), F_INCLUDE_TYPE);
}
write_char(converter, '\n');
return B_SUCCESS;
}
static b_status write_func_definition(
struct mie_ir_converter *converter, struct mie_value *value)
{
struct mie_func *func = MIE_FUNC(value);
char type_name[32];
mie_type_to_string(func->f_ret, type_name, sizeof type_name);
write_string_f(
converter, "define %s @%s(", type_name, func->f_base.v_name.n_str);
unsigned int i = 0;
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, entry, v_entry);
if (i > 0) {
write_string(converter, ", ");
}
mie_type_to_string(func->f_ret, type_name, sizeof type_name);
write_string_f(
converter, "%s %%%s", type_name,
arg->arg_base.v_name.n_str);
i++;
entry = b_queue_next(entry);
}
write_string_f(converter, ")");
switch (func->f_type) {
case MIE_FUNC_STATIC:
write_string_f(converter, " static");
break;
case MIE_FUNC_INSTANCE:
write_string_f(converter, " instance");
break;
case MIE_FUNC_LAMBDA:
write_string_f(converter, " lambda");
break;
default:
break;
}
write_string_f(converter, " {\n");
entry = b_queue_first(&func->f_blocks);
while (entry) {
struct mie_value *block
= b_unbox(struct mie_value, entry, v_entry);
write_value_to_text(converter, block);
entry = b_queue_next(entry);
}
write_string_f(converter, "}\n");
return B_SUCCESS;
}
static b_status write_block_definition(
struct mie_ir_converter *converter, struct mie_value *value)
{
struct mie_block *block = MIE_BLOCK(value);
write_string_f(converter, "%s:\n", block->b_base.v_name.n_str);
b_queue_entry *entry = b_queue_first(&block->b_phi);
while (entry) {
struct mie_value *instr
= b_unbox(struct mie_value, entry, v_entry);
write_value_to_text(converter, instr);
entry = b_queue_next(entry);
}
entry = b_queue_first(&block->b_instr);
while (entry) {
struct mie_value *instr
= b_unbox(struct mie_value, entry, v_entry);
write_value_to_text(converter, instr);
entry = b_queue_next(entry);
}
if (block->b_terminator) {
write_value_to_text(converter, MIE_VALUE(block->b_terminator));
}
return B_SUCCESS;
}
static b_status write_instr(
struct mie_ir_converter *converter, struct mie_value *value)
{
struct mie_instr *instr = MIE_INSTR(value);
write_string_f(converter, "\t");
if (instr->i_base.v_name.n_str) {
write_string_f(converter, "%%%s = ", instr->i_base.v_name.n_str);
}
char type[128];
switch (instr->i_type) {
case MIE_INSTR_RET: {
struct mie_ret *ret = (struct mie_ret *)instr;
write_string(converter, "ret ");
if (!ret->r_val) {
write_string(converter, "void");
break;
}
write_operand(converter, ret->r_val, F_INCLUDE_TYPE);
break;
}
case MIE_INSTR_ADD: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
mie_type_to_string(op->op_type, type, sizeof type);
write_string_f(converter, "add %s ", type);
write_operand(converter, op->op_left, 0);
write_string(converter, ", ");
write_operand(converter, op->op_right, 0);
break;
}
case MIE_INSTR_SUB: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
mie_type_to_string(op->op_type, type, sizeof type);
write_string_f(converter, "sub %s ", type);
write_operand(converter, op->op_left, 0);
write_string(converter, ", ");
write_operand(converter, op->op_right, 0);
break;
}
case MIE_INSTR_MUL: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
mie_type_to_string(op->op_type, type, sizeof type);
write_string_f(converter, "mul %s ", type);
write_operand(converter, op->op_left, 0);
write_string(converter, ", ");
write_operand(converter, op->op_right, 0);
break;
}
case MIE_INSTR_DIV: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
mie_type_to_string(op->op_type, type, sizeof type);
write_string_f(converter, "div %s ", type);
write_operand(converter, op->op_left, 0);
write_string(converter, ", ");
write_operand(converter, op->op_right, 0);
break;
}
case MIE_INSTR_LOAD: {
struct mie_load *load = (struct mie_load *)instr;
mie_type_to_string(load->l_type, type, sizeof type);
write_string_f(converter, "load %s, ", type);
write_operand(converter, load->l_src, F_INCLUDE_TYPE);
break;
}
case MIE_INSTR_STORE: {
struct mie_store *store = (struct mie_store *)instr;
write_string(converter, "store ");
write_operand(converter, store->s_val, F_INCLUDE_TYPE);
write_string(converter, ", ");
write_operand(converter, store->s_dest, F_INCLUDE_TYPE);
break;
}
case MIE_INSTR_ALLOCA: {
struct mie_alloca *alloca = (struct mie_alloca *)instr;
mie_type_to_string(alloca->a_type, type, sizeof type);
write_string_f(converter, "alloca %s", type);
break;
}
case MIE_INSTR_SWITCH:
write_string(converter, "switch");
break;
case MIE_INSTR_BR: {
struct mie_branch *br = (struct mie_branch *)instr;
write_string(converter, "br ");
write_operand(converter, MIE_VALUE(br->b_dest), F_INCLUDE_TYPE);
break;
}
case MIE_INSTR_BR_IF: {
struct mie_branch_if *br = (struct mie_branch_if *)instr;
write_string(converter, "br ");
write_operand(converter, MIE_VALUE(br->b_cond), F_INCLUDE_TYPE);
write_string(converter, ", ");
write_operand(
converter, MIE_VALUE(br->b_true_block), F_INCLUDE_TYPE);
write_string(converter, ", ");
write_operand(
converter, MIE_VALUE(br->b_false_block), F_INCLUDE_TYPE);
break;
}
case MIE_INSTR_MSG: {
struct mie_msg *msg = (struct mie_msg *)instr;
mie_type_to_string(msg->msg_ret_type, type, sizeof type);
write_string_f(converter, "msg %s, ", type);
write_operand(converter, msg->msg_recipient, F_INCLUDE_TYPE);
write_string(converter, ", ");
write_operand(converter, msg->msg_selector, F_INCLUDE_TYPE);
if (msg->msg_nr_args == 0) {
break;
}
write_string(converter, " [");
for (size_t i = 0; i < msg->msg_nr_args; i++) {
if (i > 0) {
write_string(converter, ", ");
}
write_operand(converter, msg->msg_args[i], F_INCLUDE_TYPE);
}
write_string(converter, "]");
break;
}
case MIE_INSTR_CMP_EQ: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
mie_type_to_string(op->op_type, type, sizeof type);
write_string_f(converter, "cmp eq %s ", type);
write_operand(converter, op->op_left, 0);
write_string(converter, ", ");
write_operand(converter, op->op_right, 0);
break;
}
case MIE_INSTR_CMP_NEQ: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
mie_type_to_string(op->op_type, type, sizeof type);
write_string_f(converter, "cmp neq %s ", type);
write_operand(converter, op->op_left, 0);
write_string(converter, ", ");
write_operand(converter, op->op_right, 0);
break;
}
case MIE_INSTR_CMP_LT: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
mie_type_to_string(op->op_type, type, sizeof type);
write_string_f(converter, "cmp lt %s ", type);
write_operand(converter, op->op_left, 0);
write_string(converter, ", ");
write_operand(converter, op->op_right, 0);
break;
}
case MIE_INSTR_CMP_LEQ: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
mie_type_to_string(op->op_type, type, sizeof type);
write_string_f(converter, "cmp leq %s ", type);
write_operand(converter, op->op_left, 0);
write_string(converter, ", ");
write_operand(converter, op->op_right, 0);
break;
}
case MIE_INSTR_CMP_GT: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
mie_type_to_string(op->op_type, type, sizeof type);
write_string_f(converter, "cmp gt %s ", type);
write_operand(converter, op->op_left, 0);
write_string(converter, ", ");
write_operand(converter, op->op_right, 0);
break;
}
case MIE_INSTR_CMP_GEQ: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
mie_type_to_string(op->op_type, type, sizeof type);
write_string_f(converter, "cmp geq %s ", type);
write_operand(converter, op->op_left, 0);
write_string(converter, ", ");
write_operand(converter, op->op_right, 0);
break;
}
case MIE_INSTR_GETELEMENTPTR:
write_string(converter, "getelementptr");
break;
case MIE_INSTR_SETELEMENTPTR:
write_string(converter, "setelementptr");
break;
case MIE_INSTR_PHI: {
struct mie_phi *phi = (struct mie_phi *)instr;
mie_type_to_string(phi->p_type, type, sizeof type);
write_string_f(converter, "phi %s ", type);
for (size_t i = 0; i < phi->p_nr_edges; i++) {
if (i > 0) {
write_string(converter, ", ");
}
write_string(converter, "[ ");
write_operand(
converter,
MIE_VALUE(phi->p_edges[i].e_incoming_block), 0);
write_string(converter, ", ");
write_operand(converter, phi->p_edges[i].e_value, 0);
write_string(converter, " ]");
}
break;
}
default:
write_string_f(converter, "<unknown>");
break;
}
write_char(converter, '\n');
return B_SUCCESS;
}
static b_status write_data(
struct mie_ir_converter *converter, struct mie_value *value)
{
char type_name[128];
struct mie_data *data = MIE_DATA(value);
write_string_f(converter, "data @%s = ", value->v_name.n_str);
switch (data->d_type) {
case MIE_DATA_EXTERN_GLOBAL:
mie_type_to_string(
data->d_extern_global.g_type, type_name, sizeof type_name);
write_string_f(converter, "extern global %s", type_name);
break;
case MIE_DATA_CONST:
write_operand_const(
converter, MIE_VALUE(data->d_const.c_value),
F_INCLUDE_TYPE);
break;
default:
write_string(converter, "<unknown>");
break;
}
write_char(converter, '\n');
return B_SUCCESS;
}
static const write_function value_writers[] = {
[MIE_VALUE_MODULE] = write_module,
[MIE_VALUE_TYPE] = write_type_definition,
[MIE_VALUE_RECORD] = write_record,
[MIE_VALUE_FUNC] = write_func_definition,
[MIE_VALUE_ARG] = NULL,
[MIE_VALUE_BLOCK] = write_block_definition,
[MIE_VALUE_INSTR] = write_instr,
[MIE_VALUE_DATA] = write_data,
[MIE_VALUE_CONST] = NULL,
};
static const size_t nr_value_printers
= sizeof value_writers / sizeof value_writers[0];
b_status write_value_to_text(
struct mie_ir_converter *converter, struct mie_value *value)
{
write_function writer = value_writers[value->v_type->t_id];
return writer(converter, value);
}

52
mie/ir/data.c
View File

@@ -1,52 +0,0 @@
#include <blue/ds/string.h>
#include <mie/ctx.h>
#include <mie/ir/data.h>
#include <mie/type.h>
#include <stdlib.h>
#include <string.h>
struct mie_data *mie_data_create_extern_global(
struct mie_type *type, const char *ident)
{
struct mie_data *data = malloc(sizeof *data);
if (!data) {
return NULL;
}
memset(data, 0x0, sizeof *data);
mie_value_init(&data->d_base, MIE_VALUE_DATA);
data->d_type = MIE_DATA_EXTERN_GLOBAL;
data->d_extern_global.g_type = type;
data->d_base.v_name.n_str = b_strdup(ident);
return data;
}
struct mie_data *mie_data_create_const(struct mie_const *value)
{
struct mie_data *data = malloc(sizeof *data);
if (!data) {
return NULL;
}
memset(data, 0x0, sizeof *data);
mie_value_init(&data->d_base, MIE_VALUE_DATA);
data->d_type = MIE_DATA_CONST;
data->d_const.c_value = value;
return data;
}
static struct mie_type *get_type(struct mie_value *v, struct mie_ctx *ctx)
{
return mie_ctx_get_type(ctx, MIE_TYPE_PTR);
}
const struct mie_value_type data_value_type = {
.t_id = MIE_VALUE_DATA,
.t_get_type = get_type,
};

150
mie/ir/func.c
View File

@@ -1,150 +0,0 @@
#include <blue/core/hash.h>
#include <blue/ds/string.h>
#include <mie/ir/arg.h>
#include <mie/ir/block.h>
#include <mie/ir/func.h>
#include <mie/name.h>
#include <stdlib.h>
#include <string.h>
struct mie_func *mie_func_create(enum mie_func_type type, struct mie_type *ret_type)
{
struct mie_func *out = malloc(sizeof *out);
if (!out) {
return NULL;
}
memset(out, 0x0, sizeof *out);
mie_value_init(&out->f_base, MIE_VALUE_FUNC);
out->f_type = type;
out->f_ret = ret_type;
out->f_names = mie_name_map_create();
return out;
}
struct mie_value *mie_func_add_arg(
struct mie_func *func, struct mie_type *type, const char *name)
{
struct mie_arg *arg = mie_arg_create(type);
if (!arg) {
return NULL;
}
struct mie_value *v
= mie_func_generate_value_name(func, MIE_VALUE(arg), name);
if (!v) {
mie_value_destroy(MIE_VALUE(arg));
return NULL;
}
b_queue_push_back(&func->f_args, &v->v_entry);
return v;
}
struct mie_block *mie_func_create_block(struct mie_func *func, const char *name)
{
struct mie_block *out = malloc(sizeof *out);
if (!out) {
return NULL;
}
memset(out, 0x0, sizeof *out);
mie_value_init(&out->b_base, MIE_VALUE_BLOCK);
struct mie_value *block = MIE_VALUE(out);
block = mie_func_generate_value_name(func, block, name);
if (!block) {
free(out);
return NULL;
}
out->b_parent = func;
return out;
}
void mie_func_insert_block(
struct mie_func *func, struct mie_block *block, struct mie_block *after)
{
if (after) {
b_queue_insert_after(
&func->f_blocks, &block->b_base.v_entry,
&after->b_base.v_entry);
} else {
b_queue_push_back(&func->f_blocks, &block->b_base.v_entry);
}
}
struct mie_value *mie_func_generate_value_name(
struct mie_func *func, struct mie_value *val, const char *hint)
{
struct mie_name *name
= mie_name_map_put(func->f_names, &val->v_name, hint, 0);
return b_unbox(struct mie_value, name, v_name);
}
struct mie_block *mie_func_get_first_block(struct mie_func *func)
{
b_queue_entry *entry = b_queue_first(&func->f_blocks);
if (!entry) {
return NULL;
}
return (struct mie_block *)b_unbox(struct mie_value, entry, v_entry);
}
struct mie_block *mie_func_get_last_block(struct mie_func *func)
{
b_queue_entry *entry = b_queue_last(&func->f_blocks);
if (!entry) {
return NULL;
}
return (struct mie_block *)b_unbox(struct mie_value, entry, v_entry);
}
static struct mie_type *get_type(struct mie_value *v, struct mie_ctx *ctx)
{
struct mie_func *f = MIE_FUNC(v);
return f->f_ret;
}
static void cleanup(struct mie_value *value)
{
struct mie_func *func = MIE_FUNC(value);
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;
}
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);
}
const struct mie_value_type func_value_type = {
.t_id = MIE_VALUE_FUNC,
.t_get_type = get_type,
.t_cleanup = cleanup,
};

60
mie/ir/instr.c
View File

@@ -1,60 +0,0 @@
#include <mie/ctx.h>
#include <mie/ir/instr.h>
#include <mie/ir/msg.h>
#include <mie/ir/op.h>
#include <mie/ir/phi.h>
#include <mie/ir/ptr.h>
void mie_instr_init(struct mie_instr *instr, enum mie_instr_type type)
{
memset(instr, 0x0, sizeof *instr);
mie_value_init(&instr->i_base, MIE_VALUE_INSTR);
instr->i_type = type;
}
static struct mie_type *get_type(struct mie_value *v, struct mie_ctx *ctx)
{
struct mie_instr *instr = MIE_INSTR(v);
switch (instr->i_type) {
case MIE_INSTR_RET: {
struct mie_ret *ret = (struct mie_ret *)instr;
return mie_value_get_type(ret->r_val, ctx);
}
case MIE_INSTR_ADD:
case MIE_INSTR_SUB:
case MIE_INSTR_MUL:
case MIE_INSTR_DIV: {
struct mie_binary_op *op = (struct mie_binary_op *)instr;
return op->op_type;
}
case MIE_INSTR_CMP_EQ:
case MIE_INSTR_CMP_NEQ:
case MIE_INSTR_CMP_LT:
case MIE_INSTR_CMP_LEQ:
case MIE_INSTR_CMP_GT:
case MIE_INSTR_CMP_GEQ:
return mie_ctx_get_int_type(ctx, 1);
case MIE_INSTR_LOAD: {
struct mie_load *load = (struct mie_load *)instr;
return load->l_type;
}
case MIE_INSTR_ALLOCA:
return mie_ctx_get_type(ctx, MIE_TYPE_PTR);
case MIE_INSTR_MSG: {
struct mie_msg *msg = (struct mie_msg *)instr;
return msg->msg_ret_type;
}
case MIE_INSTR_PHI: {
struct mie_phi *phi = (struct mie_phi *)instr;
return phi->p_type;
}
default:
return NULL;
}
}
const struct mie_value_type instr_value_type = {
.t_id = MIE_VALUE_INSTR,
.t_get_type = get_type,
};

154
mie/ir/module.c
View File

@@ -1,154 +0,0 @@
#include <blue/ds/hashmap.h>
#include <mie/ir/const.h>
#include <mie/ir/data.h>
#include <mie/ir/func.h>
#include <mie/ir/module.h>
#include <mie/type.h>
#include <stdlib.h>
#include <string.h>
struct mie_module *mie_module_create(void)
{
struct mie_module *out = malloc(sizeof *out);
if (!out) {
return NULL;
}
memset(out, 0x0, sizeof *out);
mie_value_init(&out->m_base, MIE_VALUE_MODULE);
out->m_names = mie_name_map_create();
out->m_data = b_hashmap_create(NULL, NULL);
out->m_data_strings = b_hashmap_create(NULL, NULL);
return out;
}
void mie_module_add_function(
struct mie_module *mod, struct mie_func *func, const char *name)
{
struct mie_value *v
= mie_module_generate_value_name(mod, MIE_VALUE(func), name);
if (!v) {
return;
}
b_queue_push_back(&mod->m_func, &v->v_entry);
}
struct mie_data *mie_module_get_string_ptr(struct mie_module *mod, const char *s)
{
b_hashmap_key key = {
.key_data = s,
.key_size = strlen(s),
};
const b_hashmap_value *entry = b_hashmap_get(mod->m_data_strings, &key);
if (entry) {
return entry->value_data;
}
return NULL;
}
struct mie_data *mie_module_get_data(struct mie_module *mod, const char *name)
{
b_hashmap_key key = {
.key_data = name,
.key_size = strlen(name),
};
const b_hashmap_value *entry = b_hashmap_get(mod->m_data, &key);
if (entry) {
return entry->value_data;
}
/* don't search m_data_strings, as it is keyed by the string contents
* rather than the data entry name, and its entries are duplicated in
* m_data anyway */
return NULL;
}
enum b_status mie_module_put_data(
struct mie_module *mod, struct mie_data *data, const char *name)
{
struct mie_value *v
= mie_module_generate_value_name(mod, MIE_VALUE(data), name);
b_hashmap_key key = {
.key_data = v->v_name.n_str,
.key_size = strlen(name),
};
b_hashmap_value value = {
.value_data = data,
.value_size = sizeof *data,
};
b_hashmap_put(mod->m_data, &key, &value);
if (data->d_type != MIE_DATA_CONST) {
return B_SUCCESS;
}
struct mie_const *const_data = data->d_const.c_value;
if (const_data->c_type->t_id == MIE_TYPE_STR) {
struct mie_string *s = MIE_STRING(const_data);
key.key_data = s->s_value;
key.key_size = strlen(key.key_data);
b_hashmap_put(mod->m_data_strings, &key, &value);
}
return B_SUCCESS;
}
struct mie_value *mie_module_generate_value_name(
struct mie_module *mod, struct mie_value *val, const char *hint)
{
struct mie_name *name
= mie_name_map_put(mod->m_names, &val->v_name, hint, 0);
return b_unbox(struct mie_value, name, v_name);
}
static void cleanup(struct mie_value *value)
{
struct mie_module *module = MIE_MODULE(value);
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;
}
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;
}
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_unref(module->m_data_strings);
b_hashmap_unref(module->m_data);
}
const struct mie_value_type module_value_type = {
.t_id = MIE_VALUE_MODULE,
.t_cleanup = cleanup,
};

19
mie/ir/phi.c
View File

@@ -1,19 +0,0 @@
#include <mie/ir/phi.h>
#include <stdlib.h>
#include <string.h>
struct mie_phi_edge *mie_phi_edge_create(
struct mie_block *incoming_block, struct mie_value *value)
{
struct mie_phi_edge *out = malloc(sizeof *out);
if (!out) {
return NULL;
}
memset(out, 0x0, sizeof *out);
out->e_incoming_block = incoming_block;
out->e_value = value;
return out;
}

29
mie/ir/record.c
View File

@@ -1,29 +0,0 @@
#include <mie/ir/record.h>
#include <stdlib.h>
#include <string.h>
struct mie_record *mie_record_create(const struct mie_const *val)
{
struct mie_record *out = malloc(sizeof *out);
if (!out) {
return NULL;
}
memset(out, 0x0, sizeof *out);
mie_value_init(&out->r_base, MIE_VALUE_RECORD);
out->r_value = val;
return out;
}
static struct mie_type *get_type(struct mie_value *v, struct mie_ctx *ctx)
{
struct mie_record *r = MIE_RECORD(v);
return r->r_value->c_type;
}
const struct mie_value_type record_value_type = {
.t_id = MIE_VALUE_RECORD,
.t_get_type = get_type,
};

58
mie/ir/value.c
View File

@@ -1,58 +0,0 @@
#include <mie/ir/const.h>
#include <mie/ir/value.h>
#include <stdlib.h>
const struct mie_value_type null_value_type = {
.t_id = MIE_VALUE_NONE,
};
extern const struct mie_value_type module_value_type;
extern const struct mie_value_type record_value_type;
extern const struct mie_value_type func_value_type;
extern const struct mie_value_type arg_value_type;
extern const struct mie_value_type block_value_type;
extern const struct mie_value_type instr_value_type;
extern const struct mie_value_type const_value_type;
extern const struct mie_value_type data_value_type;
static const struct mie_value_type *value_types[] = {
[MIE_VALUE_NONE] = &null_value_type,
[MIE_VALUE_MODULE] = &module_value_type,
[MIE_VALUE_RECORD] = &record_value_type,
[MIE_VALUE_FUNC] = &func_value_type,
[MIE_VALUE_ARG] = &arg_value_type,
[MIE_VALUE_BLOCK] = &block_value_type,
[MIE_VALUE_INSTR] = &instr_value_type,
[MIE_VALUE_CONST] = &const_value_type,
[MIE_VALUE_DATA] = &data_value_type,
};
static const size_t nr_value_types = sizeof value_types / sizeof value_types[0];
void mie_value_init(struct mie_value *val, enum mie_value_type_id type)
{
memset(val, 0x0, sizeof *val);
val->v_type = value_types[type];
}
void mie_value_destroy(struct mie_value *val)
{
if (val->v_type && val->v_type->t_cleanup) {
val->v_type->t_cleanup(val);
}
if (MIE_NAME_VALID(&val->v_name)) {
mie_name_destroy(&val->v_name);
}
free(val);
}
struct mie_type *mie_value_get_type(struct mie_value *val, struct mie_ctx *ctx)
{
if (val->v_type->t_get_type) {
return val->v_type->t_get_type(val, ctx);
}
return NULL;
}