MWCC/compiler_and_linker/unsorted/IroFlowgraph.c

#include "compiler/IroFlowgraph.h"
#include "compiler/IroCSE.h"
#include "compiler/IroLinearForm.h"
#include "compiler/IroPropagate.h"
#include "compiler/IROUseDef.h"
#include "compiler/IroUtil.h"
#include "compiler/CError.h"
#include "compiler/CFunc.h"
#include "compiler/CompilerTools.h"
#include "compiler/Exceptions.h"
#include "compiler/InlineAsmPPC.h"

UInt16 IRO_NumNodes;
IRONode *IRO_FirstNode;
IRONode *IRO_LastNode;
IRONode *IRO_EndNode;
IRONode **IRO_NodeTable;
BitVector *IRO_VarKills;
BitVector *IRO_Avail;
BitVector *IRO_FuncKills;
BitVector *IRO_ExprKills;

static IRONode *StartNode(IROLinear *linear) {
    IRONode *node = oalloc(sizeof(IRONode));

    node->index = IRO_NumNodes;
    node->numsucc = 0;
    node->succ = NULL;
    node->numpred = 0;
    node->pred = NULL;
    node->first = linear;
    node->last = linear;
    node->x16 = NULL;
    node->x1A = NULL;
    node->x1E = NULL;
    node->x22 = NULL;
    node->x26 = 0;
    node->x2A = NULL;
    node->dom = NULL;
    node->nextnode = NULL;
    node->x36 = 0;
    node->x37 = 0;
    node->mustreach = 0;
    node->x39 = 0;
    node->loopdepth = 0;
    node->x3C = 0;
    node->addressed = NULL;

    IRO_NumNodes++;
    if (!IRO_FirstNode)
        IRO_FirstNode = node;
    else
        IRO_LastNode->nextnode = node;
    IRO_LastNode = node;
    return node;
}

static void AddSucc(IRONode *a, IRONode *b) {
    a->succ[a->numsucc++] = b->index;
    b->numpred++;
}

static void AddLabelSucc(IRONode *node, CLabel *label) {
    IRONode *targetnode = (IRONode *) label->stmt;
    if (targetnode) {
        AddSucc(node, targetnode);
        targetnode->x39 = 1;
    } else {
#line 126
        CError_FATAL();
    }
}

static void AddSwitchSucc(IRONode *node) {
    SwitchInfo *info = node->last->u.swtch.info;
    SwitchCase *curcase = info->cases;
    SInt32 i = 1;

    while (curcase) {
        curcase = curcase->next;
        i++;
    }

    node->succ = oalloc(sizeof(UInt16) * i);
    for (curcase = info->cases; curcase; curcase = curcase->next)
        AddLabelSucc(node, curcase->label);
    AddLabelSucc(node, info->defaultlabel);
}

static void AddPred(UInt32 a, UInt16 b) {
    IRONode *node = IRO_NodeTable[a];
    node->pred[node->numpred++] = b;
}

void IRO_ComputeSuccPred(void) {
    CLabel *label;
    IRONode *node;
    SInt32 count;
    IROLinear *linear;
    ExceptionAction *action;
    IAEffects effects;
    UInt16 i;

    for (label = Labels; label; label = label->next)
        label->stmt = NULL;

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        node->x39 = 0;
        node->numsucc = 0;
        node->numpred = 0;
        node->x36 = 0;
        node->x37 = 0;
        if (node->first && node->first->type == IROLinearLabel)
            node->first->u.label.label->stmt = (Statement *) node;
    }

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        if (!node->first) {
            if (node->nextnode) {
                node->succ = oalloc(sizeof(UInt16));
                AddSucc(node, node->nextnode);
            }
        } else {
            linear = node->last;
        next_linear:
            switch (linear->type) {
                case IROLinearReturn:
                case IROLinearEnd:
                    break;
                case IROLinearGoto:
                    node->succ = oalloc(sizeof(UInt16));
                    AddLabelSucc(node, linear->u.label.label);
                    break;
                case IROLinearIf:
                case IROLinearIfNot:
                    node->succ = oalloc(sizeof(UInt16) * 2);
                    AddSucc(node, node->nextnode);
                    AddLabelSucc(node, linear->u.label.label);
                    break;
                case IROLinearSwitch:
                    AddSwitchSucc(node);
                    break;
                case IROLinearFunccall:
                    count = 1;
                    if (IRO_FunctionCallMightThrowException(linear)) {
                        for (action = linear->stmt->dobjstack; action; action = action->prev) {
                            if (action->type == EAT_CATCHBLOCK || action->type == EAT_SPECIFICATION)
                                count++;
                        }
                    }
                    node->succ = oalloc(sizeof(UInt16) * count);
                    AddSucc(node, node->nextnode);
                    if (IRO_FunctionCallMightThrowException(linear)) {
                        for (action = linear->stmt->dobjstack; action; action = action->prev) {
                            if (action->type == EAT_CATCHBLOCK)
                                AddLabelSucc(node, action->data.catch_block.catch_label);
                            else if (action->type == EAT_SPECIFICATION)
                                AddLabelSucc(node, action->data.specification.unexp_label);
                        }
                    }
                    break;
                case IROLinearAsm:
                    CodeGen_GetAsmEffects(linear->u.asm_stmt, &effects);
                    node->succ = oalloc(sizeof(UInt16) * (!effects.x5 + effects.numlabels));
                    if (!effects.x5)
                        AddSucc(node, node->nextnode);
                    for (i = 0; i < effects.numlabels; i++)
                        AddLabelSucc(node, effects.labels[i]);
                    break;
                case IROLinearOp2Arg:
                    if (linear->nodetype == ECOMMA) {
                        linear = linear->u.diadic.right;
                        goto next_linear;
                    }
                default:
                    if (node->nextnode) {
                        node->succ = oalloc(sizeof(UInt16));
                        AddSucc(node, node->nextnode);
                    }
            }
        }
    }

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        if (node->numpred)
            node->pred = oalloc(sizeof(UInt16) * node->numpred);
        else
            node->pred = NULL;
        node->numpred = 0;
    }

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        for (i = 0; i < node->numsucc; i++)
            AddPred(node->succ[i], node->index);
    }

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        if (node->first && node->first->type == IROLinearLabel) {
            IROLinear *linear = node->first;
            do {
                if (linear->type == IROLinearBeginCatch || linear->type == IROLinearEndCatch || linear->type == IROLinearEndCatchDtor) {
                    node->x39 = 1;
                    break;
                }
            } while (linear != node->last && (linear = linear->next));
        }
    }
}

void IRO_ComputeDom(void) {
    IRONode *node;
    BitVector *bv;
    SInt32 i;
    int repeat;

    Bv_AllocVector(&IRO_FirstNode->dom, IRO_NumNodes);
    Bv_SetBit(IRO_FirstNode->index, IRO_FirstNode->dom);
    for (node = IRO_FirstNode->nextnode; node; node = node->nextnode) {
        Bv_AllocVector(&node->dom, IRO_NumNodes);
        Bv_Set(node->dom);
    }

    Bv_AllocVector(&bv, IRO_NumNodes);

    do {
        repeat = 0;
        for (node = IRO_FirstNode->nextnode; node; node = node->nextnode) {
            if (node->numpred) {
                Bv_Set(bv);
                for (i = 0; i < node->numpred; i++) {
                    Bv_And(IRO_NodeTable[node->pred[i]]->dom, bv);
                }
                Bv_SetBit(node->index, bv);
            } else {
                Bv_Clear(bv);
                Bv_SetBit(node->index, bv);
            }

            if (!Bv_Compare(bv, node->dom)) {
                Bv_Copy(bv, node->dom);
                repeat = 1;
            }
        }
    } while (repeat);
}

void IRO_BuildFlowgraph(IROLinear *linear) {
    IROLinear *scan;
    CLabel *label;
    ExceptionAction *action;
    IAEffects effects;
    IRONode *node;
    SInt32 i;
    int flag;

    for (label = Labels; label; label = label->next)
        label->stmt = NULL;

    scan = linear;
    IRO_NumNodes = 0;
    IRO_FirstNode = IRO_LastNode = IRO_EndNode = NULL;
    while (scan) {
        StartNode(scan);
        if (scan->type == IROLinearLabel)
            scan->u.label.label->stmt = (Statement *) IRO_LastNode;

        flag = 0;
        while (!flag && scan->next && !(scan->next->flags & IROLF_1)) {
            switch (scan->type) {
                case IROLinearGoto:
                case IROLinearReturn:
                case IROLinearEntry:
                case IROLinearExit:
                case IROLinearEnd:
                    flag = 1;
                    break;
                case IROLinearIf:
                case IROLinearIfNot:
                case IROLinearSwitch:
                    flag = 1;
                skip:
                    if (scan->next->type == IROLinearLabel) {
                        IROLinear *nw = IRO_NewLinear(IROLinearNop);
                        nw->index = ++IRO_NumLinear;
                        nw->next = scan->next;
                        scan->next = nw;
                    }
                    break;
                case IROLinearFunccall:
                    if (IRO_FunctionCallMightThrowException(scan)) {
                        for (action = scan->stmt->dobjstack; action; action = action->prev) {
                            if (action->type == EAT_CATCHBLOCK || action->type == EAT_SPECIFICATION) {
                                flag = 1;
                                goto skip;
                            }
                        }
                    }
                    break;
                case IROLinearAsm:
                    CodeGen_GetAsmEffects(scan->u.asm_stmt, &effects);
                    if (effects.numlabels)
                        flag = 1;
                    break;
            }
            if (!flag)
                scan = scan->next;
        }

        if (scan->type == IROLinearEnd)
            IRO_EndNode = IRO_LastNode;
        IRO_LastNode->last = scan;
        scan = scan->next;
    }

    IRO_NodeTable = oalloc(IRO_NumNodes * sizeof(IRONode *));
    memset(IRO_NodeTable, 0, IRO_NumNodes * sizeof(IRONode *));
    for (node = IRO_FirstNode, i = 0; node; node = node->nextnode)
        IRO_NodeTable[i++] = node;

    IRO_ComputeSuccPred();
    IRO_ComputeDom();
    IRO_CheckForUserBreak();
}

IRONode *IRO_NewFlowGraphNode(void) {
    IRONode *node = oalloc(sizeof(IRONode));
    memset(node, 0, sizeof(IRONode));
    node->index = IRO_NumNodes;
    IRO_NumNodes++;
    node->nextnode = NULL;
    return node;
}

IRONode *IRO_MergeFlowGraphNodes(IRONode *a, IRONode *b) {
    // TODO
}