ack/mach/proto/mcg/pass_removedeadblocks.c

#include "mcg.h"

static ARRAYOF(struct basicblock) used;

static void walk_blocks(struct basicblock* bb);

static bool walk_blocks_cb(struct ir* ir, void* user)
{
    if (ir->opcode == IR_BLOCK)
        walk_blocks(ir->u.bvalue);
    return false;
}

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

    if (!array_contains(&used, bb))
    {
        array_append(&used, bb);

        for (i=0; i<bb->irs.count; i++)
            ir_walk(bb->irs.item[i], walk_blocks_cb, NULL);
    }
}

void pass_remove_dead_blocks(struct procedure* proc)
{
    int i, j;
    
    used.count = 0;
    walk_blocks(proc->blocks.item[0]);

    proc->blocks.count = 0;
    for (i=0; i<used.count; i++)
        array_append(&proc->blocks, used.item[i]);
}

/* 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"`

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			`static ARRAYOF(struct basicblock) used;`
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
			`static void walk_blocks(struct basicblock* bb);`

			`static bool walk_blocks_cb(struct ir* ir, void* user)`
			`{`
			`if (ir->opcode == IR_BLOCK)`
			`walk_blocks(ir->u.bvalue);`
			`return false;`
			`}`

			`static void walk_blocks(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			`if (!array_contains(&used, bb))`
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			`array_append(&used, bb);`
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			`for (i=0; i<bb->irs.count; i++)`
			`ir_walk(bb->irs.item[i], walk_blocks_cb, NULL);`
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			`}`
			`}`

			`void pass_remove_dead_blocks(struct procedure* proc)`
			`{`
			`int i, j;`

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			`used.count = 0;`
			`walk_blocks(proc->blocks.item[0]);`
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			`proc->blocks.count = 0;`
			`for (i=0; i<used.count; i++)`
			`array_append(&proc->blocks, used.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			`}`

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