mlir/
effects.rs

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
// Copyright 2024, Giordano Salvador
// SPDX-License-Identifier: BSD-3-Clause

#![allow(dead_code)]

use std::fmt;

pub type MemoryEffectList = &'static [&'static MemoryEffect];

#[derive(Clone, Copy, Default, PartialEq)]
pub enum MemoryEffectType {
    #[default]
    None,
    Write,
}

#[derive(Clone, Copy, Default, PartialEq)]
pub enum SideEffectResource {
    #[default]
    DefaultResource,
}

#[derive(Clone, Copy, Default, PartialEq)]
pub struct MemoryEffect(MemoryEffectType, SideEffectResource);

pub const MEFF_DEFAULT_WRITE: &MemoryEffect = &MemoryEffect::default_write();
pub const MEFF_NO_MEMORY_EFFECT: &MemoryEffect = &MemoryEffect::no_memory_effect();

impl MemoryEffect {
    #[inline]
    pub const fn default_write() -> Self {
        MemoryEffect(MemoryEffectType::Write, SideEffectResource::DefaultResource)
    }

    #[inline]
    pub const fn no_memory_effect() -> Self {
        MemoryEffect(MemoryEffectType::None, SideEffectResource::DefaultResource)
    }

    pub fn from(effect: MemoryEffectType, resource: SideEffectResource) -> Self {
        MemoryEffect(effect, resource)
    }

    pub fn get_resource(&self) -> SideEffectResource {
        self.1
    }

    pub fn get_type(&self) -> MemoryEffectType {
        self.0
    }
}

impl fmt::Display for MemoryEffectType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", match self {
            MemoryEffectType::None => "None",
            MemoryEffectType::Write => "Write",
        })
    }
}

impl fmt::Display for SideEffectResource {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", match self {
            SideEffectResource::DefaultResource => "DefaultResource",
        })
    }
}

impl fmt::Display for MemoryEffect {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "MemoryEffects::Effect{{MemoryEffects::{} on ::mlir::SideEffects::{}}}",
            self.get_type(),
            self.get_resource(),
        )
    }
}