1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::cdsl::operands::OperandKind;
use std::fmt;
use std::rc::Rc;

/// An immediate field in an instruction format.
///
/// This corresponds to a single member of a variant of the `InstructionData`
/// data type.
#[derive(Debug)]
pub(crate) struct FormatField {
    /// Immediate operand kind.
    pub kind: OperandKind,

    /// Member name in InstructionData variant.
    pub member: &'static str,
}

/// Every instruction opcode has a corresponding instruction format which determines the number of
/// operands and their kinds. Instruction formats are identified structurally, i.e., the format of
/// an instruction is derived from the kinds of operands used in its declaration.
///
/// The instruction format stores two separate lists of operands: Immediates and values. Immediate
/// operands (including entity references) are represented as explicit members in the
/// `InstructionData` variants. The value operands are stored differently, depending on how many
/// there are.  Beyond a certain point, instruction formats switch to an external value list for
/// storing value arguments. Value lists can hold an arbitrary number of values.
///
/// All instruction formats must be predefined in the meta shared/formats.rs module.
#[derive(Debug)]
pub(crate) struct InstructionFormat {
    /// Instruction format name in CamelCase. This is used as a Rust variant name in both the
    /// `InstructionData` and `InstructionFormat` enums.
    pub name: &'static str,

    pub num_value_operands: usize,

    pub has_value_list: bool,

    pub imm_fields: Vec<FormatField>,

    pub num_block_operands: usize,

    /// Index of the value input operand that is used to infer the controlling type variable. By
    /// default, this is `0`, the first `value` operand. The index is relative to the values only,
    /// ignoring immediate operands.
    pub typevar_operand: Option<usize>,
}

/// A tuple serving as a key to deduplicate InstructionFormat.
#[derive(Hash, PartialEq, Eq)]
pub(crate) struct FormatStructure {
    pub num_value_operands: usize,
    pub has_value_list: bool,
    pub num_block_operands: usize,
    /// Tuples of (Rust field name / Rust type) for each immediate field.
    pub imm_field_names: Vec<(&'static str, &'static str)>,
}

impl fmt::Display for InstructionFormat {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        let imm_args = self
            .imm_fields
            .iter()
            .map(|field| format!("{}: {}", field.member, field.kind.rust_type))
            .collect::<Vec<_>>()
            .join(", ");
        fmt.write_fmt(format_args!(
            "{}(imms=({}), vals={}, blocks={})",
            self.name, imm_args, self.num_value_operands, self.num_block_operands,
        ))?;
        Ok(())
    }
}

impl InstructionFormat {
    /// Returns a tuple that uniquely identifies the structure.
    pub fn structure(&self) -> FormatStructure {
        FormatStructure {
            num_value_operands: self.num_value_operands,
            has_value_list: self.has_value_list,
            num_block_operands: self.num_block_operands,
            imm_field_names: self
                .imm_fields
                .iter()
                .map(|field| (field.kind.rust_field_name, field.kind.rust_type))
                .collect::<Vec<_>>(),
        }
    }
}

pub(crate) struct InstructionFormatBuilder(InstructionFormat);

impl InstructionFormatBuilder {
    pub fn new(name: &'static str) -> Self {
        Self(InstructionFormat {
            name,
            num_value_operands: 0,
            has_value_list: false,
            num_block_operands: 0,
            imm_fields: Vec::new(),
            typevar_operand: None,
        })
    }

    pub fn value(mut self) -> Self {
        self.0.num_value_operands += 1;
        self
    }

    pub fn varargs(mut self) -> Self {
        self.0.has_value_list = true;
        self
    }

    pub fn block(mut self) -> Self {
        self.0.num_block_operands += 1;
        self
    }

    pub fn imm(mut self, operand_kind: &OperandKind) -> Self {
        let field = FormatField {
            kind: operand_kind.clone(),
            member: operand_kind.rust_field_name,
        };
        self.0.imm_fields.push(field);
        self
    }

    pub fn typevar_operand(mut self, operand_index: usize) -> Self {
        assert!(self.0.typevar_operand.is_none());
        assert!(operand_index < self.0.num_value_operands);
        self.0.typevar_operand = Some(operand_index);
        self
    }

    pub fn build(mut self) -> Rc<InstructionFormat> {
        if self.0.typevar_operand.is_none() && self.0.num_value_operands > 0 {
            // Default to the first value operand, if there's one.
            self.0.typevar_operand = Some(0);
        };

        Rc::new(self.0)
    }
}