MWCC/compiler_and_linker/unsorted/IroUnrollLoop.c

#include "compiler/IroUnrollLoop.h"
#include "compiler/CError.h"
#include "compiler/IroFlowgraph.h"
#include "compiler/IroLinearForm.h"
#include "compiler/IroUtil.h"
#include "compiler/LoopDetection.h"
#include "compiler/IroLoop.h"
#include "compiler/IroDump.h"
#include "compiler/IroVars.h"
#include "compiler/CFunc.h"
#include "compiler/CMachine.h"

#ifdef __MWERKS__
#pragma options align=mac68k
#endif
typedef struct LoopList {
    UInt8 flags;
    BitVector *bv;
    struct LoopList *next;
    IRONode *fnode;
    int xE;
} LoopList;
#ifdef __MWERKS__
#pragma options align=reset
#endif

// forward decls
static void IRO_FindLoops_Unroll(void);
static void LoopUnroll(int count, IRONode *fnode);
static int IsLoopUnrollable(IROLoop *loop);
static int IsDifferenceOfTermsConstant(IROAddrRecord *lowerRec, IROAddrRecord *upperRec, int isUnsigned, CInt64 *pval);
static IROLinear *BuildOrigIterationCount_DoWhile(IROList *list, IROLoop *loop);
static IROLinear *BuildPreAlignTemp(IROLoopInd *ind, UInt32 unrollFactor, IROList *list);
static IROLinear *BuildNewFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop);
static IROLinear *BuildUnrolledFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop);

void IRO_LoopUnroller(void) {
    VectorPhaseCalledFromUnroll = 1;
    IRO_FindLoops_Unroll();
    IRO_CheckForUserBreak();
}

static void IRO_FindLoops_Unroll(void) {
    IRONode *fnode;
    IRONode *pred;
    UInt16 i;
    UInt16 flag;
    LoopList *list;
    LoopList *list2;

    fnode = IRO_FirstNode;
    LoopList_First = NULL;

    while (fnode) {
        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) {
            if (!LoopList_First) {
                list = oalloc(sizeof(LoopList));
                list->next = NULL;
            } else {
                list = oalloc(sizeof(LoopList));
                list->next = LoopList_First;
            }
            LoopList_First = list;

            Bv_AllocVector(&list->bv, IRO_NumNodes + 1);
            list->flags |= 1;
            Bv_Copy(InLoop, list->bv);
            list->fnode = fnode;
            list->xE = 0;
        }

        fnode = fnode->nextnode;
    }

    list = LoopList_First;
    Bv_AllocVector(&LoopTemp, IRO_NumNodes + 1);
    while (list) {
        for (list2 = LoopList_First; list2; list2 = list2->next) {
            if (list2 != list) {
                IRO_Dump(" header = %d \n", list2->fnode->index);
                IRO_Dump(" l1 bit vector=\n");
                IRO_DumpBits("", list2->bv);
                IRO_Dump(" l bit vector=\n");
                IRO_DumpBits("", list->bv);
                if (Bv_IsSubset(list->bv, list2->bv))
                    list2->flags &= ~1;
            }
        }
        list = list->next;
    }

    for (list = LoopList_First; list; list = list->next) {
        if (list->flags & 1) {
            IRONode *listfnode;
            Bv_Copy(list->bv, InLoop);
            listfnode = list->fnode;
            IRO_Dump("IRO_FindLoops_Unroll:Found loop with header %d\n", listfnode->index);
            IRO_DumpBits("Loop includes: ", InLoop);
            LoopUnroll(copts.loop_unroll_count, listfnode);
            IRO_UpdateFlagsOnInts();
        }
    }
}

static int CheckConstant(CInt64 a, CInt64 b, CInt64 *result) {
    CInt64 shl = cint64_zero;
    CInt64 work = cint64_zero;
    CInt64 and = cint64_zero;
    CInt64 i;

    for (i = cint64_zero; CInt64_Less(i, a); i = CInt64_Add(i, cint64_one)) {
        shl = CInt64_Shl(b, i);
        and = CInt64_And(shl, work);
        if (CInt64_NotEqual(and, cint64_zero))
            return 0;
        work = CInt64_Or(shl, work);
    }

    *result = work;
    return 1;
}

typedef struct LoopPattern {
    IROLinear *nd0;
    IROLinear *nd4;
    Type *type;
    IROLinear *ndC;
    IROLinear *nd10;
    CInt64 val14;
    CInt64 val1C;
} LoopPattern;

static void UnrollWhileLoopBody(IRONode *header, IRONode *fnode2, IRONode *fnode3, IROLoop *loop, LoopPattern *pattern, UInt32 unrollFactor) {
    IRONode *scan;
    int pass;
    IROLinear *firstnode;
    IROLinear *lastnd;
    IROLinear *nd;
    IROLinear *nd1;
    IROLinear *nd2;
    IROLinear *nd3;
    IROLinear *nd4;
    IROLinear *nd5;
    IROLinear *nd6;
    IROLinear *nd8;
    IROLinear *nd7;
    ENode *expr;
    IROList list;
    CInt64 zero;
    CInt64 shiftval;

    CInt64_SetLong(&zero, 0);

    pass = 0;

    do {
        firstnode = NULL;
        for (scan = fnode3; scan && scan != header; scan = scan->nextnode) {
            IRO_InitList(&list);
            lastnd = scan->last;
            nd = scan->first;
            while (1) {
                if (nd->stmt)
                    nd->stmt->flags |= StmtFlag_10;

                if (
                    (nd->index < loop->index20 || nd->index > loop->index24) &&
                    nd->type != IROLinearLabel &&
                    nd->type != IROLinearNop &&
                    !(nd->flags & IROLF_Reffed)
                    )
                {
                    CError_ASSERT(345, nd->nodetype == EORASS || nd->nodetype == EANDASS || nd->nodetype == EXORASS);

                    IRO_DuplicateExpr(pattern->nd0, &list);
                    nd1 = list.tail;

                    shiftval = cint64_one;
                    shiftval = CInt64_Shl(shiftval, pattern->val1C);

                    nd2 = IRO_NewLinear(IROLinearOperand);
                    nd2->index = ++IRO_NumLinear;
                    nd2->rtype = pattern->nd0->rtype;
                    expr = IRO_NewENode(EINTCONST);
                    expr->rtype = pattern->nd0->rtype;
                    CInt64_SetLong(&expr->data.intval, pass * CInt64_GetULong(&shiftval));
                    nd2->u.node = expr;
                    IRO_AddToList(nd2, &list);

                    IRO_DuplicateExpr(pattern->nd4, &list);

                    nd3 = IRO_NewLinear(IROLinearOp2Arg);
                    nd3->index = ++IRO_NumLinear;
                    nd3->nodetype = EADD;
                    nd3->rtype = pattern->type;
                    nd3->u.diadic.left = list.tail;
                    nd3->u.diadic.right = nd2;
                    IRO_AddToList(nd3, &list);

                    nd4 = IRO_NewLinear(IROLinearOp2Arg);
                    nd4->index = ++IRO_NumLinear;
                    nd4->nodetype = EADD;
                    nd4->rtype = pattern->type;
                    nd4->u.diadic.left = nd3;
                    nd4->u.diadic.right = nd1;
                    IRO_AddToList(nd4, &list);

                    nd5 = IRO_NewLinear(IROLinearOp1Arg);
                    nd5->index = ++IRO_NumLinear;
                    nd5->nodetype = EINDIRECT;
                    nd5->rtype = nd->rtype;
                    nd5->u.monadic = nd4;
                    IRO_AddToList(nd5, &list);

                    nd6 = IRO_NewLinear(IROLinearOp2Arg);
                    *nd6 = *nd;
                    nd6->index = ++IRO_NumLinear;
                    nd6->u.diadic.left = list.tail;
                    nd6->next = NULL;

                    nd7 = IRO_NewLinear(IROLinearOperand);
                    nd7->index = ++IRO_NumLinear;
                    nd7->rtype = pattern->ndC->rtype;
                    expr = IRO_NewENode(EINTCONST);
                    expr->rtype = pattern->ndC->rtype;
                    nd7->u.node = expr;
                    nd7->next = NULL;
                    expr->data.intval = pattern->val14;

                    if (
                        IS_LINEAR_DIADIC(nd, EANDASS) &&
                        CInt64_Equal(pattern->val14, cint64_zero)
                        )
                    {
                        nd6->nodetype = EASS;
                    } else if (
                        IS_LINEAR_DIADIC(nd, EORASS) &&
                        !CTool_EndianReadWord32(&pattern->val14.hi)
                        )
                    {
                        UInt32 tmp = CInt64_GetULong(&pattern->val14);
                        if (
                            (nd->rtype->size == 1 && tmp == 0xFF) ||
                            (nd->rtype->size == 2 && tmp == 0xFFFF) ||
                            (nd->rtype->size == 4 && tmp == 0xFFFFFFFF)
                            )
                        {
                            nd6->nodetype = EASS;
                        }
                    }

                    IRO_AddToList(nd7, &list);

                    if (IS_LINEAR_MONADIC(pattern->nd10, ETYPCON)) {
                        nd8 = IRO_NewLinear(IROLinearOp1Arg);
                        *nd8 = *pattern->nd10;
                        nd8->index = ++IRO_NumLinear;
                        nd8->u.monadic = nd7;
                        nd8->next = NULL;
                        IRO_AddToList(nd8, &list);
                    } else {
                        nd8 = nd7;
                    }
                    nd6->u.diadic.right = nd8;
                    IRO_AddToList(nd6, &list);

                    if (!firstnode)
                        firstnode = list.head;
                }

                if (nd == lastnd)
                    break;
                nd = nd->next;
            }

            if (list.head && list.tail)
                IRO_Paste(list.head, list.tail, fnode2->last);
        }
    } while (++pass < 8);
}

static int PatternMatchLoop(IRONode *fnode, IROLoop *loop, IROLoopInd *ind, UInt32 *unrollFactor, SInt32 *result1, SInt32 *result2, LoopPattern *pattern) {
    IROLinear *scan;
    IROLinear *varnode;
    IROLinear *nd1;
    IROLinear *nd2;
    IROLinear *left1;
    IROLinear *left2;
    IROLinear *right1;
    IROLinear *right2;
    Object *obj1;
    Object *obj2;
    CInt64 shl;
    CInt64 val;

    *result1 = 0;
    *result2 = 0;

    if ((scan = fnode->first)) {
        while (1) {
            if (
                (scan->index < loop->index20 || scan->index > loop->index24) &&
                !(scan->flags & IROLF_Reffed) &&
                scan->type != IROLinearNop &&
                scan->type != IROLinearLabel
                )
            {
                if (IS_LINEAR_DIADIC_3(scan, EORASS, EXORASS, EANDASS)) {
                    (*result2)++;
                    if (IS_LINEAR_MONADIC(scan->u.diadic.left, EINDIRECT)) {
                        varnode = scan->u.diadic.left->u.monadic;
                        if (IS_LINEAR_DIADIC(varnode, EADD)) {
                            pattern->nd4 = varnode->u.diadic.left;
                            pattern->type = varnode->rtype;
                            if (IRO_IsVariable(varnode->u.diadic.left)) {
                                pattern->nd0 = varnode->u.diadic.right;
                                if (
                                    IS_LINEAR_DIADIC(pattern->nd0, ESHL) &&
                                    IRO_IsConstant(pattern->nd0->u.diadic.right)
                                    )
                                {
                                    pattern->val1C = pattern->nd0->u.diadic.right->u.node->data.intval;
                                    nd1 = pattern->nd0->u.diadic.left;
                                } else {
                                    return 0;
                                }
                            } else {
                                return 0;
                            }
                        } else {
                            return 0;
                        }
                    } else {
                        return 0;
                    }

                    pattern->nd10 = scan->u.diadic.right;

                    if (IS_LINEAR_MONADIC(pattern->nd10, ETYPCON)) {
                        if (IS_LINEAR_DIADIC(scan, EANDASS)) {
                            if (IS_LINEAR_MONADIC(pattern->nd10->u.monadic, EBINNOT)) {
                                pattern->ndC = pattern->nd10->u.monadic->u.monadic;
                            } else {
                                return 0;
                            }
                        } else {
                            pattern->ndC = pattern->nd10->u.monadic;
                        }

                        if (IS_LINEAR_DIADIC(pattern->ndC, ESHL) && IRO_IsConstant(pattern->ndC->u.diadic.left)) {
                            val = pattern->ndC->u.diadic.left->u.node->data.intval;
                            nd2 = pattern->ndC->u.diadic.right;
                        } else {
                            return 0;
                        }
                    } else if (IS_LINEAR_DIADIC(pattern->nd10, ESHL) && IS_LINEAR_DIADIC_2(scan, EORASS, EXORASS)) {
                        pattern->ndC = pattern->nd10;
                        if (IRO_IsConstant(pattern->ndC->u.diadic.left)) {
                            val = pattern->ndC->u.diadic.left->u.node->data.intval;
                            nd2 = pattern->ndC->u.diadic.right;
                        } else {
                            return 0;
                        }
                    } else if (IS_LINEAR_MONADIC(pattern->nd10, EBINNOT) && IS_LINEAR_DIADIC(scan, EANDASS)) {
                        pattern->ndC = pattern->nd10->u.monadic;
                        if (IS_LINEAR_DIADIC(pattern->ndC, ESHL) && IRO_IsConstant(pattern->ndC->u.diadic.left)) {
                            val = pattern->ndC->u.diadic.left->u.node->data.intval;
                            nd2 = pattern->ndC->u.diadic.right;
                        } else {
                            return 0;
                        }
                    } else {
                        return 0;
                    }

                    if (IS_LINEAR_DIADIC(nd2, EAND) && IS_LINEAR_DIADIC(nd1, ESHR)) {
                        left1 = nd1->u.diadic.left;
                        left2 = nd2->u.diadic.left;
                        obj1 = IRO_IsVariable(left1);
                        obj2 = IRO_IsVariable(left2);
                        if (obj1 == obj2 && obj1 == ind->var->object) {
                            right1 = nd1->u.diadic.right;
                            right2 = nd2->u.diadic.right;
                            if (IRO_IsConstant(right1) && IRO_IsConstant(right2)) {
                                shl = cint64_one;
                                shl = CInt64_Shl(shl, right1->u.node->data.intval);
                                shl = CInt64_Sub(shl, cint64_one);
                                if (CInt64_Equal(shl, right2->u.node->data.intval)) {
                                    if (CTool_EndianReadWord32(&shl.hi) == 0) {
                                        *unrollFactor = CInt64_GetULong(&shl) + 1;
                                        if (CheckConstant(CInt64_Add(shl, cint64_one), val, &pattern->val14)) {
                                            (*result1)++;
                                            if (IS_LINEAR_DIADIC(scan, EANDASS))
                                                pattern->val14 = CInt64_Not(pattern->val14);
                                        }
                                    } else {
                                        return 0;
                                    }
                                } else {
                                    return 0;
                                }
                            } else {
                                return 0;
                            }
                        } else {
                            return 0;
                        }
                    } else {
                        return 0;
                    }
                } else {
                    return 0;
                }
            }

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

    return 1;
}

static UInt32 UnrollWhileLoop(IRONode *header, IRONode *fnode2, IRONode *fnode3, IROLoop *loop, UInt32 unrollFactor) {
    IROLoopInd *ind;
    IRONode *scan;
    CLabel *lastlabel;
    IROLinear *lastlabelnode;
    IROLinear *earlyLoopExitTest;
    CLabel *earlyLoopExitTestLabel;
    IROLinear *origIterationCount;
    IROLinear *unrolledFinalValue;
    IROLinear *preAlignTemp;
    IROLinear *newFinalValue;
    IROLinear *savedHead60;
    IROLinear *unrolledBodyEntryTest;
    CLabel *label;
    IROLinear *savedHead2;
    IROLinear *loophead25;
    IROLinear *loopend;
    IROLinear *loopscan;
    IROLinear *indvar;
    IROLinear *less;
    IROLinear *loopExitTest;
    IROLinear *saveTail;
    CLabel *label2;
    IROLinear *gotond;
    CLabel *label3;
    IROLinear *savedHead3;
    IROLinear *updIndInc;
    IROLinear *label2nd;
    IROLinear *less2;
    IROLinear *saveTail2;
    IROLinear *less3;
    IROLinear *wtf;
    IROLinear *constnd;
    IROLinear *ass;
    IROLinear *nd18;
    IRONode *fn19;
    IRONode *newfnode1;
    IRONode *newfnode2;
    IRONode *newfnode3;
    IRONode *newfnode4;
    IRONode *newfnode5;
    IRONode *newfnode6;
    IRONode *newfnode7;
    IRONode *newfnode8;
    IROLinear *lastnd;
    ENode *expr;
    SInt32 result1;
    SInt32 result2;
    LoopPattern pattern;
    IROList list;

    IRO_Dump("while(n--) loop \n");

    if (loop->flags & LoopFlags_800) {
        IRO_Dump("loop not unrolled because induction used in loop \n");
        return 0;
    }
    if (loop->flags & LoopFlags_1000) {
        IRO_Dump("loop not unrolled because loop has multiple exits \n");
        return 0;
    }

    if (!(loop->flags & LP_HAS_MULTIPLE_INDUCTIONS))
        return 0;

    for (ind = FirstInd; ind; ind = ind->next) {
        if ((ind->flags & LoopInd_HasMod) && (ind->flags & LoopInd_HasDiv))
            break;
    }

    if (!ind) {
        IRO_Dump("Could not find loop with and induction with MOD and DIV operation\n");
        return 0;
    }

    if (!IRO_IsUnsignedType(ind->nd->rtype))
        return 0;

    if (ind->nd->type == IROLinearOp2Arg) {
        if (ind->nd->nodetype == EADDASS && IRO_IsConstant(ind->nd->u.diadic.right)) {
            if (ind->addConst != 1)
                return 0;
        } else if (ind->nd->nodetype == EASS) {
            if (
                ind->nd->u.diadic.right->type != IROLinearOp2Arg ||
                ind->nd->u.diadic.right->nodetype != EADD ||
                !IRO_IsConstant(ind->nd->u.diadic.right->u.diadic.right)
                )
                return 0;

            if (ind->addConst != 1)
                return 0;
        } else {
            return 0;
        }
    } else if (ind->nd->type == IROLinearOp1Arg && ind->nd->nodetype != EPREINC && ind->nd->nodetype != EPOSTINC) {
        return 0;
    }

    loop->induction = ind;
    loop->index24 = ind->nd->index;
    loop->index20 = IRO_FindStart(ind->nd)->index;

    scan = IRO_FirstNode;
    memset(&pattern, 0, sizeof(pattern));
    while (scan) {
        if (Bv_IsBitSet(scan->index, InLoop) && scan != header) {
            if (!PatternMatchLoop(scan, loop, ind, &unrollFactor, &result1, &result2, &pattern))
                return 0;
        }
        scan = scan->nextnode;
    }

    if (result1 > 1 || result2 > 1)
        return 0;

    lastlabel = fnode2->last->u.label.label;
    lastlabelnode = IRO_FindLabelNode(fnode2->last->u.label.label, fnode2->last);

    IRO_InitList(&list);
    IRO_DuplicateExprRange(lastlabelnode->next, LoopNode->last->u.label.x4->u.diadic.left, &list);
    IRO_DuplicateExpr(LoopNode->last->u.label.x4, &list);
    IRO_Paste(list.head, list.tail, fnode2->last);
    lastlabelnode = list.tail;

    IRO_InitList(&list);
    earlyLoopExitTest = BuildEarlyLoopExitTest(LoopNode->last->type, &list);
    earlyLoopExitTestLabel = IRO_NewLabel();
    earlyLoopExitTest->u.label.label = earlyLoopExitTestLabel;
    earlyLoopExitTest->u.label.x4 = lastlabelnode;
    earlyLoopExitTest->u.label.x4->flags |= IROLF_Reffed;
    earlyLoopExitTest->rtype = LoopNode->last->rtype;
    IRO_Paste(list.head, list.tail, fnode2->last);

    IRO_InitList(&list);
    origIterationCount = BuildOrigIterationCount_DoWhile(&list, loop);
    IRO_Paste(list.head, list.tail, fnode2->last);
    savedHead60 = list.head;

    IRO_InitList(&list);
    preAlignTemp = BuildPreAlignTemp(ind, unrollFactor, &list);
    IRO_Paste(list.head, list.tail, fnode2->last);

    IRO_InitList(&list);
    unrolledFinalValue = BuildUnrolledFinalvalue_DoWhile(origIterationCount, unrollFactor, &list, loop);
    IRO_Paste(list.head, list.tail, fnode2->last);

    IRO_InitList(&list);
    newFinalValue = BuildNewFinalvalue_DoWhile(origIterationCount, unrollFactor, &list, loop);
    IRO_Paste(list.head, list.tail, fnode2->last);

    IRO_InitList(&list);
    BuildUnrolledBodyEntryTest(&list, origIterationCount, unrollFactor, lastlabel);
    IRO_Paste(list.head, list.tail, fnode2->last);
    unrolledBodyEntryTest = list.tail;

    IRO_InitList(&list);
    label = BuildLabel(&list);
    IRO_Paste(list.head, list.tail, fnode2->last);

    savedHead2 = list.head;
    loophead25 = NULL;
    for (scan = fnode3; scan && scan != header; scan = scan->nextnode) {
        IRO_InitList(&list);
        loopend = scan->last;
        loopscan = scan->first;
        while (1) {
            if (loopscan->stmt)
                loopscan->stmt->flags |= StmtFlag_10;
            if (loopscan->type != IROLinearLabel && !(loopscan->flags & IROLF_Reffed)) {
                IRO_DuplicateExpr(loopscan, &list);
                if (!loophead25)
                    loophead25 = list.head;
            }
            if (loopscan == loopend)
                break;
            loopscan = loopscan->next;
        }

        if (list.head && list.tail)
            IRO_Paste(list.head, list.tail, fnode2->last);
    }

    IRO_InitList(&list);

    if (ind->nd->type == IROLinearOp1Arg)
        IRO_DuplicateExpr(ind->nd->u.monadic, &list);
    else
        IRO_DuplicateExpr(ind->nd->u.diadic.left, &list);
    list.tail->flags &= ~IROLF_Assigned;
    indvar = list.tail;

    IRO_DuplicateExpr(preAlignTemp, &list);
    list.tail->flags &= ~IROLF_Assigned;

    less = IRO_NewLinear(IROLinearOp2Arg);
    less->nodetype = ELESS;
    less->rtype = TYPE(&stbool);
    less->index = ++IRO_NumLinear;
    less->next = NULL;
    less->u.diadic.left = indvar;
    less->u.diadic.right = list.tail;
    IRO_AddToList(less, &list);
    less->flags |= IROLF_Reffed;

    loopExitTest = BuildLoopExitTest(LoopNode->last->type, &list);
    loopExitTest->u.label.label = label;
    loopExitTest->u.label.x4 = less;
    loopExitTest->u.label.x4->flags |= IROLF_Reffed;
    loopExitTest->rtype = LoopNode->last->rtype;
    IRO_Paste(list.head, list.tail, fnode2->last);
    saveTail = list.tail;

    IRO_InitList(&list);
    label2 = IRO_NewLabel();
    gotond = IRO_NewLinear(IROLinearOp1Arg);
    gotond->index = ++IRO_NumLinear;
    gotond->type = IROLinearGoto;
    gotond->u.label.label = label2;
    IRO_AddToList(gotond, &list);
    IRO_Paste(list.head, list.tail, fnode2->last);

    IRO_InitList(&list);
    label3 = BuildLabel(&list);
    IRO_Paste(list.head, list.tail, fnode2->last);
    savedHead3 = list.head;

    UnrollWhileLoopBody(header, fnode2, fnode3, loop, &pattern, unrollFactor);
    updIndInc = UpdateInductionIncrement(loop, 8 * unrollFactor, fnode2->last);

    IRO_InitList(&list);
    label2nd = IRO_NewLinear(IROLinearLabel);
    label2nd->index = IRO_NumLinear++;
    label2nd->u.label.label = label2;
    label2nd->flags |= IROLF_1;
    IRO_AddToList(label2nd, &list);
    IRO_Paste(list.head, list.tail, fnode2->last);

    IRO_InitList(&list);

    if (ind->nd->type == IROLinearOp1Arg)
        IRO_DuplicateExpr(ind->nd->u.monadic, &list);
    else
        IRO_DuplicateExpr(ind->nd->u.diadic.left, &list);
    list.tail->flags &= ~IROLF_Assigned;
    indvar = list.tail;

    IRO_DuplicateExpr(unrolledFinalValue, &list);
    list.tail->flags &= ~IROLF_Assigned;

    less2 = IRO_NewLinear(IROLinearOp2Arg);
    less2->nodetype = ELESS;
    less2->rtype = TYPE(&stbool);
    less2->index = ++IRO_NumLinear;
    less2->next = NULL;
    less2->u.diadic.left = indvar;
    less2->u.diadic.right = list.tail;
    IRO_AddToList(less2, &list);
    less2->flags |= IROLF_Reffed;

    loopExitTest = BuildLoopExitTest(LoopNode->last->type, &list);
    loopExitTest->u.label.label = label3;
    loopExitTest->u.label.x4 = less2;
    loopExitTest->u.label.x4->flags |= IROLF_Reffed;
    loopExitTest->rtype = LoopNode->last->rtype;
    IRO_Paste(list.head, list.tail, fnode2->last);
    saveTail2 = list.tail;

    IRO_InitList(&list);

    if (ind->nd->type == IROLinearOp1Arg)
        IRO_DuplicateExpr(ind->nd->u.monadic, &list);
    else
        IRO_DuplicateExpr(ind->nd->u.diadic.left, &list);
    list.tail->flags &= ~IROLF_Assigned;
    indvar = list.tail;

    IRO_DuplicateExpr(newFinalValue, &list);
    list.tail->flags &= ~IROLF_Assigned;

    less3 = IRO_NewLinear(IROLinearOp2Arg);
    less3->nodetype = ELESS;
    less3->rtype = TYPE(&stbool);
    less3->index = ++IRO_NumLinear;
    less3->next = NULL;
    less3->u.diadic.left = indvar;
    less3->u.diadic.right = list.tail;
    IRO_AddToList(less3, &list);
    less3->flags |= IROLF_Reffed;

    wtf = LoopNode->last->u.label.x4;
    IRO_Paste(list.head, list.tail, LoopNode->last);
    LoopNode->last->u.label.x4 = list.tail;

    IRO_InitList(&list);

    constnd = IRO_NewLinear(IROLinearOperand);
    constnd->index = ++IRO_NumLinear;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = wtf->u.diadic.left->rtype;
    expr->data.intval = cint64_zero;
    constnd->u.node = expr;
    constnd->rtype = expr->rtype;
    IRO_AddToList(constnd, &list);
    constnd->flags |= IROLF_Reffed;

    IRO_DuplicateExpr(wtf->u.diadic.left, &list);

    ass = IRO_NewLinear(IROLinearOp2Arg);
    ass->nodetype = EASS;
    ass->rtype = list.tail->rtype;
    ass->index = ++IRO_NumLinear;
    ass->next = NULL;
    ass->u.diadic.left = list.tail;
    ass->u.diadic.right = constnd;
    IRO_AddToList(ass, &list);
    ass->flags |= IROLF_Assigned;

    IRO_NopOut(wtf);

    fn19 = fnode2->nextnode;
    nd18 = fnode2->last;
    fnode2->last = earlyLoopExitTest;

    newfnode1 = IRO_NewFlowGraphNode();
    newfnode1->first = savedHead60;
    newfnode1->last = unrolledBodyEntryTest;
    fnode2->nextnode = newfnode1;

    newfnode2 = IRO_NewFlowGraphNode();
    newfnode2->first = savedHead2;
    newfnode2->last = saveTail;
    savedHead2->u.label.label->stmt = (Statement *) newfnode2;
    newfnode1->nextnode = newfnode2;

    newfnode3 = IRO_NewFlowGraphNode();
    newfnode3->first = gotond;
    newfnode3->last = gotond;
    newfnode2->nextnode = newfnode3;

    newfnode4 = IRO_NewFlowGraphNode();
    newfnode4->first = savedHead3;
    newfnode4->last = updIndInc;
    savedHead3->u.label.label->stmt = (Statement *) newfnode4;
    newfnode3->nextnode = newfnode4;

    newfnode5 = IRO_NewFlowGraphNode();
    newfnode5->first = label2nd;
    newfnode5->last = saveTail2;
    label2nd->u.label.label->stmt = (Statement *) newfnode5;
    newfnode4->nextnode = newfnode5;

    newfnode6 = IRO_NewFlowGraphNode();
    newfnode6->first = nd18;
    newfnode6->last = nd18;
    newfnode5->nextnode = newfnode6;
    newfnode6->nextnode = fn19;

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

    newfnode7->first = list.head;
    newfnode7->last = list.tail;

    list.tail->next = LoopNode->last->next;
    LoopNode->last->next = list.head;

    newfnode7->nextnode = LoopNode->nextnode;
    LoopNode->nextnode = newfnode7;

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

    lastnd = IRO_NewLinear(IROLinearLabel);
    lastnd->index = IRO_NumLinear++;
    lastnd->next = NULL;
    lastnd->u.label.label = earlyLoopExitTestLabel;
    lastnd->flags |= IROLF_1;
    earlyLoopExitTestLabel->stmt = (Statement *) newfnode8;

    newfnode8->first = lastnd;
    newfnode8->last = lastnd;

    lastnd->next = newfnode7->last->next;
    newfnode7->last->next = lastnd;

    newfnode8->nextnode = newfnode7->nextnode;
    newfnode7->nextnode = newfnode8;

    return 1;
}

void IRO_IterateForLoopBody(IRONode *start, IRONode *end, IROLoop *loop, IROLinear *destnode, SInt32 addConst, CInt64 *val, Boolean funkyFlag) {
    IROLinear *first = NULL;
    IROLinear *last = NULL;
    IRONode *fnode;
    IROLinear *lastnd;
    IROLinear *nd;
    IROList list;

    for (fnode = start; fnode && fnode != end; fnode = fnode->nextnode) {
        IRO_InitList(&list);

        lastnd = fnode->last;
        nd = fnode->first;
        while (1) {
            if (nd->stmt)
                nd->stmt->flags |= StmtFlag_10;

            if (
                (nd->index < loop->index20 || nd->index > loop->index24) &&
                nd->type != IROLinearLabel &&
                !(nd->flags & IROLF_Reffed)
                )
            {
                IRO_DuplicateExpr(nd, &list);
                if (!first)
                    first = list.head;
                last = list.tail;
            }

            if (nd == lastnd)
                break;
            nd = nd->next;
        }

        if (list.head && list.tail)
            IRO_Paste(list.head, list.tail, destnode);
    }

    if (funkyFlag) {
        *val = CInt64_Add(*val, IRO_MakeLong(loop->induction->addConst));
        ChangeInductionReference(first, last, *val, loop);
    }
}

void IRO_LinearizeForLoopPostLoop(IRONode *fnode1, IRONode *fnode2, IROLoop *loop, IRONode *fnode3, UInt32 unrollFactor) {
    IRONode *newfnode;
    IROLinear *newnd;
    SInt32 i;
    CInt64 val;

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

    newnd = IRO_NewLinear(IROLinearNop);
    newnd->index = IRO_NumLinear++;
    newnd->next = NULL;
    newnd->flags |= IROLF_1;

    newfnode->first = newfnode->last = newnd;

    newfnode->nextnode = fnode3->nextnode;
    fnode3->nextnode = newfnode;

    newnd->next = fnode3->last->next;
    fnode3->last->next = newnd;

    val = cint64_zero;
    for (i = 0; i < unrollFactor; i++)
        IRO_IterateForLoopBody(fnode2, fnode1, loop, newfnode->last, loop->induction->addConst, &val, i > 0);
    UpdateInductionIncrement(loop, unrollFactor, newfnode->last);
}

static UInt32 UnrollForLoop(IRONode *header, IRONode *fnode2, IRONode *fnode3, IROLoop *loop, UInt32 unrollFactor) {
    IROLinear *lastlabelnode;
    IROLinear *earlyLoopExitTest;
    IROLinear *origIterationCount;
    IROLinear *saveHead1;
    IROLinear *newFinalValue;
    IROLinear *unrolledBodyEntryTest;
    IROLinear *gotoNd;
    IROLinear *saveHead2;
    IROLinear *updIndInc;
    IROLinear *labelNd;
    IROLinear *saveTail2;
    IROLinear *ndCopy;
    IROLinear *saveTail3;
    IROLinear *loopExitTest;
    IROLinear *lastnd;
    IROLinear *labelNd2;
    IROLinear *saveTail4;
    IROLinear *labelNd3;
    IROLinear *scan;
    IRONode *nd18;
    IRONode *newfnode1;
    IRONode *newfnode2;
    IRONode *newfnode3;
    IRONode *newfnode4;
    IRONode *newfnode5;
    IRONode *newfnode6;
    CLabel *lastlabel;
    CLabel *earlyLoopExitTestLabel;
    CLabel *label;
    CLabel *label2;
    SInt32 i;

    IROList list;
    CInt64 iterCount;
    int isConstant;
    UInt32 needOrigLoop = 0;
    UInt32 needUnrollBodyTest = 0;
    UInt32 resetUnrolledFinalValue = 0;
    SInt32 leftOver;
    CInt64 val;

    lastlabelnode = IRO_FindLabelNode(fnode2->last->u.label.label, fnode2->last);
    lastlabel = IRO_NewLabel();

    IRO_InitList(&list);
    IRO_DuplicateExprRange(lastlabelnode->next, LoopNode->last->u.label.x4, &list);
    IRO_DuplicateExpr(LoopNode->last->u.label.x4, &list);
    IRO_Paste(list.head, list.tail, fnode2->last);
    lastlabelnode = list.tail;

    IRO_InitList(&list);
    earlyLoopExitTest = BuildEarlyLoopExitTest(LoopNode->last->type, &list);
    earlyLoopExitTestLabel = IRO_NewLabel();
    earlyLoopExitTest->u.label.label = earlyLoopExitTestLabel;
    earlyLoopExitTest->u.label.x4 = lastlabelnode;
    earlyLoopExitTest->u.label.x4->flags |= IROLF_Reffed;
    earlyLoopExitTest->rtype = LoopNode->last->rtype;
    IRO_Paste(list.head, list.tail, fnode2->last);

    isConstant = IsIterationCountConstant(loop, &iterCount);
    needOrigLoop = 1;
    needUnrollBodyTest = 1;
    resetUnrolledFinalValue = 0;
    if (isConstant)
        IRO_TestConstantIterationCount(loop, &iterCount, 1, &unrollFactor, &leftOver, &needOrigLoop, &needUnrollBodyTest, &resetUnrolledFinalValue);

    IRO_InitList(&list);
    origIterationCount = BuildOrigIterationCount(&list, loop);
    IRO_Paste(list.head, list.tail, fnode2->last);
    saveHead1 = list.head;

    IRO_InitList(&list);
    newFinalValue = BuildNewFinalvalue(origIterationCount, unrollFactor, &list, loop);
    IRO_Paste(list.head, list.tail, fnode2->last);

    IRO_InitList(&list);
    BuildUnrolledBodyEntryTest(&list, origIterationCount, unrollFactor, lastlabel);
    IRO_Paste(list.head, list.tail, fnode2->last);
    unrolledBodyEntryTest = list.tail;

    label = IRO_NewLabel();
    IRO_InitList(&list);
    gotoNd = IRO_NewLinear(IROLinearOp1Arg);
    gotoNd->index = ++IRO_NumLinear;
    gotoNd->type = IROLinearGoto;
    gotoNd->u.label.label = label;
    IRO_AddToList(gotoNd, &list);
    IRO_Paste(list.head, list.tail, fnode2->last);

    IRO_InitList(&list);
    label2 = BuildLabel(&list);
    IRO_Paste(list.head, list.tail, fnode2->last);
    saveHead2 = list.head;

    val = cint64_zero;
    for (i = 0; i < unrollFactor; i++)
        IRO_IterateForLoopBody(fnode3, header, loop, fnode2->last, loop->induction->addConst, &val, i > 0);
    updIndInc = UpdateInductionIncrement(loop, unrollFactor, fnode2->last);

    IRO_InitList(&list);
    labelNd = IRO_NewLinear(IROLinearLabel);
    labelNd->index = IRO_NumLinear++;
    labelNd->u.label.label = label;
    labelNd->flags |= IROLF_1;
    IRO_AddToList(labelNd, &list);
    IRO_Paste(list.head, list.tail, fnode2->last);

    IRO_InitList(&list);

    IRO_DuplicateExpr(LoopNode->last->u.label.x4->u.diadic.left, &list);
    saveTail2 = list.tail;

    if (resetUnrolledFinalValue)
        IRO_DuplicateExpr(loop->nd18->u.diadic.right, &list);
    else
        IRO_DuplicateExpr(newFinalValue, &list);

    ndCopy = IRO_NewLinear(LoopNode->last->u.label.x4->type);
    *ndCopy = *LoopNode->last->u.label.x4;
    ndCopy->index = ++IRO_NumLinear;
    ndCopy->next = NULL;
    ndCopy->expr = NULL;
    ndCopy->u.diadic.left = saveTail2;
    ndCopy->u.diadic.right = list.tail;
    IRO_AddToList(ndCopy, &list);

    IRO_Paste(list.head, list.tail, fnode2->last);
    saveTail3 = list.tail;

    IRO_InitList(&list);
    loopExitTest = BuildLoopExitTest(LoopNode->last->type, &list);
    loopExitTest->u.label.label = label2;
    loopExitTest->u.label.x4 = saveTail3;
    loopExitTest->u.label.x4->flags |= IROLF_Reffed;
    loopExitTest->rtype = LoopNode->last->rtype;
    IRO_Paste(list.head, list.tail, fnode2->last);
    saveTail4 = list.tail;

    IRO_InitList(&list);
    labelNd2 = IRO_NewLinear(IROLinearLabel);
    labelNd2->index = IRO_NumLinear++;
    labelNd2->u.label.label = lastlabel;
    labelNd2->flags |= IROLF_1;
    IRO_AddToList(labelNd2, &list);
    IRO_Paste(list.head, list.tail, fnode2->last);

    lastnd = fnode2->last;
    nd18 = fnode2->nextnode;
    fnode2->last = earlyLoopExitTest;

    newfnode1 = IRO_NewFlowGraphNode();
    newfnode1->first = saveHead1;
    newfnode1->last = unrolledBodyEntryTest;
    fnode2->nextnode = newfnode1;

    newfnode2 = IRO_NewFlowGraphNode();
    newfnode2->first = gotoNd;
    newfnode2->last = gotoNd;
    newfnode1->nextnode = newfnode2;

    newfnode3 = IRO_NewFlowGraphNode();
    newfnode3->first = saveHead2;
    newfnode3->last = updIndInc;

    saveHead2->u.label.label->stmt = (Statement *) newfnode3;
    if (newfnode2)
        newfnode2->nextnode = newfnode3;
    else
        newfnode1->nextnode = newfnode3;

    newfnode4 = IRO_NewFlowGraphNode();
    newfnode4->first = labelNd;
    newfnode4->last = saveTail4;
    labelNd->u.label.label->stmt = (Statement *) newfnode4;
    newfnode3->nextnode = newfnode4;

    newfnode5 = IRO_NewFlowGraphNode();
    newfnode5->first = labelNd2;
    newfnode5->last = lastnd;
    newfnode4->nextnode = newfnode5;
    newfnode5->nextnode = nd18;

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

    labelNd3 = IRO_NewLinear(IROLinearLabel);
    labelNd3->index = IRO_NumLinear++;
    labelNd3->next = NULL;
    labelNd3->u.label.label = earlyLoopExitTestLabel;
    labelNd3->flags |= IROLF_1;
    earlyLoopExitTestLabel->stmt = (Statement *) newfnode6;

    newfnode6->first = labelNd3;
    newfnode6->last = labelNd3;

    labelNd3->next = LoopNode->last->next;
    LoopNode->last->next = labelNd3;

    newfnode6->nextnode = LoopNode->nextnode;
    LoopNode->nextnode = newfnode6;

    if (!needOrigLoop) {
        NoOpBlock(newfnode5);
        NoOpBlock(header);
        NoOpBlock(fnode3);
        NoOpBlock(loop->induction->fnode);
        IRO_NopOut(newfnode1->last->u.label.x4);
        newfnode1->last->type = IROLinearNop;
    }

    if (!needUnrollBodyTest) {
        IRO_NopOut(earlyLoopExitTest->u.label.x4);
        earlyLoopExitTest->type = IROLinearNop;

        IRO_NopOut(newfnode4->last->u.label.x4);
        newfnode4->last->type = IROLinearNop;

        if (newfnode2)
            newfnode2->last->type = IROLinearNop;

        for (scan = newfnode1->first; scan; scan = scan->next) {
            if (!(scan->flags & IROLF_Reffed))
                IRO_NopOut(scan);
            if (scan == newfnode1->last)
                break;
        }
    }

    return 1;
}

static UInt32 UnrollStandardLoop(IRONode *header, IRONode *fnode2, IRONode *fnode3, int count) {
    IROLoop *loop;

    ConditionalHeaderAtBottom = 1;
    loop = ExtractLoopInfo(header);
    loop->xC = fnode2;
    loop->x10 = fnode3;
    FindAssignmenttoInductionVar(loop, fnode2);

    if (!IsLoopUnrollable(loop)) {
        IRO_Dump("LoopUnroll:loop with header %d not unrolled because IsLoopUnrollable failed\n", header->index);
        return 0;
    }

    if (loop->flags & LoopFlags_10000)
        return UnrollWhileLoop(header, fnode2, fnode3, loop, count);
    else
        return UnrollForLoop(header, fnode2, fnode3, loop, count);
}

static void LoopUnroll(int count, IRONode *header) {
    VarRecord *var;
    IRONode *tmp;
    UInt16 i;
    UInt16 j;
    IRONode *prevpred;
    IRONode *prevsucc;
    int foundpred;
    UInt32 predcount;
    UInt32 success = 0;

    LoopNode = header;
    FindMustReach();

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

    ComputeLoopKills();
    ComputeLoopInvariance();
    ComputeLoopInduction();

    LoopNode = header;
    ConditionalHeaderAtBottom = 0;

    prevpred = NULL;
    foundpred = 0;
    for (i = 0; i < LoopNode->numpred; i++) {
        tmp = IRO_NodeTable[LoopNode->pred[i]];
        if (!Bv_IsBitSet(tmp->index, InLoop)) {
            foundpred = 1;
            if (tmp->nextnode == header) {
                CError_ASSERT(2101, !prevpred || tmp == prevpred);
                prevpred = tmp;
            }
        }
    }

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

    if (LoopNode->last->type == IROLinearIf || LoopNode->last->type == IROLinearIfNot) {
        if (LoopNode->nextnode && !Bv_IsBitSet(LoopNode->nextnode->index, InLoop)) {
            prevsucc = NULL;
            for (i = 0; i < LoopNode->numsucc; i++) {
                tmp = IRO_NodeTable[LoopNode->succ[i]];
                if (Bv_IsBitSet(tmp->index, InLoop)) {
                    CError_ASSERT(2159, !prevsucc);
                    prevsucc = tmp;
                }
            }

            prevpred = NULL;
            predcount = 0;
            for (j = 0; j < LoopNode->numpred; j++) {
                tmp = IRO_NodeTable[LoopNode->pred[j]];
                if (!Bv_IsBitSet(tmp->index, InLoop)) {
                    prevpred = tmp;
                    predcount++;
                }
            }

            if (
                predcount == 1 &&
                prevpred->last->type == IROLinearGoto &&
                prevpred->nextnode == prevsucc &&
                prevsucc != LoopNode
                )
            {
                success = UnrollStandardLoop(header, prevpred, prevsucc, count);
            }
        }
    } else {
        IRO_Dump(" LoopUnroll:Loop with header = %d is not a conditional loop\n", header->index);
    }

    if (!success)
        return;

    IRO_NodeTable = oalloc(sizeof(IRONode *) * IRO_NumNodes);
    memset(IRO_NodeTable, 0, sizeof(IRONode *) * IRO_NumNodes);
    for (tmp = IRO_FirstNode; tmp; tmp = tmp->nextnode)
        IRO_NodeTable[tmp->index] = tmp;
    IRO_ComputeSuccPred();
    IRO_ComputeDom();
    if (success)
        IRO_Dump(" LoopUnroll:Loop with header = %d Unrolled\n", header->index);
}

static int IsLoopUnrollable(IROLoop *loop) {
    CInt64 tmp;

    if (loop->flags & LP_LOOP_HAS_ASM) {
        IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HAS_ASM \n");
        return 0;
    }
    if (loop->flags & LP_IFEXPR_NON_CANONICAL) {
        IRO_Dump("IsLoopUnrollable:No due to LP_IFEXPR_NON_CANONICAL \n");
        return 0;
    }
    if (loop->flags & LP_LOOP_HAS_CALLS) {
        IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HAS_CALLS \n");
        return 0;
    }
    if (loop->flags & LP_LOOP_HAS_CNTRLFLOW) {
        IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HAS_CNTRLFLOW \n");
        return 0;
    }
    if (loop->flags & LP_INDUCTION_NOT_FOUND) {
        IRO_Dump("IsLoopUnrollable:No due to LP_INDUCTION_NOT_FOUND \n");
        return 0;
    }
    if (loop->flags & LP_LOOP_HDR_HAS_SIDEEFFECTS) {
        IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HDR_HAS_SIDEEFFECTS \n");
        return 0;
    }
    if (!(loop->flags & LoopFlags_200)) {
        IRO_Dump("IsLoopUnrollable:No because header does not follow induction update \n");
        return 0;
    }

    if (!(loop->flags & LoopFlags_10000)) {
        IROLinear *upperBound = loop->nd18->u.diadic.right;
        if (!IRO_IsIntConstant(upperBound) && !(upperBound->flags & IROLF_LoopInvariant)) {
            IRO_Dump("IsLoopUnrollable:No because Loop Upper Bound is Variant in the loop\n");
            return 0;
        }
        if (!loop->nd14) {
            IRO_Dump("IsLoopUnrollable:No because there is no initialization of loop index in PreHeader\n");
            return 0;
        }
        if (!IRO_IsVariable(loop->nd14->u.diadic.left)) {
            IRO_Dump("IsLoopUnrollable:No because initial value of induction stored thru pointer\n");
            return 0;
        }

        if (!IRO_IsUnsignedType(loop->nd14->rtype)) {
            if (IRO_IsIntConstant(loop->nd14->u.diadic.right)) {
                if (!CInt64_GreaterEqual(loop->nd14->u.diadic.right->u.node->data.intval, cint64_zero)) {
                    IRO_Dump("IsLoopUnrollable:No because initial value of induction is signed but init < 0\n");
                    return 0;
                }
            } else if (IsIterationCountConstant(loop, &tmp)) {
                IRO_Dump("IsLoopUnrollable:Yes, the limits substract out to be constants\n");
            } else {
                IRO_Dump("IsLoopUnrollable:No because initial value of induction is signed and not constant\n");
                return 0;
            }
        }

        if (!(loop->flags & LP_LOOP_STEP_ISADD)) {
            IRO_Dump("IsLoopUnrollable:No because LP_LOOP_STEP_ISADD  is not set i.e induciton is not updated by 1\n");
            return 0;
        }

    } else {
        if (!IRO_IsUnsignedType(loop->nd18->u.diadic.left->rtype)) {
            IRO_Dump("IsLoopUnrollable:No because the while loop induction is signed\n");
            return 0;
        }
        if (!(loop->flags & LoopFlags_2000)) {
            IRO_Dump("IsLoopUnrollable:No because the while loop operator is not of decrement form\n");
            return 0;
        }
    }

    if (loop->sizeBySomeMeasurement > copts.loop_unroll_size_threshold) {
        IRO_Dump("IsLoopUnrollable:No because loop size greater than threshold\n");
        return 0;
    }

    return 1;
}

IROLinear *BuildEarlyLoopExitTest(IROLinearType type, IROList *list) {
    IROLinear *nd = IRO_NewLinear(IROLinearOp1Arg);
    nd->index = ++IRO_NumLinear;
    if (type == IROLinearIf)
        nd->type = IROLinearIfNot;
    else
        nd->type = IROLinearIf;
    IRO_AddToList(nd, list);
    return nd;
}

IROLinear *BuildLoopExitTest(IROLinearType type, IROList *list) {
    IROLinear *nd = IRO_NewLinear(IROLinearOp1Arg);
    nd->index = ++IRO_NumLinear;
    nd->type = type;
    IRO_AddToList(nd, list);
    return nd;
}

int IsIterationCountConstant(IROLoop *loop, CInt64 *pval) {
    IROLinear *lowerBound;
    IROLinear *upperBound;
    Type *type;
    int isUnsigned;
    IROAddrRecord *lowerRec;
    IROAddrRecord *upperRec;
    CInt64 lowerval;
    CInt64 upperval;
    CInt64 incval;
    CInt64 negOne;

    lowerBound = loop->nd14->u.diadic.right;
    if (loop->flags & LoopFlags_1) {
        upperBound = loop->nd18->u.diadic.right;
        type = loop->nd18->u.diadic.right->rtype;
    } else {
        upperBound = loop->nd18->u.diadic.left;
        type = loop->nd18->u.diadic.left->rtype;
    }

    isUnsigned = IRO_IsUnsignedType(type);

    if (IRO_IsIntConstant(lowerBound) && IRO_IsIntConstant(upperBound)) {
        lowerval = lowerBound->u.node->data.intval;
        upperval = upperBound->u.node->data.intval;
        if (isUnsigned) {
            if (CInt64_LessEqualU(upperval, lowerval))
                return 0;
        } else {
            if (CInt64_LessEqual(upperval, lowerval))
                return 0;
        }

        CInt64_SetLong(&incval, loop->induction->addConst);
        CInt64_SetLong(&negOne, -1);
        *pval = CInt64_Sub(upperval, lowerval);
        *pval = CInt64_Add(*pval, incval);

        if (IS_LINEAR_DIADIC(loop->nd18, ELESS))
            *pval = CInt64_Add(*pval, negOne);

        CError_ASSERT(2486, !CInt64_IsZero(&incval));

        if (isUnsigned)
            *pval = CInt64_DivU(*pval, incval);
        else
            *pval = CInt64_Div(*pval, incval);

        if (CInt64_Equal(*pval, cint64_zero))
            return 0;

        if (isUnsigned) {
            CError_ASSERT(2508, !CInt64_LessEqualU(*pval, cint64_zero));
        } else {
            CError_ASSERT(2517, !CInt64_LessEqual(*pval, cint64_zero));
        }

        return 1;
    }

    lowerRec = IRO_InitAddrRecordPointer(lowerBound);
    upperRec = IRO_InitAddrRecordPointer(upperBound);

    if (IS_LINEAR_DIADIC(lowerBound, EADD)) {
        IRO_DecomposeAddressExpression(lowerBound, lowerRec);
    } else if (IRO_IsIntConstant(lowerBound)) {
        lowerRec->numInts++;
        IRO_AddElmToList(lowerBound, &lowerRec->ints);
        lowerRec->numObjRefs = 0;
        lowerRec->numMisc = 0;
    } else {
        lowerRec->numMisc++;
        IRO_AddElmToList(lowerBound, &lowerRec->misc);
        lowerRec->numObjRefs = 0;
        lowerRec->numInts = 0;
    }

    if (IS_LINEAR_DIADIC(upperBound, EADD)) {
        IRO_DecomposeAddressExpression(upperBound, upperRec);
    } else if (IRO_IsIntConstant(upperBound)) {
        upperRec->numInts++;
        IRO_AddElmToList(upperBound, &upperRec->ints);
        upperRec->numObjRefs = 0;
        upperRec->numMisc = 0;
    } else {
        upperRec->numMisc++;
        IRO_AddElmToList(upperBound, &upperRec->misc);
        upperRec->numObjRefs = 0;
        upperRec->numInts = 0;
    }

    if (IsDifferenceOfTermsConstant(lowerRec, upperRec, isUnsigned, pval)) {
        if (IS_LINEAR_DIADIC(loop->nd18, ELESSEQU))
            *pval = CInt64_Add(*pval, cint64_one);
        return 1;
    }

    return 0;
}

static int IsDifferenceOfTermsConstant(IROAddrRecord *lowerRec, IROAddrRecord *upperRec, int isUnsigned, CInt64 *pval) {
    UInt32 i;
    CInt64 upperval;
    CInt64 lowerval;
    IROElmList *el;
    IROLinear *nd;

    if (upperRec->numObjRefs == lowerRec->numObjRefs && upperRec->numObjRefs != 0)
        return 0;
    else if (upperRec->numObjRefs != lowerRec->numObjRefs)
        return 0;

    if (upperRec->numMisc == lowerRec->numMisc && upperRec->numMisc != 0) {
        for (i = 0; i < upperRec->numMisc; i++) {
            // bug? surely this should index on i...?
            if (!IRO_ExprsSame(lowerRec->misc->element, upperRec->misc->element))
                return 0;
        }
    } else if (upperRec->numMisc != lowerRec->numMisc) {
        return 0;
    }

    upperval = cint64_zero;
    for (el = upperRec->ints; el; el = el->next) {
        nd = el->element;
        upperval = CMach_CalcIntDiadic(nd->rtype, upperval, '+', nd->u.node->data.intval);
    }

    lowerval = cint64_zero;
    for (el = lowerRec->ints; el; el = el->next) {
        nd = el->element;
        lowerval = CMach_CalcIntDiadic(nd->rtype, lowerval, '+', nd->u.node->data.intval);
    }

    if (CInt64_Equal(upperval, lowerval))
        return 0;

    if (CInt64_Greater(upperval, lowerval)) {
        *pval = CInt64_Sub(upperval, lowerval);
        return 1;
    } else {
        return 0;
    }
}

void NoOpBlock(IRONode *fnode) {
    IROLinear *last, *scan;

    for (scan = fnode->first, last = fnode->last; scan; scan = scan->next) {
        scan->type = IROLinearNop;
        if (scan == last)
            break;
    }
}

void IRO_TestConstantIterationCount(IROLoop *loop, CInt64 *iterCount, SInt32 vectorStride, UInt32 *unrollFactor, SInt32 *leftOver, UInt32 *needOrigLoop, UInt32 *needUnrollBodyTest, UInt32 *resetUnrolledFinalValue) {
    UInt32 isUnsigned;
    CInt64 val;
    CInt64 val3;
    CInt64 mod;
    CInt64 val2;
    CInt64 loopvar3;
    CInt64 loopvar1;
    CInt64 loopvar2;
    CInt64 strideVal;

    CError_ASSERT(2737, *unrollFactor);

    isUnsigned = IRO_IsUnsignedType(
        (loop->flags & LoopFlags_1) ? loop->nd18->u.diadic.right->rtype :loop->nd18->u.diadic.left->rtype);

    CError_ASSERT(2756, vectorStride);

    strideVal = IRO_MakeLong(vectorStride);
    if (isUnsigned ? CInt64_LessU(*iterCount, strideVal) : CInt64_Less(*iterCount, strideVal)) {
        *needOrigLoop = 1;
        *needUnrollBodyTest = 0;
        *unrollFactor = 0;
        *leftOver = CInt64_GetULong(iterCount);
    } else {
        switch (vectorStride) {
            case 1:
                val = *iterCount;
                break;
            case 2:
                val = CInt64_ShrU(*iterCount, cint64_one);
                break;
            case 4:
                val = CInt64_ShrU(*iterCount, IRO_MakeLong(2));
                break;
            case 8:
                val = CInt64_ShrU(*iterCount, IRO_MakeLong(3));
                break;
            case 16:
                val = CInt64_ShrU(*iterCount, IRO_MakeLong(4));
                break;
            default:
                val = CInt64_Div(*iterCount, strideVal);
        }

        if (CInt64_LessU(val, IRO_MakeLong(*unrollFactor)))
            *unrollFactor = CInt64_GetULong(&val);

        CInt64_SetLong(&val2, *unrollFactor);
        switch (vectorStride) {
            case 1:
                val3 = cint64_zero;
                break;
            case 2:
                val3 = CInt64_And(*iterCount, cint64_one);
                break;
            case 4:
                val3 = CInt64_And(*iterCount, IRO_MakeLong(3));
                break;
            case 8:
                val3 = CInt64_And(*iterCount, IRO_MakeLong(7));
                break;
            case 16:
                val3 = CInt64_And(*iterCount, IRO_MakeLong(15));
                break;
            default:
                val3 = CInt64_Mod(*iterCount, strideVal);
        }

        if (CInt64_LessEqualU(val, IRO_MakeLong(8))) {
            *needUnrollBodyTest = vectorStride > 1;
            *unrollFactor = CInt64_GetULong(&val);
            *leftOver = CInt64_GetULong(&val3);
            *needOrigLoop = *leftOver != 0;
            *resetUnrolledFinalValue = !(*needOrigLoop && *needUnrollBodyTest);
        } else {
            loopvar1 = IRO_MakeLong(0x7FFFFFFF);
            loopvar2 = IRO_MakeLong(0x7FFFFFFF);
            do {
                mod = CInt64_Mod(val, val2);
                loopvar3 = CInt64_Add(CInt64_Mul(mod, strideVal), val3);
                if (CInt64_Less(loopvar3, loopvar2)) {
                    loopvar2 = loopvar3;
                    loopvar1 = val2;
                }
                if (vectorStride > 1)
                    break;
                val2 = CInt64_Add(val2, cint64_negone);
            } while (CInt64_GreaterEqualU(CInt64_Mul(val2, val2), val));

            *unrollFactor = CInt64_GetULong(&loopvar1);
            *leftOver = CInt64_GetULong(&loopvar2);
            *needOrigLoop = *leftOver != 0;
            *needUnrollBodyTest = CInt64_Less(loopvar1, val) || vectorStride > 1;
            *resetUnrolledFinalValue = !(*needOrigLoop && *needUnrollBodyTest);
        }
    }

    IRO_Dump(
        "---- IterCount = %d, VectorStride = %d, UnrollFactor = %d, LeftOver = %d,\n"
        "\tNeedOrigLoop = %d, NeedUnrollBodyTest = %d, ResetUnrolledFinalValue = %d\n",
        CInt64_GetULong(iterCount), vectorStride, *unrollFactor, *leftOver,
        *needOrigLoop, *needUnrollBodyTest, *resetUnrolledFinalValue
        );
}

IROLinear *BuildOrigIterationCount(IROList *list, IROLoop *loop) {
    IROLinear *upperBound;
    IROLinear *nd29b;
    IROLinear *lowerBound;
    IROLinear *finalCount;
    IROLinear *divisor;
    Type *type;
    IROLinear *nd25;
    IROLinear *tmp;
    Boolean isZeroBase;
    Object *tempobj;
    IROLinear *iterCount;
    IROLinear *negone;
    IROLinear *ass;
    ENode *expr;
    SInt32 powval;

    isZeroBase = 0;
    lowerBound = loop->nd14->u.diadic.right;
    if (IRO_IsIntConstant(lowerBound) && CInt64_Equal(lowerBound->u.node->data.intval, cint64_zero))
        isZeroBase = 1;

    if (!isZeroBase)
        lowerBound = IRO_DuplicateExpr(lowerBound, list);

    if (loop->flags & LoopFlags_1) {
        upperBound = IRO_DuplicateExpr(loop->nd18->u.diadic.right, list);
        type = loop->nd18->u.diadic.right->rtype;
    } else {
        upperBound = IRO_DuplicateExpr(loop->nd18->u.diadic.left, list);
        type = loop->nd18->u.diadic.left->rtype;
    }

    CError_ASSERT(2924, loop->induction);
    CError_ASSERT(2929, loop->induction->addConst);

    divisor = IRO_NewLinear(IROLinearOperand);
    divisor->index = ++IRO_NumLinear;
    divisor->rtype = type;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = type;
    CInt64_SetLong(&expr->data.intval, loop->induction->addConst);
    divisor->u.node = expr;

    if (isZeroBase) {
        iterCount = upperBound;
    } else {
        iterCount = IRO_NewLinear(IROLinearOp2Arg);
        iterCount->index = ++IRO_NumLinear;
        iterCount->nodetype = ESUB;
        iterCount->u.diadic.left = upperBound;
        iterCount->u.diadic.right = lowerBound;
        iterCount->rtype = type;
        IRO_AddToList(iterCount, list);
    }

    nd25 = IRO_DuplicateExpr(divisor, list);

    nd29b = IRO_NewLinear(IROLinearOp2Arg);
    nd29b->index = ++IRO_NumLinear;
    nd29b->nodetype = EADD;
    nd29b->u.diadic.left = iterCount;
    nd29b->u.diadic.right = nd25;
    nd29b->rtype = type;
    IRO_AddToList(nd29b, list);

    if (loop->nd18->type == IROLinearOp2Arg && loop->nd18->nodetype == ELESS) {
        tmp = nd29b;

        negone = IRO_NewLinear(IROLinearOperand);
        negone->index = ++IRO_NumLinear;
        negone->rtype = type;
        expr = IRO_NewENode(EINTCONST);
        expr->rtype = type;
        CInt64_SetLong(&expr->data.intval, -1);
        negone->u.node = expr;
        IRO_AddToList(negone, list);

        nd29b = IRO_NewLinear(IROLinearOp2Arg);
        nd29b->index = ++IRO_NumLinear;
        nd29b->nodetype = EADD;
        nd29b->u.diadic.left = tmp;
        nd29b->u.diadic.right = negone;
        nd29b->rtype = type;
        IRO_AddToList(nd29b, list);
    }

    if (CInt64_Equal(divisor->u.node->data.intval, cint64_one)) {
        finalCount = nd29b;
    } else {
        if (divisor->rtype->size <= 4 && IS_TYPE_INT(divisor->rtype) && IRO_IsPow2(divisor, &powval)) {
            finalCount = IRO_NewLinear(IROLinearOp2Arg);
            finalCount->index = ++IRO_NumLinear;
            finalCount->nodetype = ESHL;
            finalCount->u.diadic.left = nd29b;
            finalCount->u.diadic.right = divisor;
            CInt64_SetLong(&divisor->u.node->data.intval, powval);
            finalCount->rtype = type;
            IRO_AddToList(divisor, list);
            IRO_AddToList(finalCount, list);
        } else {
            finalCount = IRO_NewLinear(IROLinearOp2Arg);
            finalCount->index = ++IRO_NumLinear;
            finalCount->nodetype = EDIV;
            finalCount->u.diadic.left = nd29b;
            finalCount->u.diadic.right = divisor;
            finalCount->rtype = type;
            IRO_AddToList(divisor, list);
            IRO_AddToList(finalCount, list);
        }
    }

    tempobj = create_temp_object(type);
    IRO_FindVar(tempobj, 1, 1);

    ass = IRO_NewLinear(IROLinearOp2Arg);
    ass->index = ++IRO_NumLinear;
    ass->nodetype = EASS;
    ass->u.diadic.left = IRO_TempReference(tempobj, list);
    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
    ass->u.diadic.right = finalCount;
    ass->u.diadic.right->flags |= IROLF_Reffed;
    ass->rtype = type;
    IRO_AddToList(ass, list);

    return ass->u.diadic.left;
}

static IROLinear *BuildOrigIterationCount_DoWhile(IROList *list, IROLoop *loop) {
    IROLinear *finalCount;
    IROLinear *count;
    IROLinear *ass;
    Type *type;
    Object *tempobj;
    ENode *expr;

    type = loop->nd18->u.diadic.left->rtype;

    count = IRO_NewLinear(IROLinearOperand);
    count->index = ++IRO_NumLinear;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = type;
    expr->data.intval = cint64_one;
    count->u.node = expr;
    count->rtype = type;
    IRO_AddToList(count, list);
    count->flags |= IROLF_Reffed;

    finalCount = IRO_NewLinear(IROLinearOp2Arg);
    finalCount->index = ++IRO_NumLinear;
    finalCount->nodetype = EADD;
    finalCount->rtype = type;
    finalCount->u.diadic.left = IRO_DuplicateExpr(loop->nd18->u.diadic.left, list);
    finalCount->u.diadic.left->flags |= IROLF_Reffed;
    finalCount->u.diadic.left->flags &= ~IROLF_Assigned;
    finalCount->u.diadic.left->u.monadic->flags &= ~IROLF_Assigned;
    finalCount->u.diadic.right = count;
    IRO_AddToList(finalCount, list);

    tempobj = create_temp_object(type);
    IRO_FindVar(tempobj, 1, 1);

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

    return ass->u.diadic.left;
}

IROLinear *BuildNewFinalvalue(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop) {
    IROLinear *sub;
    IROLinear *addvalue;
    Type *type;
    IROLinear *ass;
    IROLinear *dupbound;
    Object *tempobj;
    ENode *expr;

    type = iterCount->rtype;

    addvalue = IRO_NewLinear(IROLinearOperand);
    addvalue->index = ++IRO_NumLinear;
    addvalue->rtype = type;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = type;
    CInt64_SetLong(&expr->data.intval, loop->induction->addConst * unrollFactor);
    addvalue->u.node = expr;
    IRO_AddToList(addvalue, list);

    if (loop->flags & LoopFlags_1)
        dupbound = IRO_DuplicateExpr(loop->nd18->u.diadic.right, list);
    else
        dupbound = IRO_DuplicateExpr(loop->nd18->u.diadic.left, list);

    sub = IRO_NewLinear(IROLinearOp2Arg);
    sub->index = ++IRO_NumLinear;
    sub->nodetype = ESUB;
    sub->u.diadic.left = dupbound;
    sub->u.diadic.right = addvalue;
    sub->rtype = type;
    IRO_AddToList(sub, list);

    tempobj = create_temp_object(type);
    IRO_FindVar(tempobj, 1, 1);

    ass = IRO_NewLinear(IROLinearOp2Arg);
    ass->index = ++IRO_NumLinear;
    ass->nodetype = EASS;
    ass->u.diadic.left = IRO_TempReference(tempobj, list);
    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
    ass->u.diadic.right = sub;
    ass->u.diadic.right->flags |= IROLF_Reffed;
    ass->rtype = type;
    IRO_AddToList(ass, list);

    return ass->u.diadic.left;
}

static IROLinear *BuildPreAlignTemp(IROLoopInd *ind, UInt32 unrollFactor, IROList *list) {
    Type *type;
    IROLinear *indnd;
    IROLinear *factornd;
    IROLinear *div;
    IROLinear *constnd;
    IROLinear *add;
    IROLinear *mul;
    IROLinear *ass;
    Object *tempobj;
    ENode *expr;

    indnd = ind->nd;
    type = indnd->rtype;

    factornd = IRO_NewLinear(IROLinearOperand);
    factornd->index = ++IRO_NumLinear;
    factornd->rtype = type;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = type;
    CInt64_SetLong(&expr->data.intval, unrollFactor);
    factornd->u.node = expr;
    IRO_AddToList(factornd, list);

    if (indnd->type == IROLinearOp1Arg)
        IRO_DuplicateExpr(indnd->u.monadic, list);
    else
        IRO_DuplicateExpr(indnd->u.diadic.left, list);

    list->tail->flags &= ~IROLF_Assigned;
    list->tail->u.monadic->flags &= ~IROLF_Assigned;

    div = IRO_NewLinear(IROLinearOp2Arg);
    div->index = ++IRO_NumLinear;
    div->nodetype = EDIV;
    div->u.diadic.left = list->tail;
    div->u.diadic.right = factornd;
    div->rtype = type;
    IRO_AddToList(div, list);
    div->flags |= IROLF_Reffed;

    constnd = IRO_NewLinear(IROLinearOperand);
    constnd->index = ++IRO_NumLinear;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = type;
    expr->data.intval = cint64_one;
    constnd->u.node = expr;
    constnd->rtype = type;
    IRO_AddToList(constnd, list);
    constnd->flags |= IROLF_Reffed;

    add = IRO_NewLinear(IROLinearOp2Arg);
    add->index = ++IRO_NumLinear;
    add->nodetype = EADD;
    add->u.diadic.left = div;
    add->u.diadic.right = constnd;
    add->rtype = type;
    IRO_AddToList(add, list);
    add->flags |= IROLF_Reffed;

    IRO_DuplicateExpr(factornd, list);

    mul = IRO_NewLinear(IROLinearOp2Arg);
    mul->index = ++IRO_NumLinear;
    mul->nodetype = EMUL;
    mul->u.diadic.left = add;
    mul->u.diadic.right = list->tail;
    mul->rtype = type;
    IRO_AddToList(mul, list);
    mul->flags |= IROLF_Reffed;

    tempobj = create_temp_object(type);
    IRO_FindVar(tempobj, 1, 1);

    ass = IRO_NewLinear(IROLinearOp2Arg);
    ass->index = ++IRO_NumLinear;
    ass->nodetype = EASS;
    ass->u.diadic.left = IRO_TempReference(tempobj, list);
    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
    ass->u.diadic.right = mul;
    ass->u.diadic.right->flags |= IROLF_Reffed;
    ass->rtype = type;
    IRO_AddToList(ass, list);

    return ass->u.diadic.left;
}

static IROLinear *BuildNewFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop) {
    IROLinear *addvalue;
    IROLinear *add;
    IROLinear *mul;
    IROLinear *ass;
    Type *type;
    Object *tempobj;
    ENode *expr;

    type = iterCount->rtype;

    addvalue = IRO_NewLinear(IROLinearOperand);
    addvalue->index = ++IRO_NumLinear;
    addvalue->rtype = type;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = type;
    CInt64_SetLong(&expr->data.intval, loop->induction->addConst);
    addvalue->u.node = expr;
    IRO_AddToList(addvalue, list);
    addvalue->flags |= IROLF_Reffed;

    mul = IRO_NewLinear(IROLinearOp2Arg);
    mul->index = ++IRO_NumLinear;
    mul->nodetype = EMUL;
    mul->u.diadic.left = IRO_DuplicateExpr(iterCount, list);
    mul->u.diadic.right = addvalue;
    mul->rtype = type;
    IRO_AddToList(mul, list);
    mul->flags |= IROLF_Reffed;
    mul->u.diadic.left->flags &= ~IROLF_Assigned;
    mul->u.diadic.left->u.diadic.left->flags &= ~IROLF_Assigned;

    if (loop->induction->nd->type == IROLinearOp1Arg)
        IRO_DuplicateExpr(loop->induction->nd->u.monadic, list);
    else
        IRO_DuplicateExpr(loop->induction->nd->u.diadic.left, list);
    list->tail->flags &= ~IROLF_Assigned;
    list->tail->u.diadic.left->flags &= ~IROLF_Assigned;

    add = IRO_NewLinear(IROLinearOp2Arg);
    add->index = ++IRO_NumLinear;
    add->nodetype = EADD;
    add->u.diadic.left = mul;
    add->u.diadic.right = list->tail;
    add->rtype = type;
    IRO_AddToList(add, list);
    add->flags |= IROLF_Reffed;

    tempobj = create_temp_object(type);
    IRO_FindVar(tempobj, 1, 1);

    ass = IRO_NewLinear(IROLinearOp2Arg);
    ass->index = ++IRO_NumLinear;
    ass->nodetype = EASS;
    ass->u.diadic.left = IRO_TempReference(tempobj, list);
    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
    ass->u.diadic.right = add;
    ass->u.diadic.right->flags |= IROLF_Reffed;
    ass->rtype = type;
    IRO_AddToList(ass, list);

    return ass->u.diadic.left;
}

static IROLinear *BuildUnrolledFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop) {
    IROLinear *addvalue_mult;
    IROLinear *addvalue;
    IROLinear *mul;
    IROLinear *sub;
    IROLinear *add;
    IROLinear *ass;
    Type *type;
    Object *tempobj;
    ENode *expr;

    type = iterCount->rtype;

    addvalue_mult = IRO_NewLinear(IROLinearOperand);
    addvalue_mult->index = ++IRO_NumLinear;
    addvalue_mult->rtype = type;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = type;
    CInt64_SetLong(&expr->data.intval, loop->induction->addConst * unrollFactor);
    addvalue_mult->u.node = expr;
    IRO_AddToList(addvalue_mult, list);
    addvalue_mult->flags |= IROLF_Reffed;

    addvalue = IRO_NewLinear(IROLinearOperand);
    addvalue->index = ++IRO_NumLinear;
    addvalue->rtype = type;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = type;
    CInt64_SetLong(&expr->data.intval, loop->induction->addConst);
    addvalue->u.node = expr;
    IRO_AddToList(addvalue, list);
    addvalue->flags |= IROLF_Reffed;

    mul = IRO_NewLinear(IROLinearOp2Arg);
    mul->index = ++IRO_NumLinear;
    mul->nodetype = EMUL;
    mul->u.diadic.left = IRO_DuplicateExpr(iterCount, list);
    mul->u.diadic.right = addvalue;
    mul->rtype = type;
    IRO_AddToList(mul, list);
    mul->flags |= IROLF_Reffed;
    mul->u.diadic.left->flags &= ~IROLF_Assigned;
    mul->u.diadic.left->u.diadic.left->flags &= ~IROLF_Assigned;

    sub = IRO_NewLinear(IROLinearOp2Arg);
    sub->index = ++IRO_NumLinear;
    sub->nodetype = ESUB;
    sub->u.diadic.left = mul;
    sub->u.diadic.right = addvalue_mult;
    sub->rtype = type;
    IRO_AddToList(sub, list);
    sub->flags |= IROLF_Reffed;

    if (loop->induction->nd->type == IROLinearOp1Arg)
        IRO_DuplicateExpr(loop->induction->nd->u.monadic, list);
    else
        IRO_DuplicateExpr(loop->induction->nd->u.diadic.left, list);
    list->tail->flags &= ~IROLF_Assigned;
    list->tail->u.diadic.left->flags &= ~IROLF_Assigned;

    add = IRO_NewLinear(IROLinearOp2Arg);
    add->index = ++IRO_NumLinear;
    add->nodetype = EADD;
    add->u.diadic.left = sub;
    add->u.diadic.right = list->tail;
    add->rtype = type;
    IRO_AddToList(add, list);
    add->flags |= IROLF_Reffed;

    tempobj = create_temp_object(type);
    IRO_FindVar(tempobj, 1, 1);

    ass = IRO_NewLinear(IROLinearOp2Arg);
    ass->index = ++IRO_NumLinear;
    ass->nodetype = EASS;
    ass->u.diadic.left = IRO_TempReference(tempobj, list);
    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
    ass->u.diadic.right = add;
    ass->u.diadic.right->flags |= IROLF_Reffed;
    ass->rtype = type;
    IRO_AddToList(ass, list);

    return ass->u.diadic.left;
}

void BuildUnrolledBodyEntryTest(IROList *list, IROLinear *iterCount, UInt32 unrollFactor, CLabel *label) {
    Type *type;
    IROLinear *ifnot;
    IROLinear *comp;
    IROLinear *var;
    IROLinear *value;
    ENode *expr;

    type = iterCount->rtype;

    value = IRO_NewLinear(IROLinearOperand);
    value->index = ++IRO_NumLinear;
    value->rtype = type;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = type;
    CInt64_SetLong(&expr->data.intval, unrollFactor);
    value->u.node = expr;
    IRO_AddToList(value, list);

    var = IRO_DuplicateExpr(iterCount, list);

    comp = IRO_NewLinear(IROLinearOp2Arg);
    comp->index = ++IRO_NumLinear;
    comp->nodetype = EGREATER;
    comp->u.diadic.left = var;
    comp->u.diadic.right = value;
    comp->u.diadic.right->flags |= IROLF_Reffed;
    comp->rtype = type;
    IRO_AddToList(comp, list);

    ifnot = IRO_NewLinear(IROLinearOp1Arg);
    ifnot->index = ++IRO_NumLinear;
    ifnot->type = IROLinearIfNot;
    ifnot->u.label.x4 = comp;
    ifnot->u.label.x4->flags |= IROLF_Reffed;
    ifnot->rtype = type;
    ifnot->u.label.label = label;
    IRO_AddToList(ifnot, list);
}

void ChangeInductionReference(IROLinear *first, IROLinear *last, CInt64 val, IROLoop *loop) {
    IROLinear *nd;
    IROLinear *value;
    IROLinear *add;
    UInt32 isUnsigned;
    IROLinear *father;
    Boolean flag;
    IROLinear *father2;
    IROLinear *father3;
    Type *tmp;
    UInt32 flag2;
    Object *varobj;
    IROLinear *next;
    ENode *expr;
    Type *type;

    CInt64 val2;
    CInt64 val1;
    IROList list;

    type = loop->induction->nd->rtype;
    isUnsigned = IRO_IsUnsignedType(type);

    for (nd = first; nd; nd = next) {
        next = nd->next;

        varobj = IRO_IsVariable(nd);
        if (varobj && loop->induction->var->object == varobj) {
            value = IRO_NewLinear(IROLinearOperand);
            value->index = ++IRO_NumLinear;
            value->rtype = type;
            expr = IRO_NewENode(EINTCONST);
            expr->rtype = type;
            expr->data.intval = val;
            value->u.node = expr;

            add = IRO_NewLinear(IROLinearOp2Arg);
            add->index = ++IRO_NumLinear;
            add->nodetype = EADD;
            add->rtype = type;

            father = IRO_LocateFather(nd);
            flag = 1;
            if (father && IS_LINEAR_MONADIC(father, ETYPCON)) {
                tmp = father->rtype;
                father = IRO_LocateFather(father);
                if (tmp->type != nd->rtype->type || tmp->size < nd->rtype->size)
                    flag = 0;
            }

            flag2 = 0;
            if (
                flag &&
                father &&
                IS_LINEAR_DIADIC_2(father, ESHL, EMUL) &&
                IRO_IsIntConstant(father->u.diadic.right) &&
                (father2 = IRO_LocateFather(father)) &&
                IS_LINEAR_DIADIC(father2, EADD) &&
                father2->u.diadic.right == father &&
                (father3 = IRO_LocateFather(father2))
                )
            {
                IRO_InitList(&list);
                val2 = father->u.diadic.right->u.node->data.intval;
                if (father->nodetype == ESHL)
                    val2 = CInt64_Shl(cint64_one, val2);

                val1 = value->u.node->data.intval;
                if (isUnsigned)
                    val1 = CInt64_MulU(val2, val1);
                else
                    val1 = CInt64_Mul(val2, val1);
                value->u.node->data.intval = val1;

                IRO_AddToList(value, &list);
                IRO_AddToList(add, &list);
                add->u.diadic.right = value;
                IRO_Paste(list.head, list.tail, father3);
                IRO_LocateFather_Cut_And_Paste_Without_Nopping(father2, add);
                add->u.diadic.left = father2;
                add->rtype = father2->rtype;
                flag2 = 1;
            }

            if (!flag2) {
                add->u.diadic.right = value;
                add->u.diadic.right->flags |= IROLF_Reffed;
                value->next = add;

                add->u.diadic.left = nd;
                IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, add);
                add->flags |= IROLF_Reffed;

                nd->next = value;
                add->next = next;
            }
        }

        if (nd == last)
            break;
    }
}

IROLinear *UpdateInductionIncrement(IROLoop *loop, SInt32 value, IROLinear *before) {
    IROLinear *ind_nd;
    IROLinear *addvalue;
    IROLinear *ass;
    Type *type;
    ENode *expr;
    IROList list;

    IRO_InitList(&list);
    ind_nd = loop->induction->nd;
    type = ind_nd->rtype;

    addvalue = IRO_NewLinear(IROLinearOperand);
    addvalue->index = ++IRO_NumLinear;
    addvalue->rtype = type;
    expr = IRO_NewENode(EINTCONST);
    expr->rtype = type;
    CInt64_SetLong(&expr->data.intval, value * loop->induction->addConst);
    addvalue->u.node = expr;
    IRO_AddToList(addvalue, &list);

    if (IS_LINEAR_MONADIC_2(ind_nd, EPREINC, EPOSTINC)) {
        ind_nd = IRO_DuplicateExpr(ind_nd->u.monadic, &list);

        ass = IRO_NewLinear(IROLinearOp2Arg);
        ass->index = ++IRO_NumLinear;
        ass->nodetype = EADDASS;
        ass->u.diadic.left = ind_nd;
        ass->u.diadic.right = addvalue;
        ass->rtype = type;
        IRO_AddToList(ass, &list);
    } else if (IS_LINEAR_MONADIC_2(ind_nd, EPREDEC, EPOSTDEC)) {
        ind_nd = IRO_DuplicateExpr(ind_nd->u.monadic, &list);

        ass = IRO_NewLinear(IROLinearOp2Arg);
        ass->index = ++IRO_NumLinear;
        ass->nodetype = ESUBASS;
        ass->u.diadic.left = ind_nd;
        ass->u.diadic.right = addvalue;
        ass->rtype = type;
        IRO_AddToList(ass, &list);
    } else if (IS_LINEAR_DIADIC(ind_nd, EADDASS)) {
        ind_nd = IRO_DuplicateExpr(ind_nd->u.monadic, &list);

        ass = IRO_NewLinear(IROLinearOp2Arg);
        ass->index = ++IRO_NumLinear;
        ass->nodetype = EADDASS;
        ass->u.diadic.left = ind_nd;
        ass->u.diadic.right = addvalue;
        ass->rtype = type;
        IRO_AddToList(ass, &list);
    }

    IRO_Paste(list.head, list.tail, before);
    return list.tail;
}

void GenInitialAssignment(IROLoop *loop, Object *var, IROList *list) {
    Type *type;
    IROLinear *nd;

    CError_ASSERT(3924, loop->nd14 && loop->nd14->type == IROLinearOp2Arg);

    type = loop->induction->nd->rtype;

    nd = IRO_NewLinear(IROLinearOp2Arg);
    nd->index = ++IRO_NumLinear;
    nd->nodetype = EASS;
    nd->u.diadic.left = IRO_TempReference(var, list);
    nd->u.diadic.right = IRO_DuplicateExpr(loop->nd14->u.diadic.right, list);
    nd->rtype = type;
    IRO_AddToList(nd, list);
}

void GenNewInduction(void) {
    CError_FATAL(3941);
}