#include "compiler/IroLoop.h"
#include "compiler/IroCSE.h"
#include "compiler/IroDump.h"
#include "compiler/IroFlowgraph.h"
#include "compiler/IroLinearForm.h"
#include "compiler/IroPropagate.h"
#include "compiler/IroSubable.h"
#include "compiler/IroUtil.h"
#include "compiler/IroVars.h"
#include "compiler/CFunc.h"
#include "compiler/CInt64.h"
#include "compiler/CMachine.h"
#include "compiler/objects.h"
#include "compiler/types.h"

IRONode *LoopNode;
Boolean ConditionalHeaderAtBottom;
IROLoopInd *FirstInd;
BitVector *InLoop;
IROList IRO_InitLList;
BitVector *InLoop_Exits;
BitVector *InLoop_Tails;
UInt32 LoopExitNumber;
UInt32 LoopTailNum;
IRONode *LoopExitSuccessor;
IRONode *LoopTail;
IROLoopMemRef *IRO_LoopMemRefFirst;
IROLoopMemRef *IRO_LoopMemRefCurrent;
static IROExpr *RisList;
static BitVector *AllKills;
static Boolean KnownBounds;
static SInt32 Times;
static IROLinear *PredInt;
static IROElmList *FirstAddendLinear;
static IROElmList *LastAddendLinear;
static int NoSubableSubs;

// forward decls
static void MyHandleLoop_Vector(IRONode *fnode);
static void MyHandleLoop_Motion(IRONode *fnode);
static void CheckAllLoopAddresses(IRONode *fnode, BitVector *bv, Boolean *resultFlag);
static void MakeLoopEntry(IROLinear *nd, IROAddrRecord *rec, Boolean mustreach1, Boolean flag2);
static void MoveInvarianceInAddressExpr(void);
static IROLinear *RearrangeInvarianceInAddressExpr(IROLinear *nd, IROList *list);
static UInt32 IsAssignmentReductionCandidate(IROLinear *nd);

void FindMustReach(void) {
    IRONode *fnode;
    IRONode *fnode2;
    IRONode *pred;
    int i;

    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
        fnode->mustreach = 0;
        if (Bv_IsBitSet(fnode->index, InLoop)) {
            fnode->mustreach = 1;

            for (i = 0; i < LoopNode->numpred; i++) {
                pred = IRO_NodeTable[LoopNode->pred[i]];
                if (Bv_IsBitSet(pred->index, InLoop) && !Bv_IsBitSet(fnode->index, pred->dom)) {
                    fnode->mustreach = 0;
                    break;
                }
            }

            for (fnode2 = IRO_FirstNode; fnode2; fnode2 = fnode2->nextnode) {
                if (Bv_IsBitSet(fnode2->index, InLoop)) {
                    for (i = 0; i < fnode2->numsucc; i++) {
                        if (!Bv_IsBitSet(fnode2->succ[i], InLoop) && !Bv_IsBitSet(fnode->index, fnode2->dom)) {
                            fnode->mustreach = 0;
                            break;
                        }
                    }

                    if (!fnode->mustreach)
                        break;
                }
            }
        }
    }
}

void FindMustReach1(IRONode *checkfnode) {
    IRONode *fnode;
    IRONode *fnode2;

    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
        if (Bv_IsBitSet(fnode->index, InLoop)) {
            fnode->mustreach1 = 1;
            for (fnode2 = IRO_FirstNode; fnode2; fnode2 = fnode2->nextnode) {
                if (Bv_IsBitSet(fnode2->index, InLoop)) {
                    if (Bv_IsBitSet(fnode2->index, InLoop_Tails) && !Bv_IsBitSet(fnode->index, fnode2->dom))
                        fnode->mustreach1 = 0;

                    if (Bv_IsBitSet(fnode2->index, InLoop_Exits) && fnode2 != checkfnode && !Bv_IsBitSet(fnode->index, fnode2->dom))
                        fnode->mustreach1 = 0;

                    if (!fnode->mustreach1)
                        break;
                }
            }
        }
    }
}

static void IRO_FindLoopTailsAndExits(IRONode *fnode) {
    IRONode *scan;
    IRONode *succ;
    int i;

    for (scan = IRO_FirstNode; scan; scan = scan->nextnode) {
        if (Bv_IsBitSet(scan->index, InLoop)) {
            for (i = 0; i < scan->numsucc; i++) {
                succ = IRO_NodeTable[scan->succ[i]];
                if (succ == fnode) {
                    Bv_SetBit(scan->index, InLoop_Tails);
                    LoopTail = scan;
                    LoopTailNum++;
                }
                if (!Bv_IsBitSet(succ->index, InLoop)) {
                    LoopExitNumber++;
                    LoopExitSuccessor = succ;
                    Bv_SetBit(scan->index, InLoop_Exits);
                }
            }
        }
    }

    IRO_Dump("IRO_FindLoopTailsAndExits:For  header %d, Loop exits and loop tails are  \n", fnode->index);
    IRO_DumpBits("Loop Exits: ", InLoop_Exits);
    IRO_DumpBits("Loop Tails: ", InLoop_Tails);
    IRO_Dump("LoopExitNum=%d: \n", LoopExitNumber);
    if (LoopExitSuccessor)
        IRO_Dump("LoopExitSuccessor node =%d: \n", LoopExitSuccessor->index);
}

static int IsSafeTypcon(IROLinear *nd) {
    Type *srcType;
    Type *destType;
    SInt32 srcSize;
    SInt32 destSize;
    Boolean srcUnsigned;
    Boolean destUnsigned;

    srcType = nd->u.monadic->rtype;
    destType = nd->rtype;
    if (!IS_TYPE_INT(srcType) || !IS_TYPE_INT(destType))
        return 0;

    srcSize = srcType->size;
    destSize = destType->size;
    srcUnsigned = IRO_IsUnsignedType(srcType);
    destUnsigned = IRO_IsUnsignedType(destType);

    if (srcUnsigned == destUnsigned && destSize >= srcSize)
        return 1;
    if (srcUnsigned == 1 && destUnsigned == 0 && destSize > srcSize)
        return 1;
    return 0;
}

static int Reducable(IROLinear *nd, IROLinear **resultNd1, IROLinear **resultNd2, VarRecord **resultVar) {
    IROLinear *indirect;
    IROLinear *left;
    IROLinear *right;
    Boolean leftInvariant;
    Boolean rightInvariant;
    Boolean leftTypcon;
    Boolean rightTypcon;
    Object *obj;
    ENode *enode;
    IROLoopInd *ind;
    CInt64 val64;
    SInt32 val;
    SInt32 div;

    leftInvariant = 0;
    rightInvariant = 0;
    leftTypcon = 0;
    rightTypcon = 0;

    if (nd->type == IROLinearOp2Arg && nd->nodetype == EADD && (IS_TYPE_INT(nd->rtype) || IS_TYPE_POINTER_ONLY(nd->rtype))) {
        left = nd->u.diadic.left;
        right = nd->u.diadic.right;
        if (left->type == IROLinearOp1Arg && left->nodetype == ETYPCON) {
            leftTypcon = 1;
            leftInvariant = (left->flags & IROLF_LoopInvariant) != 0;
            left = left->u.monadic;
        }
        if (right->type == IROLinearOp1Arg && right->nodetype == ETYPCON) {
            rightTypcon = 1;
            rightInvariant = (right->flags & IROLF_LoopInvariant) != 0;
            right = right->u.monadic;
        }

        if (((left->flags & IROLF_LoopInvariant) || leftInvariant) && IRO_IsVariable(right)) {
            if (leftInvariant || ((!(obj = IRO_IsVariable(left)) || !IRO_IsRegable(obj)) && !IRO_IsConstant(left))) {
                if (
                    left->type == IROLinearOp2Arg &&
                    left->nodetype == EADD &&
                    (obj = IRO_IsVariable(left->u.diadic.left)) &&
                    IRO_IsRegable(obj) &&
                    IRO_IsConstant(left->u.diadic.right)
                    )
                    return 0;

                if (rightTypcon) {
                    if (!IsSafeTypcon(nd->u.diadic.right))
                        return 0;
                    *resultNd2 = nd->u.diadic.right;
                } else {
                    *resultNd2 = right;
                }

                indirect = right;
                *resultNd1 = IRO_NewLinear(IROLinearOperand);

                enode = IRO_NewENode(EINTCONST);
                enode->data.intval = cint64_one;
                enode->rtype = nd->u.diadic.right->rtype;
                (*resultNd1)->rtype = nd->u.diadic.right->rtype;
                (*resultNd1)->u.node = enode;
            } else {
                return 0;
            }
        } else if (
            ((left->flags & IROLF_LoopInvariant) || leftInvariant) &&
            right->type == IROLinearOp2Arg &&
            !rightTypcon &&
            (right->nodetype == EMUL || right->nodetype == ESHL)
            ) {
            if (IRO_IsConstant(right->u.diadic.right)) {
                if (right->nodetype == ESHL) {
                    right->nodetype = EMUL;
                    right->u.diadic.right->u.node->data.intval = CInt64_Shl(cint64_one, right->u.diadic.right->u.node->data.intval);
                }
                if (right->u.diadic.left->type == IROLinearOp1Arg) {
                    if (IRO_IsVariable(right->u.diadic.left)) {
                        *resultNd2 = right->u.diadic.left;
                        indirect = right->u.diadic.left;
                        *resultNd1 = right->u.diadic.right;
                    } else if (right->u.diadic.left->nodetype == ETYPCON && IRO_IsVariable(right->u.diadic.left->u.monadic)) {
                        if (!IsSafeTypcon(right->u.diadic.left))
                            return 0;
                        *resultNd2 = right->u.diadic.left;
                        indirect = right->u.diadic.left->u.monadic;
                        *resultNd1 = right->u.diadic.right;
                    } else {
                        return 0;
                    }
                } else {
                    return 0;
                }
            } else {
                return 0;
            }
        } else if (
            ((right->flags & IROLF_LoopInvariant) || rightInvariant) &&
            left->type == IROLinearOp2Arg &&
            !leftTypcon &&
            (left->nodetype == EMUL || left->nodetype == ESHL)
            ) {
            if (IRO_IsConstant(left->u.diadic.right)) {
                if (left->nodetype == ESHL) {
                    left->nodetype = EMUL;
                    left->u.diadic.right->u.node->data.intval = CInt64_Shl(cint64_one, left->u.diadic.right->u.node->data.intval);
                }
                if (left->u.diadic.left->type == IROLinearOp1Arg) {
                    if (IRO_IsVariable(left->u.diadic.left)) {
                        *resultNd2 = left->u.diadic.left;
                        indirect = left->u.diadic.left;
                        *resultNd1 = left->u.diadic.right;
                    } else if (left->u.diadic.left->nodetype == ETYPCON && IRO_IsVariable(left->u.diadic.left->u.monadic)) {
                        if (!IsSafeTypcon(left->u.diadic.left))
                            return 0;
                        *resultNd2 = left->u.diadic.left;
                        indirect = left->u.diadic.left->u.monadic;
                        *resultNd1 = left->u.diadic.right;
                    } else {
                        return 0;
                    }
                } else {
                    return 0;
                }
            } else {
                return 0;
            }
        } else if (
            ((right->flags & IROLF_LoopInvariant) || rightInvariant) &&
            IRO_IsVariable(left)
            ) {
            if (rightInvariant || ((!(obj = IRO_IsVariable(right)) || !IRO_IsRegable(obj)) && !IRO_IsConstant(right))) {
                if (
                    right->type == IROLinearOp2Arg &&
                    right->nodetype == EADD &&
                    (obj = IRO_IsVariable(right->u.diadic.left)) &&
                    IRO_IsRegable(obj) &&
                    IRO_IsConstant(right->u.diadic.right)
                    )
                    return 0;

                if (leftTypcon) {
                    if (!IsSafeTypcon(nd->u.diadic.left))
                        return 0;
                    *resultNd2 = nd->u.diadic.left;
                } else {
                    *resultNd2 = left;
                }

                indirect = left;
                *resultNd1 = IRO_NewLinear(IROLinearOperand);

                enode = IRO_NewENode(EINTCONST);
                enode->data.intval = cint64_one;
                enode->rtype = nd->u.diadic.left->rtype;
                (*resultNd1)->rtype = nd->u.diadic.left->rtype;
                (*resultNd1)->u.node = enode;
            } else {
                return 0;
            }
        } else {
            return 0;
        }
    } else if (nd->type == IROLinearOp2Arg && (nd->nodetype == EMUL || nd->nodetype == ESHL) && nd->rtype->size <= 4 && (IS_TYPE_INT(nd->rtype) || IS_TYPE_POINTER_ONLY(nd->rtype))) {
        left = nd->u.diadic.left;
        right = nd->u.diadic.right;

        if (IRO_IsConstant(right) && IRO_IsVariable(left)) {
            *resultNd2 = left;
            indirect = left;
            *resultNd1 = right;
        } else if (IRO_IsConstant(nd->u.diadic.right) && left->type == IROLinearOp1Arg && left->nodetype == ETYPCON &&
            IRO_IsVariable(left->u.monadic)) {
            if (!IsSafeTypcon(left))
                return 0;
            *resultNd2 = left;
            indirect = left->u.monadic;
            *resultNd1 = right;
        } else {
            if (nd->type == IROLinearOp2Arg && nd->nodetype == ESHL)
                return 0;

            if (nd->u.diadic.right->flags & IROLF_LoopInvariant) {
                if (IRO_IsVariable(left)) {
                    *resultNd2 = left;
                    indirect = left;
                    *resultNd1 = right;
                } else if (left->type == IROLinearOp1Arg && left->nodetype == ETYPCON && IRO_IsVariable(left->u.monadic)) {
                    if (!IsSafeTypcon(left))
                        return 0;
                    *resultNd2 = left;
                    indirect = left->u.monadic;
                    *resultNd1 = right;
                } else {
                    return 0;
                }
            } else if (nd->u.diadic.left->flags & IROLF_LoopInvariant) {
                if (IRO_IsVariable(right)) {
                    *resultNd2 = right;
                    indirect = right;
                    *resultNd1 = left;
                } else if (right->type == IROLinearOp1Arg && right->nodetype == ETYPCON && IRO_IsVariable(right->u.monadic) && nd->type == IROLinearOp2Arg && nd->nodetype == EMUL) {
                    if (!IsSafeTypcon(right))
                        return 0;
                    *resultNd2 = right;
                    indirect = right->u.monadic;
                    *resultNd1 = left;
                } else {
                    return 0;
                }
            } else {
                return 0;
            }
        }
    } else if (nd->type == IROLinearOp2Arg && (nd->nodetype == EDIV || nd->nodetype == ESHR) && nd->rtype->size <= 4 && IS_TYPE_INT(nd->rtype)) {
        if (IRO_IsVariable(nd->u.diadic.left) && IRO_IsConstant(nd->u.diadic.right)) {
            val64 = nd->u.diadic.right->u.node->data.intval;
            if (nd->type == IROLinearOp2Arg && nd->nodetype == ESHR) {
                CInt64_GetULong(&val64);
                if (CInt64_GetULong(&val64) > 32 || CTool_EndianReadWord32(&val64.hi))
                    return 0;
                val64 = CInt64_Shl(cint64_one, val64);
            }
            *resultNd2 = nd->u.diadic.left;
            indirect = nd->u.diadic.left;
        } else {
            return 0;
        }
    } else {
        return 0;
    }

    if (
        nd->type == IROLinearOp2Arg &&
        nd->nodetype == ESHL &&
        (
            !IRO_IsConstant(*resultNd1) ||
            (SInt32) CInt64_GetULong(&(*resultNd1)->u.node->data.intval) < 0 ||
            (SInt32) CInt64_GetULong(&(*resultNd1)->u.node->data.intval) > 32 ||
            CTool_EndianReadWord32(&(*resultNd1)->u.node->data.intval.hi)
            )
        )
        return 0;

    CError_ASSERT(802, indirect->u.monadic->u.node != NULL);
    *resultVar = IRO_FindVar(indirect->u.monadic->u.node->data.objref, 0, 1);
    if (!*resultVar || (*resultVar)->xA != 2)
        return 0;

    if (copts.ANSI_strict || copts.opt_strength_reduction_strict) {
        Type *type = (*resultVar)->object->type;
        if (IRO_IsUnsignedType(type) && type->size < stunsignedlong.size)
            return 0;
    }

    if (nd->type == IROLinearOp2Arg && (nd->nodetype == ESHR || nd->nodetype == EDIV)) {
        ind = FirstInd;
        while (ind && ind->var != *resultVar)
            ind = ind->next;

        CError_ASSERT(845, ind != NULL);

        if (ind->addNode == NULL) {
            if (ind->addConst < (val = CInt64_GetULong(&val64)))
                return 0;
            if ((div = ind->addConst / val) <= 0)
                return 0;

            *resultNd1 = IRO_NewLinear(IROLinearOperand);
            enode = IRO_NewENode(EINTCONST);
            CInt64_SetULong(&enode->data.intval, div);
            enode->rtype = nd->u.diadic.left->rtype;
            (*resultNd1)->rtype = nd->u.diadic.left->rtype;
            (*resultNd1)->u.node = enode;
        } else {
            return 0;
        }
    }

    return 1;
}

static void IRO_RemoveExpr_Action(IROLinear *linear, Boolean isFirst) {
    if (isFirst && linear->expr)
        IRO_RemoveExpr(linear->expr);
}

static void IRO_ActUnmarkRISCandidate(IROLinear *linear, Boolean isFirst) {
    if (isFirst && linear->expr)
        linear->flags &= ~IROLF_Ris;
}

static IROExpr *CreateRIS(IROExpr *expr, IROLinear *nd1, IROLinear *nd2, IROLoopInd *induction, int unk) {
    Object *tempObj;
    Type *type;
    Boolean flag23;
    Object *tempObj2;
    IROLinear *firstnode;
    IROLinear *fourthnode;
    IROLinear *fifthnode;
    IROLinear *secondnode;
    IROLinear *thirdnode;
    IROLinear *tmp;
    ENode *enode;
    IROList list1;
    IROList list2;

    flag23 = 0;
    type = expr->linear->rtype;
    tempObj = create_temp_object(type);
    IRO_FindVar(tempObj, 1, 1);
    IRO_InitList(&list1);

    if (IS_LINEAR_DIADIC(expr->linear, EADD)) {
        firstnode = IRO_DuplicateExpr(expr->linear, &list1);
    } else if (IS_LINEAR_DIADIC_2(expr->linear, EDIV, ESHR)) {
        firstnode = IRO_DuplicateExpr(expr->linear, &list1);
    } else {
        firstnode = IRO_NewLinear(IROLinearOp2Arg);
        firstnode->index = ++IRO_NumLinear;
        firstnode->rtype = type;
        firstnode->nodetype = EMUL;
        firstnode->u.diadic.left = IRO_DuplicateExpr(nd1, &list1);
        if (unk)
            firstnode->u.diadic.right = IRO_DuplicateExpr(nd1, &list1);
        else
            firstnode->u.diadic.right = IRO_DuplicateExpr(nd2, &list1);
        IRO_AddToList(firstnode, &list1);
    }

    secondnode = IRO_NewLinear(IROLinearOp2Arg);
    secondnode->index = ++IRO_NumLinear;
    secondnode->rtype = type;
    secondnode->nodetype = EASS;
    secondnode->u.diadic.left = IRO_TempReference(tempObj, &list1);
    secondnode->u.diadic.left->flags |= IROLF_Ind | IROLF_Assigned;
    secondnode->u.diadic.left->u.monadic->flags |= IROLF_Ind | IROLF_Assigned;
    secondnode->u.diadic.right = firstnode;
    IRO_AddToList(secondnode, &list1);
    IRO_Paste(list1.head, list1.tail, PredInt);
    if (
        !IS_LINEAR_DIADIC_2(expr->linear, EDIV, ESHR) &&
        induction->addConst != 1 &&
        (induction->addNode || !IRO_IsConstant(nd2))
        ) {
        flag23 = 1;
        IRO_InitList(&list1);
        thirdnode = IRO_NewLinear(IROLinearOp2Arg);
        thirdnode->index = ++IRO_NumLinear;
        thirdnode->rtype = nd2->rtype;
        thirdnode->nodetype = EMUL;

        if (!induction->addNode) {
            thirdnode->u.diadic.left = IRO_DuplicateExpr(nd2, &list1);
            thirdnode->u.diadic.right = IRO_NewLinear(IROLinearOperand);
            thirdnode->u.diadic.right->index = ++IRO_NumLinear;
            enode = IRO_NewENode(EINTCONST);
            enode->rtype = nd2->rtype;
            thirdnode->u.diadic.right->rtype = nd2->rtype;
            CInt64_SetLong(&enode->data.intval, induction->addConst);
            thirdnode->u.diadic.right->u.node = enode;
            IRO_AddToList(thirdnode->u.diadic.right, &list1);
        } else {
            thirdnode->u.diadic.left = IRO_DuplicateExpr(nd2, &list1);
            thirdnode->u.diadic.right = IRO_DuplicateExpr(induction->addNode, &list1);
            if (nd2->rtype != induction->addNode->rtype) {
                tmp = IRO_NewLinear(IROLinearOp1Arg);
                tmp->nodetype = ETYPCON;
                tmp->index = ++IRO_NumLinear;
                tmp->rtype = nd2->rtype;
                tmp->u.monadic = thirdnode->u.diadic.right;
                IRO_AddToList(tmp, &list1);
                thirdnode->u.diadic.right = tmp;
            }
        }
        IRO_AddToList(thirdnode, &list1);

        tempObj2 = create_temp_object(nd2->rtype);

        fourthnode = IRO_NewLinear(IROLinearOp2Arg);
        fourthnode->index = ++IRO_NumLinear;
        fourthnode->rtype = nd2->rtype;
        fourthnode->nodetype = EASS;
        fourthnode->u.diadic.left = IRO_TempReference(tempObj2, &list1);
        fourthnode->u.diadic.left->flags |= IROLF_Ind | IROLF_Assigned;
        fourthnode->u.diadic.left->u.monadic->flags |= IROLF_Ind | IROLF_Assigned;
        fourthnode->u.diadic.right = thirdnode;
        IRO_AddToList(fourthnode, &list1);
        IRO_Paste(list1.head, list1.tail, PredInt);
    }

    IRO_InitList(&list2);
    fifthnode = IRO_NewLinear(IROLinearOp2Arg);
    fifthnode->index = ++IRO_NumLinear;
    fifthnode->rtype = type;
    if (induction->nd->type == IROLinearOp2Arg) {
        if (induction->nd->nodetype == EASS && IS_LINEAR_DIADIC(induction->nd->u.diadic.right, EADD))
            fifthnode->nodetype = EADDASS;
        else if (induction->nd->nodetype == EASS && IS_LINEAR_DIADIC(induction->nd->u.diadic.right, ESUB))
            fifthnode->nodetype = ESUBASS;
        else
            fifthnode->nodetype = induction->nd->nodetype;
    } else {
        if (induction->nd->nodetype == EPREINC || induction->nd->nodetype == EPOSTINC)
            fifthnode->nodetype = EADDASS;
        else
            fifthnode->nodetype = ESUBASS;
    }

    fifthnode->u.diadic.left = IRO_TempReference(tempObj, &list2);
    fifthnode->u.diadic.left->flags |= IROLF_Ind | IROLF_Used | IROLF_Assigned;
    fifthnode->u.diadic.left->u.monadic->flags |= IROLF_Ind | IROLF_Used | IROLF_Assigned;
    if (!unk) {
        if (!flag23) {
            if (induction->addConst == 1 || IS_LINEAR_DIADIC_2(expr->linear, EDIV, ESHR)) {
                fifthnode->u.diadic.right = IRO_DuplicateExpr(nd2, &list2);
            } else {
                fifthnode->u.diadic.right = IRO_NewLinear(IROLinearOperand);
                fifthnode->u.diadic.right->index = ++IRO_NumLinear;
                enode = IRO_NewENode(EINTCONST);
                enode->rtype = nd2->rtype;
                fifthnode->u.diadic.right->rtype = nd2->rtype;
                CInt64_SetLong(&enode->data.intval, induction->addConst * CInt64_GetULong(&nd2->u.node->data.intval));
                fifthnode->u.diadic.right->u.node = enode;
                IRO_AddToList(fifthnode->u.diadic.right, &list2);
            }
        } else {
            fifthnode->u.diadic.right = IRO_TempReference(tempObj2, &list2);
            fifthnode->u.diadic.right->flags |= IROLF_Used;
        }
    }

    fifthnode->index = ++IRO_NumLinear;
    IRO_AddToList(fifthnode, &list2);
    IRO_Paste(list2.head, list2.tail, IRO_FindStart(induction->nd));
    IRO_WalkTree(expr->linear, IRO_RemoveExpr_Action);
    expr->x8 = tempObj;
    expr->next = RisList;
    RisList = expr;
    return expr;
}

static IRONode *CreatePreHeader(IRONode *fnode1, IRONode *fnode2) {
    IROLinear *labelnode;
    IRONode *newfnode;
    IRONode *iter;
    CLabel *oldlabel;
    CLabel *newlabel;
    SwitchInfo *swinfo;
    SwitchCase *swcase;

    newfnode = oalloc(sizeof(IRONode));
    memset(newfnode, 0, sizeof(IRONode));
    newfnode->index = IRO_NumNodes;
    IRO_NumNodes++;

    labelnode = IRO_NewLinear(IROLinearLabel);
    labelnode->index = IRO_NumLinear++;
    labelnode->next = NULL;
    labelnode->u.label.label = IRO_NewLabel();
    labelnode->flags |= IROLF_1;
    labelnode->u.label.label->stmt = (Statement *) newfnode;
    newfnode->first = labelnode;
    newfnode->last = labelnode;

    if (fnode2) {
        fnode2->last->next = labelnode;
        labelnode->next = IRO_NewLinear(IROLinearNop);
        labelnode->next->next = fnode1->first;
        fnode2->nextnode = newfnode;
        newfnode->nextnode = fnode1;
    } else {
        CError_ASSERT(1254, fnode1->first->type == IROLinearLabel);
        labelnode->next = IRO_NewLinear(IROLinearGoto);
        labelnode->next->u.label.label = fnode1->first->u.label.label;
        IRO_LastNode->last->next = labelnode;
        IRO_LastNode->nextnode = newfnode;
        IRO_LastNode = newfnode;
        IRO_LastLinear = labelnode->next;
    }

    newfnode->last = labelnode->next;

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

    if (fnode1->first->type == IROLinearLabel) {
        oldlabel = fnode1->first->u.label.label;
        newlabel = newfnode->first->u.label.label;
        for (iter = IRO_FirstNode; iter; iter = iter->nextnode) {
            if (!Bv_IsBitSet(iter->index, InLoop) && iter != newfnode) {
                switch (iter->last->type) {
                    case IROLinearGoto:
                        if (iter->last->u.label.label == oldlabel)
                            iter->last->u.label.label = newlabel;
                        break;
                    case IROLinearIf:
                    case IROLinearIfNot:
                        if (iter->last->u.label.label == oldlabel)
                            iter->last->u.label.label = newlabel;
                        break;
                    case IROLinearSwitch:
                        swinfo = iter->last->u.swtch.info;
                        for (swcase = swinfo->cases; swcase; swcase = swcase->next) {
                            if (swcase->label == oldlabel)
                                swcase->label = newlabel;
                        }
                        if (swinfo->defaultlabel == oldlabel)
                            swinfo->defaultlabel = newlabel;
                        break;
                }
            }
        }
    }

    IRO_ComputeSuccPred();
    IRO_ComputeDom();
    return newfnode;
}

static IRONode *CreateNewLoopExitSuccessor(IRONode *fnode1) {
    IROLinear *labelnode;
    IRONode *fnode2;
    IRONode *newfnode;
    Boolean flag;
    IRONode *iter;
    CLabel *oldlabel;
    CLabel *newlabel;
    SwitchInfo *swinfo;
    SwitchCase *swcase;
    UInt16 i;

    CError_ASSERT(1355, fnode1 != NULL && LoopExitNumber == 1);

    fnode2 = NULL;
    flag = 0;

    for (i = 0; i < fnode1->numpred; i++) {
        iter = IRO_NodeTable[fnode1->pred[i]];
        if (Bv_IsBitSet(iter->index, InLoop_Exits)) {
            CError_ASSERT(1366, fnode2 == NULL);
            fnode2 = iter;
            if (!flag) {
                if (
                    !iter->last ||
                    !fnode1->first ||
                    fnode1->first->type != IROLinearLabel ||
                    (
                        (iter->last->type == IROLinearIf || iter->last->type == IROLinearIfNot) &&
                        iter->last->u.label.label != fnode1->first->u.label.label
                    ))
                    flag = 1;
            }
        }
    }

    CError_ASSERT(1382, fnode2 != NULL);

    newfnode = oalloc(sizeof(IRONode));
    memset(newfnode, 0, sizeof(IRONode));
    newfnode->index = IRO_NumNodes;
    IRO_NumNodes++;

    labelnode = IRO_NewLinear(IROLinearLabel);
    labelnode->index = IRO_NumLinear++;
    labelnode->next = NULL;
    labelnode->u.label.label = IRO_NewLabel();
    labelnode->flags |= IROLF_1;
    labelnode->u.label.label->stmt = (Statement *) newfnode;
    newfnode->first = labelnode;
    newfnode->last = labelnode;

    if (flag) {
        fnode2->last->next = labelnode;
        labelnode->next = IRO_NewLinear(IROLinearNop);
        labelnode->next->next = fnode1->first;
        fnode2->nextnode = newfnode;
        newfnode->nextnode = fnode1;
    } else {
        CError_ASSERT(1422, fnode1->first->type == IROLinearLabel);
        labelnode->next = IRO_NewLinear(IROLinearGoto);
        labelnode->next->u.label.label = fnode1->first->u.label.label;
        IRO_LastNode->last->next = labelnode;
        IRO_LastNode->nextnode = newfnode;
        IRO_LastNode = newfnode;
        IRO_LastLinear = labelnode->next;
    }

    newfnode->last = labelnode->next;

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

    if (fnode1->first->type == IROLinearLabel) {
        oldlabel = fnode1->first->u.label.label;
        newlabel = newfnode->first->u.label.label;
        switch (fnode2->last->type) {
            case IROLinearGoto:
                if (fnode2->last->u.label.label == oldlabel)
                    fnode2->last->u.label.label = newlabel;
                break;
            case IROLinearIf:
            case IROLinearIfNot:
                if (fnode2->last->u.label.label == oldlabel)
                    fnode2->last->u.label.label = newlabel;
                break;
            case IROLinearSwitch:
                swinfo = fnode2->last->u.swtch.info;
                for (swcase = swinfo->cases; swcase; swcase = swcase->next) {
                    if (swcase->label == oldlabel)
                        swcase->label = newlabel;
                }
                if (swinfo->defaultlabel == oldlabel)
                    swinfo->defaultlabel = newlabel;
                break;
        }
    }

    IRO_ComputeSuccPred();
    IRO_ComputeDom();
    return newfnode;
}

void AddPreds(IRONode *fnode) {
    IRONode *pred;
    int i;

    for (i = 0; i < fnode->numpred; i++) {
        pred = IRO_NodeTable[fnode->pred[i]];
        if (!Bv_IsBitSet(pred->index, InLoop)) {
            Bv_SetBit(pred->index, InLoop);
            AddPreds(pred);
        }
    }
}

static void RemoveNoopsFromExprList(void) {
    IROExpr *expr;
    IROExpr *prev;

    expr = IRO_FirstExpr;
    prev = NULL;
    while (expr) {
        if (expr->linear->type == IROLinearNop) {
            if (prev)
                prev->next = expr->next;
            else
                IRO_FirstExpr = expr->next;
            expr = expr->next;
        } else {
            prev = expr;
            expr = expr->next;
        }
    }
}

void IncLoopDepth(void) {
    IRONode *fnode;

    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
        if (Bv_IsBitSet(fnode->index, InLoop))
            fnode->loopdepth++;
    }
}

void IRO_SetLoopDepth(void) {
    IRONode *fnode;
    IRONode *pred;
    UInt16 i;
    UInt16 flag;

    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode)
        fnode->loopdepth = 0;

    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
        flag = 0;

        for (i = 0; i < fnode->numpred; i++) {
            pred = IRO_NodeTable[fnode->pred[i]];
            if (Bv_IsBitSet(fnode->index, pred->dom)) {
                if (!flag) {
                    Bv_AllocVector(&InLoop, IRO_NumNodes + 1);
                    Bv_Clear(InLoop);
                    Bv_SetBit(fnode->index, InLoop);
                }
                flag = 1;
                Bv_SetBit(pred->index, InLoop);
                if (pred != fnode)
                    AddPreds(pred);
            }
        }

        if (flag)
            IncLoopDepth();
    }

    IRO_CheckForUserBreak();
}

static void InsertBranchAroundLoopPreheaders(void) {
    IRONode *fnode;
    CLabel *label;
    IRONode *iter;
    IROLinear *endnode;
    IROLinear *labelnode;

    if (IRO_EndNode && IRO_EndNode->last && IRO_EndNode->last->type == IROLinearEnd) {
        label = IRO_NewLabel();
        fnode = IRO_NewFlowGraphNode();
        IRO_LastNode->nextnode = fnode;
        label->stmt = (Statement *) fnode;

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

        labelnode = IRO_NewLinear(IROLinearLabel);
        labelnode->index = ++IRO_NumLinear;
        labelnode->u.label.label = label;
        labelnode->flags |= IROLF_1;
        fnode->first = labelnode;
        IRO_LastLinear->next = labelnode;

        endnode = IRO_NewLinear(IROLinearEnd);
        memcpy(endnode, IRO_EndNode->last, sizeof(IROLinear));
        endnode->index = ++IRO_NumLinear;
        endnode->next = NULL;
        fnode->last = endnode;
        labelnode->next = endnode;
        IRO_LastLinear = endnode;

        IRO_EndNode->last->type = IROLinearGoto;
        IRO_EndNode->last->u.label.label = label;
        IRO_LastNode = fnode;
        IRO_EndNode = fnode;

        IRO_ComputeSuccPred();
        IRO_ComputeDom();
    }
}

void IRO_FindLoops(void) {
    IRONode *fnode;
    IRONode *pred;
    UInt16 i;
    UInt16 flag;

    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
        flag = 0;

        for (i = 0; i < fnode->numpred; i++) {
            pred = IRO_NodeTable[fnode->pred[i]];
            if (Bv_IsBitSet(fnode->index, pred->dom)) {
                if (!flag) {
                    Bv_AllocVector(&InLoop, IRO_NumNodes + 1);
                    Bv_Clear(InLoop);
                    Bv_SetBit(fnode->index, InLoop);
                }
                flag = 1;
                Bv_SetBit(pred->index, InLoop);
                if (pred != fnode)
                    AddPreds(pred);
            }
        }

        if (flag) {
            IncLoopDepth();
            IRO_Dump("IRO_FindLoops:Found loop with header %d\n", fnode->index);
            IRO_DumpBits("Loop includes: ", InLoop);
            MyHandleLoop_Motion(fnode);
            IRO_UpdateFlagsOnInts();
            MyHandleLoop_Vector(fnode);
            RemoveNoopsFromExprList();
            IRO_UpdateFlagsOnInts();
            IRO_UpdateVars();
        }
    }

    if (!IRO_FunctionHasReturn && IRO_EndNode != IRO_LastNode)
        InsertBranchAroundLoopPreheaders();
}

static void CheckSubableSub(IROLinear *linear, Boolean isFirst) {
    if (isFirst && IRO_IsSubableExpression(linear)) {
        IRO_Dump("Subable Expression is %d\n", linear->index);
        NoSubableSubs = 0;
    }
}

static int NoSubableSubExprs(IROLinear *nd) {
    NoSubableSubs = 1;
    IRO_WalkTree(nd, CheckSubableSub);
    return NoSubableSubs;
}

void ComputeLoopKills(void) {
    IRONode *fnode;
    IROLinear *nd;

    Bv_AllocVector(&AllKills, IRO_NumVars + 1);
    Bv_AllocVector(&IRO_VarKills, IRO_NumVars + 1);

    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
        if (Bv_IsBitSet(fnode->index, InLoop) && (nd = fnode->first)) {
            Bv_AllocVector(&fnode->x16, IRO_NumVars + 1);
            Bv_AllocVector(&fnode->x1E, IRO_NumVars + 1);
            while (1) {
                Bv_Clear(IRO_VarKills);
                IRO_GetKills(nd);
                Bv_Or(IRO_VarKills, AllKills);
                if (nd == fnode->last)
                    break;
                nd = nd->next;
            }
        }
    }
}

void ComputeLoopInvariance(void) {
    IRONode *fnode;
    IROLinear *nd;

    IRO_Depends = IRO_VarKills;

    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
        if (Bv_IsBitSet(fnode->index, InLoop) && (nd = fnode->first)) {
            nd->flags &= ~IROLF_LoopInvariant;
            while (1) {
                if ((nd->flags & IROLF_Reffed) && nd->type != IROLinearNop) {
                    IRO_FindDepends_NoAlloc(nd);
                    if (!IRO_IsVolatile && !Bv_BitsInCommon(IRO_Depends, AllKills))
                        nd->flags |= IROLF_LoopInvariant;

                    if (IRO_CouldError)
                        nd->flags |= IROLF_CouldError;
                    else
                        nd->flags &= ~IROLF_CouldError;
                }

                if (nd == fnode->last)
                    break;
                nd = nd->next;
            }
        }
    }
}

void ComputeLoopInduction(void) {
    IRONode *fnode;
    IROLinear *nd;
    Boolean flag;
    Object *obj;
    Object *obj2;
    Object *obj3;
    VarRecord *var;
    IROLinear *tmpnd;
    IROLoopInd *ind;
    Boolean isUnsigned;

    Bv_AllocVector(&AllKills, IRO_NumVars + 1);
    Bv_AllocVector(&IRO_VarKills, IRO_NumVars + 1);

    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
        if (Bv_IsBitSet(fnode->index, InLoop) && (nd = fnode->first)) {
            while (1) {
                Bv_Clear(IRO_VarKills);
                IRO_GetKills(nd);
                Bv_Or(IRO_VarKills, AllKills);
                flag = 0;
                if (
                    (
                        nd->type == IROLinearOp2Arg &&
                        nd->rtype->size <= 4 &&
                        (nd->nodetype == EADDASS || nd->nodetype == ESUBASS) &&
                        (obj = IRO_IsVariable(nd->u.diadic.left)) &&
                        obj->type->size == nd->rtype->size &&
                        IS_TYPE_INT(obj->type) &&
                        (
                            (IRO_IsIntConstant(nd->u.diadic.right) && CInt64_GetULong(&nd->u.diadic.right->u.node->data.intval))
                            ||
                            (nd->u.diadic.right->flags & IROLF_LoopInvariant)
                        )
                    )
                    ||
                    (
                        nd->type == IROLinearOp1Arg &&
                        nd->rtype->size <= 4 &&
                        (nd->nodetype == EPOSTINC || nd->nodetype == EPOSTDEC || nd->nodetype == EPREINC || nd->nodetype == EPREDEC) &&
                        (obj = IRO_IsVariable(nd->u.monadic)) &&
                        obj->type->size == nd->rtype->size &&
                        IS_TYPE_INT(obj->type)
                    )
                    )
                {
                    flag = 1;
                }
                else if (
                    nd->type == IROLinearOp2Arg &&
                    nd->rtype->size <= 4 &&
                    nd->nodetype == EASS &&
                    (obj = IRO_IsVariable(nd->u.diadic.left)) &&
                    obj->type->size == nd->rtype->size &&
                    IS_TYPE_INT(obj->type) &&
                    nd->u.diadic.right->type == IROLinearOp2Arg &&
                    (nd->u.diadic.right->nodetype == EADD || nd->u.diadic.right->nodetype == ESUB)
                    )
                {
                    if (nd->u.diadic.right->nodetype == EADD) {
                        obj2 = IRO_IsVariable(nd->u.diadic.right->u.diadic.left);
                        obj3 = IRO_IsVariable(nd->u.diadic.right->u.diadic.right);
                        if (obj2 == obj && obj3 != obj && (nd->u.diadic.right->u.diadic.right->flags & IROLF_LoopInvariant))
                            flag = 1;

                        if (obj3 == obj && obj2 != obj && (nd->u.diadic.right->u.diadic.left->flags & IROLF_LoopInvariant)) {
                            flag = 1;
                            tmpnd = nd->u.diadic.right->u.diadic.left;
                            nd->u.diadic.right->u.diadic.left = nd->u.diadic.right->u.diadic.right;
                            nd->u.diadic.right->u.diadic.right = tmpnd;
                        }
                    } else {
                        obj2 = IRO_IsVariable(nd->u.diadic.right->u.diadic.left);
                        obj3 = IRO_IsVariable(nd->u.diadic.right->u.diadic.right);
                        if (obj2 == obj && obj3 != obj && (nd->u.diadic.right->u.diadic.right->flags & IROLF_LoopInvariant))
                            flag = 1;
                    }
                }

                if (flag) {
                    if ((var = IRO_FindAssigned(nd))) {
                        if (var->xA == 2)
                            var->xA = 0;
                        else if (var->xA == 1)
                            var->xA = 2;
                    }
                } else {
                    for (var = IRO_FirstVar; var; var = var->next) {
                        if (Bv_IsBitSet(var->index, IRO_VarKills))
                            var->xA = 0;
                    }
                }

                if (nd == fnode->last)
                    break;
                nd = nd->next;
            }
        }
    }

    IRO_DumpBits("Killed in loop: ", AllKills);

    for (fnode = IRO_FirstNode, FirstInd = NULL; fnode; fnode = fnode->nextnode) {
        if (Bv_IsBitSet(fnode->index, InLoop) && (nd = fnode->first)) {
            while (1) {
                if (
                    (
                        nd->type == IROLinearOp2Arg &&
                        (nd->nodetype == EADDASS || nd->nodetype == ESUBASS || nd->nodetype == EASS)
                    )
                    ||
                    (
                        nd->type == IROLinearOp1Arg &&
                        (nd->nodetype == EPOSTINC || nd->nodetype == EPOSTDEC || nd->nodetype == EPREINC || nd->nodetype == EPREDEC)
                    )
                    ) {
                    if ((var = IRO_FindAssigned(nd)) && var->xA == 2 && var->object->type->size <= 4) {
                        ind = oalloc(sizeof(IROLoopInd));
                        ind->fnode = fnode;
                        ind->var = var;
                        ind->nd = nd;
                        ind->next = FirstInd;
                        ind->addNode = NULL;
                        ind->addConst = 0;
                        ind->flags = 0;

                        if (nd->type == IROLinearOp2Arg) {
                            isUnsigned = IRO_IsUnsignedType(nd->rtype);
                            if (IRO_IsIntConstant(nd->u.diadic.right)) {
                                CInt64 val = nd->u.diadic.right->u.node->data.intval;
                                if (IS_LINEAR_DIADIC(nd, EADDASS) && CInt64_Less(val, cint64_zero)) {
                                    nd->nodetype = ESUBASS;
                                    nd->u.diadic.right->u.node->data.intval = CInt64_Neg(val);
                                }
                                if (isUnsigned) {
                                    CInt64_ConvertUInt32(&nd->u.diadic.right->u.node->data.intval);
                                    ind->addConst = CInt64_GetULong(&nd->u.diadic.right->u.node->data.intval);
                                } else {
                                    CInt64_ConvertInt32(&nd->u.diadic.right->u.node->data.intval);
                                    ind->addConst = CInt64_GetULong(&nd->u.diadic.right->u.node->data.intval);
                                }
                                ind->addNode = NULL;
                            } else if (nd->nodetype == EADDASS || nd->nodetype == ESUBASS) {
                                ind->addNode = nd->u.diadic.right;
                            } else if (nd->nodetype == EASS) {
                                ind->addNode = nd->u.diadic.right->u.diadic.right;
                            }
                        } else {
                            if (IS_TYPE_POINTER_ONLY(nd->rtype))
                                ind->addConst = TPTR_TARGET(nd->rtype)->size;
                            else
                                ind->addConst = 1;
                            ind->addNode = NULL;
                        }

                        FirstInd = ind;

                        if (IS_LINEAR_DIADIC_2(nd, EADDASS, ESUBASS)) {
                            if (nd->u.diadic.right->flags & IROLF_LoopInvariant)
                                IRO_Dump("Found induction variable the new way: %s\n", var->object->name->name);
                            else
                                IRO_Dump("Found induction variable the old way: %s\n", var->object->name->name);
                        } else if (nd->type == IROLinearOp2Arg && (nd->u.diadic.right->nodetype == EADD || nd->u.diadic.right->nodetype == ESUB)) {
                            IRO_Dump("Found induction variable the new way: %s\n", var->object->name->name);
                        } else {
                            IRO_Dump("Found induction variable the old way: %s\n", var->object->name->name);
                        }
                    }
                }

                if (nd == fnode->last)
                    break;
                nd = nd->next;
            }
        }
    }
}

static void IRO_ActUnmarkLoopInvariance(IROLinear *linear, Boolean isFirst) {
    if (isFirst)
        linear->flags &= ~IROLF_LoopInvariant;
}

static void UnmarkSubexpressionsOfInvariantExpressions(void) {
    IROExpr *expr;

    for (expr = IRO_FirstExpr; expr; expr = expr->next) {
        if (
            Bv_IsBitSet(expr->node->index, InLoop) &&
            !expr->notSubable &&
            (!expr->couldError || expr->node->mustreach) &&
            (expr->linear->flags & IROLF_LoopInvariant)
            ) {
            IRO_WalkTree(expr->linear, IRO_ActUnmarkLoopInvariance);
            expr->linear->flags |= IROLF_LoopInvariant;
        }
    }
}

static void MyHandleLoop_Vector(IRONode *fnode) {
    IRONode *pred;
    UInt16 i;
    IROExpr *expr;
    IROExpr *removedExprs;
    IROExpr *exprnext;
    IROLoopInd *induction;
    IROExpr *exprinner;
    Boolean flag24;
    IRONode *v2;
    IRONode *node22;
    int flag21;
    IRONode *iter;
    IROExpr *searchris;
    IROLinear *reduceNd1;
    VarRecord *var;
    IROLinear *reduceNd2;

    IRO_FirstExpr = NULL;
    LoopNode = fnode;
    FindMustReach();

    for (var = IRO_FirstVar; var; var = var->next)
        var->xA = 1;

    ComputeLoopKills();
    ComputeLoopInvariance();
    ComputeLoopInduction();
    LoopNode = fnode;
    ConditionalHeaderAtBottom = 0;

    v2 = NULL;
    flag21 = 0;
    node22 = NULL;
    for (i = 0; i < LoopNode->numpred; i++) {
        pred = IRO_NodeTable[LoopNode->pred[i]];
        if (!Bv_IsBitSet(pred->index, InLoop)) {
            if (flag21)
                node22 = NULL;
            else
                node22 = pred;
            flag21 = 1;
            if (pred->nextnode == fnode) {
                CError_ASSERT(2880, v2 == NULL || pred == v2);
                v2 = pred;
            }
        }
    }

    if (!flag21) {
        IRO_Dump("No predecessor outside the loop\n");
        return;
    }

    if (!node22 || node22->last->type != IROLinearGoto)
        node22 = CreatePreHeader(fnode, v2);
    PredInt = node22->last;

    if (PredInt->type == IROLinearGoto && PredInt->u.label.label != LoopNode->first->u.label.label) {
        if (!KnownBounds || !Times) {
            for (iter = IRO_FirstNode; iter; iter = iter->nextnode)
                iter->mustreach = 0;
        } else {
            PredInt->u.label.label = LoopNode->first->u.label.label;
            IRO_ComputeSuccPred();
        }
    }

    if (copts.opt_loop_invariants || copts.opt_strength_reduction) {
        MoveInvarianceInAddressExpr();
        IRO_DumpAfterPhase("MoveInvarianceInAddressExpr", 0);
        IRO_FindExpressions(InLoop, 1);
        IRO_DumpExprs();
    }

    if (copts.opt_loop_invariants)
        UnmarkSubexpressionsOfInvariantExpressions();

    if (!copts.optimize_for_size && copts.opt_strength_reduction) {
        for (expr = IRO_FirstExpr; expr; expr = expr->next) {
            if (
                !(expr->x0 & 4) &&
                Bv_IsBitSet(expr->node->index, InLoop) &&
                !expr->notSubable &&
                (!expr->couldError || expr->node->mustreach) &&
                Reducable(expr->linear, &reduceNd1, &reduceNd2, &var)
                ) {
                IRO_WalkTree(expr->linear, IRO_ActUnmarkRISCandidate);
                expr->linear->flags |= IROLF_Ris;
                expr->x1A = reduceNd1;
                expr->x1E = var;
                expr->x22 = reduceNd2;
            }
        }
    }

    if (!copts.optimize_for_size && copts.opt_strength_reduction) {
        RisList = NULL;
        for (expr = IRO_FirstExpr; expr; expr = exprnext) {
            exprnext = expr->next;
            if (!(expr->x0 & 4) && (expr->linear->flags & IROLF_Ris)) {
                reduceNd1 = expr->x1A;
                var = expr->x1E;
                reduceNd2 = expr->x22;

                induction = FirstInd;
                while (induction && induction->var != var)
                    induction = induction->next;
                CError_ASSERT(3529, induction != NULL);

                IRO_FindDepends(reduceNd1);
                if (!Bv_BitsInCommon(IRO_Depends, AllKills)) {
                    IRO_Dump("Found reduction in strength: %d\n", expr->linear->index);
                    if (IS_LINEAR_DIADIC(expr->linear, ESHL)) {
                        expr->linear->nodetype = EMUL;
                        CInt64_SetULong(&reduceNd1->u.node->data.intval, 1 << CInt64_GetULong(&reduceNd1->u.node->data.intval));
                        reduceNd1->u.node->rtype = expr->linear->rtype;
                    }

                    searchris = RisList;
                    while (1) {
                        if (!searchris)
                            break;
                        if (IRO_ExprsSame(expr->linear, searchris->linear))
                            break;
                        searchris = searchris->next;
                    }

                    if (searchris) {
                        IRO_Dump("Using existing RIS: %d\n", searchris->linear->index);
                        IRO_WalkTree(expr->linear, IRO_RemoveExpr_Action);
                    } else {
                        searchris = CreateRIS(expr, reduceNd2, reduceNd1, induction, 0);
                    }
                    IRO_ReplaceReference(expr->linear, searchris->x8, expr->linear);
                    IRO_ClipExpr(expr);
                }
            }
        }
    }

    RisList = NULL;

    expr = IRO_FirstExpr;
    removedExprs = NULL;
    if (copts.opt_loop_invariants) {
        while (expr) {
            exprnext = expr->next;
            flag24 = 0;

            if (
                Bv_IsBitSet(expr->node->index, InLoop) &&
                !expr->notSubable &&
                (!expr->couldError || expr->node->mustreach) &&
                (expr->linear->flags & IROLF_LoopInvariant) &&
                !(expr->x0 & 4)
                ) {
                IRO_Dump("Found loop invariant: %d\n", expr->linear->index);

                for (exprinner = removedExprs; exprinner; exprinner = exprinner->next) {
                    if (IRO_ExprsSame(exprinner->linear, expr->linear)) {
                        IRO_ReplaceReference(expr->linear, exprinner->x8, expr->linear);
                        IRO_NopOut(expr->linear);
                        IRO_Dump("Using already removed expr: %d\n", exprinner->linear->index);
                        IRO_RemoveExpr(expr);
                        flag24 = 1;
                    }
                }

                if (!flag24 && !expr->x8) {
                    IRO_GetTemp(expr);
                    IRO_ReplaceReference(expr->linear, expr->x8, expr->linear);
                    IRO_MoveExpression(expr, PredInt);
                    IRO_AssignToTemp(expr);
                    IRO_RemoveExpr(expr);
                    expr->next = removedExprs;
                    removedExprs = expr;
                }
            }

            expr = exprnext;
        }
    }
}

static void MyHandleLoop_Motion(IRONode *fnode) {
    IROLoopMemRef *memref;
    IRONode *pred;
    UInt16 i;
    IRONode *v2;
    IRONode *node21;
    Object *tempobj;
    int flag20;
    IRONode *iter;
    IROLinear *ass;
    VarRecord *var;
    Boolean checkflag;
    IROLoop *loop;
    IROList list;
    IROElmList *refiter;

    IRO_FirstExpr = NULL;
    LoopNode = fnode;
    FindMustReach();

    for (var = IRO_FirstVar; var; var = var->next)
        var->xA = 1;

    ComputeLoopKills();
    ComputeLoopInvariance();
    ComputeLoopInduction();
    LoopNode = fnode;
    ConditionalHeaderAtBottom = 0;

    v2 = NULL;
    flag20 = 0;
    node21 = NULL;
    for (i = 0; i < LoopNode->numpred; i++) {
        pred = IRO_NodeTable[LoopNode->pred[i]];
        if (!Bv_IsBitSet(pred->index, InLoop)) {
            if (flag20)
                node21 = NULL;
            else
                node21 = pred;
            flag20 = 1;
            if (pred->nextnode == fnode) {
                CError_ASSERT(3880, v2 == NULL || pred == v2);
                v2 = pred;
            }
        }
    }

    if (!flag20) {
        IRO_Dump("No predecessor outside the loop\n");
        return;
    }

    if (!node21 || node21->last->type != IROLinearGoto)
        node21 = CreatePreHeader(fnode, v2);
    PredInt = node21->last;

    if (PredInt->type == IROLinearGoto && PredInt->u.label.label != LoopNode->first->u.label.label) {
        if (!KnownBounds || !Times) {
            for (iter = IRO_FirstNode; iter; iter = iter->nextnode)
                iter->mustreach = 0;
        } else {
            PredInt->u.label.label = LoopNode->first->u.label.label;
            IRO_ComputeSuccPred();
        }
    }

    if (copts.opt_loop_invariants || copts.opt_strength_reduction) {
        MoveInvarianceInAddressExpr();
        IRO_DumpAfterPhase("MoveInvarianceInAddressExpr", 0);
        IRO_FindExpressions(InLoop, 0);
        IRO_DumpExprs();
    }

    if (copts.opt_loop_invariants)
        UnmarkSubexpressionsOfInvariantExpressions();

    checkflag = 1;
    Bv_AllocVector(&InLoop_Exits, IRO_NumNodes + 1);
    Bv_AllocVector(&InLoop_Tails, IRO_NumNodes + 1);
    LoopExitNumber = 0;
    LoopExitSuccessor = NULL;
    LoopTailNum = 0;
    LoopTail = NULL;
    IRO_FindLoopTailsAndExits(fnode);
    FindMustReach1(fnode);

    loop = NULL;
    if (LoopTailNum == 1) {
        if (fnode->last->type == IROLinearIf || fnode->last->type == IROLinearIfNot)
            loop = ExtractLoopInfo(fnode);
        else if (LoopTail->last->type == IROLinearIf || LoopTail->last->type == IROLinearIfNot)
            loop = ExtractLoopInfo(LoopTail);
    }

    if (loop && !(loop->flags & LP_IFEXPR_NON_CANONICAL) && LoopExitNumber == 1) {
        IRO_LoopMemRefFirst = NULL;
        IRO_LoopMemRefCurrent = NULL;
        CheckAllLoopAddresses(IRO_FirstNode, InLoop, &checkflag);
        CheckAllLoopAddresses(IRO_FirstNode, InLoop, &checkflag);
        if (checkflag) {
            for (memref = IRO_LoopMemRefFirst; memref; memref = memref->next) {
                if (memref->flags & LoopMemRef_10)
                    memref->flags |= LoopMemRef_8;
            }

            for (memref = IRO_LoopMemRefFirst; memref; memref = memref->next) {
                IRO_Dump("Loop Motion Candidate:: Int= %d", memref->nd->index);
                if (memref->flags & LoopMemRef_8)
                    IRO_Dump("<invalid>");
                if (memref->flags & LoopMemRef_1)
                    IRO_Dump("<load>");
                if (memref->flags & LoopMemRef_2)
                    IRO_Dump("<store>");
                IRO_Dump("\n");

                if (!(memref->flags & LoopMemRef_8)) {
                    tempobj = create_temp_object(memref->nd->rtype);
                    IRO_FindVar(tempobj, 1, 1);
                    if (IRO_FindVar(((IROLinear *) memref->rec->objRefs->element)->u.node->data.objref, 0, 1)) {
                        IRO_InitList(&list);
                        ass = IRO_NewLinear(IROLinearOp2Arg);
                        ass->index = ++IRO_NumLinear;
                        ass->rtype = memref->nd->rtype;
                        ass->nodetype = EASS;
                        ass->u.diadic.left = IRO_TempReference(tempobj, &list);
                        ass->u.diadic.left->flags |= IROLF_Ind | IROLF_Assigned;
                        ass->u.diadic.left->u.monadic->flags |= IROLF_Ind | IROLF_Assigned;
                        ass->u.diadic.right = IRO_DuplicateExpr(memref->nd, &list);
                        IRO_AddToList(ass, &list);
                        IRO_Paste(list.head, list.tail, PredInt);
                    } else {
                        CError_FATAL(4123);
                    }

                    if (LoopExitSuccessor->numpred != 1)
                        LoopExitSuccessor = CreateNewLoopExitSuccessor(LoopExitSuccessor);

                    IRO_InitList(&list);
                    ass = IRO_NewLinear(IROLinearOp2Arg);
                    ass->index = ++IRO_NumLinear;
                    ass->rtype = memref->nd->rtype;
                    ass->nodetype = EASS;
                    ass->u.diadic.left = IRO_DuplicateExpr(memref->nd, &list);
                    ass->u.diadic.left->flags |= IROLF_Ind | IROLF_Assigned;
                    ass->u.diadic.left->u.monadic->flags |= IROLF_Ind | IROLF_Assigned;
                    ass->u.diadic.right = IRO_TempReference(tempobj, &list);
                    IRO_AddToList(ass, &list);

                    if (LoopExitSuccessor->first->type == IROLinearLabel)
                        IRO_PasteAfter(list.head, list.tail, LoopExitSuccessor->first);
                    else
                        IRO_Paste(list.head, list.tail, LoopExitSuccessor->first);

                    for (refiter = memref->list; refiter; refiter = refiter->next) {
                        IRO_Dump("Loop Motion Candidate Reference at Int= %d\n", ((IROLinear *) refiter->element)->index);
                        IRO_InitList(&list);
                        IRO_TempReference(tempobj, &list);
                        IRO_Paste(list.head, list.tail, refiter->element);
                        IRO_LocateFather_Cut_And_Paste(refiter->element, list.tail);
                    }
                }
            }
        }
    }

    IRO_DumpAfterPhase("After Motion", 0);
}

static Boolean CheckLoopAddress(IROLinear *nd, Boolean mustreach1) {
    IROLoopMemRef *memref;
    IROAddrRecord *rec;
    IROAddrRecord *otherrec;
    IROLinear *inner;
    IROElmList *list;
    Boolean flag;

    inner = nd->u.monadic;
    rec = IRO_InitAddrRecordPointer(inner);
    if (IS_LINEAR_ENODE(inner, EOBJREF)) {
        rec->numObjRefs++;
        IRO_AddElmToList(inner, &rec->objRefs);
    } else if (IS_LINEAR_DIADIC(inner, EADD)) {
        IRO_DecomposeAddressExpression(inner, rec);
    } else {
        return 0;
    }

    if (rec->numObjRefs != 1)
        return 0;

    flag = (nd->flags & IROLF_CouldError) || !(nd->flags & IROLF_Reffed);
    if (!IRO_LoopMemRefFirst) {
        MakeLoopEntry(nd, rec, mustreach1, flag);
    } else {
        for (memref = IRO_LoopMemRefFirst; memref; memref = memref->next) {
            otherrec = memref->rec;
            if (((IROLinear *) rec->objRefs->element)->u.node->data.objref == ((IROLinear *) otherrec->objRefs->element)->u.node->data.objref) {
                if (IRO_ExprsSame(inner, otherrec->linear)) {
                    list = oalloc(sizeof(IROElmList));
                    list->element = nd;
                    list->next = NULL;
                    if (!memref->list) {
                        memref->list = list;
                    } else {
                        list->next = memref->list;
                        memref->list = list;
                    }
                } else {
                    memref->flags |= LoopMemRef_8;
                }

                if (!mustreach1 && flag)
                    memref->flags |= LoopMemRef_8;
                if (mustreach1 || flag)
                    memref->flags &= ~LoopMemRef_10;
                break;
            }
        }

        if (!memref)
            MakeLoopEntry(nd, rec, mustreach1, flag);
    }

    return 1;
}

static void CheckAllLoopAddresses(IRONode *fnode, BitVector *bv, Boolean *resultFlag) {
    IROLinear *nd;
    Boolean flag;

    flag = *resultFlag;
    while (fnode) {
        if (Bv_IsBitSet(fnode->index, bv) && (nd = fnode->first)) {
            while (flag) {
                if (nd->type == IROLinearOp1Arg && nd->nodetype == EINDIRECT)
                    flag = CheckLoopAddress(nd, fnode->mustreach1);
                else if (nd->type == IROLinearFunccall)
                    flag = 0;

                if (nd == fnode->last)
                    break;
                nd = nd->next;
            }

            if (!flag)
                break;
        }
        fnode = fnode->nextnode;
    }
    *resultFlag = flag;
}

static void MakeLoopEntry(IROLinear *nd, IROAddrRecord *rec, Boolean mustreach1, Boolean flag2) {
    IROElmList *list;

    if (!IRO_IsRegable(((IROLinear *) rec->objRefs->element)->u.node->data.objref) &&
        (nd->u.monadic->flags & IROLF_LoopInvariant) &&
        !IRO_HasSideEffect(nd)) {
        if (!IRO_LoopMemRefFirst) {
            IRO_LoopMemRefCurrent = IRO_LoopMemRefFirst = oalloc(sizeof(IROLoopMemRef));
        } else {
            IRO_LoopMemRefCurrent->next = oalloc(sizeof(IROLoopMemRef));
            IRO_LoopMemRefCurrent = IRO_LoopMemRefCurrent->next;
        }
        IRO_LoopMemRefCurrent->flags = LoopMemRef_10;
        IRO_LoopMemRefCurrent->nd = nd;
        IRO_LoopMemRefCurrent->rec = rec;
        IRO_LoopMemRefCurrent->next = NULL;
        IRO_LoopMemRefCurrent->list = NULL;

        list = oalloc(sizeof(IROElmList));
        list->element = nd;
        list->next = NULL;
        if (!IRO_LoopMemRefCurrent->list) {
            IRO_LoopMemRefCurrent->list = list;
        } else {
            list->next = IRO_LoopMemRefCurrent->list;
            IRO_LoopMemRefCurrent->list = list;
        }

        if (((IROLinear *) rec->objRefs->element)->flags & IROLF_Assigned) {
            IRO_LoopMemRefCurrent->flags |= LoopMemRef_2;
            if (((IROLinear *) rec->objRefs->element)->flags & IROLF_Used)
                IRO_LoopMemRefCurrent->flags |= LoopMemRef_1;
        } else {
            IRO_LoopMemRefCurrent->flags |= LoopMemRef_1;
        }

        if (!mustreach1 && flag2)
            IRO_LoopMemRefCurrent->flags |= LoopMemRef_8;

        if (mustreach1 || flag2)
            IRO_LoopMemRefCurrent->flags &= ~LoopMemRef_10;
    }
}

void FindAssignmenttoInductionVar(IROLoop *loop, IRONode *fnode) {
    IROLinear *nd;
    UInt32 index;

    if (!loop->induction) {
        loop->nd14 = NULL;
    } else {
        index = loop->induction->var->index;
        for (nd = fnode->first; nd; nd = nd->next) {
            Bv_Clear(IRO_VarKills);
            IRO_GetKills(nd);
            if (Bv_IsBitSet(index, IRO_VarKills))
                loop->nd14 = nd;

            if (nd == fnode->last)
                break;
        }

        if (loop->nd14 && loop->nd14->type != IROLinearOp2Arg)
            loop->nd14 = NULL;
    }
}

static void ComputeIntWeight(IROLoop *loop, IROLinear *Int) {
    loop->sizeBySomeMeasurement++;
}

static IROLinear *IsTypconVar(IROLinear *nd) {
    if (IS_LINEAR_MONADIC(nd, ETYPCON) && IRO_IsVariable(nd->u.monadic))
        return nd->u.monadic;
    else
        return NULL;
}

IROLoop *ExtractLoopInfo(IRONode *fnode) {
    Boolean flag30;
    Boolean flag29;
    Boolean flag28;
    UInt32 counter27;
    IROLoopInd *ind23;
    Object *obj;
    IROLinear *nd21;
    IRONode *scanfnode;
    IROLinear *left19;
    IROLinear *right18;
    IROLinear *tmp18;
    IROLinear *scannd;
    IROLinear *tmp;
    VarRecord *var;
    IROLoopInd *scanind;
    IROLinear *left;
    IROLinear *right;
    UInt32 counter2;
    UInt32 i;
    IROLoop *loop;

    flag30 = 0;
    flag29 = 0;
    flag28 = 0;
    counter27 = 0;
    LoopNode = fnode;

    loop = oalloc(sizeof(IROLoop));
    loop->fnode = fnode;
    nd21 = LoopNode->last->u.label.x4;
    loop->nd18 = nd21;
    loop->flags = 0;
    loop->x8 = 0;
    loop->nd14 = NULL;
    loop->induction = NULL;
    loop->index20 = -1;
    loop->index24 = -1;
    loop->sizeBySomeMeasurement = 0;

    if (nd21->type == IROLinearOp2Arg && IS_TYPE_INT(nd21->rtype)) {
        ind23 = NULL;
        left19 = nd21->u.diadic.left;
        right18 = nd21->u.diadic.right;
        if (IRO_IsVariable(left19) || (left19 = IsTypconVar(left19))) {
            if ((var = IRO_FindVar(left19->u.monadic->u.node->data.objref, 0, 1))) {
                scanind = FirstInd;
                while (scanind && scanind->var != var)
                    scanind = scanind->next;
                if (scanind) {
                    ind23 = scanind;
                    loop->flags |= LoopFlags_1;
                    loop->induction = scanind;
                }
            }
        }

        if (IRO_IsVariable(right18) || (right18 = IsTypconVar(right18))) {
            if ((var = IRO_FindVar(right18->u.monadic->u.node->data.objref, 0, 1))) {
                scanind = FirstInd;
                while (scanind && scanind->var != var)
                    scanind = scanind->next;
                if (scanind) {
                    ind23 = scanind;
                    loop->flags &= ~LoopFlags_1;
                    loop->induction = scanind;
                }
            }
        }

        if (ind23 && ind23->addConst > 0) {
            if (loop->flags & LoopFlags_1) {
                if (
                    loop->nd18->type != IROLinearOp2Arg ||
                    !(loop->nd18->nodetype == ELESS || loop->nd18->nodetype == EGREATER || loop->nd18->nodetype == ELESSEQU || loop->nd18->nodetype == EGREATEREQU) ||
                    !loop->nd18->u.diadic.left ||
                    !loop->nd18->u.diadic.left->rtype ||
                    !IS_TYPE_INT(loop->nd18->u.diadic.left->rtype) ||
                    !loop->nd18->u.diadic.right ||
                    !loop->nd18->u.diadic.right->rtype ||
                    !IS_TYPE_INT(loop->nd18->u.diadic.right->rtype)
                    ) {
                    loop->flags |= LP_IFEXPR_NON_CANONICAL;
                    return loop;
                }
            } else {
                if (
                    loop->nd18->type == IROLinearOp2Arg &&
                    (loop->nd18->nodetype == EGREATER || loop->nd18->nodetype == EGREATEREQU) &&
                    (left = loop->nd18->u.diadic.left) &&
                    left->rtype &&
                    IS_TYPE_INT(left->rtype) &&
                    (right = loop->nd18->u.diadic.right) &&
                    right->rtype &&
                    IS_TYPE_INT(right->rtype)
                    ) {
                    loop->nd18->u.diadic.left = right;
                    loop->nd18->u.diadic.right = left;
                    if (loop->nd18->nodetype == EGREATER)
                        loop->nd18->nodetype = ELESS;
                    else if (loop->nd18->nodetype == EGREATEREQU)
                        loop->nd18->nodetype = ELESSEQU;
                    loop->flags |= LoopFlags_1;
                } else if (
                    loop->nd18->type == IROLinearOp2Arg &&
                    (loop->nd18->nodetype == ELESS || loop->nd18->nodetype == ELESSEQU) &&
                    (left = loop->nd18->u.diadic.left) &&
                    left->rtype &&
                    IS_TYPE_INT(left->rtype) &&
                    (right = loop->nd18->u.diadic.right) &&
                    right->rtype &&
                    IS_TYPE_INT(right->rtype)
                    ) {
                    loop->nd18->u.diadic.left = right;
                    loop->nd18->u.diadic.right = left;
                    if (loop->nd18->nodetype == ELESS)
                        loop->nd18->nodetype = EGREATER;
                    else if (loop->nd18->nodetype == ELESSEQU)
                        loop->nd18->nodetype = EGREATEREQU;
                    loop->flags |= LoopFlags_1;
                } else {
                    loop->flags |= LP_IFEXPR_NON_CANONICAL;
                    return loop;
                }
            }
        } else {
            loop->flags |= LP_INDUCTION_NOT_FOUND;
            return loop;
        }
    } else if (nd21->type == IROLinearOp1Arg && IS_TYPE_INT(nd21->rtype)) {
        if (nd21->nodetype == EPREINC || nd21->nodetype == EPOSTINC || nd21->nodetype == EPREDEC || nd21->nodetype == EPOSTDEC) {
            if (IRO_IsVariable(nd21->u.monadic)) {
                if ((var = IRO_FindVar(nd21->u.monadic->u.monadic->u.node->data.objref, 0, 1))) {
                    scanind = FirstInd;
                    while (scanind && scanind->var != var)
                        scanind = scanind->next;
                    if (scanind) {
                        ind23 = scanind;
                        loop->flags |= LoopFlags_10000;
                        loop->induction = scanind;
                    } else {
                        loop->flags |= LP_INDUCTION_NOT_FOUND;
                        return loop;
                    }
                } else {
                    loop->flags |= LP_INDUCTION_NOT_FOUND;
                    return loop;
                }
            } else {
                loop->flags |= LP_INDUCTION_NOT_FOUND;
                return loop;
            }
        } else {
            loop->flags |= LP_INDUCTION_NOT_FOUND;
            return loop;
        }
    } else {
        loop->flags |= LP_IFEXPR_NON_CANONICAL;
        return loop;
    }

    counter2 = 0;
    scanind = FirstInd;
    while (scanind) {
        scanind = scanind->next;
        counter2++;
    }

    if (counter2 > 1)
        loop->flags |= LP_HAS_MULTIPLE_INDUCTIONS;

    if ((scanind = loop->induction)) {
        nd21 = scanind->nd;
        if (nd21->type == IROLinearOp2Arg) {
            if (IS_LINEAR_DIADIC_2(loop->nd18, ELESS, ELESSEQU)) {
                if (nd21->nodetype == EADDASS) {
                    if (scanind->addConst == 1)
                        loop->flags |= LoopFlags_100;
                    if (scanind->addConst > 0)
                        loop->flags |= LP_LOOP_STEP_ISPOS;
                } else if (nd21->nodetype == EASS &&
                    IS_LINEAR_DIADIC(nd21->u.diadic.right, EADD) &&
                    IRO_IsIntConstant(tmp18 = nd21->u.diadic.right->u.diadic.right) &&
                    CTool_EndianReadWord32(&tmp18->u.node->data.intval.hi) == 0) {
                    if (CInt64_GetULong(&tmp18->u.node->data.intval) == 1)
                        loop->flags |= LoopFlags_100;
                    if (CInt64_GetULong(&tmp18->u.node->data.intval) > 0)
                        loop->flags |= LP_LOOP_STEP_ISPOS;
                }
            }
        } else if (nd21->type == IROLinearOp1Arg) {
            if (nd21->nodetype == EPREINC || nd21->nodetype == EPOSTINC) {
                if (scanind->addConst == 1)
                    loop->flags |= LoopFlags_100;
                if (scanind->addConst > 0)
                    loop->flags |= LP_LOOP_STEP_ISPOS;
            }
            if (nd21->nodetype == EPREDEC || nd21->nodetype == EPOSTDEC) {
                if (scanind->addConst == 1)
                    loop->flags |= LoopFlags_2000;
                if (scanind->addConst > 0)
                    loop->flags |= LP_LOOP_STEP_ISNEG;
            }
        }
        loop->index24 = nd21->index;
        loop->index20 = IRO_FindStart(nd21)->index;
    }

    if (ind23) {
        tmp = IRO_FindStart(fnode->last->u.diadic.right);
        loop->flags |= LoopFlags_200;
        if (loop->flags & LoopFlags_10000) {
            for (scannd = loop->fnode->first; scannd && scannd != tmp; scannd = scannd->next) {
                if (scannd->type != IROLinearLabel && scannd->type != IROLinearNop)
                    loop->flags &= ~LoopFlags_200;
            }
        } else {
            for (scannd = ind23->nd->next; scannd && scannd != tmp; scannd = scannd->next){
                if (scannd->type != IROLinearLabel && scannd->type != IROLinearNop)
                    loop->flags &= ~LoopFlags_200;
            }
            for (scannd = loop->fnode->first; scannd && scannd != tmp; scannd = scannd->next){
                if ((scannd->index < loop->index20 || scannd->index > loop->index24) && scannd->type != IROLinearLabel && scannd->type != IROLinearNop)
                    loop->flags &= ~LoopFlags_200;
            }
        }
    }

    for (scanfnode = IRO_FirstNode; scanfnode; scanfnode = scanfnode->nextnode) {
        if (Bv_IsBitSet(scanfnode->index, InLoop) && scanfnode != fnode && (scannd = scanfnode->first)) {
            while (1) {
                if (scannd->type == IROLinearFunccall)
                    flag30 = 1;
                if (scannd->type == IROLinearGoto)
                    flag28++;
                if (flag28 >= 1)
                    flag29 = 1;
                if (scannd->type == IROLinearIf || scannd->type == IROLinearIfNot || scannd->type == IROLinearSwitch || scannd->type == IROLinearReturn)
                    flag29 = 1;

                if (scannd->type == IROLinearAsm)
                    loop->flags |= LP_LOOP_HAS_ASM;

                if (!(scannd->flags & IROLF_Reffed) && scannd->type != IROLinearNop && scannd->type != IROLinearLabel) {
                    if (!IRO_IsAssignOp[scannd->nodetype]) {
                        loop->flags |= LoopFlags_8;
                    } else if (scannd->index < loop->index20 || scannd->index > loop->index24) {
                        counter27++;
                        if (IsAssignmentReductionCandidate(scannd) && counter27 == 1)
                            loop->flags |= LoopFlags_40000;
                        if (counter27 > 1)
                            loop->flags &= ~LoopFlags_40000;
                    }
                }

                if (scannd->index < loop->index20 || scannd->index > loop->index24) {
                    if (IS_LINEAR_ENODE(scannd, EOBJREF)) {
                        obj = scannd->u.node->data.objref;
                        if ((scannd->flags & IROLF_Ind) && obj && obj == loop->induction->var->object) {
                            if (!(scannd->flags & IROLF_Assigned) && (scannd->flags & IROLF_Used)) {
                                IRO_Dump("Induction Used in loop\n");
                                loop->flags |= LoopFlags_800;
                            }
                        }
                    }

                    if (IS_LINEAR_DIADIC(scannd, ESHR) &&
                        (obj = IRO_IsVariable(scannd->u.diadic.left)) &&
                        IRO_IsConstant(scannd->u.diadic.right)) {
                        for (scanind = FirstInd; scanind; scanind = scanind->next) {
                            if (scanind->var->object == obj) {
                                IRO_Dump("Induction has DIV: %s\n", obj->name->name);
                                scanind->flags |= LoopInd_2;
                            }
                        }
                    }

                    if (IS_LINEAR_DIADIC(scannd, EAND) &&
                        (obj = IRO_IsVariable(scannd->u.diadic.left)) &&
                        IRO_IsConstant(scannd->u.diadic.right)) {
                        for (scanind = FirstInd; scanind && obj; scanind = scanind->next) {
                            if (scanind->var->object == obj) {
                                IRO_Dump("Induction has MOD: %s\n", obj->name->name);
                                scanind->flags |= LoopInd_1;
                            }
                        }
                    }
                }

                ComputeIntWeight(loop, scannd);
                if (scannd == scanfnode->last)
                    break;
                scannd = scannd->next;
            }
        }

        if (flag30)
            loop->flags |= LP_LOOP_HAS_CALLS;
        if (flag29)
            loop->flags |= LP_LOOP_HAS_CNTRLFLOW;

        for (i = 0; i < scanfnode->numsucc && scanfnode != fnode; i++) {
            if (Bv_IsBitSet(scanfnode->index, InLoop) && !Bv_IsBitSet(scanfnode->succ[i], InLoop)) {
                IRO_Dump("Node %d has an out of loop successor %d\n", scanfnode->index, scanfnode->succ[i]);
                IRO_DumpBits("Loop includes: ", InLoop);
                IRO_Dump("loop has multiple exits\n");
                loop->flags |= LoopFlags_1000;
            }
        }
    }

    return loop;
}

CLabel *BuildLabel(IROList *list) {
    IROLinear *nd;

    nd = IRO_NewLinear(IROLinearLabel);
    nd->index = IRO_NumLinear++;
    nd->u.label.label = IRO_NewLabel();
    nd->flags |= IROLF_1;
    IRO_AddToList(nd, list);
    return nd->u.label.label;
}

static void MoveInvarianceInAddressExpr(void) {
    IRONode *fnode;
    IROLinear *nd;
    IROLinear *start;
    IROList list;

    IRO_FirstExpr = IRO_LastExpr = NULL;
    IRO_NumExprs = 0;

    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
        if (Bv_IsBitSet(fnode->index, InLoop)) {
            for (nd = fnode->first; nd; nd = nd->next) {
                if (nd->type == IROLinearOp1Arg &&
                    (nd->nodetype == EINDIRECT || nd->nodetype == EINDIRECT) &&
                    IS_LINEAR_DIADIC(nd->u.monadic, EADD)) {
                    RearrangeInvarianceInAddressExpr(nd->u.monadic, &list);
                    start = IRO_FindStart(nd->u.monadic);
                    IRO_LocateFather_Cut_And_Paste(nd->u.monadic, list.tail);
                    IRO_Paste(list.head, list.tail, start);
                }

                if (nd == fnode->last)
                    break;
            }
        }
    }

    IRO_UpdateFlagsOnInts();
}

static void AddAddendLinear(IROLinear *nd) {
    IROElmList *list;

    if (IS_LINEAR_DIADIC(nd, EADD)) {
        AddAddendLinear(nd->u.diadic.left);
        AddAddendLinear(nd->u.diadic.right);
    } else {
        list = oalloc(sizeof(IROElmList));
        list->element = nd;
        list->next = NULL;
        if (FirstAddendLinear)
            LastAddendLinear->next = list;
        else
            FirstAddendLinear = list;
        LastAddendLinear = list;
    }
}

static IROLinear *RearrangeInvarianceInAddressExpr(IROLinear *nd, IROList *list) {
    IROLinear *result;
    IROElmList *scanlist;
    IROElmList *elist;
    IROLinear *scannd;

    IRO_InitList(list);
    FirstAddendLinear = LastAddendLinear = NULL;
    AddAddendLinear(nd->u.diadic.left);
    AddAddendLinear(nd->u.diadic.right);

    elist = NULL;
    result = NULL;
    for (scanlist = FirstAddendLinear; scanlist; scanlist = scanlist->next) {
        scannd = scanlist->element;
        if (!IRO_IsIntConstant(scannd) && (scannd->flags & IROLF_LoopInvariant)) {
            if (result) {
                IROLinear *tmp = IRO_NewLinear(IROLinearOp2Arg);
                tmp->index = ++IRO_NumLinear;
                tmp->nodetype = EADD;
                tmp->u.diadic.left = result;
                tmp->u.diadic.right = IRO_DuplicateExpr(scannd, list);
                IRO_AddToList(tmp, list);
                tmp->flags |= IROLF_LoopInvariant;
                tmp->flags |= IROLF_Reffed;
                tmp->rtype = result->rtype;
                result = tmp;
            } else {
                result = IRO_DuplicateExpr(scannd, list);
            }

            if (elist)
                elist->next = scanlist->next;
            else
                FirstAddendLinear = scanlist->next;
        } else {
            elist = scanlist;
        }
    }

    for (scanlist = FirstAddendLinear, elist = NULL; scanlist; scanlist = scanlist->next) {
        scannd = scanlist->element;
        if (!IRO_IsIntConstant(scannd)) {
            if (result) {
                IROLinear *tmp = IRO_NewLinear(IROLinearOp2Arg);
                tmp->index = ++IRO_NumLinear;
                tmp->nodetype = EADD;
                tmp->u.diadic.left = result;
                tmp->u.diadic.right = IRO_DuplicateExpr(scannd, list);
                IRO_AddToList(tmp, list);
                tmp->flags |= IROLF_Reffed;
                tmp->rtype = result->rtype;
                result = tmp;
            } else {
                result = IRO_DuplicateExpr(scannd, list);
            }

            if (elist)
                elist->next = scanlist->next;
            else
                FirstAddendLinear = scanlist->next;
        } else {
            elist = scanlist;
        }
    }

    for (scanlist = FirstAddendLinear; scanlist; scanlist = scanlist->next) {
        scannd = scanlist->element;
        if (result) {
            IROLinear *tmp = IRO_NewLinear(IROLinearOp2Arg);
            tmp->index = ++IRO_NumLinear;
            tmp->nodetype = EADD;
            tmp->u.diadic.left = result;
            tmp->u.diadic.right = scannd;
            tmp->u.diadic.right = IRO_DuplicateExpr(scannd, list);
            IRO_AddToList(tmp, list);
            tmp->flags |= IROLF_Reffed;
            tmp->rtype = result->rtype;
            result = tmp;
        } else {
            result = IRO_DuplicateExpr(scannd, list);
        }
    }

    return result;
}

static IROLinear *FindAddendForReductionPattern(IROLinear *a, IROLinear *b, Boolean *resultFlag) {
    IROLinear *left;
    IROLinear *right;
    IROLinear *node28;
    Boolean subflag;

    left = b->u.diadic.left;
    right = b->u.diadic.right;
    if (b->nodetype == EADD || b->nodetype == ESUB) {
        node28 = left;
        while (IS_LINEAR_MONADIC(node28, ETYPCON))
            node28 = node28->u.monadic;

        if (IS_LINEAR_MONADIC(node28, EINDIRECT) && (node28->u.monadic->flags & IROLF_LoopInvariant) && IRO_ExprsSame(a, node28)) {
            *resultFlag = 1;
            return left;
        }

        if (IS_LINEAR_DIADIC_2(node28, EADD, ESUB)) {
            if ((node28 = FindAddendForReductionPattern(a, node28, &subflag))) {
                *resultFlag = 1;
                return node28;
            }
        }
    }

    *resultFlag = 0;
    if (b->nodetype == EADD) {
        node28 = right;
        while (IS_LINEAR_MONADIC(node28, ETYPCON))
            node28 = node28->u.monadic;

        if (IS_LINEAR_MONADIC(node28, EINDIRECT) && (node28->u.monadic->flags & IROLF_LoopInvariant) && IRO_ExprsSame(a, node28)) {
            return right;
        }

        if (IS_LINEAR_DIADIC_2(node28, EADD, ESUB)) {
            if ((node28 = FindAddendForReductionPattern(a, node28, &subflag))) {
                return node28;
            }
        }
    }

    return NULL;
}

static void ReorderOperandsForReductionPattern(IROLinear *a, IROLinear *b) {
    IROLinear *left;
    IROLinear *right;
    IROLinear *addend;
    IROLinear *tmp;
    Boolean flag;

    left = b->u.diadic.left;
    right = b->u.diadic.right;

    if (b->nodetype == EADD && (addend = FindAddendForReductionPattern(a, b, &flag)) && addend != left) {
        if (flag && IS_LINEAR_DIADIC_2(left, EADD, ESUB) && addend->rtype == right->rtype) {
            tmp = left;
            b->u.diadic.left = right;
            left = right;
            b->u.diadic.right = tmp;
            right = tmp;
            flag = 0;
        }

        if (!flag && IS_LINEAR_DIADIC_2(right, EADD, ESUB) && addend->rtype == left->rtype) {
            if (IRO_LocateFather_Cut_And_Paste_Without_Nopping(addend, left))
                b->u.diadic.left = addend;
        }
    }
}

static UInt32 IsAssignmentReductionCandidate(IROLinear *nd) {
    IROLinear *left;
    IROLinear *right;
    IROLinear *tmp;

    if (nd->type == IROLinearOp2Arg) {
        if (nd->nodetype == EASS) {
            left = nd->u.diadic.left;
            right = nd->u.diadic.right;
            if (IS_LINEAR_MONADIC(left, EINDIRECT) && (left->u.monadic->flags & IROLF_LoopInvariant)) {
                if (IS_LINEAR_MONADIC(right, ETYPCON) &&
                    right->rtype->type == right->u.monadic->rtype->type &&
                    IS_TYPE_INT(right->rtype) &&
                    right->rtype->size < right->u.monadic->rtype->size)
                    right = right->u.monadic;

                if (IS_LINEAR_DIADIC_2(right, EADD, ESUB)) {
                    ReorderOperandsForReductionPattern(left, right);
                    tmp = right->u.diadic.left;
                    if (IS_LINEAR_MONADIC(tmp, ETYPCON))
                        tmp = tmp->u.monadic;
                    if (IS_LINEAR_MONADIC(tmp, EINDIRECT) &&
                        (tmp->u.monadic->flags & IROLF_LoopInvariant) &&
                        IRO_ExprsSame(left, tmp) &&
                        right->u.diadic.right->type == IROLinearOp2Arg) {
                        if (right->u.diadic.right->nodetype == EADD)
                            return 1;
                        if (right->u.diadic.right->nodetype == ESUB)
                            return 1;
                        if (right->u.diadic.right->nodetype == EMUL)
                            return 1;
                        if (right->u.diadic.right->nodetype == EDIV)
                            return 1;
                    }
                }
            }
        } else if (nd->nodetype == EADDASS || nd->nodetype == ESUBASS) {
            left = nd->u.diadic.left;
            right = nd->u.diadic.right;

            if (IS_LINEAR_MONADIC(right, ETYPCON) &&
                right->rtype->type == right->u.monadic->rtype->type &&
                IS_TYPE_INT(right->rtype) &&
                right->rtype->size < right->u.monadic->rtype->size)
                right = right->u.monadic;

            if (IS_LINEAR_MONADIC(left, EINDIRECT) &&
                (left->u.monadic->flags & IROLF_LoopInvariant) &&
                right->type == IROLinearOp2Arg) {
                if (right->nodetype == EADD)
                    return 1;
                if (right->nodetype == ESUB)
                    return 1;
                if (right->nodetype == EMUL)
                    return 1;
                if (right->nodetype == EDIV)
                    return 1;
            }
        }
    }

    return 0;
}