ir/ir_emit_c.c

#include "ir.h"
#include "ir_private.h"

static int ir_emit_dessa_move(ir_ctx *ctx, uint8_t type, int from, int to)
{
	FILE *f = ctx->data;

	if (to) {
		fprintf(f, "\td_%d = ", to);
	} else {
		fprintf(f, "\ttmp = ");
	}
	if (IR_IS_CONST_REF(from)) {
		ir_print_const(ctx, &ctx->ir_base[from], f);
		fprintf(f, ";\n");
	} else if (from) {
		fprintf(f, "d_%d;\n", from);
	} else {
		fprintf(f, "tmp;\n");
	}
	return 1;
}

static void ir_emit_ref(ir_ctx *ctx, FILE *f, ir_ref ref)
{
	if (IR_IS_CONST_REF(ref)) {
		ir_print_const(ctx, &ctx->ir_base[ref], f);
	} else {
#if 1
		ir_insn *insn = &ctx->ir_base[ref];
		if (insn->op == IR_VLOAD) {
			ir_insn *var = &ctx->ir_base[insn->op2];

			IR_ASSERT(var->op == IR_VAR/* || var->op == IR_PARAM*/);
			fprintf(f, "%s", ir_get_str(ctx, var->op2));
			return;
		}
#endif
		fprintf(f, "d_%d", ctx->vregs[ref]);
	}
}

static void ir_emit_def_ref(ir_ctx *ctx, FILE *f, ir_ref def)
{
#if 1
	ir_use_list *use_list = &ctx->use_lists[def];
	if (use_list->count == 1) {
		ir_ref use = ctx->use_edges[use_list->refs];
		ir_insn *insn = &ctx->ir_base[use];

		if (insn->op == IR_VSTORE) {
			ir_insn *var = &ctx->ir_base[insn->op2];

			IR_ASSERT(var->op == IR_VAR/* || var->op == IR_PARAM*/);
			fprintf(f, "\t%s = ", ir_get_str(ctx, var->op2));
			return;
		}
	}
#endif
	fprintf(f, "\td_%d = ", ctx->vregs[def]);
}

static void ir_emit_copy(ir_ctx *ctx, FILE *f, int def, ir_insn *insn)
{
//	fprintf(f, "\td_%d = ", ctx->vregs[def]);
	ir_emit_def_ref(ctx, f, def);
	ir_emit_ref(ctx, f, insn->op1);
	fprintf(f, ";\n");
}

static void ir_emit_unary_op(ir_ctx *ctx, FILE *f, int def, ir_insn *insn, const char *op)
{
//	fprintf(f, "\td_%d = ", ctx->vregs[def]);
	ir_emit_def_ref(ctx, f, def);
	fprintf(f, "%s", op);
	ir_emit_ref(ctx, f, insn->op1);
	fprintf(f, ";\n");
}

static void ir_emit_binary_op(ir_ctx *ctx, FILE *f, int def, ir_insn *insn, const char *op)
{
//	fprintf(f, "\td_%d = ", ctx->vregs[def]);
	ir_emit_def_ref(ctx, f, def);
	ir_emit_ref(ctx, f, insn->op1);
	fprintf(f, " %s ", op);
	ir_emit_ref(ctx, f, insn->op2);
	fprintf(f, ";\n");
}

static void ir_emit_unsigned_comparison_op(ir_ctx *ctx, FILE *f, int def, ir_insn *insn, const char *op, const char *fop)
{
	uint8_t t1 = ctx->ir_base[insn->op1].type;

	IR_ASSERT(t1 == ctx->ir_base[insn->op1].type);
//	fprintf(f, "\td_%d = ", ctx->vregs[def]);
	ir_emit_def_ref(ctx, f, def);
	if (t1 == IR_FLOAT || t1 == IR_DOUBLE) {
		fprintf(f, "!(");
	} else if (t1 == IR_I8) {
		fprintf(f, "(uint8_t)");
	} else if (t1 == IR_I16) {
		fprintf(f, "(uint16_t)");
	} else if (t1 == IR_I32) {
		fprintf(f, "(uint32_t)");
	} else if (t1 == IR_I64) {
		fprintf(f, "(uint64_t)");
	}
	ir_emit_ref(ctx, f, insn->op1);
	if (t1 == IR_FLOAT || t1 == IR_DOUBLE) {
		fprintf(f, " %s ", fop);
	} else {
		fprintf(f, " %s ", op);
		if (t1 == IR_I8) {
			fprintf(f, "(uint8_t)");
		} else if (t1 == IR_I16) {
			fprintf(f, "(uint16_t)");
		} else if (t1 == IR_I32) {
			fprintf(f, "(uint32_t)");
		} else if (t1 == IR_I64) {
			fprintf(f, "(uint64_t)");
		}
	}
	ir_emit_ref(ctx, f, insn->op2);
	if (t1 == IR_FLOAT || t1 == IR_DOUBLE) {
		fprintf(f, ")");
	}
	fprintf(f, ";\n");
}

static void ir_emit_minmax_op(ir_ctx *ctx, FILE *f, int def, ir_insn *insn)
{
//	fprintf(f, "\td_%d = ", ctx->vregs[def]);
	ir_emit_def_ref(ctx, f, def);
	ir_emit_ref(ctx, f, insn->op1);
	if (insn->op == IR_MIN) {
		fprintf(f, " < ");
	} else if (insn->op == IR_MAX) {
		fprintf(f, " > ");
	} else {
		IR_ASSERT(0);
	}
	ir_emit_ref(ctx, f, insn->op2);
	fprintf(f, " ? ");
	ir_emit_ref(ctx, f, insn->op1);
	fprintf(f, " : ");
	ir_emit_ref(ctx, f, insn->op2);
	fprintf(f, ";\n");
}

static void ir_emit_conditional_op(ir_ctx *ctx, FILE *f, int def, ir_insn *insn)
{
//	fprintf(f, "\td_%d = ", ctx->vregs[def]);
	ir_emit_def_ref(ctx, f, def);
	ir_emit_ref(ctx, f, insn->op1);
	fprintf(f, " ? ");
	ir_emit_ref(ctx, f, insn->op2);
	fprintf(f, " : ");
	ir_emit_ref(ctx, f, insn->op3);
	fprintf(f, ";\n");
}

static int ir_skip_empty_blocks(ir_ctx *ctx, int b)
{
	while (ctx->cfg_blocks[b].flags & IR_BB_MAY_SKIP) {
		b++;
	}
	return b;
}

static bool ir_needs_block_label(ir_ctx *ctx, int b)
{
	while (1) {
		if (ctx->cfg_blocks[b].predecessors_count == 0) {
			return 0;
		} else if (ctx->cfg_blocks[b].predecessors_count == 1
		 && ctx->cfg_edges[ctx->cfg_blocks[b].predecessors] == b - 1
		 && ctx->ir_base[ctx->cfg_blocks[b - 1].end].op != IR_SWITCH) {
			b--;
			if (!(ctx->cfg_blocks[b].flags & IR_BB_MAY_SKIP)) {
				return 0;
			}
		} else {
			return 1;
		}
	}
	return 1;
}

static void ir_emit_if(ir_ctx *ctx, FILE *f, int b, ir_ref def, ir_insn *insn)
{
	ir_use_list *use_list;
	ir_insn *use_insn;
	ir_ref i, *p, use, n;
	int true_block = 0, false_block = 0, next_block;
	bool short_true = 0, short_false = 0;

	use_list = &ctx->use_lists[def];
	n = use_list->count;
	for (i = 0, p = &ctx->use_edges[use_list->refs]; i < n; i++, p++) {
		use = *p;
		use_insn = &ctx->ir_base[use];
		if (use_insn->op == IR_IF_TRUE) {
			true_block = ir_skip_empty_blocks(ctx, ctx->bb_num[use]);
		} else if (use_insn->op == IR_IF_FALSE) {
			false_block = ir_skip_empty_blocks(ctx, ctx->bb_num[use]);
		} else {
			IR_ASSERT(0);
		}
	}
	IR_ASSERT(true_block && false_block);

	next_block = ir_skip_empty_blocks(ctx, b + 1);
	if (true_block == next_block) {
		short_false = 1;
	} else if (false_block == next_block) {
		short_true = 1;
	}

	fprintf(f, "\tif (");
	if (short_false) {
		fprintf(f, "!");
	}
	ir_emit_ref(ctx, f, insn->op2);
	fprintf(f, ")");

	if (short_true) {
		fprintf(f, " goto bb%d;\n", true_block);
	} else if (short_false) {
		fprintf(f, " goto bb%d;\n", false_block);
	} else {
		fprintf(f, " goto bb%d; else goto bb%d;\n", true_block, false_block);
	}
}

static void ir_emit_switch(ir_ctx *ctx, FILE *f, ir_ref def, ir_insn *insn)
{
	ir_use_list *use_list;
	ir_insn *use_insn;
	ir_ref i, *p, use, n;

	fprintf(f, "\tswitch (");
	ir_emit_ref(ctx, f, insn->op2);
	fprintf(f, ") {\n");

	use_list = &ctx->use_lists[def];
	n = use_list->count;
	for (i = 0, p = &ctx->use_edges[use_list->refs]; i < n; i++, p++) {
		use = *p;
		use_insn = &ctx->ir_base[use];
		if (use_insn->op == IR_CASE_VAL) {
			fprintf(f, "\t\tcase ");
			ir_emit_ref(ctx, f, use_insn->op2);
			fprintf(f, ": goto bb%d;\n", ir_skip_empty_blocks(ctx, ctx->bb_num[use]));
		} else if (use_insn->op == IR_CASE_DEFAULT) {
			fprintf(f, "\t\tdefault: goto bb%d;\n", ir_skip_empty_blocks(ctx, ctx->bb_num[use]));
		} else {
			IR_ASSERT(0);
		}
	}

	fprintf(f, "\t}\n");
}

static void ir_emit_call(ir_ctx *ctx, FILE *f, ir_ref def, ir_insn *insn)
{
	int j, n;

	if (insn->type != IR_VOID) {
//		fprintf(f, "\td_%d = ", ctx->vregs[def]);
		ir_emit_def_ref(ctx, f, def);
	}
	if (IR_IS_CONST_REF(insn->op2)) {
		fprintf(f, "%s", ir_get_str(ctx, ctx->ir_base[insn->op2].val.addr));
	} else {
		ir_emit_ref(ctx, f, insn->op2);
	}
	fprintf(f, "(");
	n = ir_input_edges_count(ctx, insn);
	for (j = 3; j <= n; j++) {
		if (j != 3) {
			fprintf(f, ", ");
		}
		ir_emit_ref(ctx, f, insn->ops[j]);
	}
	fprintf(f, ");\n");
}

static void ir_emit_tailcall(ir_ctx *ctx, FILE *f, ir_insn *insn)
{
	int j, n;

	if (insn->type != IR_VOID) {
		fprintf(f, "\treturn ");
	}
	if (IR_IS_CONST_REF(insn->op2)) {
		fprintf(f, "%s", ir_get_str(ctx, ctx->ir_base[insn->op2].val.addr));
	} else {
		ir_emit_ref(ctx, f, insn->op2);
	}
	fprintf(f, "(");
	n = ir_input_edges_count(ctx, insn);
	for (j = 3; j <= n; j++) {
		if (j != 3) {
			fprintf(f, ", ");
		}
		ir_emit_ref(ctx, f, insn->ops[j]);
	}
	fprintf(f, ");\n");
	if (insn->type == IR_VOID) {
		fprintf(f, "\treturn;");
	}
}

static void ir_emit_alloca(ir_ctx *ctx, FILE *f, ir_ref def, ir_insn *insn)
{
	ir_emit_def_ref(ctx, f, def);
	fprintf(f, "alloca(%d);\n", insn->op2);
}

static void ir_emit_vload(ir_ctx *ctx, FILE *f, ir_ref def, ir_insn *insn)
{
#if 0
	ir_insn *var;

	IR_ASSERT(insn->op2 > 0);
	var = &ctx->ir_base[insn->op2];
	IR_ASSERT(var->op == IR_VAR/* || var->op == IR_PARAM*/);
	fprintf(f, "\td_%d = %s;\n", ctx->vregs[def], ir_get_str(ctx, var->op2));
#endif
}

static void ir_emit_vstore(ir_ctx *ctx, FILE *f, ir_insn *insn)
{
#if 1
	if (ctx->use_lists[insn->op3].count != 1) {
		ir_insn *var;

		IR_ASSERT(insn->op2 > 0);
		var = &ctx->ir_base[insn->op2];
		IR_ASSERT(var->op == IR_VAR/* || var->op == IR_PARAM*/);
		fprintf(f, "\t%s = ", ir_get_str(ctx, var->op2));
		ir_emit_ref(ctx, f, insn->op3);
		fprintf(f, ";\n");
	}
#endif
}

static void ir_emit_load(ir_ctx *ctx, FILE *f, ir_ref def, ir_insn *insn)
{
	ir_emit_def_ref(ctx, f, def);
	fprintf(f, "*((%s*)d_%d);\n", ir_type_cname[insn->type], ctx->vregs[insn->op2]);
}

static void ir_emit_store(ir_ctx *ctx, FILE *f, ir_insn *insn)
{
	ir_type type = ctx->ir_base[insn->op3].type;

	fprintf(f, "\t*((%s*)d_%d) = ", ir_type_cname[type], ctx->vregs[insn->op2]);
	ir_emit_ref(ctx, f, insn->op3);
	fprintf(f, ";\n");
}

static int ir_emit_func(ir_ctx *ctx, FILE *f)
{
	ir_ref ref, i, n, *p;
	ir_insn *insn;
	ir_use_list *use_list;
	uint8_t ret_type = 255;
	bool has_params = 0;
	ir_bitset vars;
	int b, target;
	ir_block *bb;
	uint32_t flags;

	/* Check all RETURN nodes */
	ref = ctx->ir_base[1].op1;
	while (ref) {
		insn = &ctx->ir_base[ref];
		if (insn->op == IR_RETURN) {
			if (ret_type == 255) {
				if (insn->op2) {
					ret_type = ctx->ir_base[insn->op2].type;
				} else {
					ret_type = IR_VOID;
				}
			} else if (insn->op2) {
				if (ret_type != ctx->ir_base[insn->op2].type) {
					IR_ASSERT(0 && "conflicting return types");
					return 0;
				}
			} else {
				if (ret_type != IR_VOID) {
					IR_ASSERT(0 && "conflicting return types");
					return 0;
				}
			}
		}
		ref = ctx->ir_base[ref].op3;
	}

	use_list = &ctx->use_lists[1];
	n = use_list->count;
	for (i = 0, p = &ctx->use_edges[use_list->refs]; i < n; i++, p++) {
		insn = &ctx->ir_base[*p];
		if (insn->op == IR_PARAM) {
			has_params = 1;
			break;
		}
	}

	/* Emit function prototype */
	if (ret_type != 255 || has_params) {
		if (ret_type == 255) {
			ret_type = IR_VOID;
		}
		fprintf(f, "%s", ir_type_cname[ret_type]);
		fprintf(f, " test(");
		if (has_params) {
			use_list = &ctx->use_lists[1];
			n = use_list->count;
			for (i = 0, p = &ctx->use_edges[use_list->refs]; i < n; i++, p++) {
				insn = &ctx->ir_base[*p];
				if (insn->op == IR_PARAM) {
					if (has_params) {
						has_params = 0;
					} else {
						fprintf(f, ", ");
					}
					fprintf(f, "%s %s", ir_type_cname[insn->type], ir_get_str(ctx, insn->op2));
				}
			}
		}
		fprintf(f, ")\n");
	}

	fprintf(f, "{\n");

	/* Emit declarations for local variables */
	vars = ir_bitset_malloc(ctx->vregs_count + 1);
	for (b = 1, bb = ctx->cfg_blocks + b; b <= ctx->cfg_blocks_count; b++, bb++) {
		bb->flags &= ~IR_BB_MAY_SKIP;
		flags = IR_BB_MAY_SKIP;
		if (bb->successors_count != 1
		 || ctx->cfg_edges[bb->successors] != b + 1
		 || (bb->flags & IR_BB_DESSA_MOVES)) {
			flags = 0;
		}
		for (i = bb->start, insn = ctx->ir_base + i; i <= bb->end;) {
			switch (insn->op) {
				case IR_START:
				case IR_BEGIN:
				case IR_END:
				case IR_IF_TRUE:
				case IR_IF_FALSE:
				case IR_CASE_VAL:
				case IR_CASE_DEFAULT:
				case IR_MERGE:
				case IR_LOOP_BEGIN:
				case IR_LOOP_END:
				case IR_LOOP_EXIT:
				case IR_PARAM:
				case IR_VAR:
				case IR_PHI:
				case IR_PI:
					/* skip */
					break;
				default:
					flags = 0;
			}
			if (ctx->vregs[i]) {
				if (!ir_bitset_in(vars, ctx->vregs[i])) {
					ir_bitset_incl(vars, ctx->vregs[i]);
					if (insn->op == IR_PARAM) {
						fprintf(f, "\t%s d_%d = %s;\n", ir_type_cname[insn->type], ctx->vregs[i], ir_get_str(ctx, insn->op2));
					} else {
						fprintf(f, "\t%s d_%d;\n", ir_type_cname[insn->type], ctx->vregs[i]);
					}
				} else if (insn->op == IR_PARAM) {
					IR_ASSERT(0 && "unexpected PARAM");
					return 0;
				}
			}
			n = ir_operands_count(ctx, insn);
			n = 1 + (n >> 2); // support for multi-word instructions like MERGE and PHI
			i += n;
			insn += n;
		}
		bb->flags |= flags;
	}
	ir_mem_free(vars);

	for (b = 1, bb = ctx->cfg_blocks + b; b <= ctx->cfg_blocks_count; b++, bb++) {
		if (bb->flags & IR_BB_MAY_SKIP) {
			continue;
		}
		if (ir_needs_block_label(ctx, b)) {
			fprintf(f, "bb%d:\n", b);
		}
		for (i = bb->start, insn = ctx->ir_base + i; i <= bb->end;) {
			switch (insn->op) {
				case IR_START:
				case IR_BEGIN:
				case IR_IF_TRUE:
				case IR_IF_FALSE:
				case IR_CASE_VAL:
				case IR_CASE_DEFAULT:
				case IR_MERGE:
				case IR_LOOP_BEGIN:
				case IR_LOOP_EXIT:
				case IR_UNREACHABLE:
				case IR_PARAM:
				case IR_VAR:
				case IR_PHI:
				case IR_PI:
					/* skip */
					break;
				case IR_EQ:
					ir_emit_binary_op(ctx, f, i, insn, "==");
					break;
				case IR_NE:
					ir_emit_binary_op(ctx, f, i, insn, "!=");
					break;
				case IR_LT:
					ir_emit_binary_op(ctx, f, i, insn, "<");
					break;
				case IR_GE:
					ir_emit_binary_op(ctx, f, i, insn, ">=");
					break;
				case IR_LE:
					ir_emit_binary_op(ctx, f, i, insn, "<=");
					break;
				case IR_GT:
					ir_emit_binary_op(ctx, f, i, insn, ">");
					break;
				case IR_ULT:
					ir_emit_unsigned_comparison_op(ctx, f, i, insn, "<", ">=");
					break;
				case IR_UGE:
					ir_emit_unsigned_comparison_op(ctx, f, i, insn, ">=", "<");
					break;
				case IR_ULE:
					ir_emit_unsigned_comparison_op(ctx, f, i, insn, "<=", ">");
					break;
				case IR_UGT:
					ir_emit_unsigned_comparison_op(ctx, f, i, insn, ">", "<=");
					break;
				case IR_ADD:
					ir_emit_binary_op(ctx, f, i, insn, "+");
					break;
				case IR_SUB:
					ir_emit_binary_op(ctx, f, i, insn, "-");
					break;
				case IR_MUL:
					ir_emit_binary_op(ctx, f, i, insn, "*");
					break;
				case IR_DIV:
					ir_emit_binary_op(ctx, f, i, insn, "/");
					break;
				case IR_MOD:
					ir_emit_binary_op(ctx, f, i, insn, "%");
					break;
				case IR_NEG:
					ir_emit_unary_op(ctx, f, i, insn, "-");
					break;
				case IR_NOT:
					ir_emit_unary_op(ctx, f, i, insn, insn->type == IR_BOOL ? "!" : "~");
					break;
				case IR_OR:
					ir_emit_binary_op(ctx, f, i, insn, insn->type == IR_BOOL ? "||" : "|");
					break;
				case IR_AND:
					ir_emit_binary_op(ctx, f, i, insn, insn->type == IR_BOOL ? "&&" : "&");
					break;
				case IR_XOR:
					ir_emit_binary_op(ctx, f, i, insn, "^");
					break;
				case IR_MIN:
				case IR_MAX:
					ir_emit_minmax_op(ctx, f, i, insn);
					break;
				case IR_COND:
					ir_emit_conditional_op(ctx, f, i, insn);
					break;
//				case IR_POW:
//					ir_emit_func1df_op(ctx, f, i, insn, "pow", "powf");
//				case IR_ABS:
//					ir_emit_func1df_op(ctx, f, i, insn, "fabs", "fabsf", "abs", "llab");
//				case IR_SHL:
//				case IR_SHR:
//				case IR_SAR:
//				case IR_ROL:
//				case IR_ROR:
//				case IR_BSWAP:
				case IR_COPY:
					ir_emit_copy(ctx, f, i, insn);
					break;
				case IR_RETURN:
					IR_ASSERT(bb->successors_count == 0);
					fprintf(f, "\treturn");
					if (!insn->op2) {
						fprintf(f, ";");
					} else {
						fprintf(f, " ");
						ir_emit_ref(ctx, f, insn->op2);
						fprintf(f, ";\n");
					}
					break;
				case IR_END:
				case IR_LOOP_END:
					IR_ASSERT(bb->successors_count == 1);
					if (bb->flags & IR_BB_DESSA_MOVES) {
						ctx->data = f;
						ir_gen_dessa_moves(ctx, b, ir_emit_dessa_move);
					}
					target = ir_skip_empty_blocks(ctx, ctx->cfg_edges[bb->successors]);
					if (b == ctx->cfg_blocks_count || target != ir_skip_empty_blocks(ctx, b + 1)) {
						fprintf(f, "\tgoto bb%d;\n", target);
					}
					break;
				case IR_IF:
					ir_emit_if(ctx, f, b, i, insn);
					break;
				case IR_SWITCH:
					ir_emit_switch(ctx, f, i, insn);
					break;
				case IR_CALL:
					ir_emit_call(ctx, f, i, insn);
					break;
				case IR_TAILCALL:
					ir_emit_tailcall(ctx, f, insn);
					break;
				case IR_ALLOCA:
					ir_emit_alloca(ctx, f, i, insn);
					break;
				case IR_VLOAD:
					ir_emit_vload(ctx, f, i, insn);
					break;
				case IR_VSTORE:
					ir_emit_vstore(ctx, f, insn);
					break;
				case IR_LOAD:
					ir_emit_load(ctx, f, i, insn);
					break;
				case IR_STORE:
					ir_emit_store(ctx, f, insn);
					break;
				default:
					IR_ASSERT(0 && "NIY instruction");
			}
			n = ir_operands_count(ctx, insn);
			n = 1 + (n >> 2); // support for multi-word instructions like MERGE and PHI
			i += n;
			insn += n;
		}
	}

	fprintf(f, "}\n");

	return 1;
}

int ir_emit_c(ir_ctx *ctx, FILE *f)
{
	return ir_emit_func(ctx, f);
}