src/shader_recompiler/frontend/ir/opcode.inc


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

// Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.

//     opcode name,                                         return type,    arg1 type,      arg2 type,      arg3 type,      arg4 type,      ...
OPCODE(Void,                                                Void,                                                                           )
OPCODE(Identity,                                            Opaque,         Opaque,                                                         )

// Control flow
OPCODE(Branch,                                              Void,           Label,                                                          )
OPCODE(BranchConditional,                                   Void,           U1,             Label,          Label,                          )
OPCODE(Exit,                                                Void,                                                                           )
OPCODE(Return,                                              Void,                                                                           )
OPCODE(Unreachable,                                         Void,                                                                           )

// Context getters/setters
OPCODE(GetRegister,                                         U32,            Reg,                                                            )
OPCODE(SetRegister,                                         Void,           Reg,            U32,                                            )
OPCODE(GetPred,                                             U1,             Pred,                                                           )
OPCODE(SetPred,                                             Void,           Pred,           U1,                                             )
OPCODE(GetCbuf,                                             U32,            U32,            U32,                                            )
OPCODE(GetAttribute,                                        U32,            Attribute,                                                      )
OPCODE(SetAttribute,                                        U32,            Attribute,                                                      )
OPCODE(GetAttributeIndexed,                                 U32,            U32,                                                            )
OPCODE(SetAttributeIndexed,                                 U32,            U32,                                                            )
OPCODE(GetZSCORaw,                                          U32,                                                                            )
OPCODE(SetZSCORaw,                                          Void,           U32,                                                            )
OPCODE(SetZSCO,                                             Void,           ZSCO,                                                           )
OPCODE(GetZFlag,                                            U1,             Void,                                                           )
OPCODE(GetSFlag,                                            U1,             Void,                                                           )
OPCODE(GetCFlag,                                            U1,             Void,                                                           )
OPCODE(GetOFlag,                                            U1,             Void,                                                           )
OPCODE(SetZFlag,                                            Void,           U1,                                                             )
OPCODE(SetSFlag,                                            Void,           U1,                                                             )
OPCODE(SetCFlag,                                            Void,           U1,                                                             )
OPCODE(SetOFlag,                                            Void,           U1,                                                             )

// Memory operations
OPCODE(WriteGlobalU8,                                       Void,           U64,            U32,                                            )
OPCODE(WriteGlobalS8,                                       Void,           U64,            U32,                                            )
OPCODE(WriteGlobalU16,                                      Void,           U64,            U32,                                            )
OPCODE(WriteGlobalS16,                                      Void,           U64,            U32,                                            )
OPCODE(WriteGlobal32,                                       Void,           U64,            U32,                                            )
OPCODE(WriteGlobal64,                                       Void,           U64,            Opaque,                                         )
OPCODE(WriteGlobal128,                                      Void,           U64,            Opaque,                                         )

// Vector utility
OPCODE(CompositeConstruct2,                                 Opaque,         Opaque,         Opaque,                                         )
OPCODE(CompositeConstruct3,                                 Opaque,         Opaque,         Opaque,         Opaque,                         )
OPCODE(CompositeConstruct4,                                 Opaque,         Opaque,         Opaque,         Opaque,         Opaque,         )
OPCODE(CompositeExtract,                                    Opaque,         Opaque,         U32,                                            )

// Bitwise conversions
OPCODE(PackUint2x32,                                        U64,            Opaque,                                                         )
OPCODE(UnpackUint2x32,                                      Opaque,         U64,                                                            )
OPCODE(PackFloat2x16,                                       U32,            Opaque,                                                         )
OPCODE(UnpackFloat2x16,                                     Opaque,         U32,                                                            )
OPCODE(PackDouble2x32,                                      U64,            Opaque,                                                         )
OPCODE(UnpackDouble2x32,                                    Opaque,         U64,                                                            )

// Pseudo-operation, handled specially at final emit
OPCODE(GetZeroFromOp,                                       U1,             Opaque,                                                         )
OPCODE(GetSignFromOp,                                       U1,             Opaque,                                                         )
OPCODE(GetCarryFromOp,                                      U1,             Opaque,                                                         )
OPCODE(GetOverflowFromOp,                                   U1,             Opaque,                                                         )
OPCODE(GetZSCOFromOp,                                       ZSCO,           Opaque,                                                         )

// Floating-point operations
OPCODE(FPAbs16,                                             U16,            U16                                                             )
OPCODE(FPAbs32,                                             U32,            U32                                                             )
OPCODE(FPAbs64,                                             U64,            U64                                                             )
OPCODE(FPAdd16,                                             U16,            U16,            U16                                             )
OPCODE(FPAdd32,                                             U32,            U32,            U32                                             )
OPCODE(FPAdd64,                                             U64,            U64,            U64                                             )
OPCODE(FPFma16,                                             U16,            U16,            U16                                             )
OPCODE(FPFma32,                                             U32,            U32,            U32                                             )
OPCODE(FPFma64,                                             U64,            U64,            U64                                             )
OPCODE(FPMax32,                                             U32,            U32,            U32                                             )
OPCODE(FPMax64,                                             U64,            U64,            U64                                             )
OPCODE(FPMin32,                                             U32,            U32,            U32                                             )
OPCODE(FPMin64,                                             U64,            U64,            U64                                             )
OPCODE(FPMul16,                                             U16,            U16,            U16                                             )
OPCODE(FPMul32,                                             U32,            U32,            U32                                             )
OPCODE(FPMul64,                                             U64,            U64,            U64                                             )
OPCODE(FPNeg16,                                             U16,            U16                                                             )
OPCODE(FPNeg32,                                             U32,            U32                                                             )
OPCODE(FPNeg64,                                             U64,            U64                                                             )
OPCODE(FPRecip32,                                           U32,            U32                                                             )
OPCODE(FPRecip64,                                           U64,            U64                                                             )
OPCODE(FPRecipSqrt32,                                       U32,            U32                                                             )
OPCODE(FPRecipSqrt64,                                       U64,            U64                                                             )
OPCODE(FPSqrt,                                              U32,            U32                                                             )
OPCODE(FPSin,                                               U32,            U32                                                             )
OPCODE(FPSinNotReduced,                                     U32,            U32                                                             )
OPCODE(FPExp2,                                              U32,            U32                                                             )
OPCODE(FPExp2NotReduced,                                    U32,            U32                                                             )
OPCODE(FPCos,                                               U32,            U32                                                             )
OPCODE(FPCosNotReduced,                                     U32,            U32                                                             )
OPCODE(FPLog2,                                              U32,            U32                                                             )
OPCODE(FPSaturate16,                                        U16,            U16                                                             )
OPCODE(FPSaturate32,                                        U32,            U32                                                             )
OPCODE(FPSaturate64,                                        U64,            U64                                                             )
OPCODE(FPRoundEven16,                                       U16,            U16                                                             )
OPCODE(FPRoundEven32,                                       U32,            U32                                                             )
OPCODE(FPRoundEven64,                                       U64,            U64                                                             )
OPCODE(FPFloor16,                                           U16,            U16                                                             )
OPCODE(FPFloor32,                                           U32,            U32                                                             )
OPCODE(FPFloor64,                                           U64,            U64                                                             )
OPCODE(FPCeil16,                                            U16,            U16                                                             )
OPCODE(FPCeil32,                                            U32,            U32                                                             )
OPCODE(FPCeil64,                                            U64,            U64                                                             )
OPCODE(FPTrunc16,                                           U16,            U16                                                             )
OPCODE(FPTrunc32,                                           U32,            U32                                                             )
OPCODE(FPTrunc64,                                           U64,            U64                                                             )

// Logical operations
OPCODE(LogicalOr,                                           U1,             U1,             U1,                                             )
OPCODE(LogicalAnd,                                          U1,             U1,             U1,                                             )
OPCODE(LogicalNot,                                          U1,             U1,                                                             )

// Conversion operations
OPCODE(ConvertS16F16,                                       U32,            U16,                                                            )
OPCODE(ConvertS16F32,                                       U32,            U32,                                                            )
OPCODE(ConvertS16F64,                                       U32,            U64,                                                            )
OPCODE(ConvertS32F16,                                       U32,            U16,                                                            )
OPCODE(ConvertS32F32,                                       U32,            U32,                                                            )
OPCODE(ConvertS32F64,                                       U32,            U64,                                                            )
OPCODE(ConvertS64F16,                                       U64,            U16,                                                            )
OPCODE(ConvertS64F32,                                       U64,            U32,                                                            )
OPCODE(ConvertS64F64,                                       U64,            U64,                                                            )
OPCODE(ConvertU16F16,                                       U32,            U16,                                                            )
OPCODE(ConvertU16F32,                                       U32,            U32,                                                            )
OPCODE(ConvertU16F64,                                       U32,            U64,                                                            )
OPCODE(ConvertU32F16,                                       U32,            U16,                                                            )
OPCODE(ConvertU32F32,                                       U32,            U32,                                                            )
OPCODE(ConvertU32F64,                                       U32,            U64,                                                            )
OPCODE(ConvertU64F16,                                       U64,            U16,                                                            )
OPCODE(ConvertU64F32,                                       U64,            U32,                                                            )
OPCODE(ConvertU64F64,                                       U64,            U64,                                                            )

OPCODE(ConvertU64U32,                                       U64,            U32,                                                            )
OPCODE(ConvertU32U64,                                       U32,            U64,                                                            )