gpcas_forwardcom 0.2.0

// Filename: jumps.rs
// Author:	 Kai Rese
// Version:	 0.11
// Date:	 15-07-2022 (DD-MM-YYYY)
// Library:  gpcas_forwardcom
//
// Copyright (c) 2022 Kai Rese
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program. If not, see
// <https://www.gnu.org/licenses/>.

//! All instruction functions for jumps.
//!
//! As ForwardCom has ALU-and-branch instructions, some instructions have a arithmetical or logical
//! component, but are listed here because they still are jumps.

use crate::emulator::constants::operand_indices;
use crate::emulator::core::OperandType;
use crate::emulator::instructions::functions::quad_word_not_supported;
use crate::emulator::{EmulatorInstruction, ForwardComEmulator};

use gpcas_isa::instruction_flags;

/// Subtraction of one operand from another. Jump if the result is zero.
#[inline]
pub fn sub_jump_zero(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let value = emulator
        .operands
        .get_i64(operand_indices::INPUT1)
        .wrapping_sub(emulator.operands.get_i64(operand_indices::INPUT2));

    instruction.core.flags |= instruction_flags::BR_TAKEN * (value == 0) as u16;
    emulator.operands.set_i64(operand_indices::OUTPUT, value);
}

/// Subtraction of one operand from another. Jump if the result is negative.
#[inline]
pub fn sub_jump_neg(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let value = emulator
        .operands
        .get_i64(operand_indices::INPUT1)
        .wrapping_sub(emulator.operands.get_i64(operand_indices::INPUT2));

    instruction.core.flags |= instruction_flags::BR_TAKEN * ((value < 0) as u16);
    emulator.operands.set_i64(operand_indices::OUTPUT, value);
}

/// Subtraction of one operand from another. Jump if the result is positive.
#[inline]
pub fn sub_jump_pos(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let value = emulator
        .operands
        .get_i64(operand_indices::INPUT1)
        .wrapping_sub(emulator.operands.get_i64(operand_indices::INPUT2));

    instruction.core.flags |= instruction_flags::BR_TAKEN * (value > 0) as u16;
    emulator.operands.set_i64(operand_indices::OUTPUT, value);
}

/// Subtraction of one operand from another. Jump if the result overflows.
#[inline]
pub fn sub_jump_overflow(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let (result, overflow) = emulator
        .operands
        .get_i64(operand_indices::INPUT1)
        .overflowing_sub(emulator.operands.get_i64(operand_indices::INPUT2));

    instruction.core.flags |= instruction_flags::BR_TAKEN * overflow as u16;
    emulator.operands.set_i64(operand_indices::OUTPUT, result);
}

/// Subtraction of one operand from another. Jump if the result triggers a borrow.
#[inline]
pub fn sub_jump_borrow(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let (result, borrow) = emulator
        .operands
        .get_u64(operand_indices::INPUT1)
        .overflowing_sub(emulator.operands.get_u64(operand_indices::INPUT2));

    instruction.core.flags |= instruction_flags::BR_TAKEN * borrow as u16;
    emulator.operands.set_u64(operand_indices::OUTPUT, result);
}

/// Addition of two operands. Jump if the result is zero.
#[inline]
pub fn add_jump_zero(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let value = emulator
        .operands
        .get_i64(operand_indices::INPUT1)
        .wrapping_add(emulator.operands.get_i64(operand_indices::INPUT2));

    instruction.core.flags |= instruction_flags::BR_TAKEN * (value == 0) as u16;
    emulator.operands.set_i64(operand_indices::OUTPUT, value);
}

/// Addition of two operands. Jump if the result is negative.
#[inline]
pub fn add_jump_neg(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let value = emulator
        .operands
        .get_i64(operand_indices::INPUT1)
        .wrapping_add(emulator.operands.get_i64(operand_indices::INPUT2));

    instruction.core.flags |= instruction_flags::BR_TAKEN * (value < 0) as u16;
    emulator.operands.set_i64(operand_indices::OUTPUT, value);
}

/// Addition of two operands. Jump if the result is positive.
#[inline]
pub fn add_jump_pos(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let value = emulator
        .operands
        .get_i64(operand_indices::INPUT1)
        .wrapping_add(emulator.operands.get_i64(operand_indices::INPUT2));

    instruction.core.flags |= instruction_flags::BR_TAKEN * (value > 0) as u16;
    emulator.operands.set_i64(operand_indices::OUTPUT, value);
}

/// Addition of two operands. Jump if the result overflows.
#[inline]
pub fn add_jump_overflow(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let (result, overflow) = emulator
        .operands
        .get_i64(operand_indices::INPUT1)
        .overflowing_add(emulator.operands.get_i64(operand_indices::INPUT2));

    instruction.core.flags |= instruction_flags::BR_TAKEN * overflow as u16;
    emulator.operands.set_i64(operand_indices::OUTPUT, result);
}

/// Addition of two operands. Jump if the result has a carry.
#[inline]
pub fn add_jump_carry(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let (result, carry) = emulator
        .operands
        .get_u64(operand_indices::INPUT1)
        .overflowing_add(emulator.operands.get_u64(operand_indices::INPUT2));

    instruction.core.flags |= instruction_flags::BR_TAKEN * carry as u16;
    emulator.operands.set_u64(operand_indices::OUTPUT, result);
}

/// AND of two operands. Jump if the result is zero.
#[inline]
pub fn and_jump_zero(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let value = emulator.operands.get_u64(operand_indices::INPUT1)
        & emulator.operands.get_u64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * (value == 0) as u16;
    emulator.operands.set_u64(operand_indices::OUTPUT, value);
}

/// OR of two operands. Jump if the result is zero.
#[inline]
pub fn or_jump_zero(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let value = emulator.operands.get_u64(operand_indices::INPUT1)
        | emulator.operands.get_u64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * (value == 0) as u16;
    emulator.operands.set_u64(operand_indices::OUTPUT, value);
}

/// XOR of two operands. Jump if the result is zero.
#[inline]
pub fn xor_jump_zero(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let value = emulator.operands.get_u64(operand_indices::INPUT1)
        ^ emulator.operands.get_u64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * (value == 0) as u16;
    emulator.operands.set_u64(operand_indices::OUTPUT, value);
}

/// Comparison of two operands. Jump if they are equal.
#[inline]
pub fn compare_jump_equal(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let first = emulator.operands.get_i64(operand_indices::INPUT1);
    let second = emulator.operands.get_i64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * (first == second) as u16;
}

/// Comparison of two signed operands. Jump if the first is below the second.
#[inline]
pub fn compare_jump_signed_below(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let first = emulator.operands.get_i64(operand_indices::INPUT1);
    let second = emulator.operands.get_i64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * (first < second) as u16;
}

/// Comparison of two signed operands. Jump if the first is above the second.
#[inline]
pub fn compare_jump_signed_above(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let first = emulator.operands.get_i64(operand_indices::INPUT1);
    let second = emulator.operands.get_i64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * (first > second) as u16;
}

/// Comparison of two unsigned operands. Jump if the first is below the second.
#[inline]
pub fn compare_jump_unsigned_below(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let first = emulator.operands.get_u64(operand_indices::INPUT1);
    let second = emulator.operands.get_u64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * (first < second) as u16;
}

/// Comparison of two unsigned operands. Jump if the first is above the second.
#[inline]
pub fn compare_jump_unsigned_above(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let first = emulator.operands.get_u64(operand_indices::INPUT1);
    let second = emulator.operands.get_u64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * (first > second) as u16;
}

/// Test of one bit of an operand defined by another. Jump if it is set.
#[inline]
pub fn test_bit_jump_true(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let first = emulator.operands.get_u64(operand_indices::INPUT1);
    let second = emulator.operands.get_u64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * ((first & (1 << second)) != 0) as u16;
}

/// Test of a range of bits defined by one operand in another. Jump if all bits are set.
#[inline]
pub fn test_bits_and_jump_true(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let first = emulator.operands.get_u64(operand_indices::INPUT1);
    let second = emulator.operands.get_u64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * ((first & second) == second) as u16;
}

/// Test of a range of bits defined by one operand in another. Jump if any bit it set.
#[inline]
pub fn test_bits_or_jump_true(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let first = emulator.operands.get_u64(operand_indices::INPUT1);
    let second = emulator.operands.get_u64(operand_indices::INPUT2);

    instruction.core.flags |= instruction_flags::BR_TAKEN * ((first & second) != 0) as u16;
}

/// Incrementation of one operand and jump if the result is below another.
#[inline]
pub fn increment_compare_jump_below(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let first = emulator.operands.get_i64(operand_indices::INPUT1);
    let second = emulator.operands.get_i64(operand_indices::INPUT2);
    let result = first.wrapping_add(1);
    emulator.operands.set_i64(operand_indices::OUTPUT, result);

    instruction.core.flags |= instruction_flags::BR_TAKEN * (result < second) as u16;
}

/// Incrementation of one operand and jump if the result is above another.
#[inline]
pub fn increment_compare_jump_above(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let first = emulator.operands.get_i64(operand_indices::INPUT1);
    let second = emulator.operands.get_i64(operand_indices::INPUT2);
    emulator
        .operands
        .set_i64(operand_indices::OUTPUT, first.wrapping_add(1));

    instruction.core.flags |= instruction_flags::BR_TAKEN * (first >= second) as u16;
}

/// Subtraction of the maximum vector length from one operand. Jump if the result is positive.
#[inline]
pub fn sub_max_len_jump_pos(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let result = emulator
        .operands
        .get_i64(operand_indices::INPUT1)
        .wrapping_sub(emulator.operands.operand_size() as i64);
    emulator.operands.set_i64(operand_indices::OUTPUT, result);

    instruction.core.flags |= instruction_flags::BR_TAKEN * (result > 0) as u16;
}

/// Computes the jump target as the sum of the input operand and the pre-set offset.
pub fn indirect_jump(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    instruction.core.branch_address = instruction
        .core
        .branch_address
        .wrapping_add(emulator.operands.get_u64(operand_indices::INPUT1) as usize);
}

/// Computes the target as the sum of the base in the first operand and the scaled offset in the
/// second operand.
pub fn multiway_jump(
    emulator: &mut ForwardComEmulator,
    instruction: &mut EmulatorInstruction,
    _: usize,
) {
    let base = emulator.operands.get_i64(operand_indices::INPUT1);
    let offset = match instruction.operand_type {
        OperandType::I8 => emulator.operands.get_i8(operand_indices::INPUT2) as i64,
        OperandType::I16 => emulator.operands.get_i16(operand_indices::INPUT2) as i64,
        OperandType::I32 => emulator.operands.get_i32(operand_indices::INPUT2) as i64,
        OperandType::I128 => {
            quad_word_not_supported(instruction);
            0
        }
        _ => unimplemented!(),
    };

    instruction.core.branch_address = (base + (offset << 2)) as usize;
}