#include "compiler/IroUtil.h"
#include "compiler/IroCSE.h"
#include "compiler/IroDump.h"
#include "compiler/IroFlowgraph.h"
#include "compiler/IroLinearForm.h"
#include "compiler/IroLoop.h"
#include "compiler/IroVars.h"
#include "compiler/InlineAsmPPC.h"
#include "compiler/CompilerTools.h"
#include "compiler/CCompiler.h"
#include "compiler/CError.h"
#include "compiler/CException.h"
#include "compiler/CExpr.h"
#include "compiler/CFunc.h"
#include "compiler/CInt64.h"
#include "compiler/CMachine.h"
#include "compiler/CParser.h"
#include "compiler/Exceptions.h"
#include "compiler/objects.h"
#include "compiler/types.h"
#include "cos.h"

static UInt32 IRO_LastUserBreakTick;
static IROLinear *ExprStart;
static IROLinear *ExprEnd;
static IRONode *IRO_Node;
static SInt32 FuncLevel;
Object *FunctionName;
Boolean IRO_IsLeafFunction;
Boolean IRO_FunctionHasReturn;
Boolean DisableDueToAsm;
Boolean LoopOptimizerRun;

Object *IRO_IsVariable(IROLinear *linear) {
    if (linear->type == IROLinearOp1Arg &&
        linear->nodetype == EINDIRECT &&
        linear->u.monadic->type == IROLinearOperand &&
        linear->u.monadic->u.node->type == EOBJREF)
        return linear->u.monadic->u.node->data.objref;

    return NULL;
}

Boolean IRO_IsConstant(IROLinear *linear) {
    if (linear->type == IROLinearOperand && ENODE_IS3(linear->u.node, EINTCONST, EVECTOR128CONST, EFLOATCONST))
        return 1;
    return 0;
}

Boolean IRO_IsPow2(IROLinear *linear, SInt32 *powvalue) {
    UInt32 desired;
    UInt32 value;
    SInt32 i;

    *powvalue = -1;
    if (linear->type == IROLinearOperand && linear->u.node->type == EINTCONST) {
        if (CTool_EndianReadWord32(&linear->u.node->data.intval.hi))
            return 0;

        desired = CInt64_GetULong(&linear->u.node->data.intval);
        value = 1;
        for (i = 0; i < 31; i++) {
            if (value == desired) {
                *powvalue = i;
                return 1;
            }
            value += value;
        }
    }

    return 0;
}

Boolean IRO_IsIntConstant(IROLinear *linear) {
    if (linear->type == IROLinearOperand && ENODE_IS(linear->u.node, EINTCONST))
        return 1;
    return 0;
}

Boolean IRO_IsFloatConstant(IROLinear *linear) {
    if (linear->type == IROLinearOperand && ENODE_IS(linear->u.node, EFLOATCONST))
        return 1;
    return 0;
}

Boolean IRO_IsVector128Constant(IROLinear *linear) {
    if (linear->type == IROLinearOperand && ENODE_IS(linear->u.node, EVECTOR128CONST))
        return 1;
    return 0;
}

Boolean IRO_IsAssignment(IROLinear *linear) {
    if (linear->type == IROLinearOp1Arg || linear->type == IROLinearOp2Arg) {
        if (IRO_IsAssignOp[linear->nodetype])
            return 1;
    }
    return 0;
}

static Boolean IRO_OperandsSame(ENode *a, ENode *b) {
    if (a->type == b->type) {
        switch (a->type) {
            case EINTCONST:
                return CInt64_Equal(a->data.intval, b->data.intval);
            case ESTRINGCONST:
                return 0;
            case EFLOATCONST:
                return a->data.floatval.value == b->data.floatval.value;
            case EVECTOR128CONST:
                return (a->data.vector128val.ul[0] == b->data.vector128val.ul[0]) &&
                        (a->data.vector128val.ul[1] == b->data.vector128val.ul[1]) &&
                        (a->data.vector128val.ul[2] == b->data.vector128val.ul[2]) &&
                        (a->data.vector128val.ul[3] == b->data.vector128val.ul[3]);
            case EOBJREF:
                return a->data.objref == b->data.objref;
        }
    }

    return 0;
}

Boolean IRO_TypesEqual(Type *a, Type *b) {
    if (IS_TYPE_BITFIELD(a)) {
        if (IS_TYPE_BITFIELD(b)) {
            if (
                (TYPE_BITFIELD(a)->bitfieldtype == TYPE_BITFIELD(b)->bitfieldtype) &&
                (TYPE_BITFIELD(a)->offset == TYPE_BITFIELD(b)->offset) &&
                (TYPE_BITFIELD(a)->bitlength == TYPE_BITFIELD(b)->bitlength))
                return 1;
        }
        return 0;
    }

    if (IS_TYPE_POINTER_ONLY(a) && IS_TYPE_POINTER_ONLY(b))
        return 1;

    return is_typeequal(a, b) != 0;
}

Type *IRO_UnsignedType(Type *type) {
    if (IS_TYPE_ENUM(type) || IS_TYPE_POINTER_ONLY(type)) {
        if (type->size == stunsignedchar.size)
            return TYPE(&stunsignedchar);
        if (type->size == stunsignedint.size)
            return TYPE(&stunsignedint);
        if (type->size == stunsignedshort.size)
            return TYPE(&stunsignedshort);
        if (type->size == stunsignedlong.size)
            return TYPE(&stunsignedlong);
        if (type->size == stunsignedlonglong.size)
            return TYPE(&stunsignedlonglong);
        CError_FATAL(281);
        return NULL;
    }

    if (!IS_TYPE_INT(type)) {
        CError_FATAL(287);
        return NULL;
    }

    if (type == TYPE(&stbool) || type == TYPE(&stwchar))
        return type;

    if (type == TYPE(&stchar) || type == TYPE(&stsignedchar) || type == TYPE(&stunsignedchar))
        return TYPE(&stunsignedchar);
    if (type == TYPE(&stsignedshort) || type == TYPE(&stunsignedshort))
        return TYPE(&stunsignedshort);
    if (type == TYPE(&stsignedint) || type == TYPE(&stunsignedint))
        return TYPE(&stunsignedint);
    if (type == TYPE(&stsignedlong) || type == TYPE(&stunsignedlong))
        return TYPE(&stunsignedlong);
    if (type == TYPE(&stsignedlonglong) || type == TYPE(&stunsignedlonglong))
        return TYPE(&stunsignedlonglong);

    CError_FATAL(319);
    return NULL;
}

Type *IRO_SignedType(Type *type) {
    if (IS_TYPE_ENUM(type) || IS_TYPE_POINTER_ONLY(type)) {
        if (type->size == stsignedchar.size)
            return TYPE(&stsignedchar);
        if (type->size == stsignedint.size)
            return TYPE(&stsignedint);
        if (type->size == stsignedshort.size)
            return TYPE(&stsignedshort);
        if (type->size == stsignedlong.size)
            return TYPE(&stsignedlong);
        if (type->size == stsignedlonglong.size)
            return TYPE(&stsignedlonglong);
        CError_FATAL(357);
        return NULL;
    }

    if (!IS_TYPE_INT(type)) {
        CError_FATAL(363);
        return NULL;
    }

    if (type == TYPE(&stbool) && type->size == stsignedchar.size)
        return TYPE(&stsignedchar);

    if (type == TYPE(&stwchar) && type->size == stsignedshort.size)
        return TYPE(&stsignedshort);

    if (type == TYPE(&stchar) || type == TYPE(&stsignedchar) || type == TYPE(&stunsignedchar))
        return TYPE(&stsignedchar);
    if (type == TYPE(&stsignedshort) || type == TYPE(&stunsignedshort))
        return TYPE(&stsignedshort);
    if (type == TYPE(&stsignedint) || type == TYPE(&stunsignedint))
        return TYPE(&stsignedint);
    if (type == TYPE(&stsignedlong) || type == TYPE(&stunsignedlong))
        return TYPE(&stsignedlong);
    if (type == TYPE(&stsignedlonglong) || type == TYPE(&stunsignedlonglong))
        return TYPE(&stsignedlonglong);

    CError_FATAL(399);
    return NULL;
}

Boolean IRO_is_CPtypeequal(Type *a, Type *b) {
    if (IS_TYPE_POINTER_ONLY(a) && IS_TYPE_POINTER_ONLY(b))
        return 1;

    return is_typeequal(a, b) != 0;
}

Boolean IRO_ExprsSame(IROLinear *a, IROLinear *b) {
    if (a->type == b->type && IRO_TypesEqual(a->rtype, b->rtype)) {
        switch (a->type) {
            case IROLinearOperand:
                return IRO_OperandsSame(a->u.node, b->u.node);
            case IROLinearOp1Arg:
                if (a->nodetype == b->nodetype)
                    return IRO_ExprsSame(a->u.monadic, b->u.monadic);
                return 0;
            case IROLinearOp2Arg:
                if (a->nodetype == b->nodetype)
                    return IRO_ExprsSame(a->u.diadic.left, b->u.diadic.left) &&
                    IRO_ExprsSame(a->u.diadic.right, b->u.diadic.right);
                return 0;
            case IROLinearOp3Arg:
                if (a->nodetype == b->nodetype)
                    return IRO_ExprsSame(a->u.args3.a, b->u.args3.a) &&
                           IRO_ExprsSame(a->u.args3.b, b->u.args3.b) &&
                            IRO_ExprsSame(a->u.args3.c, b->u.args3.c);
                return 0;
            case IROLinearFunccall:
                return 0;
            default:
                return 0;
        }
    }

    return 0;
}

CLabel *IRO_NewLabel(void) {
    CLabel *label = newlabel();
    label->next = Labels;
    Labels = label;
    return label;
}

Boolean IRO_ExprsSameSemantically(IROLinear *a, IROLinear *b) {
    if (a->type == b->type && IRO_TypesEqual(a->rtype, b->rtype)) {
        Boolean flag = 0;

        switch (a->type) {
            case IROLinearOperand:
                return IRO_OperandsSame(a->u.node, b->u.node);
            case IROLinearOp1Arg:
                if (a->nodetype == b->nodetype)
                    return IRO_ExprsSameSemantically(a->u.monadic, b->u.monadic);
                return 0;
            case IROLinearOp2Arg:
                if (a->nodetype == b->nodetype) {
                    switch (a->nodetype) {
                        case EMUL:
                        case EADD:
                        case EAND:
                        case EXOR:
                        case EOR:
                        case ELAND:
                        case ELOR:
                            if (!IRO_HasSideEffect(a)) {
                                flag = IRO_ExprsSameSemantically(a->u.diadic.left, b->u.diadic.right) &&
                                        IRO_ExprsSameSemantically(a->u.diadic.right, b->u.diadic.left);
                            }
                    }

                    return flag || (IRO_ExprsSameSemantically(a->u.diadic.left, b->u.diadic.left) &&
                            IRO_ExprsSameSemantically(a->u.diadic.right, b->u.diadic.right));
                }
                return 0;
            case IROLinearOp3Arg:
                if (a->nodetype == b->nodetype)
                    return IRO_ExprsSameSemantically(a->u.args3.a, b->u.args3.a) &&
                           IRO_ExprsSameSemantically(a->u.args3.b, b->u.args3.b) &&
                           IRO_ExprsSameSemantically(a->u.args3.c, b->u.args3.c);
                return 0;
            case IROLinearFunccall:
                return 0;
            default:
                return 0;
        }
    }

    return 0;
}

IROLinear *IRO_FindPrecedAfter(IROLinear *a, IROLinear *iter) {
    IROLinear *prev = iter;
    while (iter && iter != a) {
        prev = iter;
        iter = iter->next;
    }

    if (iter)
        return prev;
    return iter;
}

IROLinear *IRO_FindPreced(IROLinear *a) {
    IROLinear *iter;
    IROLinear *prev;

    prev = iter = IRO_FirstLinear;
    while (iter && iter != a) {
        prev = iter;
        iter = iter->next;
    }

    if (iter)
        return prev;
    return iter;
}

IROLinear *IRO_FindFirst(IROLinear *linear) {
    short i;

    switch (linear->type) {
        case IROLinearOperand:
            return linear;
        case IROLinearOp1Arg:
            return IRO_FindFirst(linear->u.monadic);
        case IROLinearOp2Arg:
            if (linear->u.diadic.right->index < linear->u.diadic.left->index)
                return IRO_FindFirst(linear->u.diadic.right);
            else
                return IRO_FindFirst(linear->u.diadic.left);
        case IROLinearOp3Arg:
            if (linear->u.args3.a->index < linear->u.args3.b->index) {
                if (linear->u.args3.b->index < linear->u.args3.c->index)
                    return IRO_FindFirst(linear->u.args3.a);
                else
                    return IRO_FindFirst(linear->u.args3.c);
            } else {
                if (linear->u.args3.b->index < linear->u.args3.c->index)
                    return IRO_FindFirst(linear->u.args3.b);
                else
                    return IRO_FindFirst(linear->u.args3.c);
            }
        case IROLinearFunccall:
            i = linear->u.funccall.argCount - 1;
            return IRO_FindFirst(linear->u.funccall.args[i]);
        default:
            CError_FATAL(641);
            return NULL;
    }
}

void IRO_CutAndPasteAfter(IROLinear *a, IROLinear *b, IROLinear *c) {
    IROLinear *preced = IRO_FindPreced(a);
    preced->next = b->next;
    b->next = c->next;
    c->next = a;
}

Boolean IRO_IsConstantZero(IROLinear *linear) {
    return (IRO_IsIntConstant(linear) && CInt64_IsZero(&linear->u.node->data.intval)) ||
            (IRO_IsFloatConstant(linear) && CMach_FloatIsZero(linear->u.node->data.floatval));
}

Boolean IRO_IsConstantOne(IROLinear *linear) {
    return (IRO_IsIntConstant(linear) && CInt64_IsOne(&linear->u.node->data.intval)) ||
           (IRO_IsFloatConstant(linear) && CMach_FloatIsOne(linear->u.node->data.floatval));
}

Boolean IRO_IsConstantNegativeOne(IROLinear *linear) {
    CInt64 neg = CInt64_Neg(linear->u.node->data.intval);
    return (IRO_IsIntConstant(linear) && CInt64_IsOne(&neg)) ||
           (IRO_IsFloatConstant(linear) && CMach_FloatIsNegOne(linear->u.node->data.floatval));
}

static void ActNop(IROLinear *linear, Boolean isEntry) {
    if (!isEntry) {
        linear->type = IROLinearNop;
        linear->expr = NULL;
    }
}

void IRO_NopOut(IROLinear *linear) {
    IRO_WalkTree(linear, ActNop);
}

static Boolean NotNoppable(IROLinear *linear) {
    return (
            (linear->type == IROLinearFunccall) ||
                    IRO_IsAssignment(linear) ||
                    ((linear->type == IROLinearOperand) && ENODE_IS(linear->u.node, EINSTRUCTION)) ||
                    (linear->rtype && CParser_IsVolatile(linear->rtype, linear->nodeflags & ENODE_FLAG_QUALS)) ||
                    ((linear->type == IROLinearOperand) && ENODE_IS(linear->u.node, EOBJREF) && is_volatile_object(linear->u.node->data.objref))
            );
}

static void ActNopNonSideEffects(IROLinear *linear, Boolean isEntry) {
    if (isEntry) {
        if (NotNoppable(linear)) {
            if (!FuncLevel)
                linear->flags &= ~IROLF_Reffed;
            FuncLevel++;
        }
    } else {
        if (NotNoppable(linear)) {
            FuncLevel--;
        } else if (!FuncLevel) {
            linear->type = IROLinearNop;
        }
    }
}

void IRO_NopNonSideEffects(IROLinear *linear, SInt32 level) {
    FuncLevel = level;
    IRO_WalkTree(linear, ActNopNonSideEffects);
}

void IRO_BuildList(IROLinear *linear, Boolean isEntry) {
    if (!isEntry) {
        linear->next = NULL;
        IRO_AddToList(linear, &IRO_InitLList);
    }
}

void IRO_WalkTree(IROLinear *linear, IROWalkTreeFunc func) {
    int i;

    func(linear, 1);
    switch (linear->type) {
        case IROLinearOperand:
            break;
        case IROLinearOp1Arg:
            IRO_WalkTree(linear->u.monadic, func);
            break;
        case IROLinearOp2Arg:
            IRO_WalkTree(linear->u.diadic.left, func);
            IRO_WalkTree(linear->u.diadic.right, func);
            break;
        case IROLinearOp3Arg:
            IRO_WalkTree(linear->u.args3.a, func);
            IRO_WalkTree(linear->u.args3.b, func);
            IRO_WalkTree(linear->u.args3.c, func);
            break;
        case IROLinearFunccall:
            IRO_WalkTree(linear->u.funccall.linear8, func);
            for (i = 0; i < linear->u.funccall.argCount; i++)
                IRO_WalkTree(linear->u.funccall.args[i], func);
            break;
    }
    func(linear, 0);
}

void IRO_WalkTreeToPropagateFlags(IROLinear *linear, IROWalkTreeFunc func) {
    int i;

    switch (linear->type) {
        case IROLinearOperand:
            break;
        case IROLinearOp1Arg:
            IRO_WalkTreeToPropagateFlags(linear->u.monadic, func);
            break;
        case IROLinearOp2Arg:
            IRO_WalkTreeToPropagateFlags(linear->u.diadic.left, func);
            IRO_WalkTreeToPropagateFlags(linear->u.diadic.right, func);
            break;
        case IROLinearOp3Arg:
            IRO_WalkTreeToPropagateFlags(linear->u.args3.a, func);
            IRO_WalkTreeToPropagateFlags(linear->u.args3.b, func);
            IRO_WalkTreeToPropagateFlags(linear->u.args3.c, func);
            break;
        case IROLinearFunccall:
            IRO_WalkTreeToPropagateFlags(linear->u.funccall.linear8, func);
            for (i = 0; i < linear->u.funccall.argCount; i++)
                IRO_WalkTreeToPropagateFlags(linear->u.funccall.args[i], func);
            break;
    }
    func(linear, 0);
}

void IRO_WalkInts(IROLinear *a, IROLinear *b, IROWalkTreeFunc func) {
    IROLinear *scan;

    for (scan = a; scan; scan = scan->next) {
        switch (scan->type) {
            case IROLinearBeginCatch:
            case IROLinearEndCatch:
            case IROLinearEndCatchDtor:
                IRO_WalkTree(scan->u.ctch.linear, func);
                break;
            case IROLinearOperand:
            case IROLinearOp1Arg:
            case IROLinearOp2Arg:
            case IROLinearOp3Arg:
            case IROLinearFunccall:
                IRO_WalkTree(scan, func);
                break;
            case IROLinearIf:
            case IROLinearIfNot:
                IRO_WalkTree(scan->u.label.x4, func);
                break;
            case IROLinearReturn:
                if (scan->u.monadic)
                    IRO_WalkTree(scan->u.monadic, func);
                break;
            case IROLinearSwitch:
                IRO_WalkTree(scan->u.swtch.x4, func);
                break;
            case IROLinearAsm:
                func(scan, 1);
                func(scan, 0);
                break;
            case IROLinearEnd:
                break;
        }

        if (scan == b)
            break;
    }
}

void IRO_Cut(IROLinear *a, IROLinear *b) {
    IROLinear *scan;
    IROLinear *prev;
    IRONode *node;

    scan = a;
    while (1) {
        scan->stmt = NULL;
        if (scan == b)
            break;
        scan = scan->next;
    }

    prev = NULL;
    for (scan = IRO_FirstLinear; scan && scan != a; scan = scan->next)
        prev = scan;

    CError_ASSERT(951, scan);

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        if (node->first == a) {
            if (node->last == b) {
                node->first = node->last = NULL;
                break;
            } else {
                node->first = b->next;
                break;
            }
        } else if (node->last == b) {
            node->last = prev;
            break;
        }
    }

    if (prev)
        prev->next = b->next;
    else
        IRO_FirstLinear = b->next;
}

void IRO_Paste(IROLinear *a, IROLinear *b, IROLinear *c) {
    IROLinear *prev;
    IROLinear *scan;
    IRONode *node;

    CError_ASSERT(1002, c && c->type != IROLinearLabel);

    prev = NULL;
    for (scan = IRO_FirstLinear; scan && scan != c; scan = scan->next)
        prev = scan;

    CError_ASSERT(1016, scan);

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        if (node->first == c) {
            node->first = a;
            break;
        }
    }

    b->next = c;
    if (prev)
        prev->next = a;
    else
        IRO_FirstLinear = a;
}

void IRO_PasteAfter(IROLinear *a, IROLinear *b, IROLinear *c) {
    IRONode *node;

    switch (c->type) {
        case IROLinearGoto:
        case IROLinearIf:
        case IROLinearIfNot:
        case IROLinearSwitch:
            CError_FATAL(1060);
    }

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        if (node->last == c) {
            node->last = b;
            break;
        }
    }

    b->next = c->next;
    c->next = a;
}

static void FindStart(IROLinear *linear, Boolean isEntry) {
    IROLinear *scan;
    if (isEntry) {
        scan = linear;
        do {
            if (scan == ExprStart) {
                ExprStart = linear;
                return;
            }
            if (scan == ExprEnd)
                return;
        } while ((scan = scan->next));
    }
}

void IRO_ClipExpr(IROExpr *expr) {
    ExprStart = ExprEnd = expr->linear;
    IRO_WalkTree(expr->linear, FindStart);
    IRO_Cut(ExprStart, ExprEnd);
}

void IRO_ClipExprTree(IROLinear *linear) {
    ExprStart = ExprEnd = linear;
    IRO_WalkTree(linear, FindStart);
    IRO_Cut(ExprStart, ExprEnd);
}

static void SetNodeNumInExprList(IROLinear *linear, Boolean isEntry) {
    if (isEntry && linear->expr)
        linear->expr->node = IRO_Node;
}

void IRO_MoveExpression(IROExpr *expr, IROLinear *linear) {
    IRONode *node;
    IROLinear *scan;

    ExprStart = ExprEnd = expr->linear;
    IRO_WalkTree(expr->linear, FindStart);

    if (ExprStart != linear) {
        IRO_Cut(ExprStart, ExprEnd);
        IRO_Paste(ExprStart, ExprEnd, linear);
        for (node = IRO_FirstNode; node; node = node->nextnode) {
            for (scan = node->first; scan; scan = scan->next) {
                if (scan == expr->linear) {
                    expr->node = node;
                    break;
                }
                if (scan == node->last)
                    break;
            }
        }

        IRO_Node = expr->node;
        IRO_WalkTree(expr->linear, SetNodeNumInExprList);
    }
}

void IRO_InitList(IROList *list) {
    list->head = list->tail = NULL;
}

void IRO_AddToList(IROLinear *linear, IROList *list) {
    if (list->head)
        list->tail->next = linear;
    else
        list->head = linear;

    list->tail = linear;
    while (list->tail->next)
        list->tail = list->tail->next;
}

IROLinear *IRO_FindLabelNode(CLabel *label, IROLinear *linear) {
    IROLinear *scan;

    for (scan = linear; scan; scan = scan->next) {
        if (scan->type == IROLinearLabel && scan->u.label.label == label)
            break;
    }

    CError_ASSERT(1244, scan);
    return scan;
}

void IRO_DuplicateExprRange(IROLinear *start, IROLinear *end, IROList *list) {
    IROLinear *scan;

    for (scan = start; scan; scan = scan->next) {
        if (scan->type != IROLinearNop && !(scan->flags & IROLF_Reffed))
            IRO_DuplicateExpr(scan, list);
        if (scan == end)
            break;
    }
}

IROLinear *IRO_DuplicateExpr(IROLinear *linear, IROList *list) {
    IROLinear *copy;
    ENode *copynode;
    int i;

    copy = IRO_NewLinear(linear->type);
    *copy = *linear;

    copy->index = ++IRO_NumLinear;
    copy->next = NULL;
    copy->expr = NULL;

    switch (copy->type) {
        case IROLinearOperand:
            copynode = lalloc(sizeof(ENode));
            *copynode = *linear->u.node;
            copy->u.node = copynode;
            break;
        case IROLinearOp1Arg:
            copy->u.monadic = IRO_DuplicateExpr(copy->u.monadic, list);
            break;
        case IROLinearOp2Arg:
            if (linear->flags & IROLF_8000) {
                copy->u.diadic.right = IRO_DuplicateExpr(copy->u.diadic.right, list);
                copy->u.diadic.left = IRO_DuplicateExpr(copy->u.diadic.left, list);
            } else {
                copy->u.diadic.left = IRO_DuplicateExpr(copy->u.diadic.left, list);
                copy->u.diadic.right = IRO_DuplicateExpr(copy->u.diadic.right, list);
            }
            break;
        case IROLinearOp3Arg:
            copy->u.args3.a = IRO_DuplicateExpr(copy->u.args3.a, list);
            copy->u.args3.b = IRO_DuplicateExpr(copy->u.args3.b, list);
            copy->u.args3.c = IRO_DuplicateExpr(copy->u.args3.c, list);
            break;
        case IROLinearFunccall:
            copy->u.funccall.linear8 = IRO_DuplicateExpr(copy->u.funccall.linear8, list);
            copy->u.funccall.args = oalloc(sizeof(IROLinear *) * copy->u.funccall.argCount);
            for (i = 0; i < copy->u.funccall.argCount; i++) {
                copy->u.funccall.args[i] = IRO_DuplicateExpr(linear->u.funccall.args[i], list);
            }
            break;
        case IROLinearAsm:
            copy->u.asm_stmt = CodeGen_CopyAsmStat(linear->u.asm_stmt);
            break;
    }

    IRO_AddToList(copy, list);
    return copy;
}

IROLinear *IRO_TempReference(Object *obj, IROList *list) {
    IROLinear *op;
    IROLinear *ind;

    op = IRO_NewLinear(IROLinearOperand);
    op->u.node = create_objectrefnode(obj);
    op->rtype = op->u.node->data.objref->type;
    op->index = ++IRO_NumLinear;
    op->flags |= IROLF_Reffed | IROLF_Ind;
    IRO_AddToList(op, list);

    ind = IRO_NewLinear(IROLinearOp1Arg);
    ind->nodetype = EINDIRECT;
    ind->rtype = obj->type;
    ind->u.monadic = op;
    ind->index = ++IRO_NumLinear;
    ind->next = NULL;
    IRO_AddToList(ind, list);

    return ind;
}

CW_INLINE IROLinear *LocateFatherHelper(IROLinear *linear, Boolean a, IROLinear ***b) {
    IROLinear *scan;
    SInt32 index;
    int i;

    for (scan = linear->next, index = 0; index < (a ? 2 : 1); index++) {
        while (scan) {
            switch (scan->type) {
                case IROLinearIf:
                case IROLinearIfNot:
                    if (scan->u.label.x4 == linear) {
                        if (b)
                            *b = &scan->u.label.x4;
                        return scan;
                    }
                    break;
                case IROLinearReturn:
                    if (scan->u.monadic == linear) {
                        if (b)
                            *b = &scan->u.monadic;
                        return scan;
                    }
                    break;
                case IROLinearOp1Arg:
                    if (scan->u.monadic == linear) {
                        if (b)
                            *b = &scan->u.monadic;
                        return scan;
                    }
                    break;
                case IROLinearSwitch:
                    if (scan->u.swtch.x4 == linear) {
                        if (b)
                            *b = &scan->u.swtch.x4;
                        return scan;
                    }
                    break;
                case IROLinearOp2Arg:
                    if (scan->u.diadic.left == linear) {
                        if (b)
                            *b = &scan->u.diadic.left;
                        return scan;
                    }
                    if (scan->u.diadic.right == linear) {
                        if (b)
                            *b = &scan->u.diadic.right;
                        return scan;
                    }
                    break;
                case IROLinearOp3Arg:
                    if (scan->u.args3.a == linear) {
                        if (b)
                            *b = &scan->u.args3.a;
                        return scan;
                    }
                    if (scan->u.args3.b == linear) {
                        if (b)
                            *b = &scan->u.args3.b;
                        return scan;
                    }
                    if (scan->u.args3.c == linear) {
                        if (b)
                            *b = &scan->u.args3.c;
                        return scan;
                    }
                    break;
                case IROLinearFunccall:
                    if (scan->u.funccall.linear8 == linear) {
                        if (b)
                            *b = &scan->u.funccall.linear8;
                        return scan;
                    }
                    for (i = 0; i < scan->u.funccall.argCount; i++) {
                        if (scan->u.funccall.args[i] == linear) {
                            if (b)
                                *b = &scan->u.funccall.args[i];
                            return scan;
                        }
                    }
                    break;
                case IROLinearNop:
                case IROLinearOperand:
                case IROLinearGoto:
                case IROLinearLabel:
                case IROLinearEntry:
                case IROLinearExit:
                case IROLinearBeginCatch:
                case IROLinearEndCatch:
                case IROLinearEndCatchDtor:
                case IROLinearAsm:
                case IROLinearEnd:
                    break;
                default:
                    CError_FATAL(1536);
            }
            scan = scan->next;
        }

        scan = IRO_FirstLinear;
    }

    if (b)
        *b = NULL;
    return NULL;
}

IROLinear *IRO_LocateFather(IROLinear *linear) {
    return LocateFatherHelper(linear, 0, NULL);
}

IROLinear *IRO_LocateFather_Cut_And_Paste(IROLinear *a, IROLinear *b) {
    IROLinear **p;
    IROLinear *l = LocateFatherHelper(a, 0, &p);
    if (l) {
        CError_ASSERT(1568, p && *p);
        IRO_NopOut(a);
        *p = b;
    }
    return l;
}

IROLinear *IRO_LocateFather_Cut_And_Paste_Without_Nopping(IROLinear *a, IROLinear *b) {
    IROLinear **p;
    IROLinear *l = LocateFatherHelper(a, 0, &p);
    if (l) {
        CError_ASSERT(1585, p && *p);
        *p = b;
    }
    return l;
}

void IRO_ReplaceReference(IROLinear *a, Object *obj, IROLinear *b) {
    IROLinear **ptr;
    IROList list;

    if (LocateFatherHelper(a, 1, &ptr)) {
        CError_ASSERT(1605, ptr && *ptr);
        IRO_InitList(&list);
        *ptr = IRO_TempReference(obj, &list);
        IRO_PasteAfter(list.head, list.tail, b);
        if (a->flags & IROLF_LoopInvariant)
            list.tail->flags |= IROLF_LoopInvariant;
    } else {
        IRO_Dump("Oh, oh, did not find reference to replace\n");
    }
}

void IRO_ReplaceReferenceWithNode(IROLinear *a, IROLinear *b) {
    IROLinear **ptr;
    IROList list;

    if (LocateFatherHelper(a, 1, &ptr)) {
        CError_ASSERT(1664, ptr && *ptr);
        *ptr = b;
        b->flags |= IROLF_Reffed;
    } else {
        IRO_Dump("Oh, oh, did not find reference to replace\n");
    }
}

VarRecord *IRO_GetTemp(IROExpr *expr) {
    expr->x8 = create_temp_object(expr->linear->rtype);
    return IRO_FindVar(expr->x8, 1, 1);
}

IROLinear *IRO_AssignToTemp(IROExpr *expr) {
    IROLinear *objref;
    IROLinear *ind;
    IROLinear *ass;

    objref = IRO_NewLinear(IROLinearOperand);
    objref->u.node = create_objectrefnode(expr->x8);
    objref->rtype = objref->u.node->data.objref->type;
    objref->index = ++IRO_NumLinear;
    objref->flags |= IROLF_Reffed | IROLF_Assigned | IROLF_Ind;

    ind = IRO_NewLinear(IROLinearOp1Arg);
    ind->nodetype = EINDIRECT;
    ind->rtype = expr->linear->rtype;
    ind->u.monadic = objref;
    ind->index = ++IRO_NumLinear;
    ind->flags |= IROLF_Reffed | IROLF_Assigned;

    ass = IRO_NewLinear(IROLinearOp2Arg);
    ass->nodetype = EASS;
    ass->u.diadic.left = ind;
    ass->u.diadic.right = expr->linear;
    ass->rtype = expr->linear->rtype;
    ass->index = ++IRO_NumLinear;

    objref->next = ind;
    ind->next = ass;
    IRO_PasteAfter(objref, ass, expr->linear);
    return ass;
}

IROLinear *IRO_FindStart(IROLinear *linear) {
    ExprStart = ExprEnd = linear;
    IRO_WalkTree(linear, FindStart);
    return ExprStart;
}

void IRO_DeleteCommaNode(IROLinear *linear, IROExpr *expr) {
    IROLinear *scan;
    for (scan = linear; scan; scan = scan->next) {
        if (scan->nodetype == ECOMMA) {
            if (scan != expr->linear) {
                IRO_NopOut(scan->u.diadic.left);
                IRO_LocateFather_Cut_And_Paste(scan, scan->u.diadic.right);
            } else {
                IRO_NopOut(scan->u.diadic.left);
                expr->linear = scan->u.diadic.right;
            }
        }
    }
}

void IRO_RemoveCommaNodeFromIR(void) {
    IRONode *node;
    IROLinear *linear;

    for (node = IRO_FirstNode; node; node = node->nextnode) {
        linear = node->first;
        do {
            if (!linear)
                break;
            if (linear->nodetype == ECOMMA) {
                linear->u.diadic.left->flags = linear->u.diadic.left->flags & ~IROLF_Reffed;
                IRO_LocateFather_Cut_And_Paste_Without_Nopping(linear, linear->u.diadic.right);
                linear->type = IROLinearNop;
            }
            linear = linear->next;
        } while (linear != node->last);
    }
}

IROAddrRecord *IRO_InitAddrRecordPointer(IROLinear *linear) {
    IROAddrRecord *rec = oalloc(sizeof(IROAddrRecord));
    rec->numObjRefs = 0;
    rec->objRefs = NULL;
    rec->numMisc = 0;
    rec->misc = NULL;
    rec->numInts = 0;
    rec->ints = NULL;
    rec->x16 = 0;
    rec->linear = linear;
    return rec;
}

IROLinear *IRO_HasSideEffect(IROLinear *linear) {
    IROLinear *tmp;

    if (!linear)
        return linear;

    if (linear->rtype && CParser_IsVolatile(linear->rtype, linear->nodeflags & ENODE_FLAG_QUALS))
        return linear;

    switch (linear->type) {
        case IROLinearAsm:
            return linear;
        case IROLinearOperand:
            if (ENODE_IS(linear->u.node, EOBJREF) && is_volatile_object(linear->u.node->data.objref))
                return linear;
            return NULL;
        case IROLinearOp1Arg:
            if (IRO_IsAssignOp[linear->nodetype])
                return linear;
            else
                return IRO_HasSideEffect(linear->u.monadic);
        case IROLinearOp2Arg:
            if (IRO_IsAssignOp[linear->nodetype])
                return linear;
            else if ((tmp = IRO_HasSideEffect(linear->u.diadic.left)))
                return tmp;
            else
                return IRO_HasSideEffect(linear->u.diadic.right);
        case IROLinearOp3Arg:
            if ((tmp = IRO_HasSideEffect(linear->u.args3.a)))
                return tmp;
            else if ((tmp = IRO_HasSideEffect(linear->u.args3.b)))
                return tmp;
            else
                return IRO_HasSideEffect(linear->u.args3.c);
        case IROLinearFunccall:
            return linear;
        default:
            return linear;
    }
}

IROLinear *IRO_CheckSideEffect(IROLinear *linear) {
    IROLinear *result;
    IROLinear *tmp;
    IROLinear *tmp2;
    IROLinear *tmp3;

    if (!linear)
        return linear;

    if (linear->rtype && CParser_IsVolatile(linear->rtype, linear->nodeflags & ENODE_FLAG_QUALS)) {
        linear->flags &= ~IROLF_Reffed;
        return linear;
    }

    result = NULL;
    switch (linear->type) {
        case IROLinearAsm:
            linear->flags &= ~IROLF_Reffed;
            return linear;
        case IROLinearOperand:
            if (ENODE_IS(linear->u.node, EOBJREF) && is_volatile_object(linear->u.node->data.objref)) {
                linear->flags &= ~IROLF_Reffed;
                return linear;
            }
            break;
        case IROLinearOp1Arg:
            if (IRO_IsAssignOp[linear->nodetype]) {
                linear->flags &= ~IROLF_Reffed;
                return linear;
            }
            if ((result = IRO_CheckSideEffect(linear->u.monadic))) {
                if (linear->nodetype == EINDIRECT && linear->u.monadic->type == IROLinearOperand) {
                    linear->flags &= ~IROLF_Reffed;
                    return linear;
                }
            }
            break;
        case IROLinearOp2Arg:
            if (IRO_IsAssignOp[linear->nodetype]) {
                linear->flags &= ~IROLF_Reffed;
                return linear;
            }
            tmp = IRO_CheckSideEffect(linear->u.diadic.left);
            tmp2 = IRO_CheckSideEffect(linear->u.diadic.right);
            if (tmp)
                result = tmp;
            else
                result = tmp2;
            break;
        case IROLinearOp3Arg:
            tmp = IRO_CheckSideEffect(linear->u.args3.a);
            tmp2 = IRO_CheckSideEffect(linear->u.args3.b);
            tmp3 = IRO_CheckSideEffect(linear->u.args3.c);
            result = tmp ? tmp : tmp2 ? tmp2 : tmp3;
            break;
        case IROLinearFunccall:
            linear->flags &= ~IROLF_Reffed;
            return linear;
        default:
            return linear;
    }

    linear->type = IROLinearNop;
    IRO_Dump("Nop out with side-effects checking at: %d\n", linear->index);
    return result;
}

void IRO_WalkExcActions(ExceptionAction *action, WalkObjFunc func) {
    while (action) {
        switch (action->type) {
            case EAT_DESTROYLOCAL:
                func(action->data.destroy_local.local);
                break;
            case EAT_DESTROYLOCALCOND:
                func(action->data.destroy_local_cond.local);
                func(action->data.destroy_local_cond.cond);
                break;
            case EAT_DESTROYLOCALOFFSET:
                func(action->data.destroy_local_offset.local);
                break;
            case EAT_DESTROYLOCALPOINTER:
                func(action->data.destroy_local_pointer.pointer);
                break;
            case EAT_DESTROYLOCALARRAY:
                func(action->data.destroy_local_array.localarray);
                break;
            case EAT_DESTROYPARTIALARRAY:
                func(action->data.destroy_partial_array.arraypointer);
                func(action->data.destroy_partial_array.arraycounter);
                func(action->data.destroy_partial_array.element_size);
                break;
            case EAT_DESTROYBASE:
                func(action->data.destroy_member.objectptr); // wrong union?
                break;
            case EAT_DESTROYMEMBER:
                func(action->data.destroy_member.objectptr);
                break;
            case EAT_DESTROYMEMBERCOND:
                func(action->data.destroy_member_cond.objectptr);
                func(action->data.destroy_member_cond.cond);
                break;
            case EAT_DESTROYMEMBERARRAY:
                func(action->data.destroy_member_array.objectptr);
                break;
            case EAT_DELETEPOINTER:
                func(action->data.delete_pointer.pointerobject);
                break;
            case EAT_DELETEPOINTERCOND:
                func(action->data.delete_pointer_cond.pointerobject);
                func(action->data.delete_pointer_cond.cond);
                break;
        }
        action = action->prev;
    }
}

Boolean IRO_FunctionCallMightThrowException(IROLinear *linear) {
    Object *obj;
    if (linear->type == IROLinearFunccall) {
        obj = NULL;
        if (linear->u.funccall.linear8->type == IROLinearOperand && ENODE_IS(linear->u.funccall.linear8->u.node, EOBJREF))
            obj = linear->u.funccall.linear8->u.node->data.objref;
        if (!obj || CExcept_CanThrowException(obj, obj->datatype == DVFUNC && !(linear->nodeflags & ENODE_FLAG_80)))
            return 1;
    }
    return 0;
}

IROLinear *IRO_NewIntConst(CInt64 val, Type *type) {
    ENode *node;
    IROLinear *linear;

    node = IRO_NewENode(EINTCONST);
    node->data.intval = val;
    node->rtype = type;

    linear = IRO_NewLinear(IROLinearOperand);
    linear->index = ++IRO_NumLinear;
    linear->rtype = type;
    linear->u.node = node;
    return linear;
}

IROLinear *IRO_NewFloatConst(const Float val, Type *type) {
    ENode *node;
    IROLinear *linear;

    node = IRO_NewENode(EFLOATCONST);
    node->data.floatval = val;
    node->rtype = type;

    linear = IRO_NewLinear(IROLinearOperand);
    linear->index = ++IRO_NumLinear;
    linear->rtype = type;
    linear->u.node = node;
    return linear;
}

Boolean IRO_IsAddressMultiply(IROLinear *linear) {
    return 0;
}

void IRO_SetupForUserBreakChecking(void) {
    IRO_LastUserBreakTick = 0;
}

void IRO_CheckForUserBreak(void) {
    if (IRO_LastUserBreakTick + 8 < COS_GetTicks()) {
        if (CWUserBreak(cparams.context))
            CError_UserBreak();
        IRO_LastUserBreakTick = COS_GetTicks();
    }
}