rarvm.c File Reference

#include "rarvm.h"
#include "../common/allocator.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

Include dependency graph for rarvm.c:

Go to the source code of this file.

Data Structures
struct	RAROpcode_s
struct	RARProgram_s

Macros
#define	EXTMACRO_BEGIN   do {
#define	EXTMACRO_END   } while (0)
#define	CarryFlag   1
#define	ZeroFlag   2
#define	SignFlag   0x80000000
#define	SignExtend(a)   ((uint32_t)((int8_t)(a)))
#define	GetOperand1()   _RARGetOperand(vm, opcode->addressingmode1, opcode->value1, opcode->bytemode & 1)
#define	GetOperand2()   _RARGetOperand(vm, opcode->addressingmode2, opcode->value2, opcode->bytemode & 2)
#define	SetOperand1(data)   _RARSetOperand(vm, opcode->addressingmode1, opcode->value1, opcode->bytemode & 1, data)
#define	SetOperand2(data)   _RARSetOperand(vm, opcode->addressingmode2, opcode->value2, opcode->bytemode & 2, data)
#define	SetFlagsWithCarry(res, carry)   EXTMACRO_BEGIN uint32_t result = (res); flags = (result == 0 ? ZeroFlag : (result & SignFlag)) | ((carry) ? CarryFlag : 0); EXTMACRO_END
#define	SetByteFlagsWithCarry(res, carry)   EXTMACRO_BEGIN uint8_t result = (res); flags = (result == 0 ? ZeroFlag : (SignExtend(result) & SignFlag)) | ((carry) ? CarryFlag : 0); EXTMACRO_END
#define	SetFlags(res)   SetFlagsWithCarry(res, 0)
#define	SetOperand1AndFlagsWithCarry(res, carry)   EXTMACRO_BEGIN uint32_t r = (res); SetFlagsWithCarry(r, carry); SetOperand1(r); EXTMACRO_END
#define	SetOperand1AndByteFlagsWithCarry(res, carry)   EXTMACRO_BEGIN uint8_t r = (res); SetByteFlagsWithCarry(r, carry); SetOperand1(r); EXTMACRO_END
#define	SetOperand1AndFlags(res)   EXTMACRO_BEGIN uint32_t r = (res); SetFlags(r); SetOperand1(r); EXTMACRO_END
#define	NextInstruction()   { opcode++; continue; }
#define	Jump(offs)   { uint32_t o = (offs); if (o >= prog->length) return false; opcode = &prog->opcodes[o]; continue; }
#define	RAR0OperandsFlag   0
#define	RAR1OperandFlag   1
#define	RAR2OperandsFlag   2
#define	RAROperandsFlag   3
#define	RARHasByteModeFlag   4
#define	RARIsUnconditionalJumpFlag   8
#define	RARIsRelativeJumpFlag   16
#define	RARWritesFirstOperandFlag   32
#define	RARWritesSecondOperandFlag   64
#define	RARReadsStatusFlag   128
#define	RARWritesStatusFlag   256

Typedefs
typedef struct RAROpcode_s	RAROpcode

Functions
RARProgram *	RARCreateProgram ()
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)
static uint32_t	_RARGetOperand (RARVirtualMachine *vm, uint8_t addressingmode, uint32_t value, bool bytemode)
static void	_RARSetOperand (RARVirtualMachine *vm, uint8_t addressingmode, uint32_t value, bool bytemode, uint32_t data)
bool	RARExecuteProgram (RARVirtualMachine *vm, RARProgram *prog)
static uint32_t	_RARRead32 (const uint8_t *b)
static void	_RARWrite32 (uint8_t *b, uint32_t n)
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)
static void	RARPrintOperand (uint8_t addressingmode, uint32_t value)
void	RARPrintProgram (RARProgram *prog)

Variables
static const int	InstructionFlags [RARNumberOfInstructions]

Macro Definition Documentation

#define CarryFlag   1

Definition at line 115 of file rarvm.c.

#define EXTMACRO_BEGIN   do {

Definition at line 108 of file rarvm.c.

#define EXTMACRO_END   } while (0)

Definition at line 112 of file rarvm.c.

#define GetOperand1

(

)

_RARGetOperand(vm, opcode->addressingmode1, opcode->value1, opcode->bytemode & 1)

Definition at line 124 of file rarvm.c.

#define GetOperand2

(

)

_RARGetOperand(vm, opcode->addressingmode2, opcode->value2, opcode->bytemode & 2)

Definition at line 125 of file rarvm.c.

#define Jump

(

offs)

{ uint32_t o = (offs); if (o >= prog->length) return false; opcode = &prog->opcodes[o]; continue; }

Definition at line 138 of file rarvm.c.

#define NextInstruction

(

)

{ opcode++; continue; }

Definition at line 137 of file rarvm.c.

#define RAR0OperandsFlag   0

Definition at line 473 of file rarvm.c.

#define RAR1OperandFlag   1

Definition at line 474 of file rarvm.c.

#define RAR2OperandsFlag   2

Definition at line 475 of file rarvm.c.

#define RARHasByteModeFlag   4

Definition at line 477 of file rarvm.c.

#define RARIsRelativeJumpFlag   16

Definition at line 479 of file rarvm.c.

#define RARIsUnconditionalJumpFlag   8

Definition at line 478 of file rarvm.c.

#define RAROperandsFlag   3

Definition at line 476 of file rarvm.c.

#define RARReadsStatusFlag   128

Definition at line 482 of file rarvm.c.

#define RARWritesFirstOperandFlag   32

Definition at line 480 of file rarvm.c.

#define RARWritesSecondOperandFlag   64

Definition at line 481 of file rarvm.c.

#define RARWritesStatusFlag   256

Definition at line 483 of file rarvm.c.

#define SetByteFlagsWithCarry	(		res,
			carry
	)		EXTMACRO_BEGIN uint8_t result = (res); flags = (result == 0 ? ZeroFlag : (SignExtend(result) & SignFlag)) | ((carry) ? CarryFlag : 0); EXTMACRO_END

Definition at line 130 of file rarvm.c.

#define SetFlags

(

res)

SetFlagsWithCarry(res, 0)

Definition at line 131 of file rarvm.c.

#define SetFlagsWithCarry	(		res,
			carry
	)		EXTMACRO_BEGIN uint32_t result = (res); flags = (result == 0 ? ZeroFlag : (result & SignFlag)) | ((carry) ? CarryFlag : 0); EXTMACRO_END

Definition at line 129 of file rarvm.c.

#define SetOperand1

(

data)

_RARSetOperand(vm, opcode->addressingmode1, opcode->value1, opcode->bytemode & 1, data)

Definition at line 126 of file rarvm.c.

#define SetOperand1AndByteFlagsWithCarry	(		res,
			carry
	)		EXTMACRO_BEGIN uint8_t r = (res); SetByteFlagsWithCarry(r, carry); SetOperand1(r); EXTMACRO_END

Definition at line 134 of file rarvm.c.

#define SetOperand1AndFlags

(

res)

EXTMACRO_BEGIN uint32_t r = (res); SetFlags(r); SetOperand1(r); EXTMACRO_END

Definition at line 135 of file rarvm.c.

#define SetOperand1AndFlagsWithCarry	(		res,
			carry
	)		EXTMACRO_BEGIN uint32_t r = (res); SetFlagsWithCarry(r, carry); SetOperand1(r); EXTMACRO_END

Definition at line 133 of file rarvm.c.

#define SetOperand2

(

data)

_RARSetOperand(vm, opcode->addressingmode2, opcode->value2, opcode->bytemode & 2, data)

Definition at line 127 of file rarvm.c.

#define SignExtend

(

a)

((uint32_t)((int8_t)(a)))

Definition at line 119 of file rarvm.c.

#define SignFlag   0x80000000

Definition at line 117 of file rarvm.c.

#define ZeroFlag   2

Definition at line 116 of file rarvm.c.

Typedef Documentation

typedef struct RAROpcode_s RAROpcode

Definition at line 12 of file rarvm.c.

Function Documentation

static uint32_t _RARGetOperand ( RARVirtualMachine *  vm, uint8_t  addressingmode, uint32_t  value, bool  bytemode  )

static

Definition at line 417 of file rarvm.c.

{
    if (RARRegisterAddressingMode(0) <= addressingmode && addressingmode <= RARRegisterAddressingMode(7)) {
        uint32_t result = vm->registers[addressingmode % 8];
        if (bytemode)
            result = result & 0xFF;
        return result;
    }
    if (RARRegisterIndirectAddressingMode(0) <= addressingmode && addressingmode <= RARRegisterIndirectAddressingMode(7)) {
        if (bytemode)
            return RARVirtualMachineRead8(vm, vm->registers[addressingmode % 8]);
        return RARVirtualMachineRead32(vm, vm->registers[addressingmode % 8]);
    }
    if (RARIndexedAbsoluteAddressingMode(0) <= addressingmode && addressingmode <= RARIndexedAbsoluteAddressingMode(7)) {
        if (bytemode)
            return RARVirtualMachineRead8(vm, value + vm->registers[addressingmode % 8]);
        return RARVirtualMachineRead32(vm, value + vm->registers[addressingmode % 8]);
    }
    if (addressingmode == RARAbsoluteAddressingMode) {
        if (bytemode)
            return RARVirtualMachineRead8(vm, value);
        return RARVirtualMachineRead32(vm, value);
    }
    /* if (addressingmode == RARImmediateAddressingMode) */
    return value;
}

static uint32_t _RARRead32 ( const uint8_t *  b)

static

Definition at line 376 of file rarvm.c.

{
    return ((uint32_t)b[3] << 24) | ((uint32_t)b[2] << 16) | ((uint32_t)b[1] << 8) | (uint32_t)b[0];
}

Here is the caller graph for this function:

static void _RARSetOperand ( RARVirtualMachine *  vm, uint8_t  addressingmode, uint32_t  value, bool  bytemode, uint32_t  data  )

static

Definition at line 444 of file rarvm.c.

{
    if (RARRegisterAddressingMode(0) <= addressingmode && addressingmode <= RARRegisterAddressingMode(7)) {
        if (bytemode)
            data = data & 0xFF;
        vm->registers[addressingmode % 8] = data;
    }
    else if (RARRegisterIndirectAddressingMode(0) <= addressingmode && addressingmode <= RARRegisterIndirectAddressingMode(7)) {
        if (bytemode)
            RARVirtualMachineWrite8(vm, vm->registers[addressingmode % 8], (uint8_t)data);
        else
            RARVirtualMachineWrite32(vm, vm->registers[addressingmode % 8], data);
    }
    else if (RARIndexedAbsoluteAddressingMode(0) <= addressingmode && addressingmode <= RARIndexedAbsoluteAddressingMode(7)) {
        if (bytemode)
            RARVirtualMachineWrite8(vm, value + vm->registers[addressingmode % 8], (uint8_t)data);
        else
            RARVirtualMachineWrite32(vm, value + vm->registers[addressingmode % 8], data);
    }
    else if (addressingmode == RARAbsoluteAddressingMode) {
        if (bytemode)
            RARVirtualMachineWrite8(vm, value, (uint8_t)data);
        else
            RARVirtualMachineWrite32(vm, value, data);
    }
}

static void _RARWrite32 ( uint8_t *  b, uint32_t  n  )

static

Definition at line 381 of file rarvm.c.

{
    b[3] = (n >> 24) & 0xFF;
    b[2] = (n >> 16) & 0xFF;
    b[1] = (n >> 8) & 0xFF;
    b[0] = n & 0xFF;
}

Here is the caller graph for this function:

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:

static void RARPrintOperand ( uint8_t  addressingmode, uint32_t  value  )

static

Definition at line 575 of file rarvm.c.

{
    if (RARRegisterAddressingMode(0) <= addressingmode && addressingmode <= RARRegisterAddressingMode(7))
        printf("r%d", addressingmode % 8);
    else if (RARRegisterIndirectAddressingMode(0) <= addressingmode && addressingmode <= RARRegisterIndirectAddressingMode(7))
        printf("@(r%d)", addressingmode % 8);
    else if (RARIndexedAbsoluteAddressingMode(0) <= addressingmode && addressingmode <= RARIndexedAbsoluteAddressingMode(7))
        printf("@(r%d+$%02x)", addressingmode % 8, value);
    else if (addressingmode == RARAbsoluteAddressingMode)
        printf("@($%02x)", value);
    else if (addressingmode == RARImmediateAddressingMode)
        printf("$%02x", value);
}

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:

Variable Documentation

const int InstructionFlags[RARNumberOfInstructions]

static

Definition at line 485 of file rarvm.c.