#include "compiler/IROUseDef.h"
#include "compiler/IRODump.h"
#include "compiler/IROVars.h"
#include "compiler/IroFlowgraph.h"
#include "compiler/IroLinearForm.h"
#include "compiler/IroMalloc.h"
#include "compiler/IroPointerAnalysis.h"
#include "compiler/IroTransform.h"
#include "compiler/IroUtil.h"
#include "compiler/CompilerTools.h"
#include "compiler/CError.h"
#include "compiler/CFunc.h"
#include "compiler/CInt64.h"
#include "compiler/CMachine.h"
#include "compiler/CParser.h"
#include "compiler/objects.h"
#include "compiler/types.h"
#include "compiler/InlineAsm.h"
#include "compiler/InlineAsmPPC.h"

ENodeType IRO_NonAssignmentOp[MAXEXPR];
typedef CInt64 (*AssignmentFoldingFunc)(CInt64, CInt64);
static AssignmentFoldingFunc AssignmentFoldingFunction[MAXEXPR];
static SInt32 NumDefs;
static IRODef *FirstDef;
static IRODef *LastDef;
static SInt32 NumUses;
static BitVector *Reaches;
static BitVector *MightReachAnyUse;
static BitVector *alldefs;
static BitVector *alluses;
static BitVector *defset;
static BitVector *useset;
IROUse *IRO_FirstVarUse;
IROUse *IRO_LastVarUse;

// forward decls
static void AddDefToRange(IRODef *def);

static void MakeDef(VarRecord *var, IROLinear *linear, IRONode *node, Boolean flag) {
    IRODef *def = oalloc(sizeof(IRODef));

    def->index = NumDefs++;
    def->node = node;
    def->linear = linear;
    def->var = var;
    def->globalnext = NULL;
    def->x18 = 0;
    def->x1A = Inline_IsObjectData(var->object);
    def->x1B = var->xB;
    def->x1C = flag;
    def->x1D = 0;

    if (FirstDef)
        LastDef->globalnext = def;
    else
        FirstDef = def;
    LastDef = def;

    def->varnext = var->defs;
    var->defs = def;
}

static void MakeUse(VarRecord *var, IROLinear *linear, IRONode *node) {
    IROUse *use = oalloc(sizeof(IROUse));

    use->index = NumUses++;
    use->node = node;
    use->linear = linear;
    use->var = var;
    use->globalnext = NULL;
    use->x1C = 0;

    if (IRO_FirstVarUse)
        IRO_LastVarUse->globalnext = use;
    else
        IRO_FirstVarUse = use;
    IRO_LastVarUse = use;

    use->varnext = var->uses;
    var->uses = use;
}

static void FindDefsAndUses(void) {
    VarRecord *var;
    IROLinear *linear;
    IRONode *node;

    NumDefs = 0;
    NumUses = 0;
    IRO_FirstVarUse = NULL;
    FirstDef = NULL;

    for (var = IRO_FirstVar; var; var = var->next) {
        var->defs = NULL;
        var->uses = NULL;
        var->xC = 0;
    }

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        for (linear = node->first; linear; linear = linear->next) {
            if (IS_LINEAR_ENODE(linear, EOBJREF)) {
                Object *obj = linear->u.node->data.objref;
                if ((linear->flags & IROLF_Ind) && (!(linear->flags & IROLF_Assigned) || (linear->flags & IROLF_Used))) {
                    if ((var = IRO_FindVar(obj, 0, 1)))
                        MakeUse(var, linear, node);
                }
            }

            if (IRO_IsAssignment(linear) && (var = IRO_FindAssigned(linear))) {
                MakeDef(
                        var,
                        linear,
                        node,
                        (linear->rtype->size == var->object->type->size) && !IRO_IsBitField
                        );
            }

            if (linear->type == IROLinearAsm) {
                IAEffects effects;
                int i;
                CodeGen_GetAsmEffects(linear->u.asm_stmt, &effects);

                for (i = 0; i < effects.numoperands; i++) {
                    var = IRO_FindVar(effects.operands[i].object, 0, 1);
                    switch (effects.operands[i].type) {
                        case IAEffect_0:
                            MakeUse(var, linear, node);
                            break;
                        case IAEffect_1:
                            MakeDef(
                                    var,
                                    linear,
                                    node,
                                    (effects.operands[i].offset == 0) && (effects.operands[i].size == var->object->type->size)
                            );
                            break;
                        case IAEffect_2:
                            MakeDef(var, linear, node, 0);
                            break;
                        case IAEffect_4:
                            MakeUse(var, linear, node);
                            MakeDef(
                                    var,
                                    linear,
                                    node,
                                    (effects.operands[i].offset == 0) && (effects.operands[i].size == var->object->type->size)
                            );
                            break;
                    }
                }
            }

            if (linear == node->last)
                break;
        }
    }

    for (var = IRO_FirstVar; var; var = var->next)
        MakeDef(var, NULL, NULL, 1);
}

static void MarkUses(Object *obj) {
    VarRecord *var;
    IRODef *def;

    if ((var = IRO_FindVar(obj, 0, 1))) {
        for (def = var->defs; def; def = def->varnext) {
            if (Bv_IsBitSet(def->index, Reaches)) {
                Bv_SetBit(def->index, MightReachAnyUse);
                def->x18++;
            }
        }

        var->xC = 1;
    }
}

static Boolean IsIncOrDec(IROLinear *linear) {
    switch (linear->type) {
        case IROLinearOp1Arg:
            if (linear->nodetype == EPOSTINC || linear->nodetype == EPOSTDEC || linear->nodetype == EPREINC || linear->nodetype == EPREDEC) {
                if (!(linear->u.monadic->flags & IROLF_BitfieldIndirect))
                    return 1;
            }
            break;
        case IROLinearOp2Arg:
            if (linear->nodetype == EADDASS || linear->nodetype == ESUBASS) {
                if (IRO_IsIntConstant(linear->u.diadic.right) && !(linear->u.diadic.left->flags & IROLF_BitfieldIndirect))
                    return 1;
            }
            break;
    }

    return 0;
}

static Boolean IsOtherSelfAssignment(IROLinear *linear) {
    switch (linear->type) {
        case IROLinearOp2Arg:
            switch (linear->nodetype) {
                case EMULASS:
                case EDIVASS:
                case ESHLASS:
                case ESHRASS:
                case EANDASS:
                case EXORASS:
                case EORASS:
                    if (IRO_IsIntConstant(linear->u.diadic.right))
                        return 1;
                    break;
            }
            break;
    }

    return 0;
}

CInt64 IRO_GetSelfAssignmentVal(IROLinear *linear) {
    CInt64 result;

    if (linear->type == IROLinearOp1Arg) {
        switch (linear->nodetype) {
            case EPOSTINC:
            case EPREINC:
                CInt64_SetLong(&result, 1);
                break;
            case EPOSTDEC:
            case EPREDEC:
                CInt64_SetLong(&result, -1);
                break;
            default:
                CError_FATAL(445);
        }

        if (IS_TYPE_POINTER_ONLY(linear->rtype)) {
            CInt64 mul;
            CInt64_SetLong(&mul, TPTR_TARGET(linear->rtype)->size);
            result = CInt64_Mul(result, mul);
        }
    } else if (linear->type == IROLinearOp2Arg) {
        switch (linear->nodetype) {
            case EMULASS:
            case EDIVASS:
            case EMODASS:
            case EADDASS:
            case ESHLASS:
            case ESHRASS:
            case EANDASS:
            case EXORASS:
            case EORASS:
                result = linear->u.diadic.right->u.node->data.intval;
                break;
            case ESUBASS:
                result = linear->u.diadic.right->u.node->data.intval;
                result = CInt64_Neg(result);
                break;
            default:
                CError_FATAL(491);
        }
    } else {
        CError_FATAL(496);
    }

    return result;
}

static void UpdateUse(IROLinear *linear, CInt64 val, Type *type) {
    IROLinear *father;
    IROLinear *repl;
    IROLinear *newdiadic;

    if ((father = IRO_LocateFather(linear))) {
        switch (father->type) {
            case IROLinearOp1Arg:
                switch (father->nodetype) {
                    case EPOSTINC:
                    case EPOSTDEC:
                    case EPREINC:
                    case EPREDEC:
                        val = CInt64_Add(val, IRO_GetSelfAssignmentVal(father));
                        father->nodetype = EADDASS;
                        father->type = IROLinearOp2Arg;
                        repl = IRO_NewIntConst(val, type);
                        father->u.diadic.right = repl;
                        IRO_PasteAfter(repl, repl, linear);
                        return;
                }
                break;
            case IROLinearOp2Arg:
                if (IRO_IsIntConstant(father->u.diadic.right)) {
                    switch (father->nodetype) {
                        case EADD:
                        case EADDASS:
                            father->u.diadic.right->u.node->data.intval = CInt64_Add(
                                    father->u.diadic.right->u.node->data.intval, val);
                            return;
                        case ESUB:
                        case ESUBASS:
                            father->u.diadic.right->u.node->data.intval = CInt64_Sub(
                                    father->u.diadic.right->u.node->data.intval, val);
                            return;
                    }
                }
                break;
        }
    }

    repl = IRO_NewIntConst(val, type);
    newdiadic = IRO_NewLinear(IROLinearOp2Arg);
    newdiadic->index = ++IRO_NumLinear;
    newdiadic->nodetype = EADD;
    newdiadic->u.diadic.left = linear;
    newdiadic->u.diadic.right = repl;
    newdiadic->rtype = linear->rtype;
    repl->next = newdiadic;
    IRO_LocateFather_Cut_And_Paste_Without_Nopping(linear, newdiadic);
    IRO_PasteAfter(repl, newdiadic, linear);
}

void IRO_InitializeNonAssignmentOpArray(void) {
    int i;

    for (i = 0; i < MAXEXPR; i++)
        IRO_NonAssignmentOp[i] = MAXEXPR;

    IRO_NonAssignmentOp[EPOSTINC] = MAXEXPR;
    IRO_NonAssignmentOp[EPOSTDEC] = MAXEXPR;
    IRO_NonAssignmentOp[EPREINC] = MAXEXPR;
    IRO_NonAssignmentOp[EPREDEC] = MAXEXPR;
    IRO_NonAssignmentOp[EINDIRECT] = MAXEXPR;
    IRO_NonAssignmentOp[EMONMIN] = MAXEXPR;
    IRO_NonAssignmentOp[EBINNOT] = MAXEXPR;
    IRO_NonAssignmentOp[ELOGNOT] = MAXEXPR;
    IRO_NonAssignmentOp[EFORCELOAD] = MAXEXPR;
    IRO_NonAssignmentOp[EMUL] = MAXEXPR;
    IRO_NonAssignmentOp[EMULV] = MAXEXPR;
    IRO_NonAssignmentOp[EDIV] = MAXEXPR;
    IRO_NonAssignmentOp[EMODULO] = MAXEXPR;
    IRO_NonAssignmentOp[EADDV] = MAXEXPR;
    IRO_NonAssignmentOp[ESUBV] = MAXEXPR;
    IRO_NonAssignmentOp[EADD] = MAXEXPR;
    IRO_NonAssignmentOp[ESUB] = MAXEXPR;
    IRO_NonAssignmentOp[ESHL] = MAXEXPR;
    IRO_NonAssignmentOp[ESHR] = MAXEXPR;
    IRO_NonAssignmentOp[ELESS] = MAXEXPR;
    IRO_NonAssignmentOp[EGREATER] = MAXEXPR;
    IRO_NonAssignmentOp[ELESSEQU] = MAXEXPR;
    IRO_NonAssignmentOp[EGREATEREQU] = MAXEXPR;
    IRO_NonAssignmentOp[EEQU] = MAXEXPR;
    IRO_NonAssignmentOp[ENOTEQU] = MAXEXPR;
    IRO_NonAssignmentOp[EAND] = MAXEXPR;
    IRO_NonAssignmentOp[EXOR] = MAXEXPR;
    IRO_NonAssignmentOp[EOR] = MAXEXPR;
    IRO_NonAssignmentOp[ELAND] = MAXEXPR;
    IRO_NonAssignmentOp[ELOR] = MAXEXPR;
    IRO_NonAssignmentOp[EASS] = MAXEXPR;
    IRO_NonAssignmentOp[EMULASS] = EMUL;
    IRO_NonAssignmentOp[EDIVASS] = EDIV;
    IRO_NonAssignmentOp[EMODASS] = EMODULO;
    IRO_NonAssignmentOp[EADDASS] = EADD;
    IRO_NonAssignmentOp[ESUBASS] = ESUB;
    IRO_NonAssignmentOp[ESHLASS] = ESHL;
    IRO_NonAssignmentOp[ESHRASS] = ESHR;
    IRO_NonAssignmentOp[EANDASS] = EAND;
    IRO_NonAssignmentOp[EXORASS] = EXOR;
    IRO_NonAssignmentOp[EORASS] = EOR;
    IRO_NonAssignmentOp[ECOMMA] = MAXEXPR;
    IRO_NonAssignmentOp[EPMODULO] = MAXEXPR;
    IRO_NonAssignmentOp[EROTL] = MAXEXPR;
    IRO_NonAssignmentOp[EROTR] = MAXEXPR;
    IRO_NonAssignmentOp[EBCLR] = MAXEXPR;
    IRO_NonAssignmentOp[EBTST] = MAXEXPR;
    IRO_NonAssignmentOp[EBSET] = MAXEXPR;
    IRO_NonAssignmentOp[ETYPCON] = MAXEXPR;
    IRO_NonAssignmentOp[EBITFIELD] = MAXEXPR;
    IRO_NonAssignmentOp[EINTCONST] = MAXEXPR;
    IRO_NonAssignmentOp[EFLOATCONST] = MAXEXPR;
    IRO_NonAssignmentOp[ESTRINGCONST] = MAXEXPR;
    IRO_NonAssignmentOp[ECOND] = MAXEXPR;
    IRO_NonAssignmentOp[EFUNCCALL] = MAXEXPR;
    IRO_NonAssignmentOp[EFUNCCALLP] = MAXEXPR;
    IRO_NonAssignmentOp[EOBJREF] = MAXEXPR;
    IRO_NonAssignmentOp[EMFPOINTER] = MAXEXPR;
    IRO_NonAssignmentOp[ENULLCHECK] = MAXEXPR;
    IRO_NonAssignmentOp[EPRECOMP] = MAXEXPR;
    IRO_NonAssignmentOp[ETEMP] = MAXEXPR;
    IRO_NonAssignmentOp[EARGOBJ] = MAXEXPR;
    IRO_NonAssignmentOp[ELOCOBJ] = MAXEXPR;
    IRO_NonAssignmentOp[ELABEL] = MAXEXPR;
    IRO_NonAssignmentOp[ESETCONST] = MAXEXPR;
    IRO_NonAssignmentOp[ENEWEXCEPTION] = MAXEXPR;
    IRO_NonAssignmentOp[ENEWEXCEPTIONARRAY] = MAXEXPR;
    IRO_NonAssignmentOp[EOBJLIST] = MAXEXPR;
    IRO_NonAssignmentOp[EMEMBER] = MAXEXPR;
    IRO_NonAssignmentOp[ETEMPLDEP] = MAXEXPR;
    IRO_NonAssignmentOp[EINSTRUCTION] = MAXEXPR;
    IRO_NonAssignmentOp[EDEFINE] = MAXEXPR;
    IRO_NonAssignmentOp[EREUSE] = MAXEXPR;
    IRO_NonAssignmentOp[EASSBLK] = MAXEXPR;
    IRO_NonAssignmentOp[EVECTOR128CONST] = MAXEXPR;
    IRO_NonAssignmentOp[ECONDASS] = MAXEXPR;
}

void IRO_InitializeAssignmentFoldingFunctionArray(void) {
    int i;

    for (i = 0; i < MAXEXPR; i++)
        AssignmentFoldingFunction[i] = NULL;

    AssignmentFoldingFunction[EPOSTINC] = NULL;
    AssignmentFoldingFunction[EPOSTDEC] = NULL;
    AssignmentFoldingFunction[EPREINC] = NULL;
    AssignmentFoldingFunction[EPREDEC] = NULL;
    AssignmentFoldingFunction[EINDIRECT] = NULL;
    AssignmentFoldingFunction[EMONMIN] = NULL;
    AssignmentFoldingFunction[EBINNOT] = NULL;
    AssignmentFoldingFunction[ELOGNOT] = NULL;
    AssignmentFoldingFunction[EFORCELOAD] = NULL;
    AssignmentFoldingFunction[EMUL] = NULL;
    AssignmentFoldingFunction[EMULV] = NULL;
    AssignmentFoldingFunction[EDIV] = NULL;
    AssignmentFoldingFunction[EMODULO] = NULL;
    AssignmentFoldingFunction[EADDV] = NULL;
    AssignmentFoldingFunction[ESUBV] = NULL;
    AssignmentFoldingFunction[EADD] = NULL;
    AssignmentFoldingFunction[ESUB] = NULL;
    AssignmentFoldingFunction[ESHL] = NULL;
    AssignmentFoldingFunction[ESHR] = NULL;
    AssignmentFoldingFunction[ELESS] = NULL;
    AssignmentFoldingFunction[EGREATER] = NULL;
    AssignmentFoldingFunction[ELESSEQU] = NULL;
    AssignmentFoldingFunction[EGREATEREQU] = NULL;
    AssignmentFoldingFunction[EEQU] = NULL;
    AssignmentFoldingFunction[ENOTEQU] = NULL;
    AssignmentFoldingFunction[EAND] = NULL;
    AssignmentFoldingFunction[EXOR] = NULL;
    AssignmentFoldingFunction[EOR] = NULL;
    AssignmentFoldingFunction[ELAND] = NULL;
    AssignmentFoldingFunction[ELOR] = NULL;
    AssignmentFoldingFunction[EASS] = NULL;
    AssignmentFoldingFunction[EMULASS] = CInt64_Mul;
    AssignmentFoldingFunction[EDIVASS] = CInt64_Mul;
    AssignmentFoldingFunction[EMODASS] = NULL;
    AssignmentFoldingFunction[EADDASS] = CInt64_Add;
    AssignmentFoldingFunction[ESUBASS] = CInt64_Add;
    AssignmentFoldingFunction[ESHLASS] = CInt64_Add;
    AssignmentFoldingFunction[ESHRASS] = CInt64_Add;
    AssignmentFoldingFunction[EANDASS] = CInt64_And;
    AssignmentFoldingFunction[EXORASS] = CInt64_Xor;
    AssignmentFoldingFunction[EORASS] = CInt64_Or;
    AssignmentFoldingFunction[ECOMMA] = NULL;
    AssignmentFoldingFunction[EPMODULO] = NULL;
    AssignmentFoldingFunction[EROTL] = NULL;
    AssignmentFoldingFunction[EROTR] = NULL;
    AssignmentFoldingFunction[EBCLR] = NULL;
    AssignmentFoldingFunction[EBTST] = NULL;
    AssignmentFoldingFunction[EBSET] = NULL;
    AssignmentFoldingFunction[ETYPCON] = NULL;
    AssignmentFoldingFunction[EBITFIELD] = NULL;
    AssignmentFoldingFunction[EINTCONST] = NULL;
    AssignmentFoldingFunction[EFLOATCONST] = NULL;
    AssignmentFoldingFunction[ESTRINGCONST] = NULL;
    AssignmentFoldingFunction[ECOND] = NULL;
    AssignmentFoldingFunction[EFUNCCALL] = NULL;
    AssignmentFoldingFunction[EFUNCCALLP] = NULL;
    AssignmentFoldingFunction[EOBJREF] = NULL;
    AssignmentFoldingFunction[EMFPOINTER] = NULL;
    AssignmentFoldingFunction[ENULLCHECK] = NULL;
    AssignmentFoldingFunction[EPRECOMP] = NULL;
    AssignmentFoldingFunction[ETEMP] = NULL;
    AssignmentFoldingFunction[EARGOBJ] = NULL;
    AssignmentFoldingFunction[ELOCOBJ] = NULL;
    AssignmentFoldingFunction[ELABEL] = NULL;
    AssignmentFoldingFunction[ESETCONST] = NULL;
    AssignmentFoldingFunction[ENEWEXCEPTION] = NULL;
    AssignmentFoldingFunction[ENEWEXCEPTIONARRAY] = NULL;
    AssignmentFoldingFunction[EOBJLIST] = NULL;
    AssignmentFoldingFunction[EMEMBER] = NULL;
    AssignmentFoldingFunction[ETEMPLDEP] = NULL;
    AssignmentFoldingFunction[EINSTRUCTION] = NULL;
    AssignmentFoldingFunction[EDEFINE] = NULL;
    AssignmentFoldingFunction[EREUSE] = NULL;
    AssignmentFoldingFunction[EASSBLK] = NULL;
    AssignmentFoldingFunction[EVECTOR128CONST] = NULL;
    AssignmentFoldingFunction[ECONDASS] = NULL;
}

static void UpdateUseForOtherSelfAssignment(IROLinear *a, IROLinear *b, Type *type) {
    CInt64 val;
    IROLinear *father;
    IROLinear *repl;
    IROLinear *newdiadic;

    val = IRO_GetSelfAssignmentVal(b);
    if ((father = IRO_LocateFather(a)) && father->type == IROLinearOp2Arg && IRO_IsIntConstant(father->u.diadic.right)) {
        CInt64 var_30 = father->u.diadic.right->u.node->data.intval;
        if (AssignmentFoldingFunction[b->nodetype] && ((father->nodetype == b->nodetype) || (father->nodetype == IRO_NonAssignmentOp[b->nodetype]))) {
            CInt64 v;
            CInt64 folded;
            CInt64_SetLong(&v, b->rtype->size * 8);
            folded = AssignmentFoldingFunction[b->nodetype](var_30, val);
            if (b->nodetype == ESHRASS && !is_unsigned(b->rtype)) {
                if (CInt64_LessU(var_30, v) && CInt64_LessU(val, v)) {
                    if (CInt64_GreaterEqualU(folded, v))
                        folded = CInt64_Sub(v, cint64_one);
                    father->u.diadic.right->u.node->data.intval = folded;
                    return;
                }
            } else {
                father->u.diadic.right->u.node->data.intval = folded;
                return;
            }
        } else {
            switch (b->nodetype) {
                case EMULASS:
                    if (father->nodetype == ESHL || father->nodetype == ESHLASS) {
                        SInt32 powvalue;
                        if (IRO_IsPow2(b->u.diadic.right, &powvalue)) {
                            if (powvalue > 0) {
                                CInt64 v;
                                CInt64_SetLong(&v, powvalue);
                                father->u.diadic.right->u.node->data.intval = CInt64_Add(v, var_30);
                            }
                        } else {
                            father->nodetype = (father->nodetype == ESHL) ? EMUL : EMULASS;
                            var_30 = CInt64_Shl(cint64_one, var_30);
                            father->u.diadic.right->u.node->data.intval = CInt64_Mul(var_30, val);
                        }
                        return;
                    }
                    break;
                case EDIVASS:
                    if ((father->nodetype == ESHR || father->nodetype == ESHRASS) && is_unsigned(father->rtype)) {
                        SInt32 powvalue;
                        if (IRO_IsPow2(b->u.diadic.right, &powvalue)) {
                            if (powvalue > 0) {
                                CInt64 v;
                                CInt64_SetLong(&v, powvalue);
                                father->u.diadic.right->u.node->data.intval = CInt64_Add(v, var_30);
                            }
                        } else {
                            father->nodetype = (father->nodetype == ESHR) ? EDIV : EDIVASS;
                            var_30 = CInt64_Shl(cint64_one, var_30);
                            father->u.diadic.right->u.node->data.intval = CInt64_Mul(var_30, val);
                        }
                        return;
                    }
                    break;
                case ESHLASS:
                    if (father->nodetype == EMUL || father->nodetype == EMULASS) {
                        SInt32 powvalue;
                        if (IRO_IsPow2(father->u.diadic.right, &powvalue)) {
                            if (powvalue > 0) {
                                CInt64 v;
                                father->nodetype = (father->nodetype == EMUL) ? ESHL : ESHLASS;
                                CInt64_SetLong(&v, powvalue);
                                father->u.diadic.right->u.node->data.intval = CInt64_Add(v, val);
                            }
                        } else {
                            val = CInt64_Shl(cint64_one, val);
                            father->u.diadic.right->u.node->data.intval = CInt64_Mul(var_30, val);
                        }
                        return;
                    } else if (father->nodetype == ESHR || father->nodetype == ESHRASS) {
                        if (CInt64_Equal(var_30, val) && is_unsigned(father->rtype)) {
                            father->nodetype = (father->nodetype == ESHR) ? EAND : EANDASS;
                            if (father->rtype->size < 8) {
                                CInt64 v;
                                CInt64_SetLong(&v, 64 - (father->rtype->size * 8));
                                val = CInt64_Add(val, v);
                            }
                            father->u.diadic.right->u.node->data.intval = CInt64_ShrU(cint64_negone, val);
                            return;
                        }
                    }
                    break;
                case ESHRASS:
                    if ((father->nodetype == EDIV || father->nodetype == EDIVASS) && is_unsigned(father->rtype)) {
                        SInt32 powvalue;
                        if (IRO_IsPow2(father->u.diadic.right, &powvalue)) {
                            if (powvalue > 0) {
                                CInt64 v;
                                father->nodetype = (father->nodetype == EDIV) ? ESHR : ESHRASS;
                                CInt64_SetLong(&v, powvalue);
                                father->u.diadic.right->u.node->data.intval = CInt64_Add(v, val);
                            }
                        } else {
                            val = CInt64_Shl(cint64_one, val);
                            father->u.diadic.right->u.node->data.intval = CInt64_Mul(var_30, val);
                        }
                        return;
                    } else if (father->nodetype == ESHL || father->nodetype == ESHLASS) {
                        if (CInt64_Equal(var_30, val)) {
                            father->nodetype = (father->nodetype == ESHL) ? EAND : EANDASS;
                            father->u.diadic.right->u.node->data.intval = CInt64_Shl(cint64_negone, val);
                            return;
                        }
                    }
                    break;
            }
        }
    }

    repl = IRO_NewIntConst(val, type);
    newdiadic = IRO_NewLinear(IROLinearOp2Arg);
    newdiadic->index = ++IRO_NumLinear;
    newdiadic->nodetype = IRO_NonAssignmentOp[b->nodetype];
    newdiadic->u.diadic.left = a;
    newdiadic->u.diadic.right = repl;
    newdiadic->rtype = a->rtype;
    repl->next = newdiadic;
    IRO_LocateFather_Cut_And_Paste_Without_Nopping(a, newdiadic);
    IRO_PasteAfter(repl, newdiadic, a);
}

static Boolean PropagateIncsAndDecs(void) {
    IRODef *def;
    Boolean result;

    result = 0;
    def = FirstDef;
    while (def) {
        if (
                def->linear &&
                def->x1C &&
                IsIncOrDec(def->linear) &&
                !(def->linear->flags & IROLF_Reffed) &&
                (IS_TYPE_INT_OR_ENUM(def->linear->rtype) || IS_TYPE_POINTER_ONLY(def->linear->rtype)) &&
                IRO_TypesEqual(def->linear->rtype, def->var->object->type) &&
                !is_volatile_object(def->var->object)
                ) {
            IROUse *use;
            IROUse *use2;
            IROLinear *father;
            CInt64 val;
            SInt32 i;
            Type *type;

            for (use = def->var->uses, i = 0; use; use = use->varnext) {
                if (Bv_IsBitSet(def->index, use->x18)) {
                    if (
                            use->x1C == 1 &&
                            use->linear->type == IROLinearOperand &&
                                    (father = IRO_LocateFather(use->linear)) &&
                                    IRO_IsVariable(father) &&
                                    IRO_TypesEqual(def->linear->rtype, father->rtype)
                            ) {
                        if (use->linear->flags & IROLF_Assigned) {
                            if (!((father = IRO_LocateFather(father)) && IsIncOrDec(father) && !(father->flags & IROLF_Reffed)))
                                goto nextDef;
                        }
                        i++;
                    } else {
                        goto nextDef;
                    }
                }
            }

            if (i == def->x18) {
                for (use = def->var->uses; use; use = use->varnext) {
                    if (Bv_IsBitSet(def->index, use->x18)) {
                        IRO_Dump("Propagating inc/dec from %d to %d\n", def->linear->index, use->linear->index);
                        father = IRO_LocateFather(use->linear);
                        val = IRO_GetSelfAssignmentVal(def->linear);
                        type = def->linear->rtype;
                        if (IS_TYPE_POINTER_ONLY(def->linear->rtype))
                            type = TYPE(&stunsignedlong);
                        UpdateUse(father, val, type);

                        result = 1;
                        for (use2 = def->var->uses; use2; use2 = use2->varnext) {
                            if (use2->linear == def->linear->u.monadic->u.diadic.left) {
                                use->x1C = use2->x1C;
                                Bv_Copy(use2->x18, use->x18);
                                break;
                            }
                        }
                    }
                }
                def->x18 = 0;
                IRO_NopNonSideEffects(def->linear, -1);
                def->linear->type = IROLinearNop;
                IRO_Dump("Removing deadddd assignment %d\n", def->linear->index);
            }
        }
    nextDef:
        def = def->globalnext;
    }

    return result;
}

static Boolean PropagateOtherSelfAssignments(void) {
    IRODef *def;
    Boolean result;

    result = 0;

    def = FirstDef;
    while (def) {
        if (
                def->linear &&
                def->x1C &&
                IsOtherSelfAssignment(def->linear) &&
                !(def->linear->flags & IROLF_Reffed) &&
                IS_TYPE_INT_OR_ENUM(def->linear->rtype) &&
                IRO_TypesEqual(def->linear->rtype, def->var->object->type) &&
                !is_volatile_object(def->var->object)
                )
        {
            IROUse *use;
            IROUse *use2;
            IROLinear *father;
            SInt32 i;
            Type *type;

            for (use = def->var->uses, i = 0; use; use = use->varnext) {
                if (Bv_IsBitSet(def->index, use->x18)) {
                    if (
                            use->x1C == 1 &&
                            use->linear->type == IROLinearOperand &&
                            (father = IRO_LocateFather(use->linear)) &&
                            IRO_IsVariable(father) &&
                            IRO_TypesEqual(def->linear->rtype, father->rtype)
                            ) {
                        if (use->linear->flags & IROLF_Assigned) {
                            if (!((father = IRO_LocateFather(father)) && IsOtherSelfAssignment(father) && (father->nodetype == def->linear->nodetype) && !(father->flags & IROLF_Reffed)))
                                goto nextDef;
                        }
                        i++;
                    } else {
                        goto nextDef;
                    }
                }
            }

            if (i == def->x18) {
                for (use = def->var->uses; use; use = use->varnext) {
                    if (Bv_IsBitSet(def->index, use->x18)) {
                        IRO_Dump("Propagating self assignment from %d to %d\n", def->linear->index, use->linear->index);
                        father = IRO_LocateFather(use->linear);
                        UpdateUseForOtherSelfAssignment(father, def->linear, def->linear->rtype);

                        result = 1;
                        for (use2 = def->var->uses; use2; use2 = use2->varnext) {
                            if (use2->linear == def->linear->u.monadic->u.diadic.left) {
                                use->x1C = use2->x1C;
                                Bv_Copy(use2->x18, use->x18);
                                break;
                            }
                        }
                    }
                }
                def->x18 = 0;
                IRO_NopNonSideEffects(def->linear, -1);
                def->linear->type = IROLinearNop;
                IRO_Dump("Removing deadddd assignment %d\n", def->linear->index);
            }
        }
    nextDef:
        def = def->globalnext;
    }

    return result;
}

static void MarkUsesByIndirect(IROLinear *linear, BitVector *a, BitVector *b) {
    IROListNode *list;
    IROLinear *nd;
    Object *obj;
    VarRecord *var;
    Boolean foundObjRef;
    IROListNode *scan;
    IRODef *def;
    Boolean found;

    found = 0;

    if (linear && copts.opt_pointer_analysis && linear->pointsToFunction && FunctionName) {
        IROListNode *resultList;
        resultList = NULL;
        PointerAnalysis_LookupLinearNodePointerExpr(FunctionName, linear, &resultList);
        if ((list = resultList)) {
            for (scan = list; scan; scan = scan->nextList) {
                if (!scan->list.head || !scan->list.tail) {
                    found = 1;
                    break;
                }

                foundObjRef = 0;
                for (nd = scan->list.head; nd != scan->list.tail->next; nd = nd->next) {
                    if (nd->type == IROLinearOperand && nd->u.node->type == EOBJREF) {
                        foundObjRef = 1;
                        break;
                    }
                }

                if (!foundObjRef) {
                    found = 1;
                    break;
                }
            }

            if (!found) {
                while (list) {
                    for (nd = list->list.head; nd != list->list.tail->next; nd = nd->next) {
                        if (nd->type == IROLinearOperand && nd->u.node->type == EOBJREF) {
                            obj = nd->u.node->data.objref;
                            CError_ASSERT(1422, obj != NULL);
                            var = IRO_FindVar(obj, 1, 1);
                            CError_ASSERT(1424, var != NULL);

                            for (def = var->defs; def; def = def->varnext) {
                                if (def->x1A || (def->x1B && Bv_IsBitSet(def->index, Reaches))) {
                                    def->x18++;
                                    Bv_SetBit(def->index, MightReachAnyUse);
                                }
                            }
                        }
                    }
                    list = list->nextList;
                }
            }

            while (resultList) {
                IROListNode *next = resultList->nextList;
                IRO_free(resultList);
                resultList = next;
            }
        } else {
            found = 1;
        }
    } else {
        found = 1;
    }

    if (found) {
        Bv_Copy(Reaches, a);
        Bv_And(b, a);
        Bv_Or(a, MightReachAnyUse);
        for (def = FirstDef; def; def = def->globalnext) {
            if (def->x1A || (def->x1B && Bv_IsBitSet(def->index, Reaches)))
                def->x18++;
        }
    }
}

static void MarkUsesByFunctionCall(IROLinear *linear, BitVector *a, BitVector *b) {
    ObjectList *olist;
    IROLinear *funcnd;
    IROListNode *list;
    IROLinear *nd;
    Object *obj;
    VarRecord *var;
    Boolean foundObjRef;
    IROListNode *scan;
    IRODef *def;
    Boolean found;

    found = 0;

    if ((funcnd = linear->u.funccall.linear8) && copts.opt_pointer_analysis && funcnd->pointsToFunction && FunctionName) {
        IROListNode *resultList;
        ObjectList *depsList;

        resultList = NULL;
        PointerAnalysis_LookupLinearNodePointerExpr(FunctionName, funcnd, &resultList);
        if (resultList) {
            for (scan = resultList; scan; scan = scan->nextList) {
                if (!scan->list.head || !scan->list.tail) {
                    found = 1;
                    break;
                }

                foundObjRef = 0;
                for (nd = scan->list.head; nd != scan->list.tail->next; nd = nd->next) {
                    if (nd->type == IROLinearOperand && nd->u.node->type == EOBJREF) {
                        foundObjRef = 1;
                        obj = nd->u.node->data.objref;
                        CError_ASSERT(1522, obj != NULL);

                        depsList = NULL;
                        PointerAnalysis_GetFunctionDependencies(obj, linear, &depsList);
                        for (olist = depsList; olist; olist = olist->next) {
                            if (!olist->object) {
                                found = 1;
                                break;
                            }
                        }

                        while (depsList) {
                            olist = depsList->next;
                            IRO_free(depsList);
                            depsList = olist;
                        }

                        if (found)
                            break;
                    }
                }

                if (!foundObjRef)
                    found = 1;
                if (found)
                    break;
            }

            if (!found) {
                for (list = resultList; list; list = list->nextList) {
                    for (nd = list->list.head; nd != list->list.tail->next; nd = nd->next) {
                        if (nd->type == IROLinearOperand && nd->u.node->type == EOBJREF) {
                            obj = nd->u.node->data.objref;
                            depsList = NULL;
                            PointerAnalysis_GetFunctionDependencies(obj, linear, &depsList);

                            for (olist = depsList; olist; olist = olist->next) {
                                var = IRO_FindVar(olist->object, 1, 1);
                                CError_ASSERT(1573, var != NULL);

                                for (def = var->defs; def; def = def->varnext) {
                                    if (def->x1A || (def->x1B && Bv_IsBitSet(def->index, Reaches))) {
                                        def->x18++;
                                        Bv_SetBit(def->index, MightReachAnyUse);
                                    }
                                }
                            }

                            while (depsList) {
                                olist = depsList->next;
                                IRO_free(depsList);
                                depsList = olist;
                            }
                        }
                    }
                }
            }

            while (resultList) {
                IROListNode *next = resultList->nextList;
                IRO_free(resultList);
                resultList = next;
            }
        } else {
            found = 1;
        }
    } else {
        found = 1;
    }

    if (found) {
        Bv_Copy(Reaches, a);
        Bv_And(b, a);
        Bv_Or(a, MightReachAnyUse);
        for (def = FirstDef; def; def = def->globalnext) {
            if (def->x1A || (def->x1B && Bv_IsBitSet(def->index, Reaches)))
                def->x18++;
        }
    }

    if (linear->stmt && IRO_FunctionCallMightThrowException(linear))
        IRO_WalkExcActions(linear->stmt->dobjstack, MarkUses);
}

static Boolean UseOfVarIsInsideASimpleDefOfVar(IROUse *use) {
    VarRecord *var;
    VarRecord *varAss;
    IROLinear *nd;
    IROLinear *nd2;

    if ((var = use->var)) {
        if ((nd = use->linear) && (nd->flags & IROLF_4000))
            return 0;

        while (nd && (nd->flags & IROLF_Reffed))
            nd = nd->next;

        if (
            nd &&
            IRO_IsAssignment(nd) &&
                (varAss = IRO_FindAssigned(nd)) &&
                varAss == var &&
                !IRO_HasSideEffect((nd->type == IROLinearOp1Arg) ? nd->u.monadic : nd->u.diadic.left) &&
                (!(nd2 = (nd->type == IROLinearOp1Arg) ? NULL : nd->u.diadic.right) || !IRO_HasSideEffect(nd2))
                ) {
            return 1;
        }
    }

    return 0;
}

static Boolean AllLoopDefUsesAreInSimpleLoopDefs(IRODef *def) {
    VarRecord *var;
    IRODef *scan;
    IROUse *use;

    if ((var = def->var)) {
        for (scan = var->defs; scan; scan = scan->varnext) {
            if (scan->node && scan->node->loopdepth) {
                for (use = var->uses; use; use = use->varnext) {
                    if (Bv_IsBitSet(scan->index, use->x18)) {
                        if (!use->node || !use->node->loopdepth || !UseOfVarIsInsideASimpleDefOfVar(use))
                            return 0;
                    }
                }
            }
        }
        return 1;
    } else {
        return 0;
    }
}

static void MarkRemovableLoopDefs(void) {
    IRODef *def;
    IRODef *scan;

    for (def = FirstDef; def; def = def->globalnext) {
        if (!def->x1A && !def->x1B && def->node && def->node->loopdepth && !def->x1D &&
            AllLoopDefUsesAreInSimpleLoopDefs(def) && def->var) {
            for (scan = def->var->defs; scan; scan = scan->varnext) {
                if (scan->node && scan->node->loopdepth)
                    scan->x1D = 1;
            }
        }
    }
}

static Boolean EliminateReffedDeadStore(IRODef *def) {
    Boolean isPostIncOrDec;
    IROLinear *nd;
    Boolean result;

    nd = def->linear;
    isPostIncOrDec = (nd->type == IROLinearOp1Arg) && (nd->nodetype == EPOSTINC || nd->nodetype == EPOSTDEC);

    result = IRO_LocateFather(nd) != NULL;
    if (result && IRO_IsAssignment(nd) && IRO_IsModifyOp[nd->nodetype])
        result = IRO_TransformSelfAssignmentToAssignment(nd);
    result = result && (nd->type == IROLinearOp2Arg) && (nd->nodetype == EASS);

    if (result) {
        def->x18 = 0;
        IRO_Dump("Removing referenced dead assignment %d\n", nd->index);

        if (isPostIncOrDec) {
            IRO_NopNonSideEffects(nd->u.diadic.right, 0);
            nd->type = IROLinearNop;
            IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, nd->u.diadic.left);
        } else {
            IRO_NopNonSideEffects(nd->u.diadic.left, 0);
            nd->type = IROLinearNop;
            IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, nd->u.diadic.right);
        }
    }

    return result;
}

Boolean IRO_UseDef(Boolean optDeadAssignments, Boolean optPropagation) {
    Boolean result;
    IRODef *gdef;
    IROUse *guse;
    IRODef *def;
    IROUse *use;
    IRONode *node;
    IROLinear *nd;
    VarRecord *var;
    Boolean flag;
    BitVector *bv3;
    BitVector *bv2;
    BitVector *bv;
    int i;

    FindDefsAndUses();

    IRO_CheckForUserBreak();

    for (use = IRO_FirstVarUse; use; use = use->globalnext)
        Bv_AllocVector(&use->x18, NumDefs);
    Bv_AllocVector(&MightReachAnyUse, NumDefs);
    Bv_AllocVector(&bv, NumDefs);

    IRO_CheckForUserBreak();

    for (def = FirstDef; def; def = def->globalnext) {
        if (def->x1A || def->x1B)
            Bv_SetBit(def->index, bv);
    }

    Bv_AllocVector(&bv2, NumDefs);
    gdef = FirstDef;
    for (node = IRO_FirstNode; node; node = node->nextnode) {
        Bv_AllocVector(&node->x16, NumDefs);
        Bv_AllocVector(&node->x1E, NumDefs);
        Bv_AllocVector(&node->x22, NumDefs);
        Bv_AllocVector(&node->x1A, NumDefs);

        for (nd = node->first; nd; nd = nd->next) {
            while (gdef && gdef->linear == nd) {
                Bv_SetBit(gdef->index, node->x1E);
                if (gdef->x1C) {
                    for (def = gdef->var->defs; def; def = def->varnext) {
                        if (def != gdef) {
                            Bv_SetBit(def->index, node->x22);
                            Bv_ClearBit(def->index, node->x1E);
                        }
                    }
                }
                gdef = gdef->globalnext;
            }
            if (nd == node->last)
                break;
        }

        if (node->numpred)
            Bv_Set(node->x16);
        Bv_Copy(node->x1E, node->x1A);
        IRO_CheckForUserBreak();
    }

    Bv_AllocVector(&bv3, NumDefs);

    do {
        flag = 0;
        for (node = IRO_FirstNode; node; node = node->nextnode) {
            Bv_Clear(node->x16);
            if (node->numpred) {
                for (i = 0; i < node->numpred; i++)
                    Bv_Or(IRO_NodeTable[node->pred[i]]->x1A, node->x16);
            } else if (node == IRO_FirstNode) {
                for (var = IRO_FirstVar; var; var = var->next)
                    Bv_SetBit(var->defs->index, node->x16);
            }
            Bv_Copy(node->x16, bv3);
            Bv_Minus(node->x22, bv3);
            Bv_Or(node->x1E, bv3);
            if (!Bv_Compare(bv3, node->x1A)) {
                Bv_Copy(bv3, node->x1A);
                flag = 1;
            }
        }

        IRO_CheckForUserBreak();
    } while (flag);

    gdef = FirstDef;
    guse = IRO_FirstVarUse;
    Bv_AllocVector(&Reaches, NumDefs);

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        Bv_Copy(node->x16, Reaches);
        nd = node->first;
        while (1) {
            while (guse && guse->linear == nd) {
                for (def = guse->var->defs; def; def = def->varnext) {
                    if (Bv_IsBitSet(def->index, Reaches)) {
                        Bv_SetBit(def->index, guse->x18);
                        Bv_SetBit(def->index, MightReachAnyUse);
                        def->x18++;
                        guse->x1C++;
                    }
                }
                guse = guse->globalnext;
            }

            if (nd->type == IROLinearFunccall) {
                MarkUsesByFunctionCall(nd, bv2, bv);
            } else if (nd->type == IROLinearOp1Arg && nd->nodetype == EINDIRECT && !IRO_IsVariable(nd)) {
                MarkUsesByIndirect(nd, bv2, bv);
            } else if ((nd->type == IROLinearFunccall) ||
                       (nd->type == IROLinearOp1Arg && nd->nodetype == EINDIRECT && !IRO_IsVariable(nd))) {
                Bv_Copy(Reaches, bv2);
                Bv_And(bv, bv2);
                Bv_Or(bv2, MightReachAnyUse);
                for (def = FirstDef; def; def = def->globalnext) {
                    if (def->x1A || (def->x1B && Bv_IsBitSet(def->index, Reaches)))
                        def->x18++;
                }
                if (nd->type == IROLinearFunccall && nd->stmt && IRO_FunctionCallMightThrowException(nd))
                    IRO_WalkExcActions(nd->stmt->dobjstack, MarkUses);
            }

            if (nd->type == IROLinearAsm) {
                IAEffects effects;
                CodeGen_GetAsmEffects(nd->u.asm_stmt, &effects);
                if (effects.x2) {
                    Bv_Copy(Reaches, bv2);
                    Bv_And(bv, bv2);
                    Bv_Or(bv2, MightReachAnyUse);
                }
            }

            if (nd->type == IROLinearReturn || nd->type == IROLinearEnd) {
                for (def = FirstDef; def; def = def->globalnext) {
                    if (def->x1A && Bv_IsBitSet(def->index, Reaches)) {
                        Bv_SetBit(def->index, MightReachAnyUse);
                        def->x18++;
                    }
                }
            }

            while (gdef && gdef->linear == nd) {
                if (gdef->x1C) {
                    for (def = gdef->var->defs; def; def = def->varnext)
                        Bv_ClearBit(def->index, Reaches);
                }
                Bv_SetBit(gdef->index, Reaches);
                gdef = gdef->globalnext;
            }

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

    IRO_CheckForUserBreak();

    result = 0;

    if (optDeadAssignments) {
        MarkRemovableLoopDefs();
        for (def = FirstDef; def; def = def->globalnext) {
            if (def->linear &&
                (!Bv_IsBitSet(def->index, MightReachAnyUse) || def->x1D) &&
                (copts.opt_pointer_analysis || !def->x1B) &&
                def->linear->type != IROLinearAsm &&
                (!def->linear->rtype || !CParser_IsVolatile(def->linear->rtype, def->linear->nodeflags & ENODE_FLAG_QUALS)) &&
                !is_volatile_object(def->var->object)
                ) {
                if (!(def->linear->flags & IROLF_Reffed)) {
                    def->x18 = 0;
                    IRO_NopNonSideEffects(def->linear, -1);
                    def->linear->type = IROLinearNop;
                    IRO_Dump("Removing dead assignment %d\n", def->linear->index);
                    result = 1;
                } else {
                    result = EliminateReffedDeadStore(def);
                }
            }
        }
    }

    IRO_CheckForUserBreak();

    if (optPropagation) {
        while (1) {
            if (PropagateIncsAndDecs() || PropagateOtherSelfAssignments())
                result = 1;
            else
                break;
        }
    }

    IRO_CheckForUserBreak();

    return result;
}

static IROLinear *GetOperand(IROLinear *nd) {
    IROLinear *inner;

    if (nd->type == IROLinearOperand)
        return nd;

    if (nd->type == IROLinearOp2Arg && nd->nodetype == EADD) {
        inner = GetOperand(nd->u.diadic.left);
        if (!inner)
            inner = GetOperand(nd->u.diadic.right);
        return inner;
    }

    return NULL;
}

static IROLinear *GetAssigned(IROLinear *nd) {
    if (!nd)
        return NULL;

    if (nd->type == IROLinearOp2Arg)
        nd = nd->u.diadic.left;
    else if (nd->type == IROLinearOp1Arg)
        nd = nd->u.monadic;
    else
        CError_FATAL(2338);

    if (nd->type != IROLinearOp1Arg || nd->nodetype != EINDIRECT)
        CError_FATAL(2351);

    nd = nd->u.monadic;

    if (nd->type == IROLinearOp2Arg && nd->nodetype == EADD)
        nd = GetOperand(nd);

    return nd;
}

static void AddUseToRange(IROUse *use) {
    IRODef *def;

    Bv_SetBit(use->index, useset);
    Bv_ClearBit(use->index, alluses);

    for (def = use->var->defs; def; def = def->varnext) {
        if (Bv_IsBitSet(def->index, alldefs) && (Bv_IsBitSet(def->index, use->x18) || GetAssigned(def->linear) == use->linear))
            AddDefToRange(def);
    }
}

static void AddDefToRange(IRODef *def) {
    IROUse *use;
    IROLinear *assigned;

    Bv_SetBit(def->index, defset);
    Bv_ClearBit(def->index, alldefs);

    for (use = def->var->uses, assigned = GetAssigned(def->linear); use; use = use->varnext) {
        if (Bv_IsBitSet(use->index, alluses) && (Bv_IsBitSet(def->index, use->x18) || assigned == use->linear))
            AddUseToRange(use);
    }
}

static void ReplaceAssigned(IROLinear *nd, Object *from, Object *to) {
    IROLinear *assigned;

    if (
        !(assigned = GetAssigned(nd)) ||
        assigned->type != IROLinearOperand ||
        assigned->u.node->type != EOBJREF ||
        assigned->u.node->data.objref != from
        )
        CError_FATAL(2459);

    assigned->u.node->data.objref = to;
}

static void ReplaceUsed(IROLinear *nd, Object *from, Object *to) {
    CError_ASSERT(2482, nd->type == IROLinearOperand && nd->u.node->type == EOBJREF);

    if (nd->u.node->data.objref == from)
        nd->u.node->data.objref = to;
    else if (nd->u.node->data.objref != to)
        CError_FATAL(2494);
}

static void SplitOffRange(VarRecord *var) {
    Object *newObj;
    IRODef *def;
    IROUse *use;

    IRO_Dump("Splitting range for variable: %d\n", var->index);
    IRO_DumpBits("Def set: ", defset);
    IRO_DumpBits("Use set: ", useset);
    IRO_DumpBits("All defs: ", alldefs);
    IRO_DumpBits("All uses: ", alluses);

    newObj = create_temp_object(var->object->type);
    IRO_FindVar(newObj, 1, 1);

    for (def = var->defs; def; def = def->varnext) {
        if (Bv_IsBitSet(def->index, defset) && def->linear)
            ReplaceAssigned(def->linear, var->object, newObj);
    }

    for (use = var->uses; use; use = use->varnext) {
        if (Bv_IsBitSet(use->index, useset))
            ReplaceUsed(use->linear, var->object, newObj);
    }
}

void IRO_SplitLifetimes(void) {
    VarRecord *var;
    SInt32 numVars;
    IRODef *def;
    IROUse *use;
    Boolean flag;

    Bv_AllocVector(&alldefs, NumDefs);
    Bv_AllocVector(&alluses, NumUses);
    Bv_AllocVector(&defset, NumDefs);
    Bv_AllocVector(&useset, NumUses);

    var = IRO_FirstVar;
    numVars = IRO_NumVars;

    while (var && var->index <= numVars) {
        if (var->object->datatype == DLOCAL && !is_volatile_object(var->object) && !var->xC && !var->xB && !var->x1E) {
            Bv_Clear(alldefs);
            Bv_Clear(alluses);

            for (def = var->defs; def; def = def->varnext) {
                if (def->linear && def->linear->type == IROLinearAsm)
                    goto skipThisVar;
                Bv_SetBit(def->index, alldefs);
            }

            for (use = var->uses; use; use = use->varnext) {
                if (use->linear && use->linear->type == IROLinearAsm)
                    goto skipThisVar;
                Bv_SetBit(use->index, alluses);
            }

            flag = 1;
            while (1) {
                Bv_Clear(defset);
                Bv_Clear(useset);

                def = var->defs;
                while (def && !Bv_IsBitSet(def->index, alldefs))
                    def = def->varnext;

                if (!def)
                    break;

                AddDefToRange(def);
                if (Bv_IsEmpty(alldefs))
                    break;

                if (!flag)
                    SplitOffRange(var);
                flag = 0;
            }
        }

    skipThisVar:
        var = var->next;
    }

    IRO_CheckForUserBreak();
}