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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
use calyx_utils::{CalyxResult, Error, Id};
use std::str::FromStr;
use strum::EnumCount;
use strum_macros::{AsRefStr, EnumCount, EnumString, FromRepr};

/// Attributes that have been deprecated.
pub const DEPRECATED_ATTRIBUTES: &[&str] = &["static"];

#[derive(
    EnumCount,
    FromRepr,
    AsRefStr,
    EnumString,
    Clone,
    Copy,
    Hash,
    PartialEq,
    Eq,
    Debug,
)]
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
#[repr(u8)]
/// Attributes that are only allowed to take boolean values.
pub enum BoolAttr {
    #[strum(serialize = "toplevel")]
    /// This is the top-level component
    TopLevel,
    #[strum(serialize = "external")]
    /// Cell should be externalized
    External,
    #[strum(serialize = "nointerface")]
    /// The component doesn't have a standard interface
    NoInterface,
    #[strum(serialize = "reset")]
    /// Reset signal for the component
    Reset,
    #[strum(serialize = "clk")]
    /// Clk for the signal
    Clk,
    #[strum(serialize = "stable")]
    /// Is the port connected to a state element
    Stable,
    #[strum(serialize = "data")]
    /// This is a data path instance
    Data,
    #[strum(serialize = "control")]
    /// This is a control path instance
    Control,
    #[strum(serialize = "share")]
    /// Is this component shareable
    Share,
    #[strum(serialize = "state_share")]
    /// Is the component state shareable
    StateShare,
    #[strum(serialize = "generated")]
    /// IR Node was generated by the compiler
    Generated,
    #[strum(serialize = "new_fsm")]
    /// Generate a new FSM for this control node
    NewFSM,
    #[strum(serialize = "one_hot")]
    /// Generate a one-hot FSM for this control node. (Not necesarily a
    /// guarantee: if the control node does not get its own FSM, then this attribute
    /// won't necesarily be honored.)
    OneHot,
    #[strum(serialize = "inline")]
    /// Inline this subcomponent
    Inline,
    #[strum(serialize = "promoted")]
    /// denotes a static component or control promoted from dynamic
    Promoted,
    #[strum(serialize = "par")]
    /// Denotes a group that was generated from a `staticpar` during static
    /// inlining.
    ParCtrl,
    #[strum(serialize = "fast")]
    /// https://github.com/calyxir/calyx/issues/1828
    Fast,
    #[strum(serialize = "protected")]
    /// Indicate that the cell should not be removed or shared during optimization.
    Protected,
}

impl From<BoolAttr> for Attribute {
    fn from(attr: BoolAttr) -> Self {
        Attribute::Bool(attr)
    }
}
impl std::fmt::Display for BoolAttr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_ref())
    }
}

#[derive(AsRefStr, EnumString, Clone, Copy, Hash, PartialEq, Eq, Debug)]
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
/// Attributes that can take numeric values
pub enum NumAttr {
    // ============ numeric attributes ============
    // Interface ports
    #[strum(serialize = "go")]
    Go,
    #[strum(serialize = "done")]
    Done,
    // Interface properties
    #[strum(serialize = "read_together")]
    ReadTogether,
    #[strum(serialize = "write_together")]
    WriteTogether,
    #[strum(serialize = "sync")]
    /// Synchronize this thread with others in the current par block
    Sync,
    #[strum(serialize = "bound")]
    /// The bound of a while loop
    Bound,
    #[strum(serialize = "pos")]
    /// Source location position for this node
    Pos,
    #[strum(serialize = "promotable")]
    /// Can promote the group, control, or @go port of the component to static
    /// with the annotated latency
    Promotable,
    #[strum(serialize = "compactable")]
    /// suggest that the current static seq block is compactable
    Compactable,
    #[strum(serialize = "interval")]
    /// Placed on @go ports of components to denote the II of a component, which
    /// is the same as the latency for non pipelined components.
    /// This indicates the component can serve ``double-duty'' as both static and
    /// dynamic.
    /// Therefore, we only place if we can *guarantee* the interval of the component.
    Interval,
}
impl From<NumAttr> for Attribute {
    fn from(attr: NumAttr) -> Self {
        Attribute::Num(attr)
    }
}
impl std::fmt::Display for NumAttr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_ref())
    }
}

#[derive(AsRefStr, Clone, Copy, Hash, PartialEq, Eq, Debug)]
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
#[allow(non_camel_case_types)]
/// Internal attributes that cannot be parsed back from the IL.
pub enum InternalAttr {
    DEAD,
    NODE_ID,
    BEGIN_ID,
    END_ID,
    ST_ID,
    LOOP,
    START,
    END,
}
impl From<InternalAttr> for Attribute {
    fn from(attr: InternalAttr) -> Self {
        Attribute::Internal(attr)
    }
}

#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
/// Defines the known attributes that can be attached to IR nodes.
/// All caps names represent attributes that are internal to the compiler and
/// cannot be parsed back.
pub enum Attribute {
    Bool(BoolAttr),
    Num(NumAttr),
    Internal(InternalAttr),
    /// Unknown attribute. Should not appear in the Calyx codebase.
    /// Useful for other frontends using Calyx
    Unknown(Id),
}
impl std::fmt::Display for Attribute {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Attribute::Bool(b) => write!(f, "{}", b.as_ref()),
            Attribute::Num(n) => write!(f, "{}", n.as_ref()),
            Attribute::Internal(i) => write!(f, "{}", i.as_ref()),
            Attribute::Unknown(s) => write!(f, "{}", s),
        }
    }
}
impl FromStr for Attribute {
    type Err = Error;

    fn from_str(s: &str) -> CalyxResult<Self> {
        if let Ok(b) = BoolAttr::from_str(s) {
            Ok(Attribute::Bool(b))
        } else if let Ok(n) = NumAttr::from_str(s) {
            Ok(Attribute::Num(n))
        } else {
            if DEPRECATED_ATTRIBUTES.contains(&s) {
                log::warn!("The attribute @{s} is deprecated and will be ignored by the compiler.");
            }
            // Reject attributes that all caps since those are reserved for internal attributes
            if s.to_uppercase() == s {
                return Err(Error::misc(format!("Invalid attribute: {}. All caps attributes are reserved for internal use.", s)));
            }
            Ok(Attribute::Unknown(s.into()))
        }
    }
}

#[derive(Default, Debug, Clone, PartialEq, Eq)]
/// Inline storage for boolean attributes.
pub(super) struct InlineAttributes {
    /// Boolean attributes stored in a 32-bit number.
    attrs: u32,
}

impl InlineAttributes {
    /// Is the attribute set empty?
    pub const fn is_empty(&self) -> bool {
        self.attrs == 0
    }

    /// Adds an attribute to the set
    pub fn insert(&mut self, attr: BoolAttr) {
        self.attrs |= 1 << attr as u8;
    }

    /// Checks if the set contains an attribute
    pub fn has(&self, attr: BoolAttr) -> bool {
        self.attrs & (1 << (attr as u8)) != 0
    }

    /// Remove attribute from the set if present
    pub fn remove(&mut self, attr: BoolAttr) {
        self.attrs &= !(1 << attr as u8);
    }

    /// Returns an iterator over the attributes in the set
    pub(super) fn iter(&self) -> impl Iterator<Item = BoolAttr> + '_ {
        (0..(BoolAttr::COUNT as u8)).filter_map(|idx| {
            if self.attrs & (1 << idx) != 0 {
                Some(BoolAttr::from_repr(idx).unwrap())
            } else {
                None
            }
        })
    }
}

#[cfg(feature = "serialize")]
impl serde::Serialize for InlineAttributes {
    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        self.to_owned().attrs.serialize(ser)
    }
}