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
//! Original PTX specification:
//!
//! min.atype d, a, b;
//! min{.relu}.btype d, a, b;
//! .atype = { .u16, .u32, .u64, .u16x2, .s16, .s64 };
//! .btype = { .s16x2, .s32 };
//!
//! min{.ftz}{.NaN}{.xorsign.abs}.f32 d, a, b;
//! min{.ftz}{.NaN}{.abs}.f32 d, a, b, c;
//! min.f64 d, a, b;
//!
//! min{.ftz}{.NaN}{.xorsign.abs}.f16 d, a, b;
//! min{.ftz}{.NaN}{.xorsign.abs}.f16x2 d, a, b;
//! min{.NaN}{.xorsign.abs}.bf16 d, a, b;
//! min{.NaN}{.xorsign.abs}.bf16x2 d, a, b;
#![allow(unused)]
use crate::r#type::common::*;
pub mod section_0 {
use crate::r#type::common::*;
#[derive(Debug, Clone, PartialEq)]
pub enum Atype {
U16x2, // .u16x2
U16, // .u16
U32, // .u32
U64, // .u64
S16, // .s16
S64, // .s64
}
#[derive(Debug, Clone, PartialEq)]
pub enum Btype {
S16x2, // .s16x2
S32, // .s32
}
#[derive(Debug, Clone, PartialEq)]
pub struct MinAtype {
pub atype: Atype, // .atype
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
}
#[derive(Debug, Clone, PartialEq)]
pub struct MinReluBtype {
pub relu: bool, // {.relu}
pub btype: Btype, // .btype
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
}
#[derive(Debug, Clone, PartialEq)]
pub struct MinFtzNanXorsignAbsF32 {
pub ftz: bool, // {.ftz}
pub nan: bool, // {.NaN}
pub xorsign_abs: bool, // {.xorsign.abs}
pub f32: (), // .f32
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
}
#[derive(Debug, Clone, PartialEq)]
pub struct MinFtzNanAbsF32 {
pub ftz: bool, // {.ftz}
pub nan: bool, // {.NaN}
pub abs: bool, // {.abs}
pub f32: (), // .f32
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
#[derive(Debug, Clone, PartialEq)]
pub struct MinF64 {
pub f64: (), // .f64
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
}
#[derive(Debug, Clone, PartialEq)]
pub struct MinFtzNanXorsignAbsF16 {
pub ftz: bool, // {.ftz}
pub nan: bool, // {.NaN}
pub xorsign_abs: bool, // {.xorsign.abs}
pub f16: (), // .f16
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
}
#[derive(Debug, Clone, PartialEq)]
pub struct MinFtzNanXorsignAbsF16x2 {
pub ftz: bool, // {.ftz}
pub nan: bool, // {.NaN}
pub xorsign_abs: bool, // {.xorsign.abs}
pub f16x2: (), // .f16x2
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
}
#[derive(Debug, Clone, PartialEq)]
pub struct MinNanXorsignAbsBf16 {
pub nan: bool, // {.NaN}
pub xorsign_abs: bool, // {.xorsign.abs}
pub bf16: (), // .bf16
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
}
#[derive(Debug, Clone, PartialEq)]
pub struct MinNanXorsignAbsBf16x2 {
pub nan: bool, // {.NaN}
pub xorsign_abs: bool, // {.xorsign.abs}
pub bf16x2: (), // .bf16x2
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
}
}
// Re-export types with section suffixes to avoid naming conflicts
// e.g., Type0 for section_0::Type, Type1 for section_1::Type
pub use section_0::Atype as Atype0;
pub use section_0::Btype as Btype0;
pub use section_0::MinAtype;
pub use section_0::MinF64;
pub use section_0::MinFtzNanAbsF32;
pub use section_0::MinFtzNanXorsignAbsF16;
pub use section_0::MinFtzNanXorsignAbsF16x2;
pub use section_0::MinFtzNanXorsignAbsF32;
pub use section_0::MinNanXorsignAbsBf16;
pub use section_0::MinNanXorsignAbsBf16x2;
pub use section_0::MinReluBtype;