CoCalc -- nv50_ir_lowering

GitHub Repository: PojavLauncherTeam/mesa
Path: blob/21.2-virgl/src/gallium/drivers/nouveau/codegen/nv50_ir_lowering_helper.cpp
⁴⁵⁷⁴ views
1
/*
2
 * Copyright 2018 Red Hat Inc.
3
 *
4
 * Permission is hereby granted, free of charge, to any person obtaining a
5
 * copy of this software and associated documentation files (the "Software"),
6
 * to deal in the Software without restriction, including without limitation
7
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8
 * and/or sell copies of the Software, and to permit persons to whom the
9
 * Software is furnished to do so, subject to the following conditions:
10
 *
11
 * The above copyright notice and this permission notice shall be included in
12
 * all copies or substantial portions of the Software.
13
 *
14
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
17
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20
 * OTHER DEALINGS IN THE SOFTWARE.
21
 *
22
 * Authors: Karol Herbst <[email protected]>
23
 */
24

25
#include "codegen/nv50_ir_lowering_helper.h"
26

27
namespace nv50_ir {
28

29
bool
30
LoweringHelper::visit(Instruction *insn)
31
{
32
   switch (insn->op) {
33
   case OP_ABS:
34
      return handleABS(insn);
35
   case OP_CVT:
36
      return handleCVT(insn);
37
   case OP_MAX:
38
   case OP_MIN:
39
      return handleMAXMIN(insn);
40
   case OP_MOV:
41
      return handleMOV(insn);
42
   case OP_NEG:
43
      return handleNEG(insn);
44
   case OP_SAT:
45
      return handleSAT(insn);
46
   case OP_SLCT:
47
      return handleSLCT(insn->asCmp());
48
   case OP_AND:
49
   case OP_NOT:
50
   case OP_OR:
51
   case OP_XOR:
52
      return handleLogOp(insn);
53
   default:
54
      return true;
55
   }
56
}
57

58
bool
59
LoweringHelper::handleABS(Instruction *insn)
60
{
61
   DataType dTy = insn->dType;
62
   if (!(dTy == TYPE_U64 || dTy == TYPE_S64))
63
      return true;
64

65
   bld.setPosition(insn, false);
66

67
   Value *neg = bld.getSSA(8);
68
   Value *negComp[2], *srcComp[2];
69
   Value *lo = bld.getSSA(), *hi = bld.getSSA();
70
   bld.mkOp2(OP_SUB, dTy, neg, bld.mkImm((uint64_t)0), insn->getSrc(0));
71
   bld.mkSplit(negComp, 4, neg);
72
   bld.mkSplit(srcComp, 4, insn->getSrc(0));
73
   bld.mkCmp(OP_SLCT, CC_LT, TYPE_S32, lo, TYPE_S32, negComp[0], srcComp[0], srcComp[1]);
74
   bld.mkCmp(OP_SLCT, CC_LT, TYPE_S32, hi, TYPE_S32, negComp[1], srcComp[1], srcComp[1]);
75
   insn->op = OP_MERGE;
76
   insn->setSrc(0, lo);
77
   insn->setSrc(1, hi);
78

79
   return true;
80
}
81

82
bool
83
LoweringHelper::handleCVT(Instruction *insn)
84
{
85
   DataType dTy = insn->dType;
86
   DataType sTy = insn->sType;
87

88
   if (typeSizeof(dTy) <= 4 && typeSizeof(sTy) <= 4)
89
      return true;
90

91
   bld.setPosition(insn, false);
92

93
   if ((dTy == TYPE_S32 && sTy == TYPE_S64) ||
94
       (dTy == TYPE_U32 && sTy == TYPE_U64)) {
95
      Value *src[2];
96
      bld.mkSplit(src, 4, insn->getSrc(0));
97
      insn->op = OP_MOV;
98
      insn->setSrc(0, src[0]);
99
   } else if (dTy == TYPE_S64 && sTy == TYPE_S32) {
100
      Value *tmp = bld.getSSA();
101
      bld.mkOp2(OP_SHR, TYPE_S32, tmp, insn->getSrc(0), bld.loadImm(bld.getSSA(), 31));
102
      insn->op = OP_MERGE;
103
      insn->setSrc(1, tmp);
104
   } else if (dTy == TYPE_U64 && sTy == TYPE_U32) {
105
      insn->op = OP_MERGE;
106
      insn->setSrc(1, bld.loadImm(bld.getSSA(), 0));
107
   }
108

109
   return true;
110
}
111

112
bool
113
LoweringHelper::handleMAXMIN(Instruction *insn)
114
{
115
   DataType dTy = insn->dType;
116
   if (!(dTy == TYPE_U64 || dTy == TYPE_S64))
117
      return true;
118

119
   DataType sTy = typeOfSize(4, false, isSignedIntType(dTy));
120
   bld.setPosition(insn, false);
121

122
   Value *flag = bld.getSSA(1, FILE_FLAGS);
123
   Value *src0[2];
124
   Value *src1[2];
125
   Value *def[2];
126

127
   bld.mkSplit(src0, 4, insn->getSrc(0));
128
   bld.mkSplit(src1, 4, insn->getSrc(1));
129

130
   def[0] = bld.getSSA();
131
   def[1] = bld.getSSA();
132

133
   Instruction *hi = bld.mkOp2(insn->op, sTy, def[1], src0[1], src1[1]);
134
   hi->subOp = NV50_IR_SUBOP_MINMAX_HIGH;
135
   hi->setFlagsDef(1, flag);
136

137
   Instruction *lo = bld.mkOp2(insn->op, sTy, def[0], src0[0], src1[0]);
138
   lo->subOp = NV50_IR_SUBOP_MINMAX_LOW;
139
   lo->setFlagsSrc(2, flag);
140

141
   insn->op = OP_MERGE;
142
   insn->setSrc(0, def[0]);
143
   insn->setSrc(1, def[1]);
144

145
   return true;
146
}
147

148
bool
149
LoweringHelper::handleMOV(Instruction *insn)
150
{
151
   DataType dTy = insn->dType;
152

153
   if (typeSizeof(dTy) != 8)
154
      return true;
155

156
   Storage &reg = insn->getSrc(0)->reg;
157

158
   if (reg.file != FILE_IMMEDIATE)
159
      return true;
160

161
   bld.setPosition(insn, false);
162

163
   Value *hi = bld.getSSA();
164
   Value *lo = bld.getSSA();
165

166
   bld.loadImm(lo, (uint32_t)(reg.data.u64 & 0xffffffff));
167
   bld.loadImm(hi, (uint32_t)(reg.data.u64 >> 32));
168

169
   insn->op = OP_MERGE;
170
   insn->setSrc(0, lo);
171
   insn->setSrc(1, hi);
172

173
   return true;
174
}
175

176
bool
177
LoweringHelper::handleNEG(Instruction *insn)
178
{
179
   if (typeSizeof(insn->dType) != 8 || isFloatType(insn->dType))
180
      return true;
181

182
   bld.setPosition(insn, false);
183

184
   insn->op = OP_SUB;
185
   insn->setSrc(1, insn->getSrc(0));
186
   insn->setSrc(0, bld.mkImm((uint64_t)0));
187
   return true;
188
}
189

190
bool
191
LoweringHelper::handleSAT(Instruction *insn)
192
{
193
   DataType dTy = insn->dType;
194

195
   if (typeSizeof(dTy) != 8 || !isFloatType(dTy))
196
      return true;
197

198
   bld.setPosition(insn, false);
199

200
   Value *tmp = bld.mkOp2v(OP_MAX, dTy, bld.getSSA(8), insn->getSrc(0), bld.loadImm(bld.getSSA(8), 0.0));
201
   insn->op = OP_MIN;
202
   insn->setSrc(0, tmp);
203
   insn->setSrc(1, bld.loadImm(bld.getSSA(8), 1.0));
204
   return true;
205
}
206

207
bool
208
LoweringHelper::handleSLCT(CmpInstruction *insn)
209
{
210
   DataType dTy = insn->dType;
211
   DataType sTy = insn->sType;
212

213
   if (typeSizeof(dTy) != 8 || typeSizeof(sTy) == 8)
214
      return true;
215

216
   CondCode cc = insn->getCondition();
217
   DataType hdTy = typeOfSize(4, isFloatType(dTy), isSignedIntType(dTy));
218
   bld.setPosition(insn, false);
219

220
   Value *src0[2];
221
   Value *src1[2];
222
   Value *def[2];
223

224
   bld.mkSplit(src0, 4, insn->getSrc(0));
225
   bld.mkSplit(src1, 4, insn->getSrc(1));
226

227
   def[0] = bld.getSSA();
228
   def[1] = bld.getSSA();
229

230
   bld.mkCmp(OP_SLCT, cc, hdTy, def[0], sTy, src0[0], src1[0], insn->getSrc(2));
231
   bld.mkCmp(OP_SLCT, cc, hdTy, def[1], sTy, src0[1], src1[1], insn->getSrc(2));
232

233
   insn->op = OP_MERGE;
234
   insn->setSrc(0, def[0]);
235
   insn->setSrc(1, def[1]);
236
   insn->setSrc(2, NULL);
237

238
   return true;
239
}
240

241
bool
242
LoweringHelper::handleLogOp(Instruction *insn)
243
{
244
   DataType dTy = insn->dType;
245
   DataType sTy = typeOfSize(4, isFloatType(dTy), isSignedIntType(dTy));
246

247
   if (typeSizeof(dTy) != 8)
248
      return true;
249

250
   bld.setPosition(insn, false);
251

252
   Value *src0[2];
253
   Value *src1[2];
254
   Value *def0 = bld.getSSA();
255
   Value *def1 = bld.getSSA();
256

257
   bld.mkSplit(src0, 4, insn->getSrc(0));
258
   if (insn->srcExists(1))
259
      bld.mkSplit(src1, 4, insn->getSrc(1));
260

261
   Instruction *lo = bld.mkOp1(insn->op, sTy, def0, src0[0]);
262
   Instruction *hi = bld.mkOp1(insn->op, sTy, def1, src0[1]);
263
   if (insn->srcExists(1)) {
264
      lo->setSrc(1, src1[0]);
265
      hi->setSrc(1, src1[1]);
266
   }
267

268
   insn->op = OP_MERGE;
269
   insn->setSrc(0, def0);
270
   insn->setSrc(1, def1);
271

272
   return true;
273
}
274

275
} // namespace nv50_ir
276

277
Product

Resources

Company
