ack/mach/proto/mcg/pass_eliminatetrivialblocks.c

#include "mcg.h"

static bool rewrite_jumps_cb(struct ir* ir, void* user)
{
    if (ir->opcode == IR_BLOCK)
    {
        struct basicblock* bb = ir->u.bvalue;
		if (!bb->is_fake
			&& (bb->irs.count > 0)
            && (bb->irs.item[0]->opcode == IR_JUMP)
            && (bb->irs.item[0]->left->opcode == IR_BLOCK))
        {
            ir->u.bvalue = bb->irs.item[0]->left->u.bvalue;
        }
    }

    return false;
}

static void rewrite_jumps(struct basicblock* bb)
{
    int i;

    for (i=0; i<bb->irs.count; i++)
    {
        struct ir* ir = bb->irs.item[i];
        ir_walk(ir, rewrite_jumps_cb, NULL);
    }
}

void pass_eliminate_trivial_blocks(void)
{
    int i;

    for (i=0; i<current_proc->blocks.count; i++)
    {
        struct basicblock* bb = current_proc->blocks.item[i];
        rewrite_jumps(bb);
    }
}

/* vim: set sw=4 ts=4 expandtab : */
Replaced the block splicer with a trivial block eliminator (which rewrites jumps to blocks which contain only a jump). Don't bother storing the bb graph in the ir nodes; we can find it on demand by walking the tree instead --- slower, but much easier to understand and more robust. Added a terrible map library. 2016-09-23 21:59:15 +00:00			`#include "mcg.h"`

			`static bool rewrite_jumps_cb(struct ir* ir, void* user)`
			`{`
			`if (ir->opcode == IR_BLOCK)`
			`{`
			`struct basicblock* bb = ir->u.bvalue;`
Procedure compilation now happens after the entire EM file has been read in (so that we can look inside data blocks which might be defined in the future... sigh, csa and csb). csa and csb no longer generate invalid IR. 2016-09-23 23:04:00 +00:00			`if (!bb->is_fake`
Revamp the array module not to use nasty macros any more. Slightly more verbose to use, but definitely cleaner. 2016-09-26 20:48:58 +00:00			`&& (bb->irs.count > 0)`
			`&& (bb->irs.item[0]->opcode == IR_JUMP)`
			`&& (bb->irs.item[0]->left->opcode == IR_BLOCK))`
Replaced the block splicer with a trivial block eliminator (which rewrites jumps to blocks which contain only a jump). Don't bother storing the bb graph in the ir nodes; we can find it on demand by walking the tree instead --- slower, but much easier to understand and more robust. Added a terrible map library. 2016-09-23 21:59:15 +00:00			`{`
Revamp the array module not to use nasty macros any more. Slightly more verbose to use, but definitely cleaner. 2016-09-26 20:48:58 +00:00			`ir->u.bvalue = bb->irs.item[0]->left->u.bvalue;`
Replaced the block splicer with a trivial block eliminator (which rewrites jumps to blocks which contain only a jump). Don't bother storing the bb graph in the ir nodes; we can find it on demand by walking the tree instead --- slower, but much easier to understand and more robust. Added a terrible map library. 2016-09-23 21:59:15 +00:00			`}`
			`}`

			`return false;`
			`}`

			`static void rewrite_jumps(struct basicblock* bb)`
			`{`
			`int i;`

Revamp the array module not to use nasty macros any more. Slightly more verbose to use, but definitely cleaner. 2016-09-26 20:48:58 +00:00			`for (i=0; i<bb->irs.count; i++)`
Replaced the block splicer with a trivial block eliminator (which rewrites jumps to blocks which contain only a jump). Don't bother storing the bb graph in the ir nodes; we can find it on demand by walking the tree instead --- slower, but much easier to understand and more robust. Added a terrible map library. 2016-09-23 21:59:15 +00:00			`{`
Revamp the array module not to use nasty macros any more. Slightly more verbose to use, but definitely cleaner. 2016-09-26 20:48:58 +00:00			`struct ir* ir = bb->irs.item[i];`
Replaced the block splicer with a trivial block eliminator (which rewrites jumps to blocks which contain only a jump). Don't bother storing the bb graph in the ir nodes; we can find it on demand by walking the tree instead --- slower, but much easier to understand and more robust. Added a terrible map library. 2016-09-23 21:59:15 +00:00			`ir_walk(ir, rewrite_jumps_cb, NULL);`
			`}`
			`}`

Stop passing proc around, and use a global instead --- much cleaner. 2016-10-15 21:19:44 +00:00			`void pass_eliminate_trivial_blocks(void)`
Replaced the block splicer with a trivial block eliminator (which rewrites jumps to blocks which contain only a jump). Don't bother storing the bb graph in the ir nodes; we can find it on demand by walking the tree instead --- slower, but much easier to understand and more robust. Added a terrible map library. 2016-09-23 21:59:15 +00:00			`{`
			`int i;`

Stop passing proc around, and use a global instead --- much cleaner. 2016-10-15 21:19:44 +00:00			`for (i=0; i<current_proc->blocks.count; i++)`
Replaced the block splicer with a trivial block eliminator (which rewrites jumps to blocks which contain only a jump). Don't bother storing the bb graph in the ir nodes; we can find it on demand by walking the tree instead --- slower, but much easier to understand and more robust. Added a terrible map library. 2016-09-23 21:59:15 +00:00			`{`
Stop passing proc around, and use a global instead --- much cleaner. 2016-10-15 21:19:44 +00:00			`struct basicblock* bb = current_proc->blocks.item[i];`
Replaced the block splicer with a trivial block eliminator (which rewrites jumps to blocks which contain only a jump). Don't bother storing the bb graph in the ir nodes; we can find it on demand by walking the tree instead --- slower, but much easier to understand and more robust. Added a terrible map library. 2016-09-23 21:59:15 +00:00			`rewrite_jumps(bb);`
			`}`
			`}`

			`/* vim: set sw=4 ts=4 expandtab : */`