public InstructionMemoryOpAndOpAndOp(String label, Byte instruction, MemoryOp memoryOp, Op op1, Op op2) : base(label, instruction, (Byte)(1 + memoryOp.byteLength + op1.byteLength + op2.byteLength)) { this.memoryOp = memoryOp; this.op1 = op1; this.op2 = op2; }
public void JE(String label) { Debug("MOV"); if (!assemblyBuilder.inFunction) { throw ParseError("JE Instruction must be in a func"); } OperandToken condOperand1 = tokenizer.NextOperand(); Debug("COND1 : {0}", condOperand1); OperandToken condOperand2 = tokenizer.NextOperand(); Debug("COND2 : {0}", condOperand2); OperandToken jumpOperand = tokenizer.NextOperand(); Debug("JMP : {0}", jumpOperand); MemoryOp condOp1 = condOperand1.GetMemoryOp(assemblyBuilder.currentFunction); Op condOp2 = condOperand2.GetOp(assemblyBuilder.currentFunction); Op jumpOp = jumpOperand.GetJumpOp(assemblyBuilder.currentFunction); assemblyBuilder.currentFunction.AddInstruction(new InstructionMemoryOpAndOpAndOp(label, Instructions.Move, condOp1, condOp2, jumpOp)); }
public static UInt64 EmitJumpBIfEQ(byte[] byteCode, UInt64 offset, MemoryOp cnd1, Op cnd2, Op jmp) { byteCode[offset++] = Instructions.JumpBIfEQ; offset = cnd1.Emit(byteCode, offset); offset = cnd2.Emit(byteCode, offset); return(jmp.Emit(byteCode, offset)); }
private void MoveTest(params MemAndValue[] t) { UInt64 offset; memory.Reset(); // // Generate Code // offset = 0; for (int i = 0; i < t.Length; i++) { offset = ByteCode.EmitAssign(byteCode, offset, t[i].dst, t[i].src); } byteCode[offset++] = Instructions.Halt; // // Run Code // Assert.AreEqual(offset, InstructionProcessor.Execute(byteCode, 0, memory)); // // Test Results // memory.Print(0, 16); for (int i = 0; i < t.Length; i++) { MemoryOp dst = t[i].dst; Op src = t[i].src; Console.WriteLine("Asserting [{0}] EmitMem={1}, EmitVal={2}", i, dst, src); Byte[] emitWriteCode = new Byte[dst.byteLength]; Byte[] emitReadCode = new Byte[src.byteLength]; dst.Emit(emitWriteCode, 0); src.Emit(emitReadCode, 0); offset = 0; Memory.ReadOperandLogic emitWriteReadOperand = memory.ParseWriteOperandForReading(emitWriteCode, ref offset); Assert.AreEqual((UInt64)emitWriteCode.Length, offset); offset = 0; Memory.ReadOperandLogic emitReadReadOperand = memory.ParseReadOperand(emitReadCode, ref offset); Assert.AreEqual((UInt64)emitReadCode.Length, offset); Assert.IsTrue(memory.TestEquals(emitWriteReadOperand, emitReadReadOperand)); } }
/* * public void dotMain(String label) * { * Debug(".main"); * * if (!assembly.inFunction) throw ParseError(".main command must be in a func"); * if (label != null) throw ParseError(".main can't be labeled"); * * assembly.CurrentFunctionIsMain(); * parseState = ParseState.Frame; * } * * public void dotException(String label) * { * Debug(".exception"); * * if (!assembly.inFunction) throw ParseError(".exception command must be in a func"); * if(parseState != ParseState.StartOfFrame) throw ParseError(".exception must be at the start of a FRAME"); * * assembly.currentFunction.IncludeException(); * parseState = ParseState.Frame; * } * public void dotStack(String label) * { * Debug(".stack"); * UInt64 num = tokenizer.GetUnsignedNumber(); * * if (!assembly.inFunction) throw ParseError(".stack command must be in a func"); * * if (label == null) * { * assembly.currentFunction.FrameAllocateVariable(num); * } * else * { * assembly.currentFunction.AddFrameOffsetLabel(label, num); * } * parseState = ParseState.Frame; * } * public void dotReturn(String label) * { * Debug(".return"); * if (label != null) throw ParseError("A return statement can't have a Label?"); * * UInt64 size = tokenizer.GetUnsignedNumber(); * * if (!assembly.inFunction) throw ParseError(".return command must be in a func"); * assembly.currentFunction.SetReturnPointerSettings(false, (UInt32)size); * } * public void dotReturnTable(String label) * { * Debug(".returntable"); * if (label != null) throw ParseError("A return statement can't have a Label?"); * * UInt64 size = tokenizer.GetUnsignedNumber(); * * if (!assembly.inFunction) throw ParseError(".return-table command must be in a func"); * assembly.currentFunction.SetReturnPointerSettings(true, (UInt32)size); * } * * public void func(String label) * { * Debug("func"); * if (label != null) throw ParseError("A func command can't have a label"); * * assembly.NewFunction(); * * * parseState = ParseState.StartOfFrame; * } */ public void MOV(String label) { Debug("MOV"); if (!assemblyBuilder.inFunction) { throw ParseError("MOV Instruction must be in a func"); } OperandToken dstOperand = tokenizer.NextOperand(); Debug("DST : {0}", dstOperand); OperandToken srcOperand = tokenizer.NextOperand(); Debug("SRC : {0}", srcOperand); MemoryOp dstOp = dstOperand.GetMemoryOp(assemblyBuilder.currentFunction); Op srcOp = srcOperand.GetOp(assemblyBuilder.currentFunction); assemblyBuilder.currentFunction.AddInstruction(new InstructionMemoryOpAndOp(label, Instructions.Move, dstOp, srcOp)); }
public MemAndValue(MemoryOp ew, Op er) { this.dst = ew; this.src = er; }
public MachineInstructionMemoryOp(Byte instruction, MemoryOp memoryOp) : base(instruction, memoryOp.byteLength) { }
public static UInt64 EmitDecrement(byte[] byteCode, UInt64 offset, MemoryOp var) { byteCode[offset++] = Instructions.Decrement; return(var.Emit(byteCode, offset)); }
public static UInt64 EmitAssign(byte[] byteCode, UInt64 offset, MemoryOp dst, Op src) { byteCode[offset++] = Instructions.Move; offset = dst.Emit(byteCode, offset); return(src.Emit(byteCode, offset)); }
public void Test() { Int32 off; byte[] byteCode = new byte[10]; MemoryOp[] emitW = new MemoryOp[32]; Op[] emitR = new Op[32]; off = 0; emitW[off++] = new MemoryOp(0); emitW[off++] = new MemoryOp(1); emitW[off++] = new MemoryOp(23); emitW[off++] = new MemoryOp(127); emitW[off++] = new MemoryOp(Operands.WritableOpTypeFrameOffsetShortMax); for (int i = 0; i < off; i++) { Assert.AreEqual(1U, emitW[i].Emit(byteCode, 0)); Assert.AreEqual(emitW[i].infoMask, byteCode[0]); } off = 0; emitR[off++] = new Op(0); emitR[off++] = new Op(1); emitR[off++] = new Op(23); emitR[off++] = new Op(127); emitR[off++] = new Op(Operands.ReadableOpTypeFrameOffsetShortMax); for (int i = 0; i < off; i++) { Assert.AreEqual(1U, emitW[i].Emit(byteCode, 0)); Assert.AreEqual(emitW[i].infoMask, byteCode[0]); } off = 0; emitW[off++] = new MemoryOp(Operands.AddressInfoMask, 248); emitW[off++] = new MemoryOp(Operands.AddressInfoMask, 88, 1); emitW[off++] = new MemoryOp(Operands.AddressInfoMask, 1, 2, 255); emitW[off++] = new MemoryOp(Operands.AddressInfoMask, 55, 23, 255, 8, 2, 1, 100, 98); emitW[off++] = new MemoryOp(Operands.AddressInfoMask, 32, 2, 255, 204); for (int i = 0; i < off; i++) { MemoryOp w = emitW[i]; Assert.AreEqual((UInt64)(w.op.Length + 1), emitW[i].Emit(byteCode, 0)); //Assert.AreEqual((Byte)(Operands.LongVariableMask | (l.longAddress.Length-1)), byteCode[0]); for (Byte j = 0; j < w.op.Length; j++) { Assert.AreEqual(w.op[j], byteCode[j + 1]); } } /* * off = 0; * emitW[off++] = new EmitLiteral(34); * emitW[off++] = new EmitLiteral(88, 1); * emitW[off++] = new EmitLiteral(1, 2, 255); * emitW[off++] = new EmitLiteral(55, 23, 255, 8, 2, 1, 100, 98); * emitW[off++] = new EmitLiteral(32, 2, 255, 204); * for (int i = 0; i < off; i++) * { * EmitLiteral lit = (EmitLiteral)emitW[i]; * * Assert.AreEqual((UInt64)(lit.literal.Length + 1), emitW[i].Emit(byteCode, 0)); * //Assert.AreEqual((Byte)(Operands.LiteralInfoMask | (lit.literal.Length - 1)), byteCode[0]); * for (Byte j = 0; j < lit.literal.Length; j++) * { * Assert.AreEqual(lit.literal[j], byteCode[j + 1]); * } * } */ }