// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//! Bind program instructions

#![allow(dead_code)]

bitfield! {
    /// Each instruction is a pair of 32 bit unsigned integers divided as
    /// follows.
    /// lsb           msb
    /// COAABBBB VVVVVVVV  Condition Opcode paramA paramB Value
    struct RawInstruction([u32]);
    u32;
    condition, set_condition: 3, 0;
    operation, set_operation: 7, 4;
    parameter_a, set_parameter_a: 15, 8;
    parameter_b, set_parameter_b: 31, 16;
    value, set_value: 63, 32;
}

/// For all conditions (except Always), the operands to the condition
/// are (parameter_b, value) pairs in the final encoding.
#[derive(PartialEq, Eq)]
pub enum Condition {
    Always,
    Equal(u32, u32),
    NotEqual(u32, u32),
    GreaterThan(u32, u32),
    LessThan(u32, u32),
    GreaterThanEqual(u32, u32),
    LessThanEqual(u32, u32),
}

pub enum Instruction {
    Abort(Condition),
    Match(Condition),
    Goto(Condition, u32),
    Label(u32),
}

fn to_raw_condition(condition: Condition) -> (u32, u32, u32) {
    match condition {
        Condition::Always => (0, 0, 0),
        Condition::Equal(b, v) => (1, b, v),
        Condition::NotEqual(b, v) => (2, b, v),
        Condition::GreaterThan(b, v) => (3, b, v),
        Condition::LessThan(b, v) => (4, b, v),
        Condition::GreaterThanEqual(b, v) => (5, b, v),
        Condition::LessThanEqual(b, v) => (6, b, v),
    }
}

fn to_raw_instruction(instruction: Instruction) -> RawInstruction<[u32; 2]> {
    let (c, o, a, b, v) = match instruction {
        Instruction::Abort(condition) => {
            let (c, b, v) = to_raw_condition(condition);
            (c, 0, 0, b, v)
        }
        Instruction::Match(condition) => {
            let (c, b, v) = to_raw_condition(condition);
            (c, 1, 0, b, v)
        }
        Instruction::Goto(condition, a) => {
            let (c, b, v) = to_raw_condition(condition);
            (c, 2, a, b, v)
        }
        Instruction::Label(a) => (0, 5, a, 0, 0),
    };
    let mut raw_instruction = RawInstruction([0, 0]);
    raw_instruction.set_condition(c);
    raw_instruction.set_operation(o);
    raw_instruction.set_parameter_a(a);
    raw_instruction.set_parameter_b(b);
    raw_instruction.set_value(v);
    raw_instruction
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_raw_instruction() {
        let mut raw = RawInstruction([0, 0]);
        assert_eq!(raw.0[0], 0);
        assert_eq!(raw.0[1], 0);
        assert_eq!(raw.condition(), 0);
        assert_eq!(raw.operation(), 0);
        assert_eq!(raw.parameter_a(), 0);
        assert_eq!(raw.parameter_b(), 0);
        assert_eq!(raw.value(), 0);

        raw.set_condition(1);
        assert_eq!(raw.0[0], 1);
        assert_eq!(raw.0[1], 0);
        assert_eq!(raw.condition(), 1);
        assert_eq!(raw.operation(), 0);
        assert_eq!(raw.parameter_a(), 0);
        assert_eq!(raw.parameter_b(), 0);
        assert_eq!(raw.value(), 0);

        raw.set_operation(2);
        assert_eq!(raw.0[0], 1 | (2 << 4));
        assert_eq!(raw.0[1], 0);
        assert_eq!(raw.condition(), 1);
        assert_eq!(raw.operation(), 2);
        assert_eq!(raw.parameter_a(), 0);
        assert_eq!(raw.parameter_b(), 0);
        assert_eq!(raw.value(), 0);

        raw.set_parameter_a(3);
        assert_eq!(raw.0[0], 1 | (2 << 4) | (3 << 8));
        assert_eq!(raw.0[1], 0);
        assert_eq!(raw.condition(), 1);
        assert_eq!(raw.operation(), 2);
        assert_eq!(raw.parameter_a(), 3);
        assert_eq!(raw.parameter_b(), 0);
        assert_eq!(raw.value(), 0);

        raw.set_parameter_b(4);
        assert_eq!(raw.0[0], 1 | (2 << 4) | (3 << 8) | (4 << 16));
        assert_eq!(raw.0[1], 0);
        assert_eq!(raw.condition(), 1);
        assert_eq!(raw.operation(), 2);
        assert_eq!(raw.parameter_a(), 3);
        assert_eq!(raw.parameter_b(), 4);
        assert_eq!(raw.value(), 0);

        raw.set_value(5);
        assert_eq!(raw.0[0], 1 | (2 << 4) | (3 << 8) | (4 << 16));
        assert_eq!(raw.0[1], 5);
        assert_eq!(raw.condition(), 1);
        assert_eq!(raw.operation(), 2);
        assert_eq!(raw.parameter_a(), 3);
        assert_eq!(raw.parameter_b(), 4);
        assert_eq!(raw.value(), 5)
    }

    #[test]
    fn test_abort_value() {
        let instruction = Instruction::Abort(Condition::Always);
        let raw_instruction = to_raw_instruction(instruction);
        assert_eq!(raw_instruction.0[0], 0 << 4);
        assert_eq!(raw_instruction.0[1], 0);
        assert_eq!(raw_instruction.operation(), 0)
    }

    #[test]
    fn test_match_value() {
        let instruction = Instruction::Match(Condition::Always);
        let raw_instruction = to_raw_instruction(instruction);
        assert_eq!(raw_instruction.0[0], 1 << 4);
        assert_eq!(raw_instruction.0[1], 0);
        assert_eq!(raw_instruction.operation(), 1)
    }

    #[test]
    fn test_goto_value() {
        let instruction = Instruction::Goto(Condition::Always, 0);
        let raw_instruction = to_raw_instruction(instruction);
        assert_eq!(raw_instruction.0[0], 2 << 4);
        assert_eq!(raw_instruction.0[1], 0);
        assert_eq!(raw_instruction.operation(), 2)
    }

    #[test]
    fn test_label_value() {
        let instruction = Instruction::Label(0);
        let raw_instruction = to_raw_instruction(instruction);
        assert_eq!(raw_instruction.0[0], 5 << 4);
        assert_eq!(raw_instruction.0[1], 0);
        assert_eq!(raw_instruction.operation(), 5)
    }

    #[test]
    fn test_complicated_value() {
        let instruction = Instruction::Goto(Condition::LessThan(23, 1234), 42);
        let raw_instruction = to_raw_instruction(instruction);
        assert_eq!(raw_instruction.0[0], 4 | (2 << 4) | (42 << 8) | (23 << 16));
        assert_eq!(raw_instruction.0[1], 1234);
        assert_eq!(raw_instruction.condition(), 4);
        assert_eq!(raw_instruction.operation(), 2);
        assert_eq!(raw_instruction.parameter_a(), 42);
        assert_eq!(raw_instruction.parameter_b(), 23);
        assert_eq!(raw_instruction.value(), 1234)
    }
}