コード例 #1
0
        private static bool HasSharedTarget(NodeBlock pred, DJumpCondition jcc)
        {
            NodeBlock trueTarget = BlockAnalysis.EffectiveTarget(jcc.trueTarget);

            if (trueTarget.lir.numPredecessors == 1)
            {
                return(false);
            }
            if (pred.lir.idominated.Length > 3)
            {
                return(true);
            }

            // Hack... sniff out the case we care about, the true target
            // probably having a conditional.
            if (trueTarget.lir.instructions.Length == 2 &&
                trueTarget.lir.instructions[0].op == Opcode.Constant &&
                trueTarget.lir.instructions[1].op == Opcode.Jump)
            {
                return(true);
            }

            // Because of edge splitting, there will always be at least 4
            // dominators for the immediate dominator of a shared block.
            return(false);
        }
コード例 #2
0
        private void writeDoWhileLoop(WhileLoop loop)
        {
            outputLine("do" + Environment.NewLine + "{");
            increaseIndent();
            if (loop.body != null)
            {
                writeBlock(loop.body);
            }

            string cond;

            if (loop.logic == null)
            {
                writeStatements(loop.source);
                decreaseIndent();

                DJumpCondition jcc = (DJumpCondition)loop.source.nodes.last;
                cond = buildExpression(jcc.getOperand(0));
            }
            else
            {
                decreaseIndent();
                cond = buildLogicChain(loop.logic);
            }

            outputLine("}");
            outputLine("while (" + cond + ");");
            if (loop.join != null)
            {
                writeBlock(loop.join);
            }
        }
コード例 #3
0
 public override void visit(DJumpCondition jcc)
 {
     if (jcc.getOperand(0).type == NodeType.Binary)
     {
         DBinary binary = (DBinary)jcc.getOperand(0);
         propagateInputs(binary.lhs, binary.rhs);
     }
 }
コード例 #4
0
        private void writeIf(IfBlock block)
        {
            string cond;

            if (block.logic == null)
            {
                writeStatements(block.source);

                DJumpCondition jcc = (DJumpCondition)block.source.nodes.last;

                if (block.invert)
                {
                    if (jcc.getOperand(0).type == NodeType.Unary &&
                        ((DUnary)jcc.getOperand(0)).spop == SPOpcode.not)
                    {
                        cond = buildExpression(jcc.getOperand(0).getOperand(0));
                    }
                    else if (jcc.getOperand(0).type == NodeType.Load)
                    {
                        cond = "!" + buildExpression(jcc.getOperand(0));
                    }
                    else
                    {
                        cond = "!(" + buildExpression(jcc.getOperand(0)) + ")";
                    }
                }
                else
                {
                    cond = buildExpression(jcc.getOperand(0));
                }
            }
            else
            {
                cond = buildLogicChain(block.logic);
                Debug.Assert(!block.invert);
            }

            outputLine("if (" + cond + ")");
            outputLine("{");
            increaseIndent();
            writeBlock(block.trueArm);
            decreaseIndent();
            if (block.falseArm != null &&
                BlockAnalysis.GetEmptyTarget(block.falseArm.source) == null)
            {
                outputLine("}");
                outputLine("else");
                outputLine("{");
                increaseIndent();
                writeBlock(block.falseArm);
                decreaseIndent();
            }
            outputLine("}");
            if (block.join != null)
            {
                writeBlock(block.join);
            }
        }
コード例 #5
0
        private IfBlock traverseIf(NodeBlock block, DJumpCondition jcc)
        {
            if (HasSharedTarget(block, jcc))
            {
                return(traverseComplexIf(block, jcc));
            }

            NodeBlock trueTarget  = (jcc.spop == SPOpcode.jzer) ? jcc.falseTarget : jcc.trueTarget;
            NodeBlock falseTarget = (jcc.spop == SPOpcode.jzer) ? jcc.trueTarget : jcc.falseTarget;
            NodeBlock joinTarget  = findJoinOfSimpleIf(block, jcc);

            // If there is no join block (both arms terminate control flow),
            // eliminate one arm and use the other as a join point.
            if (joinTarget == null)
            {
                joinTarget = falseTarget;
            }

            // If the false target is equivalent to the join point, eliminate
            // it.
            if (BlockAnalysis.EffectiveTarget(falseTarget) == joinTarget)
            {
                falseTarget = null;
            }

            // If the true target is equivalent to the join point, promote
            // the false target to the true target and undo the inversion.
            bool invert = false;

            if (BlockAnalysis.EffectiveTarget(trueTarget) == joinTarget)
            {
                trueTarget  = falseTarget;
                falseTarget = null;
                invert     ^= true;
            }

            // If there is always a true target and a join target.
            pushScope(joinTarget);
            ControlBlock trueArm = traverseBlock(trueTarget);

            popScope();

            ControlBlock joinArm = traverseJoin(joinTarget);

            if (falseTarget == null)
            {
                return(new IfBlock(block, invert, trueArm, joinArm));
            }

            pushScope(joinTarget);
            ControlBlock falseArm = traverseBlock(falseTarget);

            popScope();

            return(new IfBlock(block, invert, trueArm, falseArm, joinArm));
        }
コード例 #6
0
        private ControlBlock traverseLoop(NodeBlock block)
        {
            DNode last = block.nodes.last;

            NodeBlock  effectiveHeader = block;
            LogicChain chain           = null;

            if (last.type == NodeType.JumpCondition)
            {
                DJumpCondition jcc = (DJumpCondition)last;
                if (HasSharedTarget(block, jcc))
                {
                    chain = buildLogicChain(block, null, out effectiveHeader);
                }
            }

            last = effectiveHeader.nodes.last;
            //Debug.Assert(last.type == NodeType.JumpCondition);

            if (last.type == NodeType.JumpCondition)
            {
                // Assert that the backedge is a straight jump.
                //Debug.Assert(BlockAnalysis.GetSingleTarget(graph_[block.lir.backedge.id]) == block);

                NodeBlock    join, body, cond;
                ControlType  type    = findLoopJoinAndBody(block, effectiveHeader, out join, out body, out cond);
                ControlBlock joinArm = traverseBlock(join);

                ControlBlock bodyArm = null;
                if (body != null)
                {
                    pushScope(block);
                    pushScope(cond);
                    bodyArm = traverseBlockNoLoop(body);
                    popScope();
                    popScope();
                }

                if (chain != null)
                {
                    return(new WhileLoop(type, chain, bodyArm, joinArm));
                }
                return(new WhileLoop(type, cond, bodyArm, joinArm));
            }

            return(null);
        }
コード例 #7
0
 private NodeBlock findJoinOfSimpleIf(NodeBlock block, DJumpCondition jcc)
 {
     //Debug.Assert(block.nodes.last == jcc);
     //Debug.Assert(block.lir.idominated[0] == jcc.falseTarget.lir || block.lir.idominated[0] == jcc.trueTarget.lir);
     //Debug.Assert(block.lir.idominated[1] == jcc.falseTarget.lir || block.lir.idominated[1] == jcc.trueTarget.lir);
     if (block.lir.idominated.Length == 2)
     {
         if (jcc.trueTarget != BlockAnalysis.EffectiveTarget(jcc.trueTarget))
         {
             return(jcc.trueTarget);
         }
         if (jcc.falseTarget != BlockAnalysis.EffectiveTarget(jcc.falseTarget))
         {
             return(jcc.falseTarget);
         }
         return(null);
     }
     return(graph_[block.lir.idominated[2].id]);
 }
コード例 #8
0
        private static LogicOperator ToLogicOp(DJumpCondition jcc)
        {
            NodeBlock trueTarget     = BlockAnalysis.EffectiveTarget(jcc.trueTarget);
            bool      targetIsTruthy = false;

            if (trueTarget.lir.instructions[0] is LConstant)
            {
                LConstant constant = (LConstant)trueTarget.lir.instructions[0];
                targetIsTruthy = (constant.val == 1);
            }

            // jump on true -> 1 == ||
            // jump on false -> 0 == &&
            // other combinations are nonsense, so assert.
            ////Debug.Assert((jcc.spop == SPOpcode.jnz && targetIsTruthy) ||
            //             (jcc.spop == SPOpcode.jzer && !targetIsTruthy));
            LogicOperator logicop = (jcc.spop == SPOpcode.jnz && targetIsTruthy)
                                    ? LogicOperator.Or
                                    : LogicOperator.And;

            return(logicop);
        }
コード例 #9
0
ファイル: TypePropagation.cs プロジェクト: not1ce111/Spedit
 public override void visit(DJumpCondition jcc)
 {
     jcc.typeSet.addType(new TypeUnit(new PawnType(CellType.Bool)));
 }
コード例 #10
0
ファイル: TypePropagation.cs プロジェクト: not1ce111/Spedit
 public override void visit(DJumpCondition jcc)
 {
     if (jcc.getOperand(0).type == NodeType.Binary)
     {
         DBinary binary = (DBinary)jcc.getOperand(0);
         propagateInputs(binary.lhs, binary.rhs);
     }
 }
コード例 #11
0
ファイル: SourceStructure.cs プロジェクト: not1ce111/Spedit
        private IfBlock traverseIf(NodeBlock block, DJumpCondition jcc)
        {
            if (HasSharedTarget(block, jcc))
                return traverseComplexIf(block, jcc);

            NodeBlock trueTarget = (jcc.spop == SPOpcode.jzer) ? jcc.falseTarget : jcc.trueTarget;
            NodeBlock falseTarget = (jcc.spop == SPOpcode.jzer) ? jcc.trueTarget : jcc.falseTarget;
            NodeBlock joinTarget = findJoinOfSimpleIf(block, jcc);

            // If there is no join block (both arms terminate control flow),
            // eliminate one arm and use the other as a join point.
            if (joinTarget == null)
                joinTarget = falseTarget;

            // If the false target is equivalent to the join point, eliminate
            // it.
            if (BlockAnalysis.EffectiveTarget(falseTarget) == joinTarget)
                falseTarget = null;

            // If the true target is equivalent to the join point, promote
            // the false target to the true target and undo the inversion.
            bool invert = false;
            if (BlockAnalysis.EffectiveTarget(trueTarget) == joinTarget)
            {
                trueTarget = falseTarget;
                falseTarget = null;
                invert ^= true;
            }

            // If there is always a true target and a join target.
            pushScope(joinTarget);
            ControlBlock trueArm = traverseBlock(trueTarget);
            popScope();

            ControlBlock joinArm = traverseJoin(joinTarget);
            if (falseTarget == null)
                return new IfBlock(block, invert, trueArm, joinArm);

            pushScope(joinTarget);
            ControlBlock falseArm = traverseBlock(falseTarget);
            popScope();

            return new IfBlock(block, invert, trueArm, falseArm, joinArm);
        }
コード例 #12
0
ファイル: SourceStructure.cs プロジェクト: not1ce111/Spedit
        private IfBlock traverseComplexIf(NodeBlock block, DJumpCondition jcc)
        {
            // Degenerate case: using || or &&, or any combination thereof,
            // will generate a chain of n+1 conditional blocks, where each
            // |n| has a target to a shared "success" block, setting a
            // phony variable. We decompose this giant mess into the intended
            // sequence of expressions.
            NodeBlock join;
            LogicChain chain = buildLogicChain(block, null, out join);

            DJumpCondition finalJcc = (DJumpCondition)join.nodes.last;
            //Debug.Assert(finalJcc.spop == SPOpcode.jzer);
          
            // The final conditional should have the normal dominator
            // properties: 2 or 3 idoms, depending on the number of arms.
            // Because of critical edge splitting, we may have 3 idoms
            // even if there are only actually two arms.
            NodeBlock joinBlock = findJoinOfSimpleIf(join, finalJcc);

            // If an AND chain reaches its end, the result is 1. jzer tests
            // for zero, so this is effectively testing (!success).
            // If an OR expression reaches its end, the result is 0. jzer
            // tests for zero, so this is effectively testing if (failure).
            //
            // In both cases, the true target represents a failure, so flip
            // the targets around.
            NodeBlock trueBlock = finalJcc.falseTarget;
            NodeBlock falseBlock = finalJcc.trueTarget;

            // If there is no join block, both arms terminate control flow,
            // eliminate one arm and use the other as a join point.
            if (joinBlock == null)
                joinBlock = falseBlock;

            if (join.lir.idominated.Length == 2 ||
                BlockAnalysis.EffectiveTarget(falseBlock) == joinBlock)
            {
                if (join.lir.idominated.Length == 3)
                    joinBlock = BlockAnalysis.EffectiveTarget(falseBlock);

                // One-armed structure.
                pushScope(joinBlock);
                ControlBlock trueArm1 = traverseBlock(trueBlock);
                popScope();

                ControlBlock joinArm1 = traverseBlock(joinBlock);
                return new IfBlock(block, chain, trueArm1, joinArm1);
            }

            //Debug.Assert(join.lir.idominated.Length == 3);

            pushScope(joinBlock);
            ControlBlock trueArm2 = traverseBlock(trueBlock);
            ControlBlock falseArm = traverseBlock(falseBlock);
            popScope();

            ControlBlock joinArm2 = traverseBlock(joinBlock);
            return new IfBlock(block, chain, trueArm2, falseArm, joinArm2);
        }
コード例 #13
0
ファイル: SourceStructure.cs プロジェクト: not1ce111/Spedit
 private NodeBlock findJoinOfSimpleIf(NodeBlock block, DJumpCondition jcc)
 {
     //Debug.Assert(block.nodes.last == jcc);
     //Debug.Assert(block.lir.idominated[0] == jcc.falseTarget.lir || block.lir.idominated[0] == jcc.trueTarget.lir);
     //Debug.Assert(block.lir.idominated[1] == jcc.falseTarget.lir || block.lir.idominated[1] == jcc.trueTarget.lir);
     if (block.lir.idominated.Length == 2)
     {
         if (jcc.trueTarget != BlockAnalysis.EffectiveTarget(jcc.trueTarget))
             return jcc.trueTarget;
         if (jcc.falseTarget != BlockAnalysis.EffectiveTarget(jcc.falseTarget))
             return jcc.falseTarget;
         return null;
     }
     return graph_[block.lir.idominated[2].id];
 }
コード例 #14
0
ファイル: SourceStructure.cs プロジェクト: not1ce111/Spedit
        private static LogicOperator ToLogicOp(DJumpCondition jcc)
        {
            NodeBlock trueTarget = BlockAnalysis.EffectiveTarget(jcc.trueTarget);
            bool targetIsTruthy = false;
            if (trueTarget.lir.instructions[0] is LConstant)
            {
                LConstant constant = (LConstant)trueTarget.lir.instructions[0];
                targetIsTruthy = (constant.val == 1);
            }

            // jump on true -> 1 == ||
            // jump on false -> 0 == &&
            // other combinations are nonsense, so assert.
            ////Debug.Assert((jcc.spop == SPOpcode.jnz && targetIsTruthy) ||
            //             (jcc.spop == SPOpcode.jzer && !targetIsTruthy));
            LogicOperator logicop = (jcc.spop == SPOpcode.jnz && targetIsTruthy)
                                    ? LogicOperator.Or
                                    : LogicOperator.And;
            return logicop;
        }
コード例 #15
0
ファイル: SourceStructure.cs プロジェクト: not1ce111/Spedit
        private static bool HasSharedTarget(NodeBlock pred, DJumpCondition jcc)
        {
            NodeBlock trueTarget = BlockAnalysis.EffectiveTarget(jcc.trueTarget);
            if (trueTarget.lir.numPredecessors == 1)
                return false;
            if (pred.lir.idominated.Length > 3)
                return true;

            // Hack... sniff out the case we care about, the true target
            // probably having a conditional.
            if (trueTarget.lir.instructions.Length == 2 &&
                trueTarget.lir.instructions[0].op == Opcode.Constant &&
                trueTarget.lir.instructions[1].op == Opcode.Jump)
            {
                return true;
            }

            // Because of edge splitting, there will always be at least 4
            // dominators for the immediate dominator of a shared block.
            return false;
        }
コード例 #16
0
ファイル: NodeRewriter.cs プロジェクト: maxijabase/SPCode
 public override void visit(DJumpCondition jcc)
 {
 }
コード例 #17
0
ファイル: Nodes.cs プロジェクト: maxijabase/SPCode
 public virtual void visit(DJumpCondition jcc)
 {
 }
コード例 #18
0
ファイル: NodeBuilder.cs プロジェクト: not1ce111/Spedit
        public void traverse(NodeBlock block)
        {
            for (int i = 0; i < block.lir.numPredecessors; i++)
            {
                NodeBlock pred = blocks_[block.lir.getPredecessor(i).id];
                
                // Don't bother with backedges yet.
                if (pred.lir.id >= block.lir.id)
                    continue;

                block.inherit(graph_, pred);
            }

            foreach (LInstruction uins in block.lir.instructions)
            {
                // Attempt to find static declarations. This is really
                // expensive - we could cheapen it by creating per-method
                // lists of statics.
                {
                    int i = -1;
                    do
                    {
                        Variable var = file_.lookupDeclarations(uins.pc, ref i, Scope.Static);
                        if (var == null)
                            break;
                        block.add(new DDeclareStatic(var));
                    } while (true);
                }

                switch (uins.op)
                {
                    case Opcode.DebugBreak:
                        break;

                    case Opcode.Stack:
                    {
                        LStack ins = (LStack)uins;
                        if (ins.amount < 0)
                        {
                            for (int i = 0; i < -ins.amount / 4; i++)
                            {
                                DDeclareLocal local = new DDeclareLocal(ins.pc, null);
                                block.stack.push(local);
                                block.add(local);
                            }
                        }
                        else
                        {
                            for (int i = 0; i < ins.amount / 4; i++)
                                block.stack.pop();
                        }
                        break;
                    }

                    case Opcode.Fill:
                    {
                        LFill ins = (LFill)uins;
                        DNode node = block.stack.alt;
                        DDeclareLocal local = (DDeclareLocal)node;
                        //Debug.Assert(block.stack.pri.type == NodeType.Constant);
                        for (int i = 0; i < ins.amount; i += 4)
                            block.stack.set(local.offset + i, block.stack.pri);
                        break;
                    }

                    case Opcode.Constant:
                    {
                        LConstant ins = (LConstant)uins;
                        DConstant v = new DConstant(ins.val, ins.pc);
                        block.stack.set(ins.reg, v);
                        block.add(v);
                        break;
                    }

                    case Opcode.PushConstant:
                    {
                        LPushConstant ins = (LPushConstant)uins;
                        DConstant v = new DConstant(ins.val);
                        DDeclareLocal local = new DDeclareLocal(ins.pc, v);
                        block.stack.push(local);
                        block.add(v);
                        block.add(local);
                        break;
                    }

                    case Opcode.PushReg:
                    {
                        LPushReg ins = (LPushReg)uins;
                        DDeclareLocal local = new DDeclareLocal(ins.pc, block.stack.reg(ins.reg));
                        block.stack.push(local);
                        block.add(local);
                        break;
                    }

                    case Opcode.Pop:
                    {
                        LPop ins = (LPop)uins;
                        DNode node = block.stack.popAsTemp();
                        block.stack.set(ins.reg, node);
                        break;
                    }

                    case Opcode.StackAddress:
                    {
                        LStackAddress ins = (LStackAddress)uins;
                        DDeclareLocal local = block.stack.getName(ins.offset);
                        block.stack.set(ins.reg, local);
                        break;
                    }

                    case Opcode.PushStackAddress:
                    {
                        LPushStackAddress ins = (LPushStackAddress)uins;
                        DLocalRef lref = new DLocalRef(block.stack.getName(ins.offset));
                        DDeclareLocal local = new DDeclareLocal(ins.pc, lref);
                        block.stack.push(local);
                        block.add(lref);
                        block.add(local);
                        break;
                    }

                    case Opcode.Goto:
                    {
                        LGoto ins = (LGoto)uins;
                        DJump node = new DJump(blocks_[ins.target.id]);
                        block.add(node);
                        break;
                    }

                    case Opcode.Jump:
                    {
                        LJump ins = (LJump)uins;
                        DJump node = new DJump(blocks_[ins.target.id]);
                        block.add(node);
                        break;
                    }

                    case Opcode.JumpCondition:
                    {
                        LJumpCondition ins = (LJumpCondition)uins;
                        NodeBlock lhtarget = blocks_[ins.trueTarget.id];
                        NodeBlock rhtarget = blocks_[ins.falseTarget.id];
                        DNode cmp = block.stack.pri;
                        SPOpcode jmp = ins.spop;
                        if (jmp != SPOpcode.jzer && jmp != SPOpcode.jnz)
                        {
                            SPOpcode newop;
                            switch (ins.spop)
                            {
                                case SPOpcode.jeq:
                                    newop = SPOpcode.neq;
                                    jmp = SPOpcode.jzer;
                                    break;
                                case SPOpcode.jneq:
                                    newop = SPOpcode.eq;
                                    jmp = SPOpcode.jzer;
                                    break;
                                case SPOpcode.jsgeq:
                                    newop = SPOpcode.sless;
                                    jmp = SPOpcode.jzer;
                                    break;
                                case SPOpcode.jsgrtr:
                                    newop = SPOpcode.sleq;
                                    jmp = SPOpcode.jzer;
                                    break;
                                case SPOpcode.jsleq:
                                    newop = SPOpcode.sgrtr;
                                    jmp = SPOpcode.jzer;
                                    break;
                                case SPOpcode.jsless:
                                    newop = SPOpcode.sgeq;
                                    jmp = SPOpcode.jzer;
                                    break;
                                default:
                                    //Debug.Assert(false);
                                    return;
                            }
                            cmp = new DBinary(newop, block.stack.pri, block.stack.alt);
                            block.add(cmp);
                        }
                        DJumpCondition jcc = new DJumpCondition(jmp, cmp, lhtarget, rhtarget);
                        block.add(jcc);
                        break;
                    }

                    case Opcode.LoadLocal:
                    {
                        LLoadLocal ins = (LLoadLocal)uins;
                        DLoad load = new DLoad(block.stack.getName(ins.offset));
                        block.stack.set(ins.reg, load);
                        block.add(load);
                        break;
                    }

                    case Opcode.LoadLocalRef:
                    {
                        LLoadLocalRef ins = (LLoadLocalRef)uins;
                        DLoad load = new DLoad(block.stack.getName(ins.offset));
                        load = new DLoad(load);
                        block.stack.set(ins.reg, load);
                        block.add(load);
                        break;
                    }

                    case Opcode.StoreLocal:
                    {
                        LStoreLocal ins = (LStoreLocal)uins;
                        DStore store = new DStore(block.stack.getName(ins.offset), block.stack.reg(ins.reg));
                        block.add(store);
                        break;
                    }

                    case Opcode.StoreLocalRef:
                    {
                        LStoreLocalRef ins = (LStoreLocalRef)uins;
                        DLoad load = new DLoad(block.stack.getName(ins.offset));
                        DStore store = new DStore(load, block.stack.reg(ins.reg));
                        block.add(store);
                        break;
                    }

                    case Opcode.SysReq:
                    {
                        LSysReq sysreq = (LSysReq)uins;
                        DConstant ins = (DConstant)block.stack.popValue();
                        List<DNode> arguments = new List<DNode>();
                        for (int i = 0; i < ins.value; i++)
                            arguments.Add(block.stack.popName());
                        DSysReq call = new DSysReq(sysreq.native, arguments.ToArray());
                        block.stack.set(Register.Pri, call);
                        block.add(call);
                        break;
                    }

                    case Opcode.AddConstant:
                    {
                        LAddConstant ins = (LAddConstant)uins;
                        DConstant val = new DConstant(ins.amount);
                        DBinary node = new DBinary(SPOpcode.add, block.stack.pri, val);
                        block.stack.set(Register.Pri, node);
                        block.add(val);
                        block.add(node);
                        break;
                    }

                    case Opcode.MulConstant:
                    {
                        LMulConstant ins = (LMulConstant)uins;
                        DConstant val = new DConstant(ins.amount);
                        DBinary node = new DBinary(SPOpcode.smul, block.stack.pri, val);
                        block.stack.set(Register.Pri, node);
                        block.add(val);
                        block.add(node);
                        break;
                    }

                    case Opcode.Bounds:
                    {
                        LBounds ins = (LBounds)uins;
                        DBoundsCheck node = new DBoundsCheck(block.stack.pri);
                        block.add(node);
                        break;
                    }

                    case Opcode.IndexAddress:
                    {
                        LIndexAddress ins = (LIndexAddress)uins;
                        DArrayRef node = new DArrayRef(block.stack.alt, block.stack.pri, ins.shift);
                        block.stack.set(Register.Pri, node);
                        block.add(node);
                        break;
                    }

                    case Opcode.Move:
                    {
                        LMove ins = (LMove)uins;
                        if (ins.reg == Register.Pri)
                            block.stack.set(Register.Pri, block.stack.alt);
                        else
                            block.stack.set(Register.Alt, block.stack.pri);
                        break;
                    }

                    case Opcode.Store:
                    {
                        LStore ins = (LStore)uins;
                        DStore store = new DStore(block.stack.alt, block.stack.pri);
                        block.add(store);
                        break;
                    }

                    case Opcode.Load:
                    {
                        LLoad ins = (LLoad)uins;
                        DLoad load = new DLoad(block.stack.pri);
                        block.stack.set(Register.Pri, load);
                        block.add(load);
                        break;
                    }

                    case Opcode.Swap:
                    {
                        LSwap ins = (LSwap)uins;
                        DNode lhs = block.stack.popAsTemp();
                        DNode rhs = block.stack.reg(ins.reg);
                        DDeclareLocal local = new DDeclareLocal(ins.pc, rhs);
                        block.stack.set(ins.reg, lhs);
                        block.stack.push(local);
                        block.add(local);
                        break;
                    }

                    case Opcode.IncI:
                    {
                        DIncDec inc = new DIncDec(block.stack.pri, 1);
                        block.add(inc);
                        break;
                    }

                    case Opcode.DecI:
                    {
                        DIncDec dec = new DIncDec(block.stack.pri, -1);
                        block.add(dec);
                        break;
                    }

                    case Opcode.IncLocal:
                    {
                        LIncLocal ins = (LIncLocal)uins;
                        DDeclareLocal local = block.stack.getName(ins.offset);
                        DIncDec inc = new DIncDec(local, 1);
                        block.add(inc);
                        break;
                    }

                    case Opcode.IncReg:
                    {
                        LIncReg ins = (LIncReg)uins;
                        DIncDec dec = new DIncDec(block.stack.reg(ins.reg), 1);
                        block.add(dec);
                        break;
                    }

                    case Opcode.DecLocal:
                    {
                        LDecLocal ins = (LDecLocal)uins;
                        DDeclareLocal local = block.stack.getName(ins.offset);
                        DIncDec dec = new DIncDec(local, -1);
                        block.add(dec);
                        break;
                    }

                    case Opcode.DecReg:
                    {
                        LDecReg ins = (LDecReg)uins;
                        DIncDec dec = new DIncDec(block.stack.reg(ins.reg), -1);
                        block.add(dec);
                        break;
                    }

                    case Opcode.Return:
                    {
                        DReturn node = new DReturn(block.stack.pri);
                        block.add(node);
                        break;
                    }

                    case Opcode.PushLocal:
                    {
                        LPushLocal ins = (LPushLocal)uins;
                        DLoad load = new DLoad(block.stack.getName(ins.offset));
                        DDeclareLocal local = new DDeclareLocal(ins.pc, load);
                        block.stack.push(local);
                        block.add(load);
                        block.add(local);
                        break;
                    }

                    case Opcode.Exchange:
                    {
                        DNode node = block.stack.alt;
                        block.stack.set(Register.Alt, block.stack.pri);
                        block.stack.set(Register.Pri, node);
                        break;
                    }

                    case Opcode.Unary:
                    {
                        LUnary ins = (LUnary)uins;
                        DUnary unary = new DUnary(ins.spop, block.stack.reg(ins.reg));
                        block.stack.set(Register.Pri, unary);
                        block.add(unary);
                        break;
                    }

                    case Opcode.Binary:
                    {
                        LBinary ins = (LBinary)uins;
                        DBinary binary = new DBinary(ins.spop, block.stack.reg(ins.lhs), block.stack.reg(ins.rhs));
                        block.stack.set(Register.Pri, binary);
                        block.add(binary);
                        break;
                    }

                    case Opcode.PushGlobal:
                    {
                        LPushGlobal ins = (LPushGlobal)uins;
                        Variable global = file_.lookupGlobal(ins.address);
                        if (global == null)
                            global = file_.lookupVariable(ins.pc, ins.address, Scope.Static);
                        DGlobal dglobal = new DGlobal(global);
                        DNode node = new DLoad(dglobal);
                        DDeclareLocal local = new DDeclareLocal(ins.pc, node);
                        block.stack.push(local);
                        block.add(dglobal);
                        block.add(node);
                        block.add(local);
                        break;
                    }

                    case Opcode.LoadGlobal:
                    {
                        LLoadGlobal ins = (LLoadGlobal)uins;
                        Variable global = file_.lookupGlobal(ins.address);
                        if (global == null)
                            global = file_.lookupVariable(ins.pc, ins.address, Scope.Static);
                        DNode dglobal = new DGlobal(global);
                        DNode node = new DLoad(dglobal);
                        block.stack.set(ins.reg, node);
                        block.add(dglobal);
                        block.add(node);
                        break;
                    }

                    case Opcode.StoreGlobal:
                    {
                        LStoreGlobal ins = (LStoreGlobal)uins;
                        Variable global = file_.lookupGlobal(ins.address);
                        if (global == null)
                            global = file_.lookupVariable(ins.pc, ins.address, Scope.Static);
                        DGlobal node = new DGlobal(global);
                        DStore store = new DStore(node, block.stack.reg(ins.reg));
                        block.add(node);
                        block.add(store);
                        break;
                    }

                    case Opcode.Call:
                    {
                        LCall ins = (LCall)uins;
                        Function f = file_.lookupFunction((uint)ins.address);
                        DConstant args = (DConstant)block.stack.popValue();
                        List<DNode> arguments = new List<DNode>();
                        for (int i = 0; i < args.value; i++)
                            arguments.Add(block.stack.popName());
                        DCall call = new DCall(f, arguments.ToArray());
                        block.stack.set(Register.Pri, call);
                        block.add(call);
                        break;
                    }

                    case Opcode.EqualConstant:
                    {
                        LEqualConstant ins = (LEqualConstant)uins;
                        DConstant c = new DConstant(ins.value);
                        DBinary node = new DBinary(SPOpcode.eq, block.stack.reg(ins.reg), c);
                        block.stack.set(Register.Pri, node);
                        block.add(c);
                        block.add(node);
                        break;
                    }

                    case Opcode.LoadIndex:
                    {
                        LLoadIndex ins = (LLoadIndex)uins;
                        DArrayRef aref = new DArrayRef(block.stack.alt, block.stack.pri, ins.shift);
                        DLoad load = new DLoad(aref);
                        block.stack.set(Register.Pri, load);
                        block.add(aref);
                        block.add(load);
                        break;
                    }

                    case Opcode.ZeroGlobal:
                    {
                        LZeroGlobal ins = (LZeroGlobal)uins;
                        Variable global = file_.lookupGlobal(ins.address);
                        DNode dglobal = new DGlobal(global);
                        DConstant rhs = new DConstant(0);
                        DStore lhs = new DStore(dglobal, rhs);
                        block.add(dglobal);
                        block.add(rhs);
                        block.add(lhs);
                        break;
                    }

                    case Opcode.IncGlobal:
                    {
                        LIncGlobal ins = (LIncGlobal)uins;
                        Variable global = file_.lookupGlobal(ins.address);
                        DNode dglobal = new DGlobal(global);

                        DLoad load = new DLoad(dglobal);
                        DConstant val = new DConstant(1);
                        DBinary add = new DBinary(SPOpcode.add, load, val);
                        DStore store = new DStore(dglobal, add);
                        block.add(load);
                        block.add(val);
                        block.add(add);
                        block.add(store);
                        break;
                    }

                    case Opcode.StoreGlobalConstant:
                    {
                        LStoreGlobalConstant lstore = (LStoreGlobalConstant)uins;
                        Variable var = file_.lookupGlobal(lstore.address);
                        DConstant val = new DConstant(lstore.value);
                        DGlobal global = new DGlobal(var);
                        DStore store = new DStore(global, val);
                        block.add(val);
                        block.add(global);
                        block.add(store);
                        break;
                    }

                    case Opcode.StoreLocalConstant:
                    {
                        LStoreLocalConstant lstore = (LStoreLocalConstant)uins;
                        DDeclareLocal var = block.stack.getName(lstore.address);
                        DConstant val = new DConstant(lstore.value);
                        DStore store = new DStore(var, val);
                        block.add(val);
                        block.add(store);
                        break;
                    }

                    case Opcode.ZeroLocal:
                    {
                        LZeroLocal lstore = (LZeroLocal)uins;
                        DDeclareLocal var = block.stack.getName(lstore.address);
                        DConstant val = new DConstant(0);
                        DStore store = new DStore(var, val);
                        block.add(val);
                        block.add(store);
                        break;
                    }

                    case Opcode.Heap:
                    {
                        LHeap ins = (LHeap)uins;
                        DHeap heap = new DHeap(ins.amount);
                        block.add(heap);
                        block.stack.set(Register.Alt, heap);
                        break;
                    }

                    case Opcode.MemCopy:
                    {
                        LMemCopy ins = (LMemCopy)uins;
                        DMemCopy copy = new DMemCopy(block.stack.alt, block.stack.pri, ins.bytes);
                        block.add(copy);
                        break;
                    }

                    case Opcode.Switch:
                    {
                        LSwitch ins = (LSwitch)uins;
                        DSwitch switch_ = new DSwitch(block.stack.pri, ins);
                        block.add(switch_);
                        break;
                    }

                    default:
                        throw new Exception("unhandled opcode");
                }
            }

            for (int i = 0; i < block.lir.idominated.Length; i++)
            {
                LBlock lir = block.lir.idominated[i];
                traverse(blocks_[lir.id]);
            }
        }
コード例 #19
0
ファイル: NodeRewriter.cs プロジェクト: not1ce111/Spedit
 public override void visit(DJumpCondition jcc)
 {
 }
コード例 #20
0
        public void traverse(NodeBlock block)
        {
            for (int i = 0; i < block.lir.numPredecessors; i++)
            {
                NodeBlock pred = blocks_[block.lir.getPredecessor(i).id];

                // Don't bother with backedges yet.
                if (pred.lir.id >= block.lir.id)
                {
                    continue;
                }

                block.inherit(graph_, pred);
            }

            foreach (LInstruction uins in block.lir.instructions)
            {
                // Attempt to find static declarations. This is really
                // expensive - we could cheapen it by creating per-method
                // lists of statics.
                {
                    int i = -1;
                    do
                    {
                        Variable var = file_.lookupDeclarations(uins.pc, ref i, Scope.Static);
                        if (var == null)
                        {
                            break;
                        }
                        block.add(new DDeclareStatic(var));
                    } while (true);
                }

                switch (uins.op)
                {
                case Opcode.DebugBreak:
                    break;

                case Opcode.Stack:
                {
                    LStack ins = (LStack)uins;
                    if (ins.amount < 0)
                    {
                        for (int i = 0; i < -ins.amount / 4; i++)
                        {
                            DDeclareLocal local = new DDeclareLocal(ins.pc, null);
                            block.stack.push(local);
                            block.add(local);
                        }
                    }
                    else
                    {
                        for (int i = 0; i < ins.amount / 4; i++)
                        {
                            block.stack.pop();
                        }
                    }
                    break;
                }

                case Opcode.Fill:
                {
                    LFill         ins   = (LFill)uins;
                    DNode         node  = block.stack.alt;
                    DDeclareLocal local = (DDeclareLocal)node;
                    //Debug.Assert(block.stack.pri.type == NodeType.Constant);
                    for (int i = 0; i < ins.amount; i += 4)
                    {
                        block.stack.set(local.offset + i, block.stack.pri);
                    }
                    break;
                }

                case Opcode.Constant:
                {
                    LConstant ins = (LConstant)uins;
                    DConstant v   = new DConstant(ins.val, ins.pc);
                    block.stack.set(ins.reg, v);
                    block.add(v);
                    break;
                }

                case Opcode.PushConstant:
                {
                    LPushConstant ins   = (LPushConstant)uins;
                    DConstant     v     = new DConstant(ins.val);
                    DDeclareLocal local = new DDeclareLocal(ins.pc, v);
                    block.stack.push(local);
                    block.add(v);
                    block.add(local);
                    break;
                }

                case Opcode.PushReg:
                {
                    LPushReg      ins   = (LPushReg)uins;
                    DDeclareLocal local = new DDeclareLocal(ins.pc, block.stack.reg(ins.reg));
                    block.stack.push(local);
                    block.add(local);
                    break;
                }

                case Opcode.Pop:
                {
                    LPop  ins  = (LPop)uins;
                    DNode node = block.stack.popAsTemp();
                    block.stack.set(ins.reg, node);
                    break;
                }

                case Opcode.StackAddress:
                {
                    LStackAddress ins   = (LStackAddress)uins;
                    DDeclareLocal local = block.stack.getName(ins.offset);
                    block.stack.set(ins.reg, local);
                    break;
                }

                case Opcode.PushStackAddress:
                {
                    LPushStackAddress ins   = (LPushStackAddress)uins;
                    DLocalRef         lref  = new DLocalRef(block.stack.getName(ins.offset));
                    DDeclareLocal     local = new DDeclareLocal(ins.pc, lref);
                    block.stack.push(local);
                    block.add(lref);
                    block.add(local);
                    break;
                }

                case Opcode.Goto:
                {
                    LGoto ins  = (LGoto)uins;
                    DJump node = new DJump(blocks_[ins.target.id]);
                    block.add(node);
                    break;
                }

                case Opcode.Jump:
                {
                    LJump ins  = (LJump)uins;
                    DJump node = new DJump(blocks_[ins.target.id]);
                    block.add(node);
                    break;
                }

                case Opcode.JumpCondition:
                {
                    LJumpCondition ins      = (LJumpCondition)uins;
                    NodeBlock      lhtarget = blocks_[ins.trueTarget.id];
                    NodeBlock      rhtarget = blocks_[ins.falseTarget.id];
                    DNode          cmp      = block.stack.pri;
                    SPOpcode       jmp      = ins.spop;
                    if (jmp != SPOpcode.jzer && jmp != SPOpcode.jnz)
                    {
                        SPOpcode newop;
                        switch (ins.spop)
                        {
                        case SPOpcode.jeq:
                            newop = SPOpcode.neq;
                            jmp   = SPOpcode.jzer;
                            break;

                        case SPOpcode.jneq:
                            newop = SPOpcode.eq;
                            jmp   = SPOpcode.jzer;
                            break;

                        case SPOpcode.jsgeq:
                            newop = SPOpcode.sless;
                            jmp   = SPOpcode.jzer;
                            break;

                        case SPOpcode.jsgrtr:
                            newop = SPOpcode.sleq;
                            jmp   = SPOpcode.jzer;
                            break;

                        case SPOpcode.jsleq:
                            newop = SPOpcode.sgrtr;
                            jmp   = SPOpcode.jzer;
                            break;

                        case SPOpcode.jsless:
                            newop = SPOpcode.sgeq;
                            jmp   = SPOpcode.jzer;
                            break;

                        default:
                            //Debug.Assert(false);
                            return;
                        }
                        cmp = new DBinary(newop, block.stack.pri, block.stack.alt);
                        block.add(cmp);
                    }
                    DJumpCondition jcc = new DJumpCondition(jmp, cmp, lhtarget, rhtarget);
                    block.add(jcc);
                    break;
                }

                case Opcode.LoadLocal:
                {
                    LLoadLocal ins  = (LLoadLocal)uins;
                    DLoad      load = new DLoad(block.stack.getName(ins.offset));
                    block.stack.set(ins.reg, load);
                    block.add(load);
                    break;
                }

                case Opcode.LoadLocalRef:
                {
                    LLoadLocalRef ins  = (LLoadLocalRef)uins;
                    DLoad         load = new DLoad(block.stack.getName(ins.offset));
                    load = new DLoad(load);
                    block.stack.set(ins.reg, load);
                    block.add(load);
                    break;
                }

                case Opcode.StoreLocal:
                {
                    LStoreLocal ins   = (LStoreLocal)uins;
                    DStore      store = new DStore(block.stack.getName(ins.offset), block.stack.reg(ins.reg));
                    block.add(store);
                    break;
                }

                case Opcode.StoreLocalRef:
                {
                    LStoreLocalRef ins   = (LStoreLocalRef)uins;
                    DLoad          load  = new DLoad(block.stack.getName(ins.offset));
                    DStore         store = new DStore(load, block.stack.reg(ins.reg));
                    block.add(store);
                    break;
                }

                case Opcode.SysReq:
                {
                    LSysReq      sysreq    = (LSysReq)uins;
                    DConstant    ins       = (DConstant)block.stack.popValue();
                    List <DNode> arguments = new List <DNode>();
                    for (int i = 0; i < ins.value; i++)
                    {
                        arguments.Add(block.stack.popName());
                    }
                    DSysReq call = new DSysReq(sysreq.native, arguments.ToArray());
                    block.stack.set(Register.Pri, call);
                    block.add(call);
                    break;
                }

                case Opcode.AddConstant:
                {
                    LAddConstant ins  = (LAddConstant)uins;
                    DConstant    val  = new DConstant(ins.amount);
                    DBinary      node = new DBinary(SPOpcode.add, block.stack.pri, val);
                    block.stack.set(Register.Pri, node);
                    block.add(val);
                    block.add(node);
                    break;
                }

                case Opcode.MulConstant:
                {
                    LMulConstant ins  = (LMulConstant)uins;
                    DConstant    val  = new DConstant(ins.amount);
                    DBinary      node = new DBinary(SPOpcode.smul, block.stack.pri, val);
                    block.stack.set(Register.Pri, node);
                    block.add(val);
                    block.add(node);
                    break;
                }

                case Opcode.Bounds:
                {
                    LBounds      ins  = (LBounds)uins;
                    DBoundsCheck node = new DBoundsCheck(block.stack.pri);
                    block.add(node);
                    break;
                }

                case Opcode.IndexAddress:
                {
                    LIndexAddress ins  = (LIndexAddress)uins;
                    DArrayRef     node = new DArrayRef(block.stack.alt, block.stack.pri, ins.shift);
                    block.stack.set(Register.Pri, node);
                    block.add(node);
                    break;
                }

                case Opcode.Move:
                {
                    LMove ins = (LMove)uins;
                    if (ins.reg == Register.Pri)
                    {
                        block.stack.set(Register.Pri, block.stack.alt);
                    }
                    else
                    {
                        block.stack.set(Register.Alt, block.stack.pri);
                    }
                    break;
                }

                case Opcode.Store:
                {
                    LStore ins   = (LStore)uins;
                    DStore store = new DStore(block.stack.alt, block.stack.pri);
                    block.add(store);
                    break;
                }

                case Opcode.Load:
                {
                    LLoad ins  = (LLoad)uins;
                    DLoad load = new DLoad(block.stack.pri);
                    block.stack.set(Register.Pri, load);
                    block.add(load);
                    break;
                }

                case Opcode.Swap:
                {
                    LSwap         ins   = (LSwap)uins;
                    DNode         lhs   = block.stack.popAsTemp();
                    DNode         rhs   = block.stack.reg(ins.reg);
                    DDeclareLocal local = new DDeclareLocal(ins.pc, rhs);
                    block.stack.set(ins.reg, lhs);
                    block.stack.push(local);
                    block.add(local);
                    break;
                }

                case Opcode.IncI:
                {
                    DIncDec inc = new DIncDec(block.stack.pri, 1);
                    block.add(inc);
                    break;
                }

                case Opcode.DecI:
                {
                    DIncDec dec = new DIncDec(block.stack.pri, -1);
                    block.add(dec);
                    break;
                }

                case Opcode.IncLocal:
                {
                    LIncLocal     ins   = (LIncLocal)uins;
                    DDeclareLocal local = block.stack.getName(ins.offset);
                    DIncDec       inc   = new DIncDec(local, 1);
                    block.add(inc);
                    break;
                }

                case Opcode.IncReg:
                {
                    LIncReg ins = (LIncReg)uins;
                    DIncDec dec = new DIncDec(block.stack.reg(ins.reg), 1);
                    block.add(dec);
                    break;
                }

                case Opcode.DecLocal:
                {
                    LDecLocal     ins   = (LDecLocal)uins;
                    DDeclareLocal local = block.stack.getName(ins.offset);
                    DIncDec       dec   = new DIncDec(local, -1);
                    block.add(dec);
                    break;
                }

                case Opcode.DecReg:
                {
                    LDecReg ins = (LDecReg)uins;
                    DIncDec dec = new DIncDec(block.stack.reg(ins.reg), -1);
                    block.add(dec);
                    break;
                }

                case Opcode.Return:
                {
                    DReturn node = new DReturn(block.stack.pri);
                    block.add(node);
                    break;
                }

                case Opcode.PushLocal:
                {
                    LPushLocal    ins   = (LPushLocal)uins;
                    DLoad         load  = new DLoad(block.stack.getName(ins.offset));
                    DDeclareLocal local = new DDeclareLocal(ins.pc, load);
                    block.stack.push(local);
                    block.add(load);
                    block.add(local);
                    break;
                }

                case Opcode.Exchange:
                {
                    DNode node = block.stack.alt;
                    block.stack.set(Register.Alt, block.stack.pri);
                    block.stack.set(Register.Pri, node);
                    break;
                }

                case Opcode.Unary:
                {
                    LUnary ins   = (LUnary)uins;
                    DUnary unary = new DUnary(ins.spop, block.stack.reg(ins.reg));
                    block.stack.set(Register.Pri, unary);
                    block.add(unary);
                    break;
                }

                case Opcode.Binary:
                {
                    LBinary ins    = (LBinary)uins;
                    DBinary binary = new DBinary(ins.spop, block.stack.reg(ins.lhs), block.stack.reg(ins.rhs));
                    block.stack.set(Register.Pri, binary);
                    block.add(binary);
                    break;
                }

                case Opcode.PushGlobal:
                {
                    LPushGlobal ins    = (LPushGlobal)uins;
                    Variable    global = file_.lookupGlobal(ins.address);
                    if (global == null)
                    {
                        global = file_.lookupVariable(ins.pc, ins.address, Scope.Static);
                    }
                    DGlobal       dglobal = new DGlobal(global);
                    DNode         node    = new DLoad(dglobal);
                    DDeclareLocal local   = new DDeclareLocal(ins.pc, node);
                    block.stack.push(local);
                    block.add(dglobal);
                    block.add(node);
                    block.add(local);
                    break;
                }

                case Opcode.LoadGlobal:
                {
                    LLoadGlobal ins    = (LLoadGlobal)uins;
                    Variable    global = file_.lookupGlobal(ins.address);
                    if (global == null)
                    {
                        global = file_.lookupVariable(ins.pc, ins.address, Scope.Static);
                    }
                    DNode dglobal = new DGlobal(global);
                    DNode node    = new DLoad(dglobal);
                    block.stack.set(ins.reg, node);
                    block.add(dglobal);
                    block.add(node);
                    break;
                }

                case Opcode.StoreGlobal:
                {
                    LStoreGlobal ins    = (LStoreGlobal)uins;
                    Variable     global = file_.lookupGlobal(ins.address);
                    if (global == null)
                    {
                        global = file_.lookupVariable(ins.pc, ins.address, Scope.Static);
                    }
                    DGlobal node  = new DGlobal(global);
                    DStore  store = new DStore(node, block.stack.reg(ins.reg));
                    block.add(node);
                    block.add(store);
                    break;
                }

                case Opcode.Call:
                {
                    LCall        ins       = (LCall)uins;
                    Function     f         = file_.lookupFunction((uint)ins.address);
                    DConstant    args      = (DConstant)block.stack.popValue();
                    List <DNode> arguments = new List <DNode>();
                    for (int i = 0; i < args.value; i++)
                    {
                        arguments.Add(block.stack.popName());
                    }
                    DCall call = new DCall(f, arguments.ToArray());
                    block.stack.set(Register.Pri, call);
                    block.add(call);
                    break;
                }

                case Opcode.EqualConstant:
                {
                    LEqualConstant ins  = (LEqualConstant)uins;
                    DConstant      c    = new DConstant(ins.value);
                    DBinary        node = new DBinary(SPOpcode.eq, block.stack.reg(ins.reg), c);
                    block.stack.set(Register.Pri, node);
                    block.add(c);
                    block.add(node);
                    break;
                }

                case Opcode.LoadIndex:
                {
                    LLoadIndex ins  = (LLoadIndex)uins;
                    DArrayRef  aref = new DArrayRef(block.stack.alt, block.stack.pri, ins.shift);
                    DLoad      load = new DLoad(aref);
                    block.stack.set(Register.Pri, load);
                    block.add(aref);
                    block.add(load);
                    break;
                }

                case Opcode.ZeroGlobal:
                {
                    LZeroGlobal ins     = (LZeroGlobal)uins;
                    Variable    global  = file_.lookupGlobal(ins.address);
                    DNode       dglobal = new DGlobal(global);
                    DConstant   rhs     = new DConstant(0);
                    DStore      lhs     = new DStore(dglobal, rhs);
                    block.add(dglobal);
                    block.add(rhs);
                    block.add(lhs);
                    break;
                }

                case Opcode.IncGlobal:
                {
                    LIncGlobal ins     = (LIncGlobal)uins;
                    Variable   global  = file_.lookupGlobal(ins.address);
                    DNode      dglobal = new DGlobal(global);

                    DLoad     load  = new DLoad(dglobal);
                    DConstant val   = new DConstant(1);
                    DBinary   add   = new DBinary(SPOpcode.add, load, val);
                    DStore    store = new DStore(dglobal, add);
                    block.add(load);
                    block.add(val);
                    block.add(add);
                    block.add(store);
                    break;
                }

                case Opcode.StoreGlobalConstant:
                {
                    LStoreGlobalConstant lstore = (LStoreGlobalConstant)uins;
                    Variable             var    = file_.lookupGlobal(lstore.address);
                    DConstant            val    = new DConstant(lstore.value);
                    DGlobal global = new DGlobal(var);
                    DStore  store  = new DStore(global, val);
                    block.add(val);
                    block.add(global);
                    block.add(store);
                    break;
                }

                case Opcode.StoreLocalConstant:
                {
                    LStoreLocalConstant lstore = (LStoreLocalConstant)uins;
                    DDeclareLocal       var    = block.stack.getName(lstore.address);
                    DConstant           val    = new DConstant(lstore.value);
                    DStore store = new DStore(var, val);
                    block.add(val);
                    block.add(store);
                    break;
                }

                case Opcode.ZeroLocal:
                {
                    LZeroLocal    lstore = (LZeroLocal)uins;
                    DDeclareLocal var    = block.stack.getName(lstore.address);
                    DConstant     val    = new DConstant(0);
                    DStore        store  = new DStore(var, val);
                    block.add(val);
                    block.add(store);
                    break;
                }

                case Opcode.Heap:
                {
                    LHeap ins  = (LHeap)uins;
                    DHeap heap = new DHeap(ins.amount);
                    block.add(heap);
                    block.stack.set(Register.Alt, heap);
                    break;
                }

                case Opcode.MemCopy:
                {
                    LMemCopy ins  = (LMemCopy)uins;
                    DMemCopy copy = new DMemCopy(block.stack.alt, block.stack.pri, ins.bytes);
                    block.add(copy);
                    break;
                }

                case Opcode.Switch:
                {
                    LSwitch ins     = (LSwitch)uins;
                    DSwitch switch_ = new DSwitch(block.stack.pri, ins);
                    block.add(switch_);
                    break;
                }

                default:
                    throw new Exception("unhandled opcode");
                }
            }

            for (int i = 0; i < block.lir.idominated.Length; i++)
            {
                LBlock lir = block.lir.idominated[i];
                traverse(blocks_[lir.id]);
            }
        }
コード例 #21
0
        private LogicChain buildLogicChain(NodeBlock block, NodeBlock earlyExitStop, out NodeBlock join)
        {
            DJumpCondition jcc   = (DJumpCondition)block.nodes.last;
            LogicChain     chain = new LogicChain(ToLogicOp(jcc));

            // Grab the true target, which will be either the "1" or "0"
            // branch of the AND/OR expression.
            NodeBlock earlyExit = BlockAnalysis.EffectiveTarget(jcc.trueTarget);

            NodeBlock exprBlock = block;

            do
            {
                do
                {
                    DJumpCondition childJcc = (DJumpCondition)exprBlock.nodes.last;
                    if (BlockAnalysis.EffectiveTarget(childJcc.trueTarget) != earlyExit)
                    {
                        // Parse a sub-expression.
                        NodeBlock  innerJoin;
                        LogicChain rhs = buildLogicChain(exprBlock, earlyExit, out innerJoin);
                        AssertInnerJoinValidity(innerJoin, earlyExit);
                        chain.append(rhs);
                        exprBlock = innerJoin;
                        childJcc  = (DJumpCondition)exprBlock.nodes.last;
                    }
                    else
                    {
                        chain.append(childJcc.getOperand(0));
                    }
                    exprBlock = childJcc.falseTarget;
                } while (exprBlock.nodes.last.type == NodeType.JumpCondition);

                do
                {
                    // We have reached the end of a sequence - a block containing
                    // a Constant and a Jump to the join point of the sequence.
                    //Debug.Assert(exprBlock.lir.instructions[0].op == Opcode.Constant);

                    // The next block is the join point.
                    NodeBlock      condBlock = SingleTarget(exprBlock);
                    var            last      = condBlock.nodes.last;
                    DJumpCondition condJcc;
                    try
                    {
                        condJcc = (DJumpCondition)last;
                    }
                    catch (Exception e)
                    {
                        throw new LogicChainConversionException(e.Message);
                    }

                    join = condBlock;

                    // If the cond block is the tagret of the early stop, we've
                    // gone a tad too far. This is the case for a simple
                    // expression like (a && b) || c.
                    if (earlyExitStop != null && SingleTarget(earlyExitStop) == condBlock)
                    {
                        return(chain);
                    }

                    // If the true connects back to the early exit stop, we're
                    // done.
                    if (BlockAnalysis.EffectiveTarget(condJcc.trueTarget) == earlyExitStop)
                    {
                        return(chain);
                    }

                    // If the true target does not have a shared target, we're
                    // done parsing the whole logic chain.
                    if (!HasSharedTarget(condBlock, condJcc))
                    {
                        return(chain);
                    }

                    // Otherwise, there is another link in the chain. This link
                    // joins the existing chain to a new subexpression, which
                    // actually starts hanging off the false branch of this
                    // conditional.
                    earlyExit = BlockAnalysis.EffectiveTarget(condJcc.trueTarget);

                    // Build the right-hand side of the expression.
                    NodeBlock  innerJoin;
                    LogicChain rhs = buildLogicChain(condJcc.falseTarget, earlyExit, out innerJoin);
                    AssertInnerJoinValidity(innerJoin, earlyExit);

                    // Build the full expression.
                    LogicChain root = new LogicChain(ToLogicOp(condJcc));
                    root.append(chain);
                    root.append(rhs);
                    chain = root;

                    // If the inner join's false target is a conditional, the
                    // outer expression may continue.
                    DJumpCondition innerJcc = (DJumpCondition)innerJoin.nodes.last;
                    if (innerJcc.falseTarget.nodes.last.type == NodeType.JumpCondition)
                    {
                        exprBlock = innerJcc.falseTarget;
                        break;
                    }

                    // Finally, the new expression block is always the early exit
                    // block. It's on the "trueTarget" edge of the expression,
                    // whereas incoming into this loop it's on the "falseTarget"
                    // edge, but this does not matter.
                    exprBlock = earlyExit;
                } while (true);
            } while (true);
        }
コード例 #22
0
 private static void AssertInnerJoinValidity(NodeBlock join, NodeBlock earlyExit)
 {
     DJumpCondition jcc = (DJumpCondition)join.nodes.last;
     //Debug.Assert(BlockAnalysis.EffectiveTarget(jcc.trueTarget) == earlyExit || join == SingleTarget(earlyExit));
 }
コード例 #23
0
 public override void visit(DJumpCondition jcc)
 {
     jcc.typeSet.addType(new TypeUnit(new PawnType(CellType.Bool)));
 }
コード例 #24
0
        private IfBlock traverseComplexIf(NodeBlock block, DJumpCondition jcc)
        {
            // Degenerate case: using || or &&, or any combination thereof,
            // will generate a chain of n+1 conditional blocks, where each
            // |n| has a target to a shared "success" block, setting a
            // phony variable. We decompose this giant mess into the intended
            // sequence of expressions.
            NodeBlock  join;
            LogicChain chain = buildLogicChain(block, null, out join);

            DJumpCondition finalJcc = (DJumpCondition)join.nodes.last;
            //Debug.Assert(finalJcc.spop == SPOpcode.jzer);

            // The final conditional should have the normal dominator
            // properties: 2 or 3 idoms, depending on the number of arms.
            // Because of critical edge splitting, we may have 3 idoms
            // even if there are only actually two arms.
            NodeBlock joinBlock = findJoinOfSimpleIf(join, finalJcc);

            // If an AND chain reaches its end, the result is 1. jzer tests
            // for zero, so this is effectively testing (!success).
            // If an OR expression reaches its end, the result is 0. jzer
            // tests for zero, so this is effectively testing if (failure).
            //
            // In both cases, the true target represents a failure, so flip
            // the targets around.
            NodeBlock trueBlock  = finalJcc.falseTarget;
            NodeBlock falseBlock = finalJcc.trueTarget;

            // If there is no join block, both arms terminate control flow,
            // eliminate one arm and use the other as a join point.
            if (joinBlock == null)
            {
                joinBlock = falseBlock;
            }

            if (join.lir.idominated.Length == 2 ||
                BlockAnalysis.EffectiveTarget(falseBlock) == joinBlock)
            {
                if (join.lir.idominated.Length == 3)
                {
                    joinBlock = BlockAnalysis.EffectiveTarget(falseBlock);
                }

                // One-armed structure.
                pushScope(joinBlock);
                ControlBlock trueArm1 = traverseBlock(trueBlock);
                popScope();

                ControlBlock joinArm1 = traverseBlock(joinBlock);
                return(new IfBlock(block, chain, trueArm1, joinArm1));
            }

            //Debug.Assert(join.lir.idominated.Length == 3);

            pushScope(joinBlock);
            ControlBlock trueArm2 = traverseBlock(trueBlock);
            ControlBlock falseArm = traverseBlock(falseBlock);

            popScope();

            ControlBlock joinArm2 = traverseBlock(joinBlock);

            return(new IfBlock(block, chain, trueArm2, falseArm, joinArm2));
        }
コード例 #25
0
ファイル: Nodes.cs プロジェクト: not1ce111/Spedit
 public virtual void visit(DJumpCondition jcc) { }