rarvm.h File Reference

#include <stdint.h>
#include <stdbool.h>

Include dependency graph for rarvm.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	RARVirtualMachine

Macros
#define	RARProgramMemorySize   0x40000
#define	RARProgramMemoryMask   (RARProgramMemorySize - 1)
#define	RARProgramWorkSize   0x3c000
#define	RARProgramGlobalSize   0x2000
#define	RARProgramSystemGlobalAddress   RARProgramWorkSize
#define	RARProgramSystemGlobalSize   64
#define	RARProgramUserGlobalAddress   (RARProgramSystemGlobalAddress + RARProgramSystemGlobalSize)
#define	RARProgramUserGlobalSize   (RARProgramGlobalSize - RARProgramSystemGlobalSize)
#define	RARRuntimeMaxInstructions   250000000
#define	RARRegisterAddressingMode(n)   (0 + (n))
#define	RARRegisterIndirectAddressingMode(n)   (8 + (n))
#define	RARIndexedAbsoluteAddressingMode(n)   (16 + (n))
#define	RARAbsoluteAddressingMode   24
#define	RARImmediateAddressingMode   25
#define	RARNumberOfAddressingModes   26

Typedefs
typedef struct RARVirtualMachine	RARVirtualMachine
typedef struct RARProgram_s	RARProgram

Enumerations
enum	{   RARMovInstruction = 0, RARCmpInstruction = 1, RARAddInstruction = 2, RARSubInstruction = 3,   RARJzInstruction = 4, RARJnzInstruction = 5, RARIncInstruction = 6, RARDecInstruction = 7,   RARJmpInstruction = 8, RARXorInstruction = 9, RARAndInstruction = 10, RAROrInstruction = 11,   RARTestInstruction = 12, RARJsInstruction = 13, RARJnsInstruction = 14, RARJbInstruction = 15,   RARJbeInstruction = 16, RARJaInstruction = 17, RARJaeInstruction = 18, RARPushInstruction = 19,   RARPopInstruction = 20, RARCallInstruction = 21, RARRetInstruction = 22, RARNotInstruction = 23,   RARShlInstruction = 24, RARShrInstruction = 25, RARSarInstruction = 26, RARNegInstruction = 27,   RARPushaInstruction = 28, RARPopaInstruction = 29, RARPushfInstruction = 30, RARPopfInstruction = 31,   RARMovzxInstruction = 32, RARMovsxInstruction = 33, RARXchgInstruction = 34, RARMulInstruction = 35,   RARDivInstruction = 36, RARAdcInstruction = 37, RARSbbInstruction = 38, RARPrintInstruction = 39,   RARNumberOfInstructions = 40 }

Functions
RARProgram *	RARCreateProgram (void)
void	RARDeleteProgram (RARProgram *prog)
bool	RARProgramAddInstr (RARProgram *prog, uint8_t instruction, bool bytemode)
bool	RARSetLastInstrOperands (RARProgram *prog, uint8_t addressingmode1, uint32_t value1, uint8_t addressingmode2, uint32_t value2)
bool	RARIsProgramTerminated (RARProgram *prog)
bool	RARExecuteProgram (RARVirtualMachine *vm, RARProgram *prog)
void	RARSetVirtualMachineRegisters (RARVirtualMachine *vm, uint32_t registers[8])
uint32_t	RARVirtualMachineRead32 (RARVirtualMachine *vm, uint32_t address)
void	RARVirtualMachineWrite32 (RARVirtualMachine *vm, uint32_t address, uint32_t val)
uint8_t	RARVirtualMachineRead8 (RARVirtualMachine *vm, uint32_t address)
void	RARVirtualMachineWrite8 (RARVirtualMachine *vm, uint32_t address, uint8_t val)
int	NumberOfRARInstructionOperands (uint8_t instruction)
bool	RARInstructionHasByteMode (uint8_t instruction)
bool	RARInstructionIsUnconditionalJump (uint8_t instruction)
bool	RARInstructionIsRelativeJump (uint8_t instruction)
bool	RARInstructionWritesFirstOperand (uint8_t instruction)
bool	RARInstructionWritesSecondOperand (uint8_t instruction)
void	RARPrintProgram (RARProgram *prog)

Macro Definition Documentation

#define RARAbsoluteAddressingMode   24

Definition at line 25 of file rarvm.h.

#define RARImmediateAddressingMode   25

Definition at line 26 of file rarvm.h.

#define RARIndexedAbsoluteAddressingMode

(

n)

(16 + (n))

Definition at line 24 of file rarvm.h.

#define RARNumberOfAddressingModes   26

Definition at line 27 of file rarvm.h.

#define RARProgramGlobalSize   0x2000

Definition at line 15 of file rarvm.h.

#define RARProgramMemoryMask   (RARProgramMemorySize - 1)

Definition at line 13 of file rarvm.h.

#define RARProgramMemorySize   0x40000

Definition at line 12 of file rarvm.h.

#define RARProgramSystemGlobalAddress   RARProgramWorkSize

Definition at line 16 of file rarvm.h.

#define RARProgramSystemGlobalSize   64

Definition at line 17 of file rarvm.h.

#define RARProgramUserGlobalAddress   (RARProgramSystemGlobalAddress + RARProgramSystemGlobalSize)

Definition at line 18 of file rarvm.h.

#define RARProgramUserGlobalSize   (RARProgramGlobalSize - RARProgramSystemGlobalSize)

Definition at line 19 of file rarvm.h.

#define RARProgramWorkSize   0x3c000

Definition at line 14 of file rarvm.h.

#define RARRegisterAddressingMode

(

n)

(0 + (n))

Definition at line 22 of file rarvm.h.

#define RARRegisterIndirectAddressingMode

(

n)

(8 + (n))

Definition at line 23 of file rarvm.h.

#define RARRuntimeMaxInstructions   250000000

Definition at line 20 of file rarvm.h.

Typedef Documentation

typedef struct RARProgram_s RARProgram

Definition at line 36 of file rarvm.h.

typedef struct RARVirtualMachine RARVirtualMachine

Definition at line 29 of file rarvm.h.

Enumeration Type Documentation

anonymous enum

Enumerator
RARMovInstruction
RARCmpInstruction
RARAddInstruction
RARSubInstruction
RARJzInstruction
RARJnzInstruction
RARIncInstruction
RARDecInstruction
RARJmpInstruction
RARXorInstruction
RARAndInstruction
RAROrInstruction
RARTestInstruction
RARJsInstruction
RARJnsInstruction
RARJbInstruction
RARJbeInstruction
RARJaInstruction
RARJaeInstruction
RARPushInstruction
RARPopInstruction
RARCallInstruction
RARRetInstruction
RARNotInstruction
RARShlInstruction
RARShrInstruction
RARSarInstruction
RARNegInstruction
RARPushaInstruction
RARPopaInstruction
RARPushfInstruction
RARPopfInstruction
RARMovzxInstruction
RARMovsxInstruction
RARXchgInstruction
RARMulInstruction
RARDivInstruction
RARAdcInstruction
RARSbbInstruction
RARPrintInstruction
RARNumberOfInstructions

Definition at line 40 of file rarvm.h.

     {
    RARMovInstruction = 0,
    RARCmpInstruction = 1,
    RARAddInstruction = 2,
    RARSubInstruction = 3,
    RARJzInstruction = 4,
    RARJnzInstruction = 5,
    RARIncInstruction = 6,
    RARDecInstruction = 7,
    RARJmpInstruction = 8,
    RARXorInstruction = 9,
    RARAndInstruction = 10,
    RAROrInstruction = 11,
    RARTestInstruction = 12,
    RARJsInstruction = 13,
    RARJnsInstruction = 14,
    RARJbInstruction = 15,
    RARJbeInstruction = 16,
    RARJaInstruction = 17,
    RARJaeInstruction = 18,
    RARPushInstruction = 19,
    RARPopInstruction = 20,
    RARCallInstruction = 21,
    RARRetInstruction = 22,
    RARNotInstruction = 23,
    RARShlInstruction = 24,
    RARShrInstruction = 25,
    RARSarInstruction = 26,
    RARNegInstruction = 27,
    RARPushaInstruction = 28,
    RARPopaInstruction = 29,
    RARPushfInstruction = 30,
    RARPopfInstruction = 31,
    RARMovzxInstruction = 32,
    RARMovsxInstruction = 33,
    RARXchgInstruction = 34,
    RARMulInstruction = 35,
    RARDivInstruction = 36,
    RARAdcInstruction = 37,
    RARSbbInstruction = 38,
    RARPrintInstruction = 39,
    RARNumberOfInstructions = 40,
};

Function Documentation

int NumberOfRARInstructionOperands

(

uint8_t

instruction)

Definition at line 528 of file rarvm.c.

{
    if (instruction >= RARNumberOfInstructions)
        return 0;
    return InstructionFlags[instruction] & RAROperandsFlag;
}

Here is the caller graph for this function:

RARProgram* RARCreateProgram

(

void

)

Definition at line 31 of file rarvm.c.

{
    return calloc(1, sizeof(RARProgram));
}

Here is the caller graph for this function:

void RARDeleteProgram

(

RARProgram *

prog)

Definition at line 36 of file rarvm.c.

{
    if (prog)
        free(prog->opcodes);
    free(prog);
}

Here is the caller graph for this function:

bool RARExecuteProgram	(	RARVirtualMachine *	vm,
		RARProgram *	prog
	)

Definition at line 140 of file rarvm.c.

{
    RAROpcode *opcode = prog->opcodes;
    uint32_t flags = 0;
    uint32_t op1, op2, carry, i;
    uint32_t counter = 0;

    if (!RARIsProgramTerminated(prog))
        return false;

    while ((uint32_t)(opcode - prog->opcodes) < prog->length && counter++ < RARRuntimeMaxInstructions) {
        switch (opcode->instruction) {
        case RARMovInstruction:
            SetOperand1(GetOperand2());
            NextInstruction();

        case RARCmpInstruction:
            op1 = GetOperand1();
            SetFlagsWithCarry(op1 - GetOperand2(), result > op1);
            NextInstruction();

        case RARAddInstruction:
            op1 = GetOperand1();
            if (opcode->bytemode)
                SetOperand1AndByteFlagsWithCarry((op1 + GetOperand2()) & 0xFF, result < op1);
            else
                SetOperand1AndFlagsWithCarry(op1 + GetOperand2(), result < op1);
            NextInstruction();

        case RARSubInstruction:
            op1 = GetOperand1();
#if 0 /* apparently not correctly implemented in the RAR VM */
            if (opcode->bytemode)
                SetOperand1AndByteFlagsWithCarry((op1 - GetOperand2()) & 0xFF, result > op1);
            else
#endif
            SetOperand1AndFlagsWithCarry(op1 - GetOperand2(), result > op1);
            NextInstruction();

        case RARJzInstruction:
            if ((flags & ZeroFlag))
                Jump(GetOperand1());
            NextInstruction();

        case RARJnzInstruction:
            if (!(flags & ZeroFlag))
                Jump(GetOperand1());
            NextInstruction();

        case RARIncInstruction:
            if (opcode->bytemode)
                SetOperand1AndFlags((GetOperand1() + 1) & 0xFF);
            else
                SetOperand1AndFlags(GetOperand1() + 1);
            NextInstruction();

        case RARDecInstruction:
            if (opcode->bytemode)
                SetOperand1AndFlags((GetOperand1() - 1) & 0xFF);
            else
                SetOperand1AndFlags(GetOperand1() - 1);
            NextInstruction();

        case RARJmpInstruction:
            Jump(GetOperand1());

        case RARXorInstruction:
            SetOperand1AndFlags(GetOperand1() ^ GetOperand2());
            NextInstruction();

        case RARAndInstruction:
            SetOperand1AndFlags(GetOperand1() & GetOperand2());
            NextInstruction();

        case RAROrInstruction:
            SetOperand1AndFlags(GetOperand1() | GetOperand2());
            NextInstruction();

        case RARTestInstruction:
            SetFlags(GetOperand1() & GetOperand2());
            NextInstruction();

        case RARJsInstruction:
            if ((flags & SignFlag))
                Jump(GetOperand1());
            NextInstruction();

        case RARJnsInstruction:
            if (!(flags & SignFlag))
                Jump(GetOperand1());
            NextInstruction();

        case RARJbInstruction:
            if ((flags & CarryFlag))
                Jump(GetOperand1());
            NextInstruction();

        case RARJbeInstruction:
            if ((flags & (CarryFlag | ZeroFlag)))
                Jump(GetOperand1());
            NextInstruction();

        case RARJaInstruction:
            if (!(flags & (CarryFlag | ZeroFlag)))
                Jump(GetOperand1());
            NextInstruction();

        case RARJaeInstruction:
            if (!(flags & CarryFlag))
                Jump(GetOperand1());
            NextInstruction();

        case RARPushInstruction:
            vm->registers[7] -= 4;
            RARVirtualMachineWrite32(vm, vm->registers[7], GetOperand1());
            NextInstruction();

        case RARPopInstruction:
            SetOperand1(RARVirtualMachineRead32(vm, vm->registers[7]));
            vm->registers[7] += 4;
            NextInstruction();

        case RARCallInstruction:
            vm->registers[7] -= 4;
            RARVirtualMachineWrite32(vm, vm->registers[7], (uint32_t)(opcode - prog->opcodes + 1));
            Jump(GetOperand1());

        case RARRetInstruction:
            if (vm->registers[7] >= RARProgramMemorySize)
                return true;
            i = RARVirtualMachineRead32(vm, vm->registers[7]);
            vm->registers[7] += 4;
            Jump(i);

        case RARNotInstruction:
            SetOperand1(~GetOperand1());
            NextInstruction();

        case RARShlInstruction:
            op1 = GetOperand1();
            op2 = GetOperand2();
            SetOperand1AndFlagsWithCarry(op1 << op2, ((op1 << (op2 - 1)) & 0x80000000) != 0);
            NextInstruction();

        case RARShrInstruction:
            op1 = GetOperand1();
            op2 = GetOperand2();
            SetOperand1AndFlagsWithCarry(op1 >> op2, ((op1 >> (op2 - 1)) & 1) != 0);
            NextInstruction();

        case RARSarInstruction:
            op1 = GetOperand1();
            op2 = GetOperand2();
            SetOperand1AndFlagsWithCarry(((int32_t)op1) >> op2, ((op1 >> (op2 - 1)) & 1) != 0);
            NextInstruction();

        case RARNegInstruction:
            SetOperand1AndFlagsWithCarry(-(int32_t)GetOperand1(), result != 0);
            NextInstruction();

        case RARPushaInstruction:
            vm->registers[7] -= 32;
            for (i = 0; i < 8; i++)
                RARVirtualMachineWrite32(vm, vm->registers[7] + (7 - i) * 4, vm->registers[i]);
            NextInstruction();

        case RARPopaInstruction:
            for (i = 0; i < 8; i++)
                vm->registers[i] = RARVirtualMachineRead32(vm, vm->registers[7] + (7 - i) * 4);
            vm->registers[7] += 32;
            NextInstruction();

        case RARPushfInstruction:
            vm->registers[7] -= 4;
            RARVirtualMachineWrite32(vm, vm->registers[7], flags);
            NextInstruction();

        case RARPopfInstruction:
            flags = RARVirtualMachineRead32(vm, vm->registers[7]);
            vm->registers[7] += 4;
            NextInstruction();

        case RARMovzxInstruction:
            SetOperand1(GetOperand2());
            NextInstruction();

        case RARMovsxInstruction:
            SetOperand1(SignExtend(GetOperand2()));
            NextInstruction();

        case RARXchgInstruction:
            op1 = GetOperand1();
            op2 = GetOperand2();
            SetOperand1(op2);
            SetOperand2(op1);
            NextInstruction();

        case RARMulInstruction:
            SetOperand1(GetOperand1() * GetOperand2());
            NextInstruction();

        case RARDivInstruction:
            op2 = GetOperand2();
            if (op2 != 0)
                SetOperand1(GetOperand1() / op2);
            NextInstruction();

        case RARAdcInstruction:
            op1 = GetOperand1();
            carry = (flags & CarryFlag);
            if (opcode->bytemode)
                SetOperand1AndFlagsWithCarry((op1 + GetOperand2() + carry) & 0xFF, result < op1 || (result == op1 && carry)); /* does not correctly set sign bit */
            else
                SetOperand1AndFlagsWithCarry(op1 + GetOperand2() + carry, result < op1 || (result == op1 && carry));
            NextInstruction();

        case RARSbbInstruction:
            op1 = GetOperand1();
            carry = (flags & CarryFlag);
            if (opcode->bytemode)
                SetOperand1AndFlagsWithCarry((op1 - GetOperand2() - carry) & 0xFF, result > op1 || (result == op1 && carry)); /* does not correctly set sign bit */
            else
                SetOperand1AndFlagsWithCarry(op1 - GetOperand2() - carry, result > op1 || (result == op1 && carry));
            NextInstruction();

        case RARPrintInstruction:
            /* TODO: ??? */
            NextInstruction();
        }
    }

    return false;
}

Here is the caller graph for this function:

bool RARInstructionHasByteMode

(

uint8_t

instruction)

Definition at line 535 of file rarvm.c.

{
    if (instruction >= RARNumberOfInstructions)
        return false;
    return (InstructionFlags[instruction] & RARHasByteModeFlag)!=0;
}

Here is the caller graph for this function:

bool RARInstructionIsRelativeJump

(

uint8_t

instruction)

Definition at line 549 of file rarvm.c.

{
    if (instruction >= RARNumberOfInstructions)
        return false;
    return (InstructionFlags[instruction] & RARIsRelativeJumpFlag) != 0;
}

Here is the caller graph for this function:

bool RARInstructionIsUnconditionalJump

(

uint8_t

instruction)

Definition at line 542 of file rarvm.c.

{
    if (instruction >= RARNumberOfInstructions)
        return false;
    return (InstructionFlags[instruction] & RARIsUnconditionalJumpFlag) != 0;
}

Here is the caller graph for this function:

bool RARInstructionWritesFirstOperand

(

uint8_t

instruction)

Definition at line 556 of file rarvm.c.

{
    if (instruction >= RARNumberOfInstructions)
        return false;
    return (InstructionFlags[instruction] & RARWritesFirstOperandFlag) != 0;
}

Here is the caller graph for this function:

bool RARInstructionWritesSecondOperand

(

uint8_t

instruction)

Definition at line 563 of file rarvm.c.

{
    if (instruction >= RARNumberOfInstructions)
        return false;
    return (InstructionFlags[instruction] & RARWritesSecondOperandFlag) != 0;
}

Here is the caller graph for this function:

bool RARIsProgramTerminated

(

RARProgram *

prog)

Definition at line 101 of file rarvm.c.

{
    return prog->length > 0 && RARInstructionIsUnconditionalJump(prog->opcodes[prog->length - 1].instruction);
}

Here is the caller graph for this function:

void RARPrintProgram

(

RARProgram *

prog)

Definition at line 589 of file rarvm.c.

{
    static const char *instructionNames[RARNumberOfInstructions] = {
        "Mov", "Cmp", "Add", "Sub", "Jz", "Jnz", "Inc", "Dec", "Jmp", "Xor",
        "And", "Or", "Test", "Js", "Jns", "Jb", "Jbe", "Ja", "Jae", "Push",
        "Pop", "Call", "Ret", "Not", "Shl", "Shr", "Sar", "Neg", "Pusha", "Popa",
        "Pushf", "Popf", "Movzx", "Movsx", "Xchg", "Mul", "Div", "Adc", "Sbb", "Print",
    };

    uint32_t i;
    for (i = 0; i < prog->length; i++) {
        RAROpcode *opcode = &prog->opcodes[i];
        int numoperands = NumberOfRARInstructionOperands(opcode->instruction);
        printf("  %02x: %s", i, instructionNames[opcode->instruction]);
        if (opcode->bytemode)
            printf("B");
        if (numoperands >= 1) {
            printf(" ");
            RARPrintOperand(opcode->addressingmode1, opcode->value1);
        }
        if (numoperands == 2) {
            printf(", ");
            RARPrintOperand(opcode->addressingmode2, opcode->value2);
        }
        printf("\n");
    }
}

bool RARProgramAddInstr	(	RARProgram *	prog,
		uint8_t	instruction,
		bool	bytemode
	)

Definition at line 43 of file rarvm.c.

{
    if (instruction >= RARNumberOfInstructions)
        return false;
    if (bytemode && !RARInstructionHasByteMode(instruction))
        return false;
    if (prog->length + 1 >= prog->capacity) {
        /* in my small file sample, 16 is the value needed most often */
        uint32_t newCapacity = prog->capacity ? prog->capacity * 4 : 32;
        RAROpcode *newCodes = calloc(newCapacity, sizeof(*prog->opcodes));
        if (!newCodes)
            return false;
        memcpy(newCodes, prog->opcodes, prog->capacity * sizeof(*prog->opcodes));
        free(prog->opcodes);
        prog->opcodes = newCodes;
        prog->capacity = newCapacity;
    }
    memset(&prog->opcodes[prog->length], 0, sizeof(prog->opcodes[prog->length]));
    prog->opcodes[prog->length].instruction = instruction;
    if (instruction == RARMovzxInstruction || instruction == RARMovsxInstruction)
        prog->opcodes[prog->length].bytemode = 2; /* second argument only */
    else if (bytemode)
        prog->opcodes[prog->length].bytemode = (1 | 2);
    else
        prog->opcodes[prog->length].bytemode = 0;
    prog->length++;
    return true;
}

Here is the caller graph for this function:

bool RARSetLastInstrOperands	(	RARProgram *	prog,
		uint8_t	addressingmode1,
		uint32_t	value1,
		uint8_t	addressingmode2,
		uint32_t	value2
	)

Definition at line 72 of file rarvm.c.

{
    RAROpcode *opcode = &prog->opcodes[prog->length - 1];
    int numoperands;

    if (addressingmode1 >= RARNumberOfAddressingModes || addressingmode2 >= RARNumberOfAddressingModes)
        return false;
    if (!prog->length || opcode->addressingmode1 || opcode->value1 || opcode->addressingmode2 || opcode->value2)
        return false;

    numoperands = NumberOfRARInstructionOperands(opcode->instruction);
    if (numoperands == 0)
        return true;

    if (addressingmode1 == RARImmediateAddressingMode && RARInstructionWritesFirstOperand(opcode->instruction))
        return false;
    opcode->addressingmode1 = addressingmode1;
    opcode->value1 = value1;

    if (numoperands == 2) {
        if (addressingmode2 == RARImmediateAddressingMode && RARInstructionWritesSecondOperand(opcode->instruction))
            return false;
        opcode->addressingmode2 = addressingmode2;
        opcode->value2 = value2;
    }

    return true;
}

Here is the caller graph for this function:

void RARSetVirtualMachineRegisters	(	RARVirtualMachine *	vm,
		uint32_t	registers[8]
	)

Definition at line 389 of file rarvm.c.

{
    if (registers)
        memcpy(vm->registers, registers, sizeof(vm->registers));
    else
        memset(vm->registers, 0, sizeof(vm->registers));
}

Here is the caller graph for this function:

uint32_t RARVirtualMachineRead32	(	RARVirtualMachine *	vm,
		uint32_t	address
	)

Definition at line 397 of file rarvm.c.

{
    return _RARRead32(&vm->memory[address & RARProgramMemoryMask]);
}

Here is the caller graph for this function:

uint8_t RARVirtualMachineRead8	(	RARVirtualMachine *	vm,
		uint32_t	address
	)

Definition at line 407 of file rarvm.c.

{
    return vm->memory[address & RARProgramMemoryMask];
}

Here is the caller graph for this function:

void RARVirtualMachineWrite32	(	RARVirtualMachine *	vm,
		uint32_t	address,
		uint32_t	val
	)

Definition at line 402 of file rarvm.c.

{
    _RARWrite32(&vm->memory[address & RARProgramMemoryMask], val);
}

Here is the caller graph for this function:

void RARVirtualMachineWrite8	(	RARVirtualMachine *	vm,
		uint32_t	address,
		uint8_t	val
	)

Definition at line 412 of file rarvm.c.

{
    vm->memory[address & RARProgramMemoryMask] = val;
}

Here is the caller graph for this function: