void gen_myfunc(ir_ctx *ctx)
{
	ir_START();
	ir_ref cnt = ir_PARAM(IR_I32, "loop_count", 1);

	ir_ref init_idx = ir_CONST_I32(1);
	ir_ref init_total = ir_CONST_I32(0);

	/* loop begin */
	ir_ref loop = ir_LOOP_BEGIN(ir_END());

	ir_ref phi_idx = ir_PHI_2(init_idx, IR_UNUSED);
	ir_ref phi_total = ir_PHI_2(init_total, IR_UNUSED);

	ir_ref if1 = ir_IF(ir_LE(phi_idx, cnt));
	ir_IF_TRUE(if1);
		ir_ref phi_idx_2 = ir_ADD_I32(phi_idx, ir_CONST_I32(1));
		ir_ref ret = ir_ADD_I32(phi_total, phi_idx);
		ir_ref loop_end = ir_LOOP_END(); /* loop end */
	ir_IF_FALSE(if1); /* loop exit */
		ir_RETURN(ret);
	ir_MERGE_SET_OP(loop, 2, loop_end);
	ir_PHI_SET_OP(phi_idx, 2, phi_idx_2);
	ir_PHI_SET_OP(phi_total, 2, ret);
}

/* ctx: used by IR construction API defined in ir_builder.h
 * Note: must be named as 'ctx'
 */
void gen_ir(ir_ctx* ctx)
{
    ir_ref c_4 = ir_CONST_I32(1);
    ir_ref c_5 = ir_CONST_I32(4);

    ir_START(); /* Mark function start */

    ir_ref d_10 = ir_LT(c_4, c_5);

    ir_ref end_inputs = IR_UNUSED;
    ir_ref if1 = ir_IF(d_10);
    ir_IF_TRUE(if1);
    ir_END_list(end_inputs);

    ir_IF_FALSE(if1);
    ir_END_list(end_inputs);

    ir_MERGE_list(end_inputs);
    ir_RETURN(c_5);
}

/*
This example shows a basic program framework of how to use IR.
*/

/* IR public APIs and target platform*/
#include "ir.h"
#include "ir_builder.h"

#if defined(IR_TARGET_X86) || defined(IR_TARGET_X64)
# include "ir_x86.h"
#endif /* IR_TARGET_X86 || IR_TARGET_X64 */

#include <stdio.h>

/* ctx: used by IR construction API defined in ir_builder.h
 * Note: must be named as 'ctx'
 */
void gen_ir(ir_ctx* ctx)
{
    ir_ref c_4 = ir_CONST_I32(1);
    ir_ref c_5 = ir_CONST_I32(4);

    ir_START(); /* Mark function start */

    ir_ref d_10 = ir_LT(c_4, c_5);

    ir_ref end_inputs = IR_UNUSED;
    ir_ref if1 = ir_IF(d_10);
    ir_IF_TRUE(if1);
    ir_END_list(end_inputs);

    ir_IF_FALSE(if1);
    ir_END_list(end_inputs);

    ir_MERGE_list(end_inputs);
    ir_RETURN(c_5);
}

int ir_compile_and_run_func(ir_ctx *ctx, int opt_level)
{
    gen_ir(ctx);
    puts("Before ...");
    ir_save(ctx, stderr);
    FILE* f = fopen("002_if.dot", "w+");
    ir_dump_dot(ctx, f);
    fclose(f);

	if (opt_level > 0 || (ctx->flags & (IR_GEN_NATIVE|IR_GEN_C))) {
		ir_build_def_use_lists(ctx);
	}

	ir_check(ctx);

	/* Global Optimization */
	if (opt_level > 1) {
		ir_sccp(ctx);
	}

	if (opt_level > 0 || (ctx->flags & (IR_GEN_NATIVE|IR_GEN_C))) {
		ir_build_cfg(ctx);
	}

	/* Schedule */
	if (opt_level > 0) {
		ir_build_dominators_tree(ctx);
		ir_find_loops(ctx);
		ir_gcm(ctx);
		ir_schedule(ctx);
	}

	if (ctx->flags & IR_GEN_NATIVE) {
		ir_match(ctx);
	}

	if (opt_level > 0) {
		ir_assign_virtual_registers(ctx);
		ir_compute_live_ranges(ctx);
		ir_coalesce(ctx);

		if (ctx->flags & IR_GEN_NATIVE) {
			ir_reg_alloc(ctx);
		}

		ir_schedule_blocks(ctx);
	} else if (ctx->flags & (IR_GEN_NATIVE|IR_GEN_C)) {
		ir_assign_virtual_registers(ctx);
		ir_compute_dessa_moves(ctx);
	}

	ir_check(ctx);

    puts("After ...\n");
    ir_save(ctx, stderr);
    /* generate native code and return function entry pointer */
    typedef void (*ir_func_t)(void);
    size_t size;
    ir_func_t entry = (ir_func_t) ir_emit_code(ctx, &size);

    if(entry) {
        entry();
    }

	return 1;
}

int main(void)
{
    ir_ctx ctx;
    /* generate a function */
    uint32_t flags = IR_FUNCTION | IR_GEN_NATIVE | IR_GEN_C;
    ir_consistency_check();
    /* 256: constants limit; 1024: instructions limit */
    ir_init(&ctx, flags, 256, 1024);
    ir_compile_and_run_func(&ctx, 2);
    ir_free(&ctx);
    return 0;
}

int32_t test(int32_t num)
{
        int32_t d_1 = num;
        int32_t d_2;
        int32_t d_3;
        int32_t d_4;
        int32_t d_5;
        d_2 = d_1 % 3;
        d_3 = d_1 * 3;
        d_4 = d_1 + 1;
        d_5 = d_1 - 2;
        switch (d_2) {
                case 0: goto bb2;
                case 1: goto bb4;
                case 2: goto bb3;
                default: goto bb3;
        }
        d_5 = d_3;
bb3:
        return d_5;
bb4:
        d_5 = d_4;
        goto bb3;
}

void gen_myfunc(ir_ctx *ctx)
{
	ir_ref divisor = ir_CONST_I32(3);
	ir_ref rem0 = ir_CONST_I32(0);
	ir_ref rem1 = ir_CONST_I32(1);
	ir_ref rem2 = ir_CONST_I32(2);

	ir_START();
	ir_ref num = ir_PARAM(IR_I32, "num", 1);
	ir_ref rets[4], ends[4];
	ir_ref remainder = ir_MOD_I32(num, divisor);

	ir_ref s = ir_SWITCH(remainder);
	ir_CASE_VAL(s, rem0);
		rets[0] = ir_MUL_I32(num, ir_CONST_I32(3));
		ends[0] = ir_END();
	ir_CASE_VAL(s, rem1);
		rets[1] = ir_ADD_I32(num, ir_CONST_I32(1));
		ends[1] = ir_END();
	ir_CASE_VAL(s, rem2);
		rets[2] = ir_SUB_I32(num, ir_CONST_I32(2));
		ends[2] = ir_END();
	ir_CASE_DEFAULT(s);
		rets[3] = rets[2];
		ends[3] = ir_END();

	ir_MERGE_N(4, ends);
	ir_ref ret = ir_PHI_N(4, rets);

	ir_RETURN(ret);
}

 int32_t myfunc(int32_t num) {
	int remainder = num % 3;
        switch (remainder)
        {
        case 0:  num = num * 3;   break;
        case 1:  num = num + 1;  break;
        case 2:  // fall through
        default: num = num - 2; break;
        }
        return num;
}