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); }
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]); } }