public Instructions()
{
instructions["ST"] = new ST();
instructions["LD"] = new LD();
instructions["ADD"] = new ADD();
instructions["SUB"] = new SUB();
instructions["JMP"] = new JMP();
instructions["JN"] = new JN();
instructions["JP"] = new JP();
instructions["JZ"] = new JZ();
instructions["JNZ"] = new JNZ();
instructions["HALT"] = new HALT();
//Second architecture functions.
instructions["LD2"] = new LD2();
instructions["LD3"] = new LD3();
instructions["ST2"] = new ST2();
instructions["ST3"] = new ST3();
instructions["POS"] = new POS();
instructions["PXL"] = new PXL();
instructions["RND"] = new RND();
instructions["CLR"] = new CLR();
instructions["COS"] = new COS();
instructions["SIN"] = new SIN();
instructions["IN"] = new IN();
}
private void AddIfElseBranches(If control, JPF jpf, JMP jmp)
{
Int32 endOfBlock = jmp.Index;
while (true)
{
Int32 newJpfIndex = jpf.Index;
JPF newJpf = _instructions[newJpfIndex] as JPF;
if (newJpf == null || newJpf.Index > endOfBlock)
{
control.AddElse(jpf.Index, endOfBlock);
return;
}
JMP newJmp = _instructions[newJpf.Index - 1] as JMP;
if (newJmp == null)
{
if (newJpf.Index == endOfBlock)
{
// if-elseif without jmp
_processed.Process(newJpf);
control.AddIf(newJpfIndex, newJpf.Index);
}
else
{
// if-else without jmp
control.AddElse(jpf.Index, endOfBlock);
}
return;
}
// Isn't our jump
if (newJmp.Index != endOfBlock)
{
control.AddElse(jpf.Index, endOfBlock);
return;
}
jpf = newJpf;
jmp = newJmp;
_processed.Process(jpf);
_processed.TryProcess(jmp);
control.AddIf(newJpfIndex, jpf.Index);
if (jpf.Index == endOfBlock)
{
return;
}
}
}
public static void execute(CPU cpu, MEM memory)
{
switch (memory.getMem(cpu.PC))
{
case 0x4C:
JMP.JMP_ABS(cpu, memory);
return;
case 0x6C:
JMP.JMP_INDIRECT(cpu, memory);
return;
}
}
IList <Run> IProgram.IVisitor <IList <Run> > .Visit(JMP jmp)
{
IList <Run> terminated = new List <Run>();
Run jmpRun = new Run(1);
if (jmp.Accept(jmpRun))
{
terminated.Add(jmpRun);
}
IProgram nop = IProgram.MakeNOP(jmp.Argument);
Run nopRun = new Run(1);
if (nop.Accept(nopRun))
{
terminated.Add(nopRun);
}
return(terminated);
}
public static void AssociateOpcodes()
{
instructions[0] = new NOP();
instructions[1] = new PRNT();
instructions[16] = new PUSH();
instructions[17] = new POP();
instructions[18] = new SAVE();
instructions[19] = new CPY();
instructions[20] = new RNDM();
instructions[21] = new EMPTY();
instructions[128] = new ADD();
instructions[129] = new SUB();
instructions[130] = new MUL();
instructions[131] = new DIV();
instructions[132] = new SUB2();
instructions[133] = new DIV2();
instructions[134] = new NEG();
instructions[135] = new ABS();
instructions[144] = new INC();
instructions[145] = new DEC();
instructions[64] = new JMP();
instructions[65] = new JGZ();
instructions[66] = new JLZ();
instructions[67] = new JEZ();
instructions[68] = new JNZ();
instructions[69] = new CALL();
instructions[70] = new RET();
instructions[71] = new LDLOC();
instructions[72] = new STLOC();
instructions[73] = new LDARG();
instructions[74] = new STARG();
instructions[0b10100100] = new CMP();
private static void AppendItems(StringBuilder sb, IEnumerable <Object> items)
{
Int32 position = -1;
JMP lastItem = null;
foreach (var item in items)
{
if (lastItem != null)
{
throw new InvalidProgramException($"Unexpected jump: {lastItem}");
}
lastItem = item as JMP;
position = sb.Length;
sb.Append('\t').AppendLine(item.ToString());
}
if (lastItem != null)
{
sb.Length = position;
}
}
private Boolean TryMakeIf()
{
JPF jpf = _begin;
JMP jmp = _instructions[_begin.Index - 1] as JMP;
If control = new If(_instructions, _index, _begin.Index);
_result.Add(control);
if (jmp == null)
{
// There is no JMP instruction. Simple if {}
return(true);
}
if (jmp.Index == jpf.Index)
{
// It isn't our jump, but an nested if. If { nested if{}<-}
return(true);
}
if (jmp.Index < jpf.Index)
{
// It isn't our jump, but an nested loop. If { nested while{}<-}
return(true);
}
if (jmp.Index < _index)
{
// It isn't our jump, but an nested goto. If { nested goto l;<-}
return(true);
}
_processed.Process(jmp);
AddIfElseBranches(control, jpf, jmp);
return(true);
}
public void TestJMP()
{
SignalBus signals = new SignalBus();
FlagsRegister flags = new FlagsRegister(null, signals, null);
flags.Value = FlagsRegister.CARRY;
Operation op = new JMP(null, signals, null);
signals.Reset();
op.Step0();
Assert.IsTrue(signals.MI);
Assert.IsTrue(signals.CO);
signals.Reset();
op.Step1();
Assert.IsTrue(signals.RO);
Assert.IsTrue(signals.II);
Assert.IsTrue(signals.CE);
signals.Reset();
op.Step2();
Assert.IsTrue(signals.IO);
Assert.IsTrue(signals.J);
}
public AnonymousInstruction(JMP parent)
{
this.parent = parent;
}
public bool Visit(JMP jmp)
{
Debug("JMP " + jmp.Argument + ": ");
UpdateState(jmp.Argument, 0);
return(Terminated);
}
public IProgram Visit(JMP jmp)
{
return(jmp);
}
public IList <IProgram> Visit(JMP jmp)
{
return(new List <IProgram> {
jmp
});
}
public int Visit(JMP jmp)
{
return(1);
}
public static Instruccion DescodificarInstruccion(byte codigo, ushort pos)
{
Instruccion instruccion = null;
ArgMemoria argumentoMemoria = Argumento.ConvertirEnArgumento((Main.ObtenerMemoria.ObtenerDireccion((ushort)(pos + 1)).Contenido * 256 + Main.ObtenerMemoria.ObtenerDireccion((ushort)(pos + 2)).Contenido).ToString("X4"), true) as ArgMemoria;
ArgRegistro argumentoRegistro = Argumento.ConvertirEnArgumento(Main.ObtenerNombreRegistro(codigo % 4), false) as ArgRegistro;
ArgLiteral argumentoLiteral = Argumento.ConvertirEnArgumento(Main.ObtenerMemoria.ObtenerDireccion((ushort)(pos + 1)).Contenido.ToString(), false) as ArgLiteral;
switch (codigo / 8)
{
case 0:
instruccion = new LD(argumentoRegistro);
break;
case 1:
instruccion = new ST(argumentoRegistro);
break;
case 4:
case 5:
instruccion = new LDM(argumentoMemoria, argumentoRegistro);
break;
case 6:
case 7:
instruccion = new STM(argumentoRegistro, argumentoMemoria);
break;
case 2:
case 3:
instruccion = new LDI(argumentoLiteral, argumentoRegistro);
break;
case 8:
instruccion = new ADD(argumentoRegistro);
break;
case 9:
instruccion = new SUB(argumentoRegistro);
break;
case 10:
instruccion = new CMP(argumentoRegistro);
break;
case 11:
instruccion = new INC();
break;
case 12:
instruccion = new ADI(argumentoLiteral);
break;
case 13:
instruccion = new SUI(argumentoLiteral);
break;
case 14:
case 15:
instruccion = new CMI(argumentoLiteral);
break;
case 16:
instruccion = new ANA(argumentoRegistro);
break;
case 17:
instruccion = new ORA(argumentoRegistro);
break;
case 18:
instruccion = new XRA(argumentoRegistro);
break;
case 19:
instruccion = new CMA();
break;
case 20:
instruccion = new ANI(argumentoLiteral);
break;
case 21:
instruccion = new ORI(argumentoLiteral);
break;
case 22:
case 23:
instruccion = new XRI(argumentoLiteral);
break;
case 24:
case 25:
instruccion = new JMP(argumentoMemoria);
break;
case 26:
instruccion = new BEQ(argumentoMemoria);
break;
case 27:
instruccion = new BC(argumentoMemoria);
break;
case 28:
case 29:
instruccion = new LF();
break;
case 30:
instruccion = new IN(argumentoMemoria, argumentoRegistro);
break;
case 31:
instruccion = new OUT(argumentoRegistro, argumentoMemoria);
break;
}
return(instruccion);
}
public static Instruction[] PeToInstructions(string FilePath)
{
UnmanagedBuffer buffer = new UnmanagedBuffer(File.ReadAllBytes(FilePath));
List <Instruction> instructs = new List <Instruction>();
Disasm disasm = new Disasm();
disasm.EIP = new IntPtr(buffer.Ptr.ToInt64() + 0x400);
List <int> Addresses = new List <int>();
while (true)
{
int result = Asm.Net.src.BeaEngine.BeaEngine.Disasm(disasm);
Addresses.Add(disasm.EIP.ToInt32());
if (result == (int)BeaConstants.SpecialInfo.UNKNOWN_OPCODE)
{
break;
}
//Console.WriteLine("0x" + disasm.EIP.ToString("X") + " " + disasm.CompleteInstr);
//convert the data to instructions so we are able to execute it in Asm.Net
//We also need to change the pointers for push, call, inc, dec etc... so Asm.Net is able to understand it
switch (disasm.Instruction.Opcode)
{
case (int)OpcodeList.CALL:
{
string tmp = disasm.Argument1.ArgMnemonic.Substring(0, disasm.Argument1.ArgMnemonic.Length - 1).Replace("FFFFFFFF", "");
int Jmpvalue = Convert.ToInt32(tmp, 16);
CALL call = new CALL(Jmpvalue);
call.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(call);
break;
}
case (int)OpcodeList.INC_EAX:
{
INC_EAX IncEax = new INC_EAX();
IncEax.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(IncEax);
break;
}
case (int)OpcodeList.INC_EDX:
{
break;
}
case (int)OpcodeList.JE:
{
break;
}
case (int)OpcodeList.JMP:
{
string tmp = disasm.Argument1.ArgMnemonic.Substring(0, disasm.Argument1.ArgMnemonic.Length - 1);
int Jmpvalue = Convert.ToInt32(tmp.Replace("FFFFFFFF", ""), 16);
JMP jmp = new JMP(Jmpvalue);
jmp.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
//instructs.Add(jmp);
break;
}
case (int)OpcodeList.JNZ:
{
string tmp = disasm.Argument1.ArgMnemonic.Substring(0, disasm.Argument1.ArgMnemonic.Length - 1);
int Jmpvalue = Convert.ToInt32(tmp.Replace("FFFFFFFF", ""), 16);
JNZ jnz = new JNZ(Jmpvalue);
jnz.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
//instructs.Add(jnz);
break;
}
case (int)OpcodeList.MOV_EAX:
{
string tmp = disasm.Argument2.ArgMnemonic.Substring(0, disasm.Argument2.ArgMnemonic.Length - 1);
int MovValue = Convert.ToInt32(tmp, 16);
MOV_EAX MovEAX = new MOV_EAX(new VirtualAddress(0, MovValue));
MovEAX.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(MovEAX);
break;
}
case (int)OpcodeList.NOP:
{
NOP nop = new NOP();
nop.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(nop);
break;
}
case (int)OpcodeList.PUSH_EAX:
{
break;
}
case (int)OpcodeList.RET:
{
RET ret = new RET();
ret.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(ret);
break;
}
case (int)OpcodeList.ADD:
{
//need to reverse check the opcodes...
Instruction ADD = null;
switch (disasm.Argument1.ArgMnemonic)
{
case "eax":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "al":
{
ADD = new ADD_BYTE_PTR_EAX_AL();
break;
}
}
break;
}
}
if (ADD != null)
{
ADD.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(ADD);
}
break;
}
case (int)OpcodeList.XOR_REGISTER:
{
Instruction xor = null;
switch (disasm.Argument1.ArgMnemonic)
{
case "eax":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_EAX_EAX(); break; }
case "ecx": { xor = new XOR_EAX_ECX(); break; }
case "edx": { xor = new XOR_EAX_EDX(); break; }
case "ebx": { xor = new XOR_EAX_EBX(); break; }
case "esp": { xor = new XOR_EAX_ESP(); break; }
case "ebp": { xor = new XOR_EAX_EBP(); break; }
case "esi": { xor = new XOR_EAX_ESI(); break; }
case "edi": { xor = new XOR_EAX_EDI(); break; }
}
break;
}
case "ecx":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_ECX_EAX(); break; }
case "ecx": { xor = new XOR_ECX_ECX(); break; }
case "edx": { xor = new XOR_ECX_EDX(); break; }
case "ebx": { xor = new XOR_ECX_EBX(); break; }
case "esp": { xor = new XOR_ECX_ESP(); break; }
case "ebp": { xor = new XOR_ECX_EBP(); break; }
case "esi": { xor = new XOR_ECX_ESI(); break; }
case "edi": { xor = new XOR_ECX_EDI(); break; }
}
break;
}
case "edx":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_EDX_EAX(); break; }
case "ecx": { xor = new XOR_EDX_ECX(); break; }
case "edx": { xor = new XOR_EDX_EDX(); break; }
case "ebx": { xor = new XOR_EDX_EBX(); break; }
case "esp": { xor = new XOR_EDX_ESP(); break; }
case "ebp": { xor = new XOR_EDX_EBP(); break; }
case "esi": { xor = new XOR_EDX_ESI(); break; }
case "edi": { xor = new XOR_EDX_EDI(); break; }
}
break;
}
case "ebx":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_EBX_EAX(); break; }
case "ecx": { xor = new XOR_EBX_ECX(); break; }
case "edx": { xor = new XOR_EBX_EDX(); break; }
case "ebx": { xor = new XOR_EBX_EBX(); break; }
case "esp": { xor = new XOR_EBX_ESP(); break; }
case "ebp": { xor = new XOR_EBX_EBP(); break; }
case "esi": { xor = new XOR_EBX_ESI(); break; }
case "edi": { xor = new XOR_EBX_EDI(); break; }
}
break;
}
case "esp":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_ESP_EAX(); break; }
case "ecx": { xor = new XOR_ESP_ECX(); break; }
case "edx": { xor = new XOR_ESP_EDX(); break; }
case "ebx": { xor = new XOR_ESP_EBX(); break; }
case "esp": { xor = new XOR_ESP_ESP(); break; }
case "ebp": { xor = new XOR_ESP_EBP(); break; }
case "esi": { xor = new XOR_ESP_ESI(); break; }
case "edi": { xor = new XOR_ESP_EDI(); break; }
}
break;
}
case "ebp":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_EBP_EAX(); break; }
case "ecx": { xor = new XOR_EBP_ECX(); break; }
case "edx": { xor = new XOR_EBP_EDX(); break; }
case "ebx": { xor = new XOR_EBP_EBX(); break; }
case "esp": { xor = new XOR_EBP_ESP(); break; }
case "ebp": { xor = new XOR_EBP_EBP(); break; }
case "esi": { xor = new XOR_EBP_ESI(); break; }
case "edi": { xor = new XOR_EBP_EDI(); break; }
}
break;
}
case "esi":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_ESI_EAX(); break; }
case "ecx": { xor = new XOR_ESI_ECX(); break; }
case "edx": { xor = new XOR_ESI_EDX(); break; }
case "ebx": { xor = new XOR_ESI_EBX(); break; }
case "esp": { xor = new XOR_ESI_ESP(); break; }
case "ebp": { xor = new XOR_ESI_EBP(); break; }
case "esi": { xor = new XOR_ESI_ESI(); break; }
case "edi": { xor = new XOR_ESI_EDI(); break; }
}
break;
}
case "edi":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_EDI_EAX(); break; }
case "ecx": { xor = new XOR_EDI_ECX(); break; }
case "edx": { xor = new XOR_EDI_EDX(); break; }
case "ebx": { xor = new XOR_EDI_EBX(); break; }
case "esp": { xor = new XOR_EDI_ESP(); break; }
case "ebp": { xor = new XOR_EDI_EBP(); break; }
case "esi": { xor = new XOR_EDI_ESI(); break; }
case "edi": { xor = new XOR_EDI_EDI(); break; }
}
break;
}
}
if (xor != null) //this check is just for temp, not all the XOR instructions are added
{
xor.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(xor);
}
break;
}
}
disasm.EIP = new IntPtr(disasm.EIP.ToInt64() + result);
}
//set all the pointers correct
int offset = Options.MemoryBaseAddress;
foreach (Instruction instruction in instructs)
{
switch (instruction.ToByteArray()[0])
{
case (int)OpcodeList.CALL:
{
break;
}
case (int)OpcodeList.INC_EAX:
{
break;
}
case (int)OpcodeList.INC_EDX:
{
break;
}
case (int)OpcodeList.JE:
{
break;
}
case (int)OpcodeList.JMP:
{
//lets set our new jmp pointer, We also should load the modules which are required to run this program
//We need to load the Import Table and get all the .dll's from it and getting all the instructions from it
bool NewSet = false;
foreach (Instruction instruct in instructs)
{
if (Addresses.Contains(((IJump)instruction).JumpAddress))
{
//Set the ASM.net pointer
int index = Addresses.IndexOf(((IJump)instruction).JumpAddress) - 1;
}
//if (((IJump)instruction).JumpAddress == instruct.NativeVirtualAddress.Address)
//{
//}
}
//if (!NewSet)
// throw new Exception("Unable to find the JMP Pointer, Invalid memory address ?");
break;
}
case (int)OpcodeList.MOV_EAX:
{
break;
}
case (int)OpcodeList.NOP:
{
break;
}
case (int)OpcodeList.PUSH_EAX:
{
break;
}
case (int)OpcodeList.RET:
{
break;
}
}
instruction.VirtualAddress.Address = offset;
offset += instruction.VirtualAddress.Size;
}
return(instructs.ToArray());
}
public JMPTest()
{
_jmp = new JMP(machine.CPU);
}
