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

mie: move op and type definition from dialect/ to ir/ and type/ respectively

Browse Source
This commit is contained in:
max 🍓
2026-01-08 22:16:50 +00:00
parent 27e42340de
commit e76e7c17db
35 changed files with 285 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
mie/ctx.c
View File

@@ -7,10 +7,10 @@
#include <mie/dialect/builtin.h> #include <mie/dialect/builtin.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/index.h> #include <mie/dialect/index.h>
#include <mie/dialect/type.h>
#include <mie/ir/op.h> #include <mie/ir/op.h>
#include <mie/type/function.h> #include <mie/type/function.h>
#include <mie/type/storage.h> #include <mie/type/storage.h>
#include <mie/type/type-definition.h>
#include <mie/type/type.h> #include <mie/type/type.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@@ -358,7 +358,7 @@ bool mie_ctx_resolve_op(const struct mie_ctx *ctx, struct mie_op *op)
return false; return false;
} }
const struct mie_dialect_op *op_info const struct mie_op_definition *op_info
= mie_dialect_get_op(dialect, op_name); = mie_dialect_get_op(dialect, op_name);
if (!op) { if (!op) {
return false; return false;
@@ -385,7 +385,7 @@ struct mie_dialect *mie_ctx_get_dialect(const struct mie_ctx *ctx, const char *n
return b_unbox(struct mie_dialect, target, d_id); return b_unbox(struct mie_dialect, target, d_id);
} }
struct mie_dialect_type *mie_ctx_get_dialect_type( struct mie_type_definition *mie_ctx_get_type_definition(
const struct mie_ctx *ctx, const char *dialect_name, const char *type_name) const struct mie_ctx *ctx, const char *dialect_name, const char *type_name)
{ {
b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name); b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name);
@@ -403,7 +403,7 @@ struct mie_dialect_type *mie_ctx_get_dialect_type(
mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_types), &type_name_rope); mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_types), &type_name_rope);
target = mie_id_map_get(&dialect->d_types, &id); target = mie_id_map_get(&dialect->d_types, &id);
return b_unbox(struct mie_dialect_type, target, ty_id); return b_unbox(struct mie_type_definition, target, ty_id);
} }
struct mie_type *mie_ctx_get_type( struct mie_type *mie_ctx_get_type(
@@ -422,8 +422,8 @@ struct mie_type *mie_ctx_get_type(
return type; return type;
} }
struct mie_dialect_type *type_info struct mie_type_definition *type_info
= mie_ctx_get_dialect_type(ctx, dialect_name, type_name); = mie_ctx_get_type_definition(ctx, dialect_name, type_name);
if (!type_info /* || (type_info->ty_flags & MIE_DIALECT_TYPE_PARAMETISED) */) { if (!type_info /* || (type_info->ty_flags & MIE_DIALECT_TYPE_PARAMETISED) */) {
/* cannot initialise unknown or parametised types */ /* cannot initialise unknown or parametised types */
return NULL; return NULL;

10
mie/dialect/arith/addf.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,7 +12,7 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_arith_addf, "addf") MIE_OP_DEFINITION_BEGIN(mie_arith_addf, "addf")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()

10
mie/dialect/arith/addi.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,7 +12,7 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_arith_addi, "addi") MIE_OP_DEFINITION_BEGIN(mie_arith_addi, "addi")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()

29
mie/dialect/arith/float.c
View File

@@ -2,8 +2,8 @@
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/arith.h> #include <mie/dialect/arith.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/type.h>
#include <mie/macros.h> #include <mie/macros.h>
#include <mie/type/type-definition.h>
#include <mie/type/type.h> #include <mie/type/type.h>
#include <mie/value.h> #include <mie/value.h>
@@ -12,7 +12,7 @@ struct float_type {
size_t f_width; size_t f_width;
}; };
static void value_print( static enum mie_status value_print(
const struct mie_type *ty, const struct mie_value *value, b_stream *out) const struct mie_type *ty, const struct mie_value *value, b_stream *out)
{ {
struct float_type *float_ty = (struct float_type *)ty; struct float_type *float_ty = (struct float_type *)ty;
@@ -32,12 +32,14 @@ static void value_print(
b_stream_write_fmt(out, NULL, "NaN : f%zu", float_ty->f_width); b_stream_write_fmt(out, NULL, "NaN : f%zu", float_ty->f_width);
break; break;
} }
return MIE_SUCCESS;
} }
struct mie_type *mie_arith_float_get_type(struct mie_ctx *ctx, size_t bit_width) struct mie_type *mie_arith_float_get_type(struct mie_ctx *ctx, size_t bit_width)
{ {
struct mie_dialect_type *type_info struct mie_type_definition *type_info
= mie_ctx_get_dialect_type(ctx, "arith", "float"); = mie_ctx_get_type_definition(ctx, "arith", "float");
if (!type_info) { if (!type_info) {
return NULL; return NULL;
} }
@@ -68,22 +70,23 @@ struct mie_type *mie_arith_float_get_type(struct mie_ctx *ctx, size_t bit_width)
} }
static enum mie_status print( static enum mie_status print(
const struct mie_dialect_type *def, const struct mie_type *ty, b_stream *out) const struct mie_type_definition *def, const struct mie_type *ty,
b_stream *out)
{ {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
static enum mie_status parse( static enum mie_status parse(
const struct mie_dialect_type *def, struct mie_parser *parser, const struct mie_type_definition *def, struct mie_parser *parser,
struct mie_type **out) struct mie_type **out)
{ {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_TYPE_BEGIN(mie_arith_float, "float") MIE_TYPE_DEFINITION_BEGIN(mie_arith_float, "float")
// MIE_DIALECT_TYPE_FLAGS(MIE_DIALECT_TYPE_PARAMETISED); // MIE_TYPE_DEFINITION_FLAGS(MIE_TYPE_DEFINITION_PARAMETISED);
MIE_DIALECT_TYPE_STRUCT(struct float_type); MIE_TYPE_DEFINITION_STRUCT(struct float_type);
MIE_DIALECT_TYPE_PRINT(print); MIE_TYPE_DEFINITION_PRINT(print);
MIE_DIALECT_TYPE_PARSE(parse); MIE_TYPE_DEFINITION_PARSE(parse);
MIE_DIALECT_TYPE_VALUE_PRINT(value_print); MIE_TYPE_DEFINITION_VALUE_PRINT(value_print);
MIE_DIALECT_TYPE_END() MIE_TYPE_DEFINITION_END()

29
mie/dialect/arith/int.c
View File

@@ -2,8 +2,8 @@
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/arith.h> #include <mie/dialect/arith.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/type.h>
#include <mie/macros.h> #include <mie/macros.h>
#include <mie/type/type-definition.h>
#include <mie/type/type.h> #include <mie/type/type.h>
#include <mie/value.h> #include <mie/value.h>
@@ -12,7 +12,7 @@ struct int_type {
size_t i_width; size_t i_width;
}; };
static void value_print( static enum mie_status value_print(
const struct mie_type *ty, const struct mie_value *value, b_stream *out) const struct mie_type *ty, const struct mie_value *value, b_stream *out)
{ {
struct int_type *int_ty = (struct int_type *)ty; struct int_type *int_ty = (struct int_type *)ty;
@@ -24,12 +24,14 @@ static void value_print(
} else { } else {
b_stream_write_fmt(out, NULL, "INF : i%zu", int_ty->i_width); b_stream_write_fmt(out, NULL, "INF : i%zu", int_ty->i_width);
} }
return MIE_SUCCESS;
} }
struct mie_type *mie_arith_int_get_type(struct mie_ctx *ctx, size_t bit_width) struct mie_type *mie_arith_int_get_type(struct mie_ctx *ctx, size_t bit_width)
{ {
struct mie_dialect_type *type_info struct mie_type_definition *type_info
= mie_ctx_get_dialect_type(ctx, "arith", "int"); = mie_ctx_get_type_definition(ctx, "arith", "int");
if (!type_info) { if (!type_info) {
return NULL; return NULL;
} }
@@ -60,22 +62,23 @@ struct mie_type *mie_arith_int_get_type(struct mie_ctx *ctx, size_t bit_width)
} }
static enum mie_status print( static enum mie_status print(
const struct mie_dialect_type *def, const struct mie_type *ty, b_stream *out) const struct mie_type_definition *def, const struct mie_type *ty,
b_stream *out)
{ {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
static enum mie_status parse( static enum mie_status parse(
const struct mie_dialect_type *def, struct mie_parser *parser, const struct mie_type_definition *def, struct mie_parser *parser,
struct mie_type **out) struct mie_type **out)
{ {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_TYPE_BEGIN(mie_arith_int, "int") MIE_TYPE_DEFINITION_BEGIN(mie_arith_int, "int")
// MIE_DIALECT_TYPE_FLAGS(MIE_DIALECT_TYPE_PARAMETISED); // MIE_TYPE_DEFINITION_FLAGS(MIE_TYPE_DEFINITION_PARAMETISED);
MIE_DIALECT_TYPE_STRUCT(struct int_type); MIE_TYPE_DEFINITION_STRUCT(struct int_type);
MIE_DIALECT_TYPE_PRINT(print); MIE_TYPE_DEFINITION_PRINT(print);
MIE_DIALECT_TYPE_PARSE(parse); MIE_TYPE_DEFINITION_PARSE(parse);
MIE_DIALECT_TYPE_VALUE_PRINT(value_print); MIE_TYPE_DEFINITION_VALUE_PRINT(value_print);
MIE_DIALECT_TYPE_END() MIE_TYPE_DEFINITION_END()

27
mie/dialect/builtin/string.c
View File

@@ -2,40 +2,43 @@
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/builtin.h> #include <mie/dialect/builtin.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/type.h>
#include <mie/macros.h> #include <mie/macros.h>
#include <mie/type/type-definition.h>
#include <mie/type/type.h> #include <mie/type/type.h>
#include <mie/value.h> #include <mie/value.h>
static void value_print( static enum mie_status value_print(
const struct mie_type *ty, const struct mie_value *value, b_stream *out) const struct mie_type *ty, const struct mie_value *value, b_stream *out)
{ {
const struct mie_string *str = (const struct mie_string *)value; const struct mie_string *str = (const struct mie_string *)value;
b_stream_write_fmt(out, NULL, "\"%s\"", str->str_val); b_stream_write_fmt(out, NULL, "\"%s\"", str->str_val);
return MIE_SUCCESS;
} }
static void type_init(const struct mie_dialect_type *type_info, struct mie_type *type) static void type_init(
const struct mie_type_definition *type_info, struct mie_type *type)
{ {
type->ty_instance_size = sizeof(struct mie_string); type->ty_instance_size = sizeof(struct mie_string);
} }
static enum mie_status print( static enum mie_status print(
const struct mie_dialect_type *def, const struct mie_type *ty, b_stream *out) const struct mie_type_definition *def, const struct mie_type *ty,
b_stream *out)
{ {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
static enum mie_status parse( static enum mie_status parse(
const struct mie_dialect_type *def, struct mie_parser *parser, const struct mie_type_definition *def, struct mie_parser *parser,
struct mie_type **out) struct mie_type **out)
{ {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_TYPE_BEGIN(mie_builtin_string, "string") MIE_TYPE_DEFINITION_BEGIN(mie_builtin_string, "string")
MIE_DIALECT_TYPE_STRUCT(struct mie_type); MIE_TYPE_DEFINITION_STRUCT(struct mie_type);
MIE_DIALECT_TYPE_INIT(type_init); MIE_TYPE_DEFINITION_INIT(type_init);
MIE_DIALECT_TYPE_PRINT(print); MIE_TYPE_DEFINITION_PRINT(print);
MIE_DIALECT_TYPE_PARSE(parse); MIE_TYPE_DEFINITION_PARSE(parse);
MIE_DIALECT_TYPE_VALUE_PRINT(value_print); MIE_TYPE_DEFINITION_VALUE_PRINT(value_print);
MIE_DIALECT_TYPE_END() MIE_TYPE_DEFINITION_END()

10
mie/dialect/cf/br-cond.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,7 +12,7 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_cf_br_cond, "br-cond") MIE_OP_DEFINITION_BEGIN(mie_cf_br_cond, "br-cond")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()

10
mie/dialect/cf/br.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,7 +12,7 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_cf_br, "br") MIE_OP_DEFINITION_BEGIN(mie_cf_br, "br")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()

12
mie/dialect/dialect.c
View File

@@ -1,8 +1,8 @@
#include <blue/ds/string.h> #include <blue/ds/string.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/dialect/type.h> #include <mie/type/type-definition.h>
#define TYPE_NS_ID \ #define TYPE_NS_ID \
MIE_ID(0xe4, 0x99, 0x42, 0x58, 0x2b, 0xdb, 0x45, 0xa3, 0xbd, 0x4b, \ MIE_ID(0xe4, 0x99, 0x42, 0x58, 0x2b, 0xdb, 0x45, 0xa3, 0xbd, 0x4b, \
@@ -38,7 +38,7 @@ struct mie_dialect *mie_dialect_create(struct mie_ctx *ctx, const char *name)
return out; return out;
} }
const struct mie_dialect_op *mie_dialect_get_op( const struct mie_op_definition *mie_dialect_get_op(
const struct mie_dialect *dialect, const char *name) const struct mie_dialect *dialect, const char *name)
{ {
b_rope name_rope = B_ROPE_CSTR(name); b_rope name_rope = B_ROPE_CSTR(name);
@@ -46,10 +46,10 @@ const struct mie_dialect_op *mie_dialect_get_op(
mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_ops), &name_rope); mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_ops), &name_rope);
mie_id *target = mie_id_map_get(&dialect->d_ops, &id); mie_id *target = mie_id_map_get(&dialect->d_ops, &id);
return b_unbox(struct mie_dialect_op, target, op_id); return b_unbox(struct mie_op_definition, target, op_id);
} }
const struct mie_dialect_type *mie_dialect_get_type( const struct mie_type_definition *mie_dialect_get_type(
const struct mie_dialect *dialect, const char *name) const struct mie_dialect *dialect, const char *name)
{ {
b_rope name_rope = B_ROPE_CSTR(name); b_rope name_rope = B_ROPE_CSTR(name);
@@ -57,5 +57,5 @@ const struct mie_dialect_type *mie_dialect_get_type(
mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_types), &name_rope); mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_types), &name_rope);
mie_id *target = mie_id_map_get(&dialect->d_types, &id); mie_id *target = mie_id_map_get(&dialect->d_types, &id);
return b_unbox(struct mie_dialect_type, target, ty_id); return b_unbox(struct mie_type_definition, target, ty_id);
} }

10
mie/dialect/func/func.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,10 +12,10 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_func_func, "func") MIE_OP_DEFINITION_BEGIN(mie_func_func, "func")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()
MIE_DIALECT_BEGIN(mie_func, "func") MIE_DIALECT_BEGIN(mie_func, "func")
MIE_DIALECT_ADD_OP(mie_func_func); MIE_DIALECT_ADD_OP(mie_func_func);

27
mie/dialect/index/index.c
View File

@@ -1,7 +1,7 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/index.h> #include <mie/dialect/index.h>
#include <mie/dialect/type.h>
#include <mie/macros.h> #include <mie/macros.h>
#include <mie/type/type-definition.h>
#include <mie/type/type.h> #include <mie/type/type.h>
#include <mie/value.h> #include <mie/value.h>
@@ -9,7 +9,7 @@ struct index_type {
struct mie_type i_base; struct mie_type i_base;
}; };
static void value_print( static enum mie_status value_print(
const struct mie_type *ty, const struct mie_value *value, b_stream *out) const struct mie_type *ty, const struct mie_value *value, b_stream *out)
{ {
struct index_type *index_ty = (struct index_type *)ty; struct index_type *index_ty = (struct index_type *)ty;
@@ -17,33 +17,36 @@ static void value_print(
b_stream_write_fmt( b_stream_write_fmt(
out, NULL, "%zu : %s", index_val->i_value, out, NULL, "%zu : %s", index_val->i_value,
index_ty->i_base.ty_def->ty_name); index_ty->i_base.ty_def->ty_name);
return MIE_SUCCESS;
} }
static void type_init(const struct mie_dialect_type *type_info, struct mie_type *type) static void type_init(
const struct mie_type_definition *type_info, struct mie_type *type)
{ {
type->ty_instance_size = sizeof(struct mie_index); type->ty_instance_size = sizeof(struct mie_index);
} }
static enum mie_status print( static enum mie_status print(
const struct mie_dialect_type *def, const struct mie_type *ty, b_stream *out) const struct mie_type_definition *def, const struct mie_type *ty,
b_stream *out)
{ {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
static enum mie_status parse( static enum mie_status parse(
const struct mie_dialect_type *def, struct mie_parser *parser, const struct mie_type_definition *def, struct mie_parser *parser,
struct mie_type **out) struct mie_type **out)
{ {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_TYPE_BEGIN(mie_index_index, "index") MIE_TYPE_DEFINITION_BEGIN(mie_index_index, "index")
MIE_DIALECT_TYPE_STRUCT(struct index_type); MIE_TYPE_DEFINITION_STRUCT(struct index_type);
MIE_DIALECT_TYPE_INIT(type_init); MIE_TYPE_DEFINITION_INIT(type_init);
MIE_DIALECT_TYPE_PRINT(print); MIE_TYPE_DEFINITION_PRINT(print);
MIE_DIALECT_TYPE_PARSE(parse); MIE_TYPE_DEFINITION_PARSE(parse);
MIE_DIALECT_TYPE_VALUE_PRINT(value_print); MIE_TYPE_DEFINITION_VALUE_PRINT(value_print);
MIE_DIALECT_TYPE_END() MIE_TYPE_DEFINITION_END()
MIE_DIALECT_BEGIN(mie_index, "index") MIE_DIALECT_BEGIN(mie_index, "index")
MIE_DIALECT_ADD_TYPE(mie_index_index); MIE_DIALECT_ADD_TYPE(mie_index_index);

10
mie/dialect/meta/source-filename.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,7 +12,7 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_meta_source_filename, "source-filename") MIE_OP_DEFINITION_BEGIN(mie_meta_source_filename, "source-filename")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()

10
mie/dialect/ptr/load.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,7 +12,7 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_ptr_load, "load") MIE_OP_DEFINITION_BEGIN(mie_ptr_load, "load")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()

19
mie/dialect/ptr/ptr.c
View File

@@ -1,29 +1,30 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/type.h>
#include <mie/macros.h> #include <mie/macros.h>
#include <mie/type/type-definition.h>
struct ptr_type { struct ptr_type {
struct mie_dialect_type ptr_base; struct mie_type_definition ptr_base;
}; };
static enum mie_status print( static enum mie_status print(
const struct mie_dialect_type *def, const struct mie_type *ty, b_stream *out) const struct mie_type_definition *def, const struct mie_type *ty,
b_stream *out)
{ {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
static enum mie_status parse( static enum mie_status parse(
const struct mie_dialect_type *def, struct mie_parser *parser, const struct mie_type_definition *def, struct mie_parser *parser,
struct mie_type **out) struct mie_type **out)
{ {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_TYPE_BEGIN(mie_ptr_ptr, "ptr") MIE_TYPE_DEFINITION_BEGIN(mie_ptr_ptr, "ptr")
MIE_DIALECT_TYPE_STRUCT(struct ptr_type); MIE_TYPE_DEFINITION_STRUCT(struct ptr_type);
MIE_DIALECT_TYPE_PRINT(print); MIE_TYPE_DEFINITION_PRINT(print);
MIE_DIALECT_TYPE_PARSE(parse); MIE_TYPE_DEFINITION_PARSE(parse);
MIE_DIALECT_TYPE_END() MIE_TYPE_DEFINITION_END()
MIE_DIALECT_BEGIN(mie_ptr, "ptr") MIE_DIALECT_BEGIN(mie_ptr, "ptr")
MIE_DIALECT_ADD_OP(mie_ptr_load); MIE_DIALECT_ADD_OP(mie_ptr_load);

10
mie/dialect/ptr/store.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,7 +12,7 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_ptr_store, "store") MIE_OP_DEFINITION_BEGIN(mie_ptr_store, "store")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()

10
mie/dialect/scf/for.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,7 +12,7 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_scf_for, "for") MIE_OP_DEFINITION_BEGIN(mie_scf_for, "for")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()

10
mie/dialect/scf/if.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,7 +12,7 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_scf_if, "if") MIE_OP_DEFINITION_BEGIN(mie_scf_if, "if")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()

2
mie/dialect/scf/scf.c
View File

@@ -1,5 +1,3 @@
#include "scf.h"
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/macros.h> #include <mie/macros.h>

7
mie/dialect/scf/scf.h
View File

@@ -1,7 +0,0 @@
#ifndef MIE_DIALECT_SCF_H_
#define MIE_DIALECT_SCF_H_
#include <mie/dialect/dialect.h>
#include <mie/dialect/op.h>
#endif

10
mie/dialect/scf/yield.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
#include <mie/macros.h> #include <mie/macros.h>
static enum mie_status print(const struct mie_op *op, b_stream *out) static enum mie_status print(const struct mie_op *op, b_stream *out)
@@ -12,7 +12,7 @@ static enum mie_status parse(struct mie_parser *parser, struct mie_op *out)
return MIE_SUCCESS; return MIE_SUCCESS;
} }
MIE_DIALECT_OP_BEGIN(mie_scf_yield, "yield") MIE_OP_DEFINITION_BEGIN(mie_scf_yield, "yield")
MIE_DIALECT_OP_PRINT(print); MIE_OP_DEFINITION_PRINT(print);
MIE_DIALECT_OP_PARSE(parse); MIE_OP_DEFINITION_PARSE(parse);
MIE_DIALECT_OP_END() MIE_OP_DEFINITION_END()

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

@@ -38,7 +38,7 @@ MIE_API bool mie_ctx_resolve_op(const struct mie_ctx *ctx, struct mie_op *op);
MIE_API struct mie_dialect *mie_ctx_get_dialect( MIE_API struct mie_dialect *mie_ctx_get_dialect(
const struct mie_ctx *ctx, const char *name); const struct mie_ctx *ctx, const char *name);
MIE_API struct mie_dialect_type *mie_ctx_get_dialect_type( MIE_API struct mie_type_definition *mie_ctx_get_type_definition(
const struct mie_ctx *ctx, const char *dialect_name, const char *type_name); const struct mie_ctx *ctx, const char *dialect_name, const char *type_name);
MIE_API struct mie_type *mie_ctx_get_type( MIE_API struct mie_type *mie_ctx_get_type(
struct mie_ctx *ctx, const char *dialect_name, const char *type_name); struct mie_ctx *ctx, const char *dialect_name, const char *type_name);

12
mie/include/mie/dialect/dialect.h
View File

@@ -9,17 +9,17 @@
struct mie_ctx; struct mie_ctx;
struct mie_dialect_op; struct mie_op_definition;
struct mie_dialect_type; struct mie_type_definition;
struct mie_trait_definition; struct mie_trait_definition;
struct mie_dialect { struct mie_dialect {
mie_id d_id; mie_id d_id;
char *d_name; char *d_name;
/* map of struct mie_dialect_op */ /* map of struct mie_op_definition */
struct mie_id_map d_ops; struct mie_id_map d_ops;
/* map of struct mie_dialect_type */ /* map of struct mie_type_definition */
struct mie_id_map d_types; struct mie_id_map d_types;
/* map of struct mie_trait_definition */ /* map of struct mie_trait_definition */
struct mie_id_map d_traits; struct mie_id_map d_traits;
@@ -28,9 +28,9 @@ struct mie_dialect {
MIE_API struct mie_dialect *mie_dialect_create( MIE_API struct mie_dialect *mie_dialect_create(
struct mie_ctx *ctx, const char *name); struct mie_ctx *ctx, const char *name);
MIE_API const struct mie_dialect_op *mie_dialect_get_op( MIE_API const struct mie_op_definition *mie_dialect_get_op(
const struct mie_dialect *dialect, const char *name); const struct mie_dialect *dialect, const char *name);
MIE_API const struct mie_dialect_type *mie_dialect_get_type( MIE_API const struct mie_type_definition *mie_dialect_get_type(
const struct mie_dialect *dialect, const char *name); const struct mie_dialect *dialect, const char *name);
MIE_API const struct mie_trait_definition *mie_dialect_get_trait( MIE_API const struct mie_trait_definition *mie_dialect_get_trait(
const struct mie_dialect *dialect, const char *name); const struct mie_dialect *dialect, const char *name);

52
mie/include/mie/dialect/type.h
View File

@@ -1,52 +0,0 @@
#ifndef MIE_DIALECT_TYPE_H_
#define MIE_DIALECT_TYPE_H_
#include <blue/core/btree.h>
#include <blue/core/stream.h>
#include <mie/id.h>
#include <mie/status.h>
#include <mie/trait/trait-table.h>
struct mie_type;
struct mie_value;
struct mie_parser;
struct mie_dialect;
enum mie_type_trait {
/* this type is parametised. one or more arguments are required to create
* a corresponding mie_type instance. in textual IR, references to this
* type will be followed by a set of arguments surrounded
* by <angle brackets>. */
MIE_TYPE_TRAIT_PARAMETISED = 0x01u,
/* this type can only be used within graph regions. unlike graph ops,
* no special prefix is required */
MIE_TYPE_TRAIT_GRAPH_TYPE = 0x02u,
};
struct mie_dialect_type {
mie_id ty_id;
struct mie_trait_table ty_traits;
struct mie_dialect *ty_parent;
char *ty_name;
size_t ty_data_size;
void (*ty_init)(const struct mie_dialect_type *, struct mie_type *);
void (*ty_cleanup)(const struct mie_dialect_type *, struct mie_type *);
void (*ty_instance_cleanup)(const struct mie_type *, struct mie_value *);
enum mie_status (*ty_print)(
const struct mie_dialect_type *, const struct mie_type *,
b_stream *);
void (*ty_value_print)(
const struct mie_type *, const struct mie_value *, b_stream *);
enum mie_status (*ty_parse)(
const struct mie_dialect_type *, struct mie_parser *,
struct mie_type **);
void (*ty_build_id)(const struct mie_type *, struct mie_id_builder *);
};
MIE_API struct mie_dialect_type *mie_dialect_type_create(
struct mie_dialect *parent, const char *name);
#endif

10
mie/include/mie/dialect/op.h → mie/include/mie/ir/op-definition.h
View File

@@ -1,5 +1,5 @@
#ifndef MIE_DIALECT_OP_H_ #ifndef MIE_IR_OP_DEFINITION_H_
#define MIE_DIALECT_OP_H_ #define MIE_IR_OP_DEFINITION_H_
#include <blue/core/btree.h> #include <blue/core/btree.h>
#include <blue/core/stream.h> #include <blue/core/stream.h>
@@ -14,6 +14,7 @@ struct mie_op;
struct mie_parser; struct mie_parser;
struct mie_dialect; struct mie_dialect;
#if 0
enum mie_op_trait { enum mie_op_trait {
MIE_OP_TRAIT_NONE = 0x00u, MIE_OP_TRAIT_NONE = 0x00u,
@@ -34,6 +35,7 @@ enum mie_op_trait {
* values defined in the enclosing scope. */ * values defined in the enclosing scope. */
MIE_OP_TRAIT_ISOLATED_FROM_ABOVE = 0x08u, MIE_OP_TRAIT_ISOLATED_FROM_ABOVE = 0x08u,
}; };
#endif
enum mie_op_param_type { enum mie_op_param_type {
/* op has no parameter */ /* op has no parameter */
@@ -88,7 +90,7 @@ struct mie_op_result {
}; };
}; };
struct mie_dialect_op { struct mie_op_definition {
mie_id op_id; mie_id op_id;
struct mie_dialect *op_parent; struct mie_dialect *op_parent;
char *op_name; char *op_name;
@@ -101,7 +103,7 @@ struct mie_dialect_op {
enum mie_status (*op_parse)(struct mie_parser *, struct mie_op *); enum mie_status (*op_parse)(struct mie_parser *, struct mie_op *);
}; };
MIE_API struct mie_dialect_op *mie_dialect_op_create( MIE_API struct mie_op_definition *mie_op_definition_create(
struct mie_dialect *parent, const char *name); struct mie_dialect *parent, const char *name);
#endif #endif

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

@@ -15,7 +15,7 @@ struct mie_block;
struct mie_region; struct mie_region;
struct mie_dialect; struct mie_dialect;
struct mie_dialect_op; struct mie_op_definition;
enum mie_op_flags { enum mie_op_flags {
MIE_OP_F_OP_RESOLVED = 0x01u, MIE_OP_F_OP_RESOLVED = 0x01u,
@@ -47,7 +47,7 @@ struct mie_op {
/* these pointers are only valid if the F_RESOLVED flag is set */ /* these pointers are only valid if the F_RESOLVED flag is set */
const struct mie_dialect *op_dialect; const struct mie_dialect *op_dialect;
const struct mie_dialect_op *op_info; const struct mie_op_definition *op_info;
struct mie_file_span op_name_span; struct mie_file_span op_name_span;
/* only valid if the F_RESOLVED flag is NOT set */ /* only valid if the F_RESOLVED flag is NOT set */

67
mie/include/mie/macros.h
View File

@@ -8,71 +8,72 @@
if (!self) { \ if (!self) { \
return NULL; \ return NULL; \
} \ } \
struct mie_dialect_op *op = NULL; \ struct mie_op_definition *op = NULL; \
struct mie_dialect_type *type = NULL; struct mie_type_definition *type = NULL;
#define __MIE_DIALECT_END() \ #define __MIE_DIALECT_END() \
return self; \ return self; \
} }
#define __MIE_DIALECT_OP_BEGIN(func_prefix, op_name) \ #define __MIE_OP_DEFINITION_BEGIN(func_prefix, op_name) \
struct mie_dialect_op *func_prefix##_op_create( \ struct mie_op_definition *func_prefix##_op_create( \
struct mie_dialect *d, struct mie_ctx *ctx) \ struct mie_dialect *d, struct mie_ctx *ctx) \
{ \ { \
struct mie_dialect_op *op = mie_dialect_op_create(d, op_name); \ struct mie_op_definition *op \
= mie_op_definition_create(d, op_name); \
if (!op) { \ if (!op) { \
return NULL; \ return NULL; \
} }
#define __MIE_DIALECT_OP_END() \ #define __MIE_OP_DEFINITION_END() \
return op; \ return op; \
} }
#define __MIE_DIALECT_TYPE_BEGIN(func_prefix, type_name) \ #define __MIE_TYPE_DEFINITION_BEGIN(func_prefix, type_name) \
struct mie_dialect_type *func_prefix##_type_create( \ struct mie_type_definition *func_prefix##_type_create( \
struct mie_dialect *d, struct mie_ctx *ctx) \ struct mie_dialect *d, struct mie_ctx *ctx) \
{ \ { \
struct mie_dialect_type *type \ struct mie_type_definition *type \
= mie_dialect_type_create(d, type_name); \ = mie_type_definition_create(d, type_name); \
if (!type) { \ if (!type) { \
return NULL; \ return NULL; \
} }
#define __MIE_DIALECT_TYPE_END() \ #define __MIE_TYPE_DEFINITION_END() \
return type; \ return type; \
} }
#define __MIE_DIALECT_ADD_OP(op_id) \ #define __MIE_DIALECT_ADD_OP(op_id) \
extern struct mie_dialect_op *op_id##_op_create( \ extern struct mie_op_definition *op_id##_op_create( \
struct mie_dialect *, struct mie_ctx *); \ struct mie_dialect *, struct mie_ctx *); \
op = op_id##_op_create(self, ctx) op = op_id##_op_create(self, ctx)
#define __MIE_DIALECT_ADD_TYPE(type_id) \ #define __MIE_DIALECT_ADD_TYPE(type_id) \
extern struct mie_dialect_type *type_id##_type_create( \ extern struct mie_type_definition *type_id##_type_create( \
struct mie_dialect *, struct mie_ctx *); \ struct mie_dialect *, struct mie_ctx *); \
type = type_id##_type_create(self, ctx) type = type_id##_type_create(self, ctx)
#define MIE_DIALECT_BEGIN(c_sym, name) __MIE_DIALECT_BEGIN(c_sym, name) #define MIE_DIALECT_BEGIN(c_sym, name) __MIE_DIALECT_BEGIN(c_sym, name)
#define MIE_DIALECT_END() __MIE_DIALECT_END() #define MIE_DIALECT_END() __MIE_DIALECT_END()
#define MIE_DIALECT_ADD_OP(c_sym) __MIE_DIALECT_ADD_OP(c_sym) #define MIE_DIALECT_ADD_OP(c_sym) __MIE_DIALECT_ADD_OP(c_sym)
#define MIE_DIALECT_ADD_TYPE(c_sym) __MIE_DIALECT_ADD_TYPE(c_sym) #define MIE_DIALECT_ADD_TYPE(c_sym) __MIE_DIALECT_ADD_TYPE(c_sym)
#define MIE_DIALECT_OP_BEGIN(c_sym, op) __MIE_DIALECT_OP_BEGIN(c_sym, op) #define MIE_OP_DEFINITION_BEGIN(c_sym, op) __MIE_OP_DEFINITION_BEGIN(c_sym, op)
#define MIE_DIALECT_OP_END() __MIE_DIALECT_OP_END() #define MIE_OP_DEFINITION_END() __MIE_OP_DEFINITION_END()
#define MIE_DIALECT_OP_PRINT(func) op->op_print = (func) #define MIE_OP_DEFINITION_PRINT(func) op->op_print = (func)
#define MIE_DIALECT_OP_PARSE(func) op->op_parse = (func) #define MIE_OP_DEFINITION_PARSE(func) op->op_parse = (func)
#define MIE_DIALECT_TYPE_BEGIN(c_sym, type) \ #define MIE_TYPE_DEFINITION_BEGIN(c_sym, type) \
__MIE_DIALECT_TYPE_BEGIN(c_sym, type) __MIE_TYPE_DEFINITION_BEGIN(c_sym, type)
#define MIE_DIALECT_TYPE_END() __MIE_DIALECT_TYPE_END() #define MIE_TYPE_DEFINITION_END() __MIE_TYPE_DEFINITION_END()
#define MIE_DIALECT_TYPE_FLAGS(flags) type->ty_flags = flags #define MIE_TYPE_DEFINITION_FLAGS(flags) type->ty_flags = flags
#define MIE_DIALECT_TYPE_STRUCT(name) type->ty_data_size = sizeof(name) #define MIE_TYPE_DEFINITION_STRUCT(name) type->ty_data_size = sizeof(name)
#define MIE_DIALECT_TYPE_INIT(func) type->ty_init = (func) #define MIE_TYPE_DEFINITION_INIT(func) type->ty_init = (func)
#define MIE_DIALECT_TYPE_PRINT(func) type->ty_print = (func) #define MIE_TYPE_DEFINITION_PRINT(func) type->ty_print = (func)
#define MIE_DIALECT_TYPE_VALUE_PRINT(func) type->ty_value_print = (func) #define MIE_TYPE_DEFINITION_VALUE_PRINT(func) type->ty_value_print = (func)
#define MIE_DIALECT_TYPE_PARSE(func) type->ty_parse = (func) #define MIE_TYPE_DEFINITION_PARSE(func) type->ty_parse = (func)
#define MIE_DIALECT_TYPE_BUILD_ID(func) type->ty_build_id = (func) #define MIE_TYPE_DEFINITION_BUILD_ID(func) type->ty_build_id = (func)
#define MIE_DIALECT_TYPE_INIT(func) type->ty_init = (func) #define MIE_TYPE_DEFINITION_INIT(func) type->ty_init = (func)
#define MIE_DIALECT_TYPE_CLEANUP(func) type->ty_cleanup = (func) #define MIE_TYPE_DEFINITION_CLEANUP(func) type->ty_cleanup = (func)
#define MIE_DIALECT_TRAIT_BEGIN(c_sym, trait) #define MIE_DIALECT_TRAIT_BEGIN(c_sym, trait)
#define MIE_DIALECT_TRAIT_END() #define MIE_DIALECT_TRAIT_END()

36
mie/include/mie/type/type-definition.h Normal file
View File

@@ -0,0 +1,36 @@
#ifndef MIE_TYPE_TYPE_DEFINITION_H_
#define MIE_TYPE_TYPE_DEFINITION_H_
#include <mie/trait/trait-table.h>
struct mie_value;
struct mie_type;
struct mie_parser;
/* a static struct that defines the properties, traits, and callbacks for a type. */
struct mie_type_definition {
mie_id ty_id;
struct mie_trait_table ty_traits;
struct mie_dialect *ty_parent;
char *ty_name;
size_t ty_data_size;
void (*ty_init)(const struct mie_type_definition *, struct mie_type *);
void (*ty_cleanup)(const struct mie_type_definition *, struct mie_type *);
void (*ty_instance_cleanup)(const struct mie_type *, struct mie_value *);
enum mie_status (*ty_print)(
const struct mie_type_definition *, const struct mie_type *,
b_stream *);
enum mie_status (*ty_value_print)(
const struct mie_type *, const struct mie_value *, b_stream *);
enum mie_status (*ty_parse)(
const struct mie_type_definition *, struct mie_parser *,
struct mie_type **);
void (*ty_build_id)(const struct mie_type *, struct mie_id_builder *);
};
MIE_API struct mie_type_definition *mie_type_definition_create(
struct mie_dialect *parent, const char *name);
#endif

33
mie/include/mie/type/type.h
View File

@@ -8,37 +8,40 @@
#include <stddef.h> #include <stddef.h>
struct mie_dialect; struct mie_dialect;
struct mie_dialect_type; struct mie_type_definition;
struct mie_value;
struct mie_id_builder; struct mie_id_builder;
enum mie_type_category { #if 0
/* all other types */ enum mie_type_trait {
MIE_TYPE_OTHER = 0, /* this type is parametised. one or more arguments are required to create
/* storage types (structs, etc) */ * a corresponding mie_type instance. in textual IR, references to this
MIE_TYPE_STORAGE, * type will be followed by a set of arguments surrounded
/* functional types (represents the param/result types of a function) */ * by <angle brackets>. */
MIE_TYPE_FUNCTION, MIE_TYPE_TRAIT_PARAMETISED = 0x01u,
};
/* a mie_type is an instance of mie_dialect_type. /* this type can only be used within graph regions. unlike graph ops,
* if the mie_dialect_type is a parametised type, the resulting mie_type * no special prefix is required */
MIE_TYPE_TRAIT_GRAPH_TYPE = 0x02u,
};
#endif
/* a mie_type is a type-instance created from a mie_type_definition.
* if the mie_type_definition is a parametised type, the resulting mie_type
* will have those parameters baked in. * will have those parameters baked in.
* this is a base struct. dialects that defined their own types do so by * this is a base struct. dialects that defined their own types do so by
* inheriting from this struct. */ * inheriting from this struct. */
struct mie_type { struct mie_type {
/* this is NOT the same as ty_def->ty_id */ /* this is NOT the same as ty_def->ty_id */
mie_id ty_id; mie_id ty_id;
enum mie_type_category ty_category;
char *ty_name; char *ty_name;
struct mie_dialect_type *ty_def; struct mie_type_definition *ty_def;
size_t ty_instance_size; size_t ty_instance_size;
}; };
MIE_API struct mie_type *mie_type_create(struct mie_dialect_type *type); MIE_API struct mie_type *mie_type_create(struct mie_type_definition *type);
MIE_API void mie_type_print(const struct mie_type *type, b_stream *out); MIE_API void mie_type_print(const struct mie_type *type, b_stream *out);
MIE_API void mie_type_build_id( MIE_API void mie_type_build_id(
const struct mie_type *type, struct mie_id_builder *ctx); const struct mie_type *type, struct mie_id_builder *ctx);

6
mie/dialect/op.c → mie/ir/op-definition.c
View File

@@ -1,11 +1,11 @@
#include <blue/ds/string.h> #include <blue/ds/string.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/op.h> #include <mie/ir/op-definition.h>
struct mie_dialect_op *mie_dialect_op_create( struct mie_op_definition *mie_op_definition_create(
struct mie_dialect *parent, const char *name) struct mie_dialect *parent, const char *name)
{ {
struct mie_dialect_op *out = malloc(sizeof *out); struct mie_op_definition *out = malloc(sizeof *out);
if (!out) { if (!out) {
return NULL; return NULL;
} }

19
mie/parse/parse.c
View File

@@ -1,7 +1,6 @@
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/arith.h> #include <mie/dialect/arith.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/type.h>
#include <mie/ir/module.h> #include <mie/ir/module.h>
#include <mie/ir/op.h> #include <mie/ir/op.h>
#include <mie/ir/region.h> #include <mie/ir/region.h>
@@ -10,6 +9,7 @@
#include <mie/parse/parse.h> #include <mie/parse/parse.h>
#include <mie/parse/token.h> #include <mie/parse/token.h>
#include <mie/type/function.h> #include <mie/type/function.h>
#include <mie/type/type-definition.h>
struct mie_parser { struct mie_parser {
struct mie_ctx *p_ctx; struct mie_ctx *p_ctx;
@@ -133,7 +133,7 @@ static bool parse_builtin_type_name(
return false; return false;
} }
const struct mie_dialect_type *type_info = NULL; const struct mie_type_definition *type_info = NULL;
const struct mie_type *type = NULL; const struct mie_type *type = NULL;
size_t width = 0; size_t width = 0;
char tmp = 0; char tmp = 0;
@@ -147,20 +147,21 @@ static bool parse_builtin_type_name(
const char *name_cstr = b_string_ptr(name); const char *name_cstr = b_string_ptr(name);
if (!strcmp(name_cstr, "memref")) { if (!strcmp(name_cstr, "memref")) {
type_info = mie_ctx_get_dialect_type( type_info = mie_ctx_get_type_definition(
ctx->p_ctx, "memref", "memref"); ctx->p_ctx, "memref", "memref");
} else if (!strcmp(name_cstr, "index")) { } else if (!strcmp(name_cstr, "index")) {
type_info type_info = mie_ctx_get_type_definition(
= mie_ctx_get_dialect_type(ctx->p_ctx, "index", "index"); ctx->p_ctx, "index", "index");
} else if (!strcmp(name_cstr, "str")) { } else if (!strcmp(name_cstr, "str")) {
type_info = mie_ctx_get_dialect_type( type_info = mie_ctx_get_type_definition(
ctx->p_ctx, "builtin", "string"); ctx->p_ctx, "builtin", "string");
} else if (sscanf(name_cstr, "i%zu%c", &width, &tmp) == 1) { } else if (sscanf(name_cstr, "i%zu%c", &width, &tmp) == 1) {
type_info = mie_ctx_get_dialect_type(ctx->p_ctx, "arith", "int"); type_info = mie_ctx_get_type_definition(
ctx->p_ctx, "arith", "int");
base_type = INT; base_type = INT;
} else if (sscanf(name_cstr, "f%zu%c", &width, &tmp) == 1) { } else if (sscanf(name_cstr, "f%zu%c", &width, &tmp) == 1) {
type_info type_info = mie_ctx_get_type_definition(
= mie_ctx_get_dialect_type(ctx->p_ctx, "arith", "float"); ctx->p_ctx, "arith", "float");
base_type = FLOAT; base_type = FLOAT;
} }

15
mie/type/function.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/type.h>
#include <mie/type/function.h> #include <mie/type/function.h>
#include <mie/type/type-definition.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@@ -12,9 +12,19 @@ static void build_id(const struct mie_type *type, struct mie_id_builder *ctx)
function->func_out.items, function->func_out.count); function->func_out.items, function->func_out.count);
} }
static struct mie_dialect_type function_type = { static enum mie_status type_print(
const struct mie_type_definition *type_info,
const struct mie_type *type, b_stream *out)
{
mie_function_type_print((const struct mie_function_type *)type, out);
return MIE_SUCCESS;
}
static struct mie_type_definition function_type = {
.ty_name = "*function",
.ty_data_size = sizeof(struct mie_type), .ty_data_size = sizeof(struct mie_type),
.ty_build_id = build_id, .ty_build_id = build_id,
.ty_print = type_print,
}; };
struct mie_function_type *mie_function_type_create(void) struct mie_function_type *mie_function_type_create(void)
@@ -27,7 +37,6 @@ struct mie_function_type *mie_function_type_create(void)
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
out->func_base.ty_def = &function_type; out->func_base.ty_def = &function_type;
out->func_base.ty_category = MIE_TYPE_FUNCTION;
return out; return out;
} }

15
mie/type/storage.c
View File

@@ -1,5 +1,5 @@
#include <mie/dialect/type.h>
#include <mie/type/storage.h> #include <mie/type/storage.h>
#include <mie/type/type-definition.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@@ -11,9 +11,19 @@ static void build_id(const struct mie_type *type, struct mie_id_builder *ctx)
ctx, storage->st_parts.items, storage->st_parts.count); ctx, storage->st_parts.items, storage->st_parts.count);
} }
static struct mie_dialect_type storage_type = { static enum mie_status type_print(
const struct mie_type_definition *type_info,
const struct mie_type *type, b_stream *out)
{
mie_storage_type_print((const struct mie_storage_type *)type, out);
return MIE_SUCCESS;
}
static struct mie_type_definition storage_type = {
.ty_name = "*storage",
.ty_data_size = sizeof(struct mie_type), .ty_data_size = sizeof(struct mie_type),
.ty_build_id = build_id, .ty_build_id = build_id,
.ty_print = type_print,
}; };
struct mie_storage_type *mie_storage_type_create(void) struct mie_storage_type *mie_storage_type_create(void)
@@ -26,7 +36,6 @@ struct mie_storage_type *mie_storage_type_create(void)
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
out->st_base.ty_def = &storage_type; out->st_base.ty_def = &storage_type;
out->st_base.ty_category = MIE_TYPE_STORAGE;
return out; return out;
} }

6
mie/dialect/type.c → mie/type/type-definition.c
View File

@@ -1,11 +1,11 @@
#include <blue/ds/string.h> #include <blue/ds/string.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/dialect/type.h> #include <mie/type/type-definition.h>
struct mie_dialect_type *mie_dialect_type_create( struct mie_type_definition *mie_type_definition_create(
struct mie_dialect *parent, const char *name) struct mie_dialect *parent, const char *name)
{ {
struct mie_dialect_type *out = malloc(sizeof *out); struct mie_type_definition *out = malloc(sizeof *out);
if (!out) { if (!out) {
return NULL; return NULL;
} }

15
mie/type/type.c
View File

@@ -1,9 +1,9 @@
#include <mie/dialect/type.h>
#include <mie/type/function.h> #include <mie/type/function.h>
#include <mie/type/storage.h> #include <mie/type/storage.h>
#include <mie/type/type-definition.h>
#include <mie/type/type.h> #include <mie/type/type.h>
struct mie_type *mie_type_create(struct mie_dialect_type *type) struct mie_type *mie_type_create(struct mie_type_definition *type)
{ {
if (type->ty_data_size < sizeof(struct mie_type)) { if (type->ty_data_size < sizeof(struct mie_type)) {
return NULL; return NULL;
@@ -22,17 +22,6 @@ struct mie_type *mie_type_create(struct mie_dialect_type *type)
void mie_type_print(const struct mie_type *type, b_stream *out) void mie_type_print(const struct mie_type *type, b_stream *out)
{ {
switch (type->ty_category) {
case MIE_TYPE_STORAGE:
mie_storage_type_print((const struct mie_storage_type *)type, out);
return;
case MIE_TYPE_FUNCTION:
mie_function_type_print((const struct mie_function_type *)type, out);
return;
default:
break;
}
if (type->ty_name) { if (type->ty_name) {
b_stream_write_string(out, type->ty_name, NULL); b_stream_write_string(out, type->ty_name, NULL);
} else if (type->ty_def && type->ty_def->ty_print) { } else if (type->ty_def && type->ty_def->ty_print) {

2
mie/value.c
View File

@@ -1,4 +1,4 @@
#include <mie/dialect/type.h> #include <mie/type/type-definition.h>
#include <mie/type/type.h> #include <mie/type/type.h>
#include <mie/value.h> #include <mie/value.h>