Debian Codegraph @

visa/iga/IGALibrary/Backend/Messages/MessageDecoderLSC.cpp

raw
1 /*========================== begin_copyright_notice ============================
2
3 Copyright (C) 2020-2021 Intel Corporation
4
5 SPDX-License-Identifier: MIT
6
7 ============================= end_copyright_notice ===========================*/
8
9 #include "MessageDecoder.hpp"
10
11 #include <utility>
12
13 using namespace iga;
14
15 enum LscOp : uint32_t {
16 LSC_LOAD = 0x00,
17 LSC_LOAD_STRIDED = 0x01,
18 LSC_LOAD_QUAD = 0x02, // aka load_cmask
19 LSC_LOAD_BLOCK2D = 0x03,
20 LSC_STORE = 0x04,
21 LSC_STORE_STRIDED = 0x05,
22 LSC_STORE_QUAD = 0x06, // aka store_cmask
23 LSC_STORE_BLOCK2D = 0x07,
24 //
25 LSC_ATOMIC_IINC = 0x08,
26 LSC_ATOMIC_IDEC = 0x09,
27 LSC_ATOMIC_LOAD = 0x0A,
28 LSC_ATOMIC_STORE = 0x0B,
29 LSC_ATOMIC_IADD = 0x0C,
30 LSC_ATOMIC_ISUB = 0x0D,
31 LSC_ATOMIC_SMIN = 0x0E,
32 LSC_ATOMIC_SMAX = 0x0F,
33 LSC_ATOMIC_UMIN = 0x10,
34 LSC_ATOMIC_UMAX = 0x11,
35 LSC_ATOMIC_ICAS = 0x12,
36 LSC_ATOMIC_FADD = 0x13,
37 LSC_ATOMIC_FSUB = 0x14,
38 LSC_ATOMIC_FMIN = 0x15,
39 LSC_ATOMIC_FMAX = 0x16,
40 LSC_ATOMIC_FCAS = 0x17,
41 LSC_ATOMIC_AND = 0x18,
42 LSC_ATOMIC_OR = 0x19,
43 LSC_ATOMIC_XOR = 0x1A,
44 //
45 LSC_LOAD_STATUS = 0x1B,
46 LSC_STORE_UNCOMPRESSED = 0x1C,
47 LSC_CCS = 0x1D,
48 //
49 LSC_RSI = 0x1E,
50 LSC_FENCE = 0x1F,
51 //
52 LSC_STORE_UNCOMPRESSED_QUAD = 0x20,
53 //
54 LSC_ATOMIC_APNDADD = 0x28,
55 LSC_ATOMIC_APNDSUB = 0x29,
56 LSC_ATOMIC_APNDSTORE = 0x2A,
57 LSC_LOAD_QUAD_MSRT = 0x31,
58 LSC_STORE_QUAD_MSRT = 0x32,
59 //
60 LSC_INVALID = 0xFFFFFFFF,
61 };
62
63 static const uint32_t LSC_AT_FLAT = 0x0;
64 static const uint32_t LSC_AT_BSS = 0x1;
65 static const uint32_t LSC_AT_SS = 0x2;
66 static const uint32_t LSC_AT_BTI = 0x3;
67
68 static const uint32_t LSC_A16 = 0x1;
69 static const uint32_t LSC_A32 = 0x2;
70 static const uint32_t LSC_A64 = 0x3;
71
72 static const uint32_t LSC_D8 = 0x0;
73 static const uint32_t LSC_D16 = 0x1;
74 static const uint32_t LSC_D32 = 0x2;
75 static const uint32_t LSC_D64 = 0x3;
76 static const uint32_t LSC_D8U32 = 0x4;
77 static const uint32_t LSC_D16U32 = 0x5;
78 static const uint32_t LSC_D16U32H = 0x6;
79
80 static const uint32_t LSC_V1 = 0x0;
81 static const uint32_t LSC_V2 = 0x1;
82 static const uint32_t LSC_V3 = 0x2;
83 static const uint32_t LSC_V4 = 0x3;
84 static const uint32_t LSC_V8 = 0x4;
85 static const uint32_t LSC_V16 = 0x5;
86 static const uint32_t LSC_V32 = 0x6;
87 static const uint32_t LSC_V64 = 0x7;
88
89 ///////////////////////////////////////////////////////
90 // Cache Opt
91 // Value for bits[19:17]
92 static const uint32_t LSC_DF_DF = 0x0;
93 //
94 static const uint32_t LSC_UC_UC = 0x1;
95 //
96 static const uint32_t LSC_UC_CA = 0x2;
97 static const uint32_t LSC_UC_WB = 0x2;
98 //
99 static const uint32_t LSC_CA_UC = 0x3;
100 static const uint32_t LSC_WT_UC = 0x3;
101 //
102 static const uint32_t LSC_CA_CA = 0x4;
103 static const uint32_t LSC_WT_WB = 0x4;
104 //
105 static const uint32_t LSC_ST_UC = 0x5;
106 //
107 static const uint32_t LSC_ST_CA = 0x6;
108 static const uint32_t LSC_ST_WB = 0x6;
109 //
110 static const uint32_t LSC_RI_CA = 0x7;
111 static const uint32_t LSC_WB_WB = 0x7;
112
113 // Value for bits [19:16]
114 static const uint32_t LSC_UC_CC = 0x5;
115 static const uint32_t LSC_CA_CC = 0x9;
116 static const uint32_t LSC_RI_RI = 0xE;
117
118 // This handles LSC messages only
119 struct MessageDecoderLSC : MessageDecoder {
120 MessageDecoderLSC(Platform _platform, SFID _sfid, ExecSize _execSize,
121 uint32_t exImmOffDesc, SendDesc _exDesc, SendDesc _desc,
122 DecodeResult &_result)
123 : MessageDecoder(_platform, _sfid, _execSize, exImmOffDesc, _exDesc,
124 _desc, _result) {}
125
126 // used by decodeLscMessage and subchildren
127 std::string dataTypePrefixSyntax; // e.g. d32 or d16 or d32
128 std::string vectorSuffixSyntax; // e.g. x16t (for d16x16t) or .yzw
129 std::string addrSizeSyntax; // e.g. a32
130 std::string cacheControlSyntax; // e.g. ca.ca
131
132 SendOp op = SendOp::INVALID;
133 //
134 int expectedExecSize = 1;
135 //
136 int addrSizeBits = 0;
137 int dataSizeRegBits = 0, dataSizeMemBits = 0;
138 int vectorSize = 1;
139 MessageInfo::Attr extraAttrs = MessageInfo::Attr::NONE;
140
141 // the symbol to return in the MessageInfo structure
142 std::string symbolFromSyntax() const {
143 std::stringstream sym;
144 sym << result.syntax.mnemonic;
145 if (!result.syntax.controls.empty())
146 sym << result.syntax.controls;
147 sym << " ";
148 if (!result.syntax.surface.empty())
149 sym << result.syntax.surface;
150 sym << "[";
151 if (!result.syntax.scale.empty()) {
152 sym << result.syntax.scale;
153 }
154 sym << "A";
155 if (!result.syntax.immOffset.empty()) {
156 sym << result.syntax.immOffset;
157 }
158 sym << "]";
159 return sym.str();
160 }
161
162 ///////////////////////////////////////////////////////////////////////////
163 void setCacheOpts(std::stringstream &sym, std::stringstream &descs,
164 CacheOpt &l1, CacheOpt &l3, CacheOpt _l1, CacheOpt _l3) {
165 l1 = _l1;
166 l3 = _l3;
167 if (_l1 == CacheOpt::DEFAULT && _l3 == CacheOpt::DEFAULT) {
168 descs << "use state settings for both L1 and L3";
169 return;
170 }
171 auto emitCacheOpt = [&](CacheOpt c) {
172 sym << '.';
173 switch (c) {
174 case CacheOpt::DEFAULT:
175 sym << "df";
176 descs << " uses default state settings";
177 break;
178 case CacheOpt::READINVALIDATE:
179 sym << "ri";
180 descs << " read-invalidate (last use)";
181 break;
182 case CacheOpt::CACHED:
183 sym << "ca";
184 descs << " cached";
185 break;
186 case CacheOpt::STREAMING:
187 sym << "st";
188 descs << " streaming";
189 break;
190 case CacheOpt::UNCACHED:
191 sym << "uc";
192 descs << " uncached (bypass)";
193 break;
194 case CacheOpt::WRITETHROUGH:
195 sym << "wt";
196 descs << " writethrough";
197 break;
198 case CacheOpt::WRITEBACK:
199 sym << "wb";
200 descs << " writeback";
201 break;
202 case CacheOpt::CONSTCACHED:
203 sym << "cc";
204 descs << " constant-cached";
205 break;
206 default:
207 sym << "?";
208 descs << " invalid";
209 break;
210 }
211 };
212 descs << "L1";
213 emitCacheOpt(_l1);
214 descs << "; L3";
215 emitCacheOpt(_l3);
216 descs << "";
217 }
218
219 // Descriptor Bits[19:16]: 4 bits of cache control
220 bool decodeLscCacheControlBits16_19(SendOp sop, CacheOpt &l1, CacheOpt &l3) {
221 // check if it's the 3 cases added for 4-bits Cache Control at [19:16]:
222 // L1UC_L3CC, L1CA_L3CC, L1RI_L3RI
223 std::stringstream sym, descs;
224 l1 = l3 = CacheOpt::DEFAULT;
225 bool isLoad = lookupSendOp(sop).isLoad();
226 auto ccBits = getDescBits(16, 4);
227 auto setCacheOptsWrapper = [&](CacheOpt _l1, CacheOpt _l3) {
228 return setCacheOpts(sym, descs, l1, l3, _l1, _l3);
229 };
230
231 switch (ccBits) {
232 case LSC_UC_CC:
233 if (isLoad) {
234 setCacheOptsWrapper(CacheOpt::UNCACHED, CacheOpt::CONSTCACHED);
235 break;
236 }
237 case LSC_CA_CC:
238 if (isLoad) {
239 setCacheOptsWrapper(CacheOpt::CACHED, CacheOpt::CONSTCACHED);
240 break;
241 }
242 case LSC_RI_RI:
243 if (isLoad) {
244 setCacheOptsWrapper(CacheOpt::READINVALIDATE, CacheOpt::READINVALIDATE);
245 break;
246 }
247 default:
248 return decodeLscCacheControlBits17_19(sop, l1, l3);
249 }
250 //
251 cacheControlSyntax = sym.str();
252 //
253 addField("Caching", 16, 4, ccBits, descs.str());
254 return true;
255 }
256
257 void decodeCacheControl(SendOp sop, CacheOpt &l1, CacheOpt &l3) {
258 if (platform() >= Platform::XE2) {
259 if (!decodeLscCacheControlBits16_19(sop, l1, l3))
260 error(16, 4, "invalid cache options");
261 return;
262 }
263
264 if (!decodeLscCacheControlBits17_19(sop, l1, l3))
265 error(17, 3, "invalid cache options");
266 }
267
268 // Descriptor Bits[19:17]: 3 bits of cache control
269 bool decodeLscCacheControlBits17_19(SendOp sop, CacheOpt &l1, CacheOpt &l3) {
270 std::stringstream sym, descs;
271 l1 = l3 = CacheOpt::DEFAULT;
272 bool isLoad = lookupSendOp(sop).isLoad();
273 auto ccBits = getDescBits(17, 3);
274 auto setCacheOptsWrapper = [&](CacheOpt _l1, CacheOpt _l3) {
275 return setCacheOpts(sym, descs, l1, l3, _l1, _l3);
276 };
277 switch (ccBits) {
278 case LSC_DF_DF:
279 setCacheOptsWrapper(CacheOpt::DEFAULT, CacheOpt::DEFAULT);
280 break;
281 case LSC_UC_UC:
282 setCacheOptsWrapper(CacheOpt::UNCACHED, CacheOpt::UNCACHED);
283 break;
284 case LSC_UC_CA: // == LSC_UC_WB
285 if (isLoad)
286 setCacheOptsWrapper(CacheOpt::UNCACHED, CacheOpt::CACHED);
287 else
288 setCacheOptsWrapper(CacheOpt::UNCACHED, CacheOpt::WRITEBACK);
289 break;
290 case LSC_CA_UC: // == LSC_WT_UC
291 if (isLoad)
292 setCacheOptsWrapper(CacheOpt::CACHED, CacheOpt::UNCACHED);
293 else
294 setCacheOptsWrapper(CacheOpt::WRITETHROUGH, CacheOpt::UNCACHED);
295 break;
296 case LSC_CA_CA: // == LSC_WT_WB
297 if (isLoad)
298 setCacheOptsWrapper(CacheOpt::CACHED, CacheOpt::CACHED);
299 else
300 setCacheOptsWrapper(CacheOpt::WRITETHROUGH, CacheOpt::WRITEBACK);
301 break;
302 case LSC_ST_UC:
303 setCacheOptsWrapper(CacheOpt::STREAMING, CacheOpt::UNCACHED);
304 break;
305 case LSC_ST_CA: // == LSC_ST_WB
306 if (isLoad)
307 setCacheOptsWrapper(CacheOpt::STREAMING, CacheOpt::CACHED);
308 else
309 setCacheOptsWrapper(CacheOpt::STREAMING, CacheOpt::WRITEBACK);
310 break;
311 case LSC_RI_CA:
312 if (isLoad) {
313 // atomic follows store semantics, so compare against load
314 setCacheOptsWrapper(CacheOpt::READINVALIDATE, CacheOpt::CACHED);
315 } else {
316 setCacheOptsWrapper(CacheOpt::WRITEBACK, CacheOpt::WRITEBACK);
317 }
318 break;
319 default:
320 return false;
321 }
322 //
323 cacheControlSyntax = sym.str();
324 //
325 addField("Caching", 17, 3, ccBits, descs.str());
326 return true;
327 }
328
329 void decodeLscImmOff(uint32_t atBits) {
330 bool exDescHasImmOff = platform() >= Platform::XE2;
331 if (!exDescHasImmOff)
332 return;
333 bool isBlock2d = op == SendOp::LOAD_BLOCK2D || op == SendOp::STORE_BLOCK2D;
334 // immediate offset bits go in SendDesc if ExDesc is imm
335 // if ExDesc is Reg then they go in dedicated exImmOffDesc
336 uint32_t baseOffBits = exDesc.isReg() ? exImmOffDesc : exDesc.imm;
337 if (atBits == LSC_AT_FLAT) {
338 // [31:12] are all S20
339 if (isBlock2d) {
340 addDoc(DocRef::EXDESC, "DP_EXT_DESC_2D", "67780");
341 // ExDescImm[31:22] = XOff (S10)
342 // ExDescImm[21:12] = YOff (S10)
343 result.info.immediateOffsetBlock2dX =
344 (int)getSignedBits((int)baseOffBits, 12, 10);
345 result.info.immediateOffsetBlock2dY =
346 (int)getSignedBits((int)baseOffBits, 22, 10);
347 addField("ImmediateOffsetBlock2dX", 22 + 32, 10,
348 (uint32_t)result.info.immediateOffsetBlock2dX,
349 fmtHexSigned(result.info.immediateOffsetBlock2dX));
350 addField("ImmediateOffsetBlock2dY", 12 + 32, 10,
351 (uint32_t)result.info.immediateOffsetBlock2dY,
352 fmtHexSigned(result.info.immediateOffsetBlock2dY));
353 if (result.info.immediateOffsetBlock2dX != 0 ||
354 result.info.immediateOffsetBlock2dY != 0) {
355 result.syntax.immOffset =
356 std::string("+(") +
357 fmtHexSigned(result.info.immediateOffsetBlock2dX) + "," +
358 fmtHexSigned(result.info.immediateOffsetBlock2dY) + ")";
359 }
360 } else {
361 addDoc(DocRef::EXDESC, "EXDESC_FLAT", "64012");
362 result.info.immediateOffset = getSignedBits((int)baseOffBits, 12, 20);
363 if (result.info.immediateOffset > 0) {
364 result.syntax.immOffset =
365 "+" + fmtHexSigned(result.info.immediateOffset);
366 } else if (result.info.immediateOffset < 0) {
367 result.syntax.immOffset = fmtHexSigned(result.info.immediateOffset);
368 }
369 addField("ImmediateOffset", 32 + 12, 20,
370 (uint32_t)result.info.immediateOffset,
371 result.syntax.immOffset);
372 }
373
374 } else if ((atBits == LSC_AT_BSS || atBits == LSC_AT_SS) &&
375 exDesc.isReg() && sfid == SFID::TGM) {
376 addDoc(DocRef::EXDESC, "EXDESC_SURFACE", "64017");
377 } else if ((atBits == LSC_AT_BSS || atBits == LSC_AT_SS) &&
378 exDesc.isReg() && sfid == SFID::UGM) {
379 addDoc(DocRef::EXDESC, "EXDESCIMM_BSSO_SSO", "70586");
380 // SS/BSS 16b or 17b (UGM)
381 // ExDescImm[31:19] are Offset[16:4]
382 // ExDescImm[18:16] are unmapped (addr reg)
383 // ExDescImm[15:12] are Offset[3:0]
384 if (sfid != SFID::UGM && baseOffBits != 0) {
385 error(32, 32, "bss/ss: immediate offset forbidden for non-ugm");
386 }
387 uint32_t packed = ((getBits(baseOffBits, 19, 31 - 19 + 1) << 4) |
388 getBits(baseOffBits, 12, 3 - 0 + 1));
389 result.info.immediateOffset = getSignedBits(packed, 0, 17);
390 if (result.info.immediateOffset > 0) {
391 result.syntax.immOffset =
392 "+" + fmtHexSigned(result.info.immediateOffset);
393 } else if (result.info.immediateOffset < 0) {
394 result.syntax.immOffset = fmtHexSigned(result.info.immediateOffset);
395 }
396 addField("ImmediateOffset[16:4]", 32 + 19, 16 - 4 + 1,
397 getBits(packed, 4, 16 - 4 + 1), result.syntax.immOffset);
398 addField("ImmediateOffset[3:0]", 32 + 12, 3 - 0 + 1,
399 getBits(packed, 0, 3 - 0 + 1), result.syntax.immOffset);
400 addField("Reserved", 32 + 16, 3, getBits(baseOffBits, 16, 3),
401 "a0.subreg");
402 if (getBits(baseOffBits, 16, 3)) {
403 error(32 + 16, 3, "ExDesc[19:16] must be zeros");
404 }
405 } else if (atBits == LSC_AT_BSS || atBits == LSC_AT_SS) { // bss/ss imm
406 addDoc(DocRef::EXDESC, "EXDESC_SURFACE", "64017");
407 } else if (atBits == LSC_AT_BTI && exDesc.isReg()) {
408 if (exImmOffDesc != 0)
409 error(32 + 12, 12, "immediate offset forbidden for BTI reg");
410 } else if (atBits == LSC_AT_BTI) {
411 addDoc(DocRef::EXDESC, "EXDESC_BTI", "63997");
412 // ExDesc[23:12] is immm off
413 result.info.immediateOffset =
414 getSignedBits((int32_t)baseOffBits, 12, 23 - 12 + 1);
415 if (result.info.immediateOffset > 0) {
416 result.syntax.immOffset =
417 "+" + fmtHexSigned(result.info.immediateOffset);
418 } else if (result.info.immediateOffset < 0) {
419 result.syntax.immOffset = fmtHexSigned(result.info.immediateOffset);
420 }
421 addField("ImmediateOffset[11:0]", 32 + 12, 23 - 12 + 1,
422 result.info.immediateOffset, result.syntax.immOffset);
423 } // else: BSS/SS with imm ex desc
424 }
425
426 static const int ADDRTYPE_LOC = 29;
427
428 AddrType decodeLscAddrType(SendDesc &surfId, bool allowsFlat = true) {
429 surfId = 0;
430 AddrType addrType = AddrType::FLAT;
431 //
432 const char *addrTypeMeaning = "?";
433 //
434 const auto atBits = getDescBits(ADDRTYPE_LOC, 2);
435 //
436 std::stringstream surfSyntax;
437 switch (atBits) {
438 case LSC_AT_FLAT:
439 addrTypeMeaning = "Flat";
440 addrType = AddrType::FLAT;
441 if (!allowsFlat)
442 error(ADDRTYPE_LOC, 2, "this message may not use FLAT address type");
443 break;
444 case LSC_AT_BSS:
445 case LSC_AT_SS:
446 if (atBits == LSC_AT_BSS) {
447 addrTypeMeaning = "BSS";
448 addrType = AddrType::BSS;
449 surfSyntax << "bss";
450 } else {
451 addrTypeMeaning = "SS";
452 addrType = AddrType::SS;
453 surfSyntax << "ss";
454 }
455 if (exDesc.isImm()) {
456 // XeHPG/XeHPC: we can pull this value out of ExDesc[31:11]
457 int exDescOff = 11, len = 31 - exDescOff + 1;
458 surfId = getDescBits(32 + exDescOff, len) << exDescOff;
459 addField("SurfaceStateOffset", exDescOff, len, surfId.imm,
460 "immediate surface state offset");
461 surfSyntax << "[" << iga::fmtHex(surfId.imm) << "]";
462 } else {
463 // XeHPG/XeHPC with reg surface state offset
464 surfSyntax << "[a0." << (int)exDesc.reg.subRegNum << "]";
465 surfId = exDesc;
466 }
467 break;
468 case LSC_AT_BTI:
469 addrTypeMeaning = "BTI";
470 addrType = AddrType::BTI;
471 if (exDesc.isImm()) {
472 uint32_t bti = decodeExDescField(
473 "BTI", 24, 8, [&](std::stringstream &ss, uint32_t bti) {
474 ss << "bti[" << bti << "]";
475 });
476 surfSyntax << "bti[" << bti << "]";
477 surfId = bti;
478 } else {
479 surfSyntax << "bti[a0." << (int)exDesc.reg.subRegNum << "]";
480 surfId = exDesc;
481 }
482 break;
483 default:
484 addrTypeMeaning = "INVALID AddrType";
485 addrType = AddrType::FLAT;
486 surfSyntax << "?";
487 error(ADDRTYPE_LOC, 2, "invalid address type");
488 break;
489 }
490 result.syntax.surface = surfSyntax.str();
491
492 /////////////////////////////
493 // immediate offset
494 decodeLscImmOff(atBits);
495 //
496 addField("AddrType", ADDRTYPE_LOC, 2, atBits, addrTypeMeaning);
497 //
498 return addrType;
499 }
500
501 void decodeLscAddrSize() {
502 int addrSzBits = getDescBits(7, 2); // [8:7]
503 std::stringstream asym;
504 const char *aDesc = "";
505 switch (addrSzBits) {
506 case 1:
507 asym << "a16";
508 aDesc = "addresses are 16b";
509 addrSizeBits = 16;
510 break;
511 case 2:
512 asym << "a32";
513 aDesc = "addresses are 32b";
514 addrSizeBits = 32;
515 break;
516 case 3:
517 asym << "a64";
518 aDesc = "addresses are 64b";
519 addrSizeBits = 64;
520 break;
521 default:
522 asym << "a???";
523 aDesc = "address size is invalid";
524 error(7, 2, "invalid address size");
525 break;
526 }
527 // result.syntax.addressType = ":" + asym.str();
528
529 addrSizeSyntax = asym.str();
530 //
531 addField("AddrSize", 7, 2, addrSzBits, aDesc);
532 }
533
534 void decodeLscDataSize() {
535 std::stringstream dsym;
536 dataSizeRegBits = dataSizeMemBits = 0;
537 std::string meaning;
538 auto dtBits = getDescBits(9, 3);
539 switch (dtBits) { // dat size [11:9]
540 case LSC_D8:
541 dataSizeRegBits = dataSizeMemBits = 8;
542 dsym << "d8";
543 meaning = "8b per data element";
544 break;
545 case LSC_D16:
546 dataSizeRegBits = dataSizeMemBits = 16;
547 meaning = "16b per data element";
548 dsym << "d16";
549 break;
550 case LSC_D32:
551 dataSizeRegBits = dataSizeMemBits = 32;
552 dsym << "d32";
553 meaning = "32b per data element";
554 break;
555 case LSC_D64:
556 dataSizeRegBits = dataSizeMemBits = 64;
557 dsym << "d64";
558 meaning = "64b per data element";
559 break;
560 case LSC_D8U32:
561 dataSizeRegBits = 32;
562 dataSizeMemBits = 8;
563 dsym << "d8u32";
564 meaning = "load 8b into the low 8b of 32b register elements "
565 "(upper bits are undefined)";
566 if (platform() >= Platform::XE2)
567 meaning = "load 8b and zero-extend to 32b per data element";
568 break;
569 case LSC_D16U32:
570 dataSizeRegBits = 32;
571 dataSizeMemBits = 16;
572 dsym << "d16u32";
573 meaning = "load 16b into the low 16b of 32b register elements "
574 "(upper bits are undefined)";
575 if (platform() >= Platform::XE2)
576 meaning = "load 16b and zero-extend to 32b per data element";
577 break;
578 case LSC_D16U32H:
579 dataSizeRegBits = 32;
580 dataSizeMemBits = 16;
581 extraAttrs |= MessageInfo::Attr::EXPAND_HIGH;
582 dsym << "d16u32h";
583 meaning = "load 16b into the high half of 32b register elements";
584 break;
585 default:
586 dsym << "0x" << std::uppercase << std::hex << dtBits;
587 meaning = "???";
588 }
589 //
590 // result.syntax.dataType = ":" + dsym.str();
591 dataTypePrefixSyntax = dsym.str();
592
593 addField("DataSize", 9, 3, dtBits, meaning);
594 }
595
596 void decodeLscVecSize() {
597 if (lookupSendOp(op).hasChMask()) {
598 decodeLscVecSizeQuad();
599 } else {
600 decodeLscVecSizeNormal();
601 }
602 }
603
604 void decodeLscVecSizeNormal() {
605 std::stringstream vsym;
606
607 uint32_t vecSzEncd = getDescBits(12, 3); // [14:12]
608 switch (vecSzEncd) {
609 case LSC_V1:
610 vectorSize = 1;
611 break;
612 case LSC_V2:
613 vectorSize = 2;
614 break;
615 case LSC_V3:
616 vectorSize = 3;
617 break;
618 case LSC_V4:
619 vectorSize = 4;
620 break;
621 case LSC_V8:
622 vectorSize = 8;
623 break;
624 case LSC_V16:
625 vectorSize = 16;
626 break;
627 case LSC_V32:
628 vectorSize = 32;
629 break;
630 case LSC_V64:
631 vectorSize = 64;
632 break;
633 default:
634 vsym << "x?";
635 }
636 bool opIsBlock2d =
637 op == SendOp::LOAD_BLOCK2D || op == SendOp::STORE_BLOCK2D;
638 auto transposed = decodeDescBitField(
639 "DataOrder", 15,
640 "non-transposed (vector elements are in successive registers)",
641 "transposed (vector elements are in the same register)");
642 if (vectorSize > 1 || (transposed && !opIsBlock2d)) {
643 vsym << 'x' << vectorSize;
644 }
645 if (transposed && op == SendOp::LOAD_STATUS) {
646 error(15, 1, "data order must be non-transposed for this op");
647 }
648 std::stringstream vdesc;
649 vdesc << "each address accesses " << vectorSize << " element";
650 if (vectorSize != 1)
651 vdesc << "s";
652 if (!opIsBlock2d)
653 addField("VecSize", 12, 3, vecSzEncd, vdesc.str());
654 if (transposed) {
655 vsym << 't';
656 extraAttrs |= MessageInfo::Attr::TRANSPOSED;
657 expectedExecSize = 1; // all transpose messages are SIMD1
658 }
659
660 if (op == SendOp::LOAD_BLOCK2D) {
661 bool vnni =
662 decodeDescBitField("Block2dVnniTransform", 7, "disabled", "enabled");
663 if (vnni)
664 vsym << 'v';
665 }
666
667 vectorSuffixSyntax = vsym.str();
668 }
669
670 void decodeLscVecSizeQuad() {
671 // LSC channels *enabled* is the inverse of the old messages
672 // because the old ChMask used in untyped old (scatter4/gather4)
673 // was really a channel "disable" mask
674 auto chEn = getDescBits(12, 4);
675 vectorSize = 0;
676 for (int i = 0; i < 4; ++i) {
677 if ((1 << i) & chEn) {
678 vectorSize++;
679 }
680 }
681 extraAttrs |= MessageInfo::Attr::HAS_CHMASK;
682
683 std::stringstream vsym;
684 vsym << ".";
685 if (chEn & 1)
686 vsym << "x";
687 if (chEn & 2)
688 vsym << "y";
689 if (chEn & 4)
690 vsym << "z";
691 if (chEn & 8)
692 vsym << "w";
693 vectorSuffixSyntax = vsym.str();
694
695 addField("CompEn", 12, 4, chEn, vsym.str());
696 }
697
698 ///////////////////////////////////////////////////////////////////////////
699 void decodeLscMessage(const std::string& msgDesc, SendOp lscOp) {
700 const std::string symbol = ToSyntax(lscOp);
701 op = lscOp;
702
703 const SendOpDefinition &opInfo = lookupSendOp(lscOp);
704 bool opSupportsUvr = lscOp == SendOp::LOAD_QUAD ||
705 lscOp == SendOp::STORE_QUAD ||
706 lscOp == SendOp::LOAD_BLOCK2D ||
707 lscOp == SendOp::STORE_BLOCK2D ||
708 lscOp == SendOp::LOAD_QUAD_MSRT ||
709 lscOp == SendOp::STORE_QUAD_MSRT ||
710 lscOp == SendOp::STORE_UNCOMPRESSED_QUAD ||
711 opInfo.isAtomic();
712 if (sfid == SFID::TGM && opSupportsUvr) {
713 extraAttrs |= MessageInfo::Attr::HAS_UVRLOD;
714 }
715
716 addField("Opcode", 0, 6, getDescBits(0, 6), symbol);
717
718 if (exDesc.isImm() && (exDesc.imm & 0x7FF)) {
719 // bit 11 may or may not be available
720 error(0, 12, "ExDesc[11:0] must be 0 on this platform");
721 }
722 //
723 SendDesc surfaceId(0x0);
724 AddrType addrType = decodeLscAddrType(surfaceId);
725 //
726 if (op == SendOp::LOAD_BLOCK2D || op == SendOp::STORE_BLOCK2D) {
727 addrSizeBits = 64;
728 addrSizeSyntax = "a64";
729 } else if (op == SendOp::ATOMIC_ACADD || op == SendOp::ATOMIC_ACSUB ||
730 op == SendOp::ATOMIC_ACSTORE) {
731 addrSizeBits = 32;
732 addrSizeSyntax = "a32";
733 } else {
734 decodeLscAddrSize();
735 }
736 //
737 decodeLscDataSize();
738 //
739 expectedExecSize = op == SendOp::LOAD_BLOCK2D || op == SendOp::STORE_BLOCK2D
740 ? 1
741 : sfid == SFID::TGM ? DEFAULT_EXEC_SIZE / 2
742 : DEFAULT_EXEC_SIZE;
743 decodeLscVecSize();
744 //
745 if (sfid == SFID::TGM)
746 extraAttrs |= MessageInfo::Attr::TYPED;
747 if (sfid == SFID::SLM)
748 extraAttrs |= MessageInfo::Attr::SLM;
749 //
750 CacheOpt l1 = CacheOpt::DEFAULT, l3 = CacheOpt::DEFAULT;
751 bool hasCc = opInfo.isLoad() || opInfo.isStore() || opInfo.isAtomic();
752 if (sfid != SFID::SLM && hasCc) {
753 decodeCacheControl(op, l1, l3);
754 }
755 //
756 result.syntax.mnemonic = symbol;
757 //
758 result.syntax.controls += '.';
759 result.syntax.controls += dataTypePrefixSyntax;
760 result.syntax.controls += vectorSuffixSyntax;
761 if (!addrSizeSyntax.empty()) {
762 result.syntax.controls += '.';
763 result.syntax.controls += addrSizeSyntax;
764 }
765 if (!cacheControlSyntax.empty()) {
766 result.syntax.controls += cacheControlSyntax;
767 }
768 //
769 setScatterGatherOpX(symbolFromSyntax(), msgDesc, op, addrType, surfaceId,
770 l1, l3, addrSizeBits, dataSizeRegBits, dataSizeMemBits,
771 vectorSize, int(instExecSize), extraAttrs);
772 if (lookupSendOp(op).hasChMask()) {
773 result.info.channelsEnabled = getDescBits(12, 4);
774 if (result.info.channelsEnabled == 0)
775 error(12, 4, "no channels enabled on quad message");
776 }
777 }
778
779 void decodeLscMessageTypeBlock2D(std::string msgDesc, SendOp lscOp) {
780 const std::string symbol = ToSyntax(lscOp);
781 op = lscOp;
782 extraAttrs |= MessageInfo::Attr::HAS_UVRLOD;
783 expectedExecSize = 1;
784 addField("Opcode", 0, 6, getDescBits(0, 6), symbol);
785
786 SendDesc surfaceId(0x0);
787 AddrType addrType = decodeLscAddrType(surfaceId);
788 if (addrType != AddrType::BSS && addrType != AddrType::BTI) {
789 error(ADDRTYPE_LOC, 2, "addr surface type must be BSS or BTI");
790 }
791
792 addrSizeBits = 32;
793 addrSizeSyntax = format("a", addrSizeBits);
794
795 dataSizeRegBits = dataSizeMemBits = 32; // ?
796 dataTypePrefixSyntax = format("d", dataSizeMemBits);
797
798 CacheOpt l1 = CacheOpt::DEFAULT, l3 = CacheOpt::DEFAULT;
799 decodeCacheControl(op, l1, l3);
800
801 result.syntax.mnemonic = symbol;
802 result.syntax.controls += '.';
803 result.syntax.controls += dataTypePrefixSyntax;
804 result.syntax.controls += '.';
805 result.syntax.controls += addrSizeSyntax;
806 if (!cacheControlSyntax.empty()) {
807 result.syntax.controls += cacheControlSyntax;
808 }
809 setScatterGatherOpX(symbolFromSyntax(), msgDesc, op, addrType, surfaceId,
810 l1, l3, addrSizeBits, dataSizeRegBits, dataSizeMemBits,
811 vectorSize, expectedExecSize, extraAttrs);
812 }
813
814 void decodeLscAtomicMessage(std::string msgDesc, SendOp atOp) {
815 extraAttrs |= getDescBits(20, 5) != 0 ? MessageInfo::Attr::ATOMIC_RETURNS
816 : MessageInfo::Attr::NONE;
817 if (sfid == SFID::TGM)
818 extraAttrs |= MessageInfo::Attr::HAS_UVRLOD;
819 decodeLscMessage(msgDesc, atOp);
820 addDocRefsVecCmask();
821 }
822
823 // similar to decodeLscAtomicMessage, but we disable syntax since
824 // we don't wish to support it yet
825 void decodeLscAtomicAppendMessage(const char *msgDesc, SendOp atOp) {
826 decodeLscAtomicMessage(msgDesc, atOp);
827 result.syntax.layout = MessageSyntax::Layout::INVALID;
828 }
829
830 // load/store/atomic etc... (non-cmask)
831 void decodeLscVectorCmask(const char *name, SendOp op) {
832 decodeLscMessage(name, op);
833 addDocRefsVecCmask();
834 }
835 void addDocRefsVecCmask() {
836 if (!result.errors.empty()) {
837 return;
838 }
839 ///// data payloads
840 auto addDataPayload = [&](DocRef::Kind kind) {
841 const auto nullaryAtomic = result.info.op == SendOp::ATOMIC_LOAD ||
842 result.info.op == SendOp::ATOMIC_IINC ||
843 result.info.op == SendOp::ATOMIC_IDEC;
844 if (nullaryAtomic && kind == DocRef::SRC1)
845 return; // no payload
846
847 const auto binaryAtomicSrc =
848 kind == DocRef::SRC1 && (result.info.op == SendOp::ATOMIC_ICAS ||
849 result.info.op == SendOp::ATOMIC_FCAS);
850
851 if (result.info.elemSizeBitsRegFile == 32) {
852 if (binaryAtomicSrc) {
853 if (result.info.execWidth <= 8 && platform() <= Platform::XE_HPG) {
854 addDocXe(kind, "D32_2SRC_ATM_PAYLOAD_SIMT8", "55499", nullptr);
855 } else if (result.info.execWidth <= 16) {
856 addDocXe(kind, "D32_2SRC_ATM_PAYLOAD_SIMT16", "54696", "64003");
857 } else if (result.info.execWidth <= 32) {
858 addDocXe(kind, "D32_2SRC_ATM_PAYLOAD", "54693", "64002");
859 }
860 } else if (result.info.execWidth <= 8 &&
861 platform() <= Platform::XE_HPG) {
862 addDocXe(kind, "D32_2SRC_ATM_PAYLOAD_SIMT8", "55499", nullptr);
863 } else if (result.info.execWidth <= 8 &&
864 platform() <= Platform::XE_HPG) {
865 addDocXe(kind, "D32_PAYLOAD_SIMT8", "55497", nullptr);
866 } else if (result.info.execWidth <= 16) {
867 addDocXe(kind, "D32_PAYLOAD_SIMT16", "54146", "64000");
868 } else {
869 addDocXe(kind, "D32_PAYLOAD", "53574", "63999");
870 }
871 } else if (result.info.elemSizeBitsRegFile == 64) {
872 if (binaryAtomicSrc) {
873 if (result.info.execWidth <= 8 && platform() <= Platform::XE_HPG) {
874 addDocXe(kind, "D64_2SRC_ATM_PAYLOAD_SIMT8", "55498", nullptr);
875 } else if (result.info.execWidth <= 16) {
876 addDocXe(kind, "D64_2SRC_ATM_PAYLOAD_SIMT16", "54695", "64008");
877 } else if (result.info.execWidth <= 32) {
878 addDocXe(kind, "D64_2SRC_ATM_PAYLOAD", "54692", "64007");
879 }
880 } else if (result.info.execWidth <= 8 &&
881 platform() <= Platform::XE_HPG) {
882 addDocXe(kind, "D64_PAYLOAD_SIMT8", "75252", nullptr);
883 } else if (result.info.execWidth <= 16) {
884 addDocXe(kind, "D64_PAYLOAD_SIMT16", "54147", "64006");
885 } else {
886 addDocXe(kind, "D64_PAYLOAD", "53575", "64005");
887 }
888 }
889 };
890
891 if (result.info.isLoad() || result.info.isAtomic()) {
892 addDataPayload(DocRef::DST);
893 }
894
895 ///// address payloads
896 if (op == SendOp::LOAD_STRIDED || op == SendOp::STORE_STRIDED) {
897 addDocXe(DocRef::SRC0, "ABLOCK_PAYLOAD", "53571", "63996");
898 } else if (result.info.isTransposed()) {
899 addDocXe(DocRef::SRC0, "A64_PAYLOAD_SIMT1", "55190", "63994");
900 } else if (result.info.addrSizeBits == 32) {
901 if (result.info.execWidth <= 16 && platform() <= Platform::XE_HPG) {
902 addDocXe(DocRef::SRC0, "A32_PAYLOAD_SIMT8", "55496", nullptr);
903 } else if (result.info.execWidth <= 16) {
904 addDocXe(DocRef::SRC0, "A32_PAYLOAD_SIMT16", "54148", "63991");
905 } else {
906 addDocXe(DocRef::SRC0, "A32_PAYLOAD", "53569", "63990");
907 }
908 } else if (result.info.addrSizeBits == 64) {
909 if (result.info.execWidth <= 16 && platform() <= Platform::XE_HPG) {
910 // pending an update
911 addDocXe(DocRef::SRC0, "A64_PAYLOAD_SIMT8", "75251", nullptr);
912 } else if (result.info.execWidth <= 16) {
913 addDocXe(DocRef::SRC0, "A64_PAYLOAD_SIMT16", "54149", "63995");
914 } else {
915 addDocXe(DocRef::SRC0, "A64_PAYLOAD", "53570", "63993");
916 }
917 }
918
919 // src1
920 if (result.info.isAtomic() || result.info.isStore()) {
921 addDataPayload(DocRef::SRC1);
922 }
923 } // addDocRefsVecCmask
924
925 void tryDecodeLsc() {
926 int lscOp = getDescBits(0, 6); // Opcode[5:0]
927 switch (lscOp) {
928 case LSC_LOAD:
929 addDocRefDESC("DP_LOAD", "53523", "63970");
930 decodeLscVectorCmask("gathering load", SendOp::LOAD);
931 break;
932 case LSC_STORE:
933 addDocRefDESC("DP_STORE", "53524", "63980");
934 decodeLscVectorCmask("scattering store", SendOp::STORE);
935 break;
936 case LSC_STORE_UNCOMPRESSED:
937 addDocRefDESC("DP_STORE_UNCOMPRESSED", "53532", "63984");
938 decodeLscMessage("scattering store uncompressed",
939 SendOp::STORE_UNCOMPRESSED);
940 break;
941 case LSC_STORE_UNCOMPRESSED_QUAD:
942 addDocRefDESC("DP_STORE_UC_CMASK", "55224", "63985");
943 decodeLscVectorCmask("store quad uncompressed",
944 SendOp::STORE_UNCOMPRESSED_QUAD);
945 break;
946 case LSC_LOAD_QUAD:
947 addDocRefDESC("DP_LOAD_CMASK", "53527", "63977");
948 decodeLscVectorCmask("quad load (a.k.a. load_cmask)", SendOp::LOAD_QUAD);
949 break;
950 case LSC_STORE_QUAD:
951 addDocRefDESC("DP_STORE_CMASK", "53527", "63983");
952 decodeLscVectorCmask("quad store (a.k.a. store_cmask)",
953 SendOp::STORE_QUAD);
954 break;
955 case LSC_LOAD_STRIDED:
956 addDocRefDESC("DP_LOAD_BLOCK", "53525", "63976");
957 decodeLscVectorCmask("strided load (a.k.a load_block)",
958 SendOp::LOAD_STRIDED);
959 break;
960 case LSC_STORE_STRIDED:
961 addDocRefDESC("DP_STORE_BLOCK", "53526", "63982");
962 decodeLscVectorCmask("strided store (a.k.a store_block)",
963 SendOp::STORE_STRIDED);
964 break;
965 case LSC_LOAD_BLOCK2D:
966 if (sfid == SFID::TGM) {
967 addDocRefDESCXE2("DP_LOAD_TYPED_2DBLOCK", "65280");
968 addDocXe(DocRef::SRC0, "Typed_2DBlock_Payload", nullptr, "65282");
969 decodeLscMessageTypeBlock2D("block2d load", SendOp::LOAD_BLOCK2D);
970 } else {
971 addDocRefDESC("DP_LOAD_2DBLOCK_ARRAY", "53680", "63972");
972 addDocXe(DocRef::SRC0, "A2DBLOCK_PAYLOAD", "53567", "63986");
973 decodeLscMessage("block2d load", SendOp::LOAD_BLOCK2D);
974 }
975 break;
976 case LSC_STORE_BLOCK2D:
977 if (sfid == SFID::TGM) {
978 addDocRefDESCXE2("DP_STORE_TYPED_2DBLOCK", "65281");
979 decodeLscMessageTypeBlock2D("block2d store", SendOp::STORE_BLOCK2D);
980 break;
981 } else {
982 addDocRefDESC("DP_STORE_2DBLOCK", "53530", "63981");
983 decodeLscMessage("block2d store", SendOp::STORE_BLOCK2D);
984 }
985 break;
986 case LSC_ATOMIC_IINC:
987 addDocRefDESC("DP_ATOMIC_INC", "53538", "63955");
988 decodeLscAtomicMessage("atomic integer increment", SendOp::ATOMIC_IINC);
989 break;
990 case LSC_ATOMIC_IDEC:
991 addDocRefDESC("DP_ATOMIC_DEC", "53539", "63949");
992 decodeLscAtomicMessage("atomic integer decrement", SendOp::ATOMIC_IDEC);
993 break;
994 case LSC_ATOMIC_LOAD:
995 addDocRefDESC("DP_ATOMIC_LOAD", "53540", "63956");
996 decodeLscAtomicMessage("atomic load", SendOp::ATOMIC_LOAD);
997 break;
998 case LSC_ATOMIC_STORE:
999 addDocRefDESC("DP_ATOMIC_STORE", "53541", "63960");
1000 decodeLscAtomicMessage("atomic store", SendOp::ATOMIC_STORE);
1001 break;
1002 case LSC_ATOMIC_IADD:
1003 addDocRefDESC("DP_ATOMIC_ADD", "53542", "63946");
1004 decodeLscAtomicMessage("atomic integer add", SendOp::ATOMIC_IADD);
1005 break;
1006 case LSC_ATOMIC_ISUB:
1007 addDocRefDESC("DP_ATOMIC_SUB", "53543", "63961");
1008 decodeLscAtomicMessage("atomic integer subtract", SendOp::ATOMIC_ISUB);
1009 break;
1010 case LSC_ATOMIC_SMIN:
1011 addDocRefDESC("DP_ATOMIC_MIN", "53544", "63958");
1012 decodeLscAtomicMessage("atomic signed-integer minimum", SendOp::ATOMIC_SMIN);
1013 break;
1014 case LSC_ATOMIC_SMAX:
1015 addDocRefDESC("DP_ATOMIC_MAX", "53545", "63957");
1016 decodeLscAtomicMessage("atomic signed-integer maximum", SendOp::ATOMIC_SMAX);
1017 break;
1018 case LSC_ATOMIC_UMIN:
1019 addDocRefDESC("DP_ATOMIC_UMIN", "53546", "63963");
1020 decodeLscAtomicMessage("atomic unsigned-integer minimum",
1021 SendOp::ATOMIC_UMIN);
1022 break;
1023 case LSC_ATOMIC_UMAX:
1024 addDocRefDESC("DP_ATOMIC_UMAX", "53547", "63962");
1025 decodeLscAtomicMessage("atomic unsigned-integer maximum",
1026 SendOp::ATOMIC_UMAX);
1027 break;
1028 case LSC_ATOMIC_ICAS:
1029 addDocRefDESC("DP_ATOMIC_CMPXCHG", "53555", "63948");
1030 decodeLscAtomicMessage("atomic integer compare and swap",
1031 SendOp::ATOMIC_ICAS);
1032 break;
1033 case LSC_ATOMIC_FADD:
1034 addDocRefDESC("DP_ATOMIC_FADD", "53548", "63950");
1035 decodeLscAtomicMessage("atomic float add", SendOp::ATOMIC_FADD);
1036 break;
1037 case LSC_ATOMIC_FSUB:
1038 addDocRefDESC("DP_ATOMIC_FSUB", "53549", "63954");
1039 decodeLscAtomicMessage("atomic float subtract", SendOp::ATOMIC_FSUB);
1040 break;
1041 case LSC_ATOMIC_FMIN:
1042 addDocRefDESC("DP_ATOMIC_FMIN", "53550", "63953");
1043 decodeLscAtomicMessage("atomic float minimum", SendOp::ATOMIC_FMIN);
1044 break;
1045 case LSC_ATOMIC_FMAX:
1046 addDocRefDESC("DP_ATOMIC_FMAX", "53551", "63952");
1047 decodeLscAtomicMessage("atomic float maximum", SendOp::ATOMIC_FMAX);
1048 break;
1049 case LSC_ATOMIC_FCAS:
1050 addDocRefDESC("DP_ATOMIC_FCMPXCHG", "DP_XXX", "63951");
1051 decodeLscAtomicMessage("atomic float compare and swap", SendOp::ATOMIC_FCAS);
1052 break;
1053 case LSC_ATOMIC_AND:
1054 addDocRefDESC("DP_ATOMIC_AND", "53552", "63947");
1055 decodeLscAtomicMessage("atomic logical and", SendOp::ATOMIC_AND);
1056 break;
1057 case LSC_ATOMIC_OR:
1058 addDocRefDESC("DP_ATOMIC_OR", "53553", "63959");
1059 decodeLscAtomicMessage("atomic logical or", SendOp::ATOMIC_OR);
1060 break;
1061 case LSC_ATOMIC_XOR:
1062 addDocRefDESC("DP_ATOMIC_XOR", "53554", "63964");
1063 decodeLscAtomicMessage("atomic logical xor", SendOp::ATOMIC_XOR);
1064 break;
1065 case LSC_ATOMIC_APNDADD:
1066 addDocRefDESCXE2("DP_APPENDCTR_ATOMIC_ADD", "68353");
1067 decodeLscAtomicAppendMessage("atomic counter append add",
1068 SendOp::ATOMIC_ACADD);
1069 break;
1070 case LSC_ATOMIC_APNDSUB:
1071 addDocRefDESCXE2("DP_APPENDCTR_ATOMIC_SUB", "68353");
1072 decodeLscAtomicAppendMessage("atomic counter append sub",
1073 SendOp::ATOMIC_ACSUB);
1074 break;
1075 case LSC_ATOMIC_APNDSTORE:
1076 addDocRefDESCXE2("DP_APPENDCTR_ATOMIC_ST", "68354");
1077 decodeLscAtomicAppendMessage("atomic counter append store",
1078 SendOp::ATOMIC_ACSTORE);
1079 break;
1080 case LSC_LOAD_QUAD_MSRT:
1081 addDocRefDESCXE2("DP_LOAD_CMASK_MSRT", "73733");
1082 decodeLscMessage("load quad from multi-sample render target",
1083 SendOp::LOAD_QUAD_MSRT);
1084 break;
1085 case LSC_STORE_QUAD_MSRT:
1086 addDocRefDESCXE2("DP_STORE_CMASK_MSRT", "73734");
1087 decodeLscMessage("store quad to multi-sample render target",
1088 SendOp::STORE_QUAD_MSRT);
1089 break;
1090 case LSC_CCS:
1091 decodeLscCcs();
1092 break;
1093 case LSC_RSI: {
1094 addDocRefDESC("DP_RSI", "54000", "63979");
1095 addDocXe(DocRef::DST, "DP_STATE_INFO_PAYLOAD", "54152", "64015");
1096 addDocXe(DocRef::SRC0, "DP_ASTATE_INFO_PAYLOAD", "55018", "64014");
1097
1098 addField("Opcode", 0, 6, getDescBits(0, 6), "read_state");
1099 //
1100 std::stringstream descs;
1101 descs << "read state information";
1102 result.syntax.mnemonic = "read_state";
1103 //
1104 SendDesc surfId = 0;
1105 auto at = decodeLscAddrType(surfId, false);
1106 //
1107 // XeHPG returns 2 GRF, XeHPC+ only 1
1108 // #54152
1109 int rlen = platform() == Platform::XE_HPG ? 2 : 1;
1110 setSpecialOpX(result.syntax.mnemonic, descs.str(), SendOp::READ_STATE, at,
1111 surfId,
1112 1, // mlen = 1 (U,V,R,LOD)
1113 rlen);
1114 result.info.addrSizeBits = 64;
1115 result.info.execWidth = 1;
1116 result.info.attributeSet |= MessageInfo::Attr::HAS_UVRLOD;
1117 result.info.attributeSet |= MessageInfo::Attr::TRANSPOSED;
1118 break;
1119 }
1120 case LSC_FENCE:
1121 addDocRefDESC("DP_FENCE", "53533", "63969");
1122 decodeLscFence();
1123 break;
1124 case LSC_LOAD_STATUS:
1125 addDocRefDESC("DP_LOAD_STATUS", "53531", "63978");
1126 addDocXe(DocRef::DST, "DP_STATUS_PAYLOAD", "55018", "64016");
1127 if (getDescBit(15)) {
1128 error(15, 1, "transpose forbidden on load_status");
1129 }
1130 if (getDescBits(20, 5) != 1) {
1131 error(20, 5, "load_status must have rlen (Desc[24:20] == 1)");
1132 }
1133 decodeLscMessage("load status", SendOp::LOAD_STATUS);
1134 break;
1135 default:
1136 addField("Opcode", 0, 6, getDescBits(0, 6), "invalid message opcode");
1137 error(0, 6, "unsupported message opcode");
1138 return;
1139 }
1140 }
1141
1142 void decodeLscCcs() {
1143 addField("Opcode", 0, 6, static_cast<uint32_t>(LSC_CCS),
1144 "compression-state control");
1145 //
1146 std::stringstream descs;
1147 result.syntax.mnemonic = "ccs";
1148 descs << "compression-state control";
1149 auto ccsOpBits = getDescBits(17, 3);
1150 SendOp sop = SendOp::INVALID;
1151 std::string opDesc;
1152 switch (ccsOpBits) {
1153 case 0:
1154 sop = SendOp::CCS_PC;
1155 result.syntax.mnemonic += "_pc";
1156 opDesc = " page clear (64k)";
1157 addDocRefDESC("DP_CCS_PAGE_CLEAR", "53536", "63965");
1158 break;
1159 case 1:
1160 sop = SendOp::CCS_SC;
1161 result.syntax.mnemonic += "_sc";
1162 opDesc = " sector clear (2-cachelines)";
1163 addDocRefDESC("DP_CCS_SEC_CLEAR", "53534", "63967");
1164 result.syntax.controls += vectorSuffixSyntax;
1165 break;
1166 case 2:
1167 sop = SendOp::CCS_PU;
1168 result.syntax.mnemonic += "_pu";
1169 opDesc = " page uncompress (64k)";
1170 addDocRefDESC("DP_CCS_PAGE_UNCOMPRESS", "53537", "63966");
1171 break;
1172 case 3:
1173 sop = SendOp::CCS_SU;
1174 result.syntax.mnemonic += "_su";
1175 opDesc = " sector uncompress (2-cachelines)";
1176 addDocRefDESC("DP_CCS_SEC_UNCOMPRESS", "53535", "63968");
1177 result.syntax.controls += vectorSuffixSyntax;
1178 break;
1179 default: {
1180 std::stringstream ss;
1181 ss << ".0x" << std::hex << std::uppercase << ccsOpBits;
1182 result.syntax.controls += ss.str();
1183 opDesc = "invalid ccs sop";
1184 error(17, 3, "invalid ccs sop");
1185 }
1186 } // switch
1187 descs << opDesc;
1188 //
1189 addField("CcsOp", 17, 3, ccsOpBits, opDesc);
1190 //
1191 SendDesc surfId = 0;
1192 auto at = decodeLscAddrType(surfId);
1193 if (ccsOpBits == 0 || ccsOpBits == 2) {
1194 // page operations: pc, pu
1195 if (at != AddrType::FLAT)
1196 error(29, 2, "ccs_{pcc,pcu} requires FLAT address type");
1197 std::stringstream dummy;
1198 decodeLscAddrSize();
1199 if (addrSizeBits != 64)
1200 error(7, 2, "AddrSize must be A64");
1201 result.info.execWidth = 1;
1202 expectedExecSize = 1;
1203 // sector uncompress has addresses
1204 // FIXME: I could derive this via exec size and a64
1205 int mlen =
1206 ccsOpBits == 1 || ccsOpBits == 3 ? 4 : // A64_PAYLOAD_SIMT32 = 4 regs
1207 1; // A64_PAYLOAD_SIMT1 = 1 reg
1208 int rlen = 0; // always 0
1209 setSpecialOpX(symbolFromSyntax(), descs.str(), sop, at, surfId, mlen,
1210 rlen);
1211 } else {
1212 // sector operations
1213 ///
1214 // these are vector messages
1215 expectedExecSize = DEFAULT_EXEC_SIZE;
1216 // const int SECTOR_SIZE_BITS = 128*8;
1217 // result.syntax.controls += ".d1024";
1218 result.syntax.controls += vectorSuffixSyntax;
1219 result.syntax.controls += addrSizeBits == 64 ? ".a64" : ".a32";
1220 //
1221 setScatterGatherOp(symbolFromSyntax(), descs.str(), sop, at, surfId,
1222 addrSizeBits,
1223 0, // dateSize = 0; nothing returned
1224 vectorSize, DEFAULT_EXEC_SIZE, extraAttrs);
1225 }
1226 }
1227
1228 void decodeLscFence() {
1229 addField("Opcode", 0, 6, getDescBits(0, 6), "fence");
1230 //
1231 std::stringstream descs;
1232 result.syntax.mnemonic = "fence";
1233 descs << "fence";
1234 //
1235 std::stringstream fenceOpts;
1236 addLscFenceFields(fenceOpts, descs);
1237 result.syntax.controls += fenceOpts.str();
1238 //
1239 setSpecialOpX(symbolFromSyntax(), descs.str(), SendOp::FENCE,
1240 AddrType::FLAT,
1241 0, // no surface
1242 1, // mlen = 1
1243 0); // rlen = 0
1244 }
1245 }; // MessageDecoderLSC
1246
1247 void iga::decodeDescriptorsLSC(Platform platform, SFID sfid, ExecSize execSize,
1248 uint32_t exImmOffDesc, SendDesc exDesc,
1249 SendDesc desc, DecodeResult &result) {
1250 MessageDecoderLSC md(platform, sfid, execSize, exImmOffDesc, exDesc, desc,
1251 result);
1252 md.tryDecodeLsc();
1253 }
1254
1255 // descriptor bits [19:17]: cache control
1256 static bool encLdStVecCachingBits17_19(SendOp op, CacheOpt cachingL1,
1257 CacheOpt cachingL3, SendDesc &desc) {
1258 const auto &opInfo = lookupSendOp(op);
1259 bool isLd = opInfo.isLoad();
1260 bool isSt = opInfo.isStore();
1261 bool isAt = opInfo.isAtomic();
1262 bool isStAt = isSt || isAt;
1263 auto ccMatches = [&](CacheOpt l1, CacheOpt l3, uint32_t enc) {
1264 if (l1 == cachingL1 && l3 == cachingL3) {
1265 desc.imm |= enc << 17;
1266 return true;
1267 }
1268 return false;
1269 };
1270 bool matched =
1271 ccMatches(CacheOpt::DEFAULT, CacheOpt::DEFAULT, LSC_DF_DF) ||
1272 //
1273 ccMatches(CacheOpt::UNCACHED, CacheOpt::UNCACHED, LSC_UC_UC) ||
1274 //
1275 (isLd && ccMatches(CacheOpt::UNCACHED, CacheOpt::CACHED, LSC_UC_CA)) ||
1276 (isStAt &&
1277 ccMatches(CacheOpt::UNCACHED, CacheOpt::WRITEBACK, LSC_UC_WB)) ||
1278 //
1279 (isLd && ccMatches(CacheOpt::CACHED, CacheOpt::UNCACHED, LSC_CA_UC)) ||
1280 (isSt &&
1281 ccMatches(CacheOpt::WRITETHROUGH, CacheOpt::UNCACHED, LSC_WT_UC)) ||
1282 //
1283 (isLd && ccMatches(CacheOpt::CACHED, CacheOpt::CACHED, LSC_CA_CA)) ||
1284 (isSt &&
1285 ccMatches(CacheOpt::WRITETHROUGH, CacheOpt::WRITEBACK, LSC_WT_WB)) ||
1286 //
1287 ccMatches(CacheOpt::STREAMING, CacheOpt::UNCACHED, LSC_ST_UC) ||
1288 //
1289 (isLd && ccMatches(CacheOpt::STREAMING, CacheOpt::CACHED, LSC_ST_CA)) ||
1290 (isSt &&
1291 ccMatches(CacheOpt::STREAMING, CacheOpt::WRITEBACK, LSC_ST_WB)) ||
1292 //
1293 (isLd &&
1294 ccMatches(CacheOpt::READINVALIDATE, CacheOpt::CACHED, LSC_RI_CA)) ||
1295 (isSt && ccMatches(CacheOpt::WRITEBACK, CacheOpt::WRITEBACK, LSC_WB_WB));
1296 return matched;
1297 }
1298
1299 // encLdStVecCachingBits17_19 - Encode 4-bits cache opt at descriptor[19:16]
1300 // Cache opt on XE2+ is 4 bits field comparing to 3 bits on pre-XE2
1301 // XE2 is [19:16] and preXE2 is [19:17]
1302 static bool encLdStVecCachingBits16_19(SendOp op, CacheOpt cachingL1,
1303 CacheOpt cachingL3, SendDesc &desc) {
1304 // special handle L1RI_L3CA which is not allowed in 4-bits-cache-opt mode
1305 if (cachingL1 == CacheOpt::READINVALIDATE &&
1306 cachingL3 == CacheOpt::CONSTCACHED)
1307 return false;
1308
1309 // bits in [19:17] are the same as encLdStVecCachingBits17_19
1310 if (encLdStVecCachingBits17_19(op, cachingL1, cachingL3, desc))
1311 return true;
1312
1313 // otherwise, check the new combination (all for load only)
1314 // L1UC_L3CC, L1CA_L3CC, L1RI_L3RI
1315 const auto &opInfo = lookupSendOp(op);
1316 bool isLd = opInfo.isLoad();
1317 auto ccMatches = [&](CacheOpt l1, CacheOpt l3, uint32_t enc) {
1318 if (l1 == cachingL1 && l3 == cachingL3) {
1319 desc.imm |= enc << 16;
1320 return true;
1321 }
1322 return false;
1323 };
1324 bool matched =
1325 (isLd &&
1326 ccMatches(CacheOpt::UNCACHED, CacheOpt::CONSTCACHED, LSC_UC_CC)) ||
1327 (isLd && ccMatches(CacheOpt::CACHED, CacheOpt::CONSTCACHED, LSC_CA_CC)) ||
1328 (isLd && ccMatches(CacheOpt::READINVALIDATE, CacheOpt::READINVALIDATE,
1329 LSC_RI_RI));
1330 return matched;
1331 }
1332
1333 static bool encLdStVecImmOffset(Platform p, const VectorMessageArgs &vma,
1334 uint32_t &exImmOffDesc, SendDesc &exDesc,
1335 std::string &err) {
1336 const bool isBlock2d =
1337 vma.op == SendOp::LOAD_BLOCK2D || vma.op == SendOp::STORE_BLOCK2D;
1338 auto fitsInBitSize = [](int bits, int offset) {
1339 return offset >= -(1 << (bits - 1)) && offset <= (1 << (bits - 1)) - 1;
1340 };
1341 uint32_t encodedOffset = 0;
1342 if (isBlock2d && vma.addrOffsetX * vma.dataSizeMem % 32 != 0) {
1343 err = "address offset-y must be 32b aligned";
1344 return false;
1345 } else if (isBlock2d && vma.addrOffsetY * vma.dataSizeMem % 32 != 0) {
1346 err = "address offset-x must be 32b aligned";
1347 return false;
1348 } else if (!isBlock2d && vma.addrOffset % 4 != 0) {
1349 err = "address offset must be 32b aligned";
1350 return false;
1351 } else if (vma.addrType == AddrType::FLAT) {
1352 if (isBlock2d) {
1353 if (vma.sfid != SFID::UGM) {
1354 err = "address offset only defined for flat ugm";
1355 return false;
1356 } else if (!fitsInBitSize(10, vma.addrOffsetX)) {
1357 err = "address offset-x only exceeds 10b";
1358 return false;
1359 } else if (!fitsInBitSize(10, vma.addrOffsetY)) {
1360 err = "address offset-y only exceeds 10b";
1361 return false;
1362 }
1363 // ExDescImm[31:22] = Y-offset
1364 // ExDescImm[21:12] = X-offset
1365 encodedOffset |= ((uint32_t)vma.addrOffsetY & 0x3FF) << 22;
1366 encodedOffset |= ((uint32_t)vma.addrOffsetX & 0x3FF) << 12;
1367 } else if (!fitsInBitSize(20, vma.addrOffset)) {
1368 err = "address offset exceeds 20b";
1369 return false;
1370 } else {
1371 // ExDescImm[31:12] = base offset
1372 encodedOffset = (uint32_t)vma.addrOffset << 12;
1373 }
1374 } else if (isBlock2d) {
1375 err = "block2d immediate offset only valid for flat";
1376 return false;
1377 } else if (vma.addrType == AddrType::BTI && !vma.addrSurface.isReg()) {
1378 if (!fitsInBitSize(12, vma.addrOffset)) {
1379 err = "bti address offset exceeds 12b";
1380 return false;
1381 }
1382 encodedOffset = ((uint32_t)(vma.addrOffset & 0x00FFF) << 12);
1383 } else if (vma.addrSurface.isReg()) {
1384 if (vma.sfid != SFID::UGM) {
1385 err = "unsupported SFID for ExDescReg + BaseOff";
1386 return false;
1387 } else if (!fitsInBitSize(17, vma.addrOffset)) {
1388 err = "address offset of ss/bss (.ugm) exceeds 17b";
1389 return false;
1390 }
1391 //
1392 // ExDesc[31:19] = BaseOffset[16:4]
1393 // ExDesc[15:12] = BaseOffset[3:0]
1394 encodedOffset |= getBits((uint32_t)vma.addrOffset, 4, 13) << 19;
1395 encodedOffset |= getBits((uint32_t)vma.addrOffset, 0, 4) << 12;
1396 } else {
1397 // BSS/SS with imm offset
1398 err = "address offset forbidden bti/ss/bss with imm ExDesc surface";
1399 return false;
1400 }
1401 // needs to write to exImmOffDesc only if ExDesc.IsReg
1402 if (vma.addrSurface.isReg()) {
1403 exImmOffDesc = encodedOffset;
1404 } else {
1405 exDesc = encodedOffset;
1406 }
1407 return true;
1408 }
1409
1410 static bool encLdStVecCaching(const Platform &p, SendOp op, CacheOpt cachingL1,
1411 CacheOpt cachingL3, SendDesc &desc) {
1412 if (p >= Platform::XE2)
1413 return encLdStVecCachingBits16_19(op, cachingL1, cachingL3, desc);
1414
1415 return encLdStVecCachingBits17_19(op, cachingL1, cachingL3, desc);
1416 }
1417
1418 static bool encLdStVec(Platform p, const VectorMessageArgs &vma,
1419 uint32_t &exImmOffDesc,
1420 SendDesc &exDesc, SendDesc &desc, std::string &err) {
1421 desc = 0x0;
1422 exDesc = 0x0;
1423 //
1424 bool hasCMask = false;
1425 switch (vma.op) {
1426 case SendOp::LOAD:
1427 desc.imm |= LSC_LOAD;
1428 break;
1429 case SendOp::LOAD_STRIDED:
1430 desc.imm |= LSC_LOAD_STRIDED;
1431 break;
1432 case SendOp::LOAD_QUAD:
1433 desc.imm |= LSC_LOAD_QUAD;
1434 hasCMask = true;
1435 break;
1436 case SendOp::LOAD_BLOCK2D:
1437 desc.imm |= LSC_LOAD_BLOCK2D;
1438 break;
1439 //
1440 case SendOp::STORE:
1441 desc.imm |= LSC_STORE;
1442 break;
1443 case SendOp::STORE_STRIDED:
1444 desc.imm |= LSC_STORE_STRIDED;
1445 break;
1446 case SendOp::STORE_QUAD:
1447 desc.imm |= LSC_STORE_QUAD;
1448 hasCMask = true;
1449 break;
1450 case SendOp::STORE_UNCOMPRESSED:
1451 desc.imm |= LSC_STORE_UNCOMPRESSED;
1452 break;
1453 case SendOp::STORE_UNCOMPRESSED_QUAD:
1454 desc.imm |= LSC_STORE_UNCOMPRESSED_QUAD;
1455 hasCMask = true;
1456 break;
1457 case SendOp::STORE_BLOCK2D:
1458 desc.imm |= LSC_STORE_BLOCK2D;
1459 break;
1460 //
1461 case SendOp::ATOMIC_AND:
1462 desc.imm |= LSC_ATOMIC_AND;
1463 break;
1464 case SendOp::ATOMIC_FADD:
1465 desc.imm |= LSC_ATOMIC_FADD;
1466 break;
1467 case SendOp::ATOMIC_FCAS:
1468 desc.imm |= LSC_ATOMIC_FCAS;
1469 break;
1470 case SendOp::ATOMIC_FMAX:
1471 desc.imm |= LSC_ATOMIC_FMAX;
1472 break;
1473 case SendOp::ATOMIC_FMIN:
1474 desc.imm |= LSC_ATOMIC_FMIN;
1475 break;
1476 case SendOp::ATOMIC_FSUB:
1477 desc.imm |= LSC_ATOMIC_FSUB;
1478 break;
1479 case SendOp::ATOMIC_IADD:
1480 desc.imm |= LSC_ATOMIC_IADD;
1481 break;
1482 case SendOp::ATOMIC_ICAS:
1483 desc.imm |= LSC_ATOMIC_ICAS;
1484 break;
1485 case SendOp::ATOMIC_IDEC:
1486 desc.imm |= LSC_ATOMIC_IDEC;
1487 break;
1488 case SendOp::ATOMIC_IINC:
1489 desc.imm |= LSC_ATOMIC_IINC;
1490 break;
1491 case SendOp::ATOMIC_ISUB:
1492 desc.imm |= LSC_ATOMIC_ISUB;
1493 break;
1494 case SendOp::ATOMIC_LOAD:
1495 desc.imm |= LSC_ATOMIC_LOAD;
1496 break;
1497 case SendOp::ATOMIC_OR:
1498 desc.imm |= LSC_ATOMIC_OR;
1499 break;
1500 case SendOp::ATOMIC_SMAX:
1501 desc.imm |= LSC_ATOMIC_SMAX;
1502 break;
1503 case SendOp::ATOMIC_SMIN:
1504 desc.imm |= LSC_ATOMIC_SMIN;
1505 break;
1506 case SendOp::ATOMIC_STORE:
1507 desc.imm |= LSC_ATOMIC_STORE;
1508 break;
1509 case SendOp::ATOMIC_UMAX:
1510 desc.imm |= LSC_ATOMIC_UMAX;
1511 break;
1512 case SendOp::ATOMIC_UMIN:
1513 desc.imm |= LSC_ATOMIC_UMIN;
1514 break;
1515 case SendOp::ATOMIC_XOR:
1516 desc.imm |= LSC_ATOMIC_XOR;
1517 break;
1518 case SendOp::ATOMIC_ACADD:
1519 desc.imm |= LSC_ATOMIC_APNDADD;
1520 break;
1521 case SendOp::ATOMIC_ACSUB:
1522 desc.imm |= LSC_ATOMIC_APNDSUB;
1523 break;
1524 case SendOp::ATOMIC_ACSTORE:
1525 desc.imm |= LSC_ATOMIC_APNDSTORE;
1526 break;
1527 case SendOp::LOAD_QUAD_MSRT:
1528 desc.imm |= LSC_LOAD_QUAD_MSRT;
1529 break;
1530 case SendOp::STORE_QUAD_MSRT:
1531 desc.imm |= LSC_STORE_QUAD_MSRT;
1532 break;
1533 default:
1534 err = "unsupported op";
1535 return false;
1536 }
1537 bool isBlock2d =
1538 vma.op == SendOp::LOAD_BLOCK2D || vma.op == SendOp::STORE_BLOCK2D;
1539 bool isBlock2dTyped = isBlock2d && vma.sfid == SFID::TGM;
1540 bool isBlock2dUntyped = isBlock2d && vma.sfid != SFID::TGM;
1541 bool hasAddrSizeField = !isBlock2d;
1542 bool isAtomicAddCounter = vma.op == SendOp::ATOMIC_ACADD ||
1543 vma.op == SendOp::ATOMIC_ACSUB ||
1544 vma.op == SendOp::ATOMIC_ACSTORE;
1545 hasAddrSizeField &= !isAtomicAddCounter;
1546
1547 //
1548 ////////////////////////////////////////
1549 // data size
1550 uint32_t dszEnc = LSC_D8;
1551 if (isBlock2dTyped && (vma.dataSizeReg != 32 || vma.dataSizeMem != 32)) {
1552 err = "block2d.tgm must be d32";
1553 return false;
1554 }
1555 if (vma.dataSizeMem == vma.dataSizeReg) {
1556 switch (vma.dataSizeMem) {
1557 case 8:
1558 dszEnc = LSC_D8;
1559 break;
1560 case 16:
1561 dszEnc = LSC_D16;
1562 break;
1563 case 32:
1564 dszEnc = LSC_D32;
1565 break;
1566 case 64:
1567 dszEnc = LSC_D64;
1568 break;
1569 default:
1570 err = "invalid data size";
1571 return false;
1572 }
1573 } else if (vma.dataSizeMem == 8 && vma.dataSizeReg == 32) {
1574 dszEnc = LSC_D8U32;
1575 } else if (vma.dataSizeMem == 16 && vma.dataSizeReg == 32) {
1576 if (vma.dataSizeExpandHigh) {
1577 dszEnc = LSC_D16U32H;
1578 } else {
1579 dszEnc = LSC_D16U32;
1580 }
1581 } else {
1582 err = "invalid data type";
1583 return false;
1584 }
1585 if (!isBlock2dTyped)
1586 desc.imm |= dszEnc << 9;
1587 //
1588 ////////////////////////////////////////
1589 // vector size
1590 if (hasCMask) {
1591 if (vma.dataComponentMask & ~0xF) {
1592 err = "invalid component mask";
1593 return false;
1594 }
1595 desc.imm |= vma.dataComponentMask << 12;
1596 } else if (isBlock2d) {
1597 if (isBlock2dTyped && vma.dataVnni) {
1598 err = "block2d.tgm forbids VNNI";
1599 return false;
1600 } else if (isBlock2dTyped && vma.dataTranspose) {
1601 err = "block2d.tgm forbids transpose data order";
1602 return false;
1603 }
1604 if (vma.dataVnni)
1605 desc.imm |= 1 << 7;
1606 if (vma.dataTranspose)
1607 desc.imm |= 1 << 15;
1608 } else {
1609 uint32_t vecEnc = LSC_V1;
1610 switch (vma.dataVectorSize) {
1611 case 1:
1612 vecEnc = LSC_V1;
1613 break;
1614 case 2:
1615 vecEnc = LSC_V2;
1616 break;
1617 case 3:
1618 vecEnc = LSC_V3;
1619 break;
1620 case 4:
1621 vecEnc = LSC_V4;
1622 break;
1623 case 8:
1624 vecEnc = LSC_V8;
1625 break;
1626 case 16:
1627 vecEnc = LSC_V16;
1628 break;
1629 case 32:
1630 vecEnc = LSC_V32;
1631 break;
1632 case 64:
1633 vecEnc = LSC_V64;
1634 break;
1635 default:
1636 err = "invalid vector size";
1637 break;
1638 }
1639 if (vma.isAtomic() && vma.dataVectorSize != 1) {
1640 err = "atomics do not support vector operations";
1641 return false;
1642 }
1643 if (vma.dataVnni) {
1644 err = "vnni only valid on block2d operations";
1645 return false;
1646 }
1647 //
1648 desc.imm |= vecEnc << 12;
1649 //
1650 if (vma.dataTranspose) {
1651 desc.imm |= 1 << 15;
1652 //
1653 if (vma.isAtomic()) {
1654 err = "atomics do not support transpose operations";
1655 return false;
1656 }
1657 }
1658 } // end vec non-cmask case
1659 //
1660 ////////////////////////////////////////
1661 // caching options
1662 if (vma.isAtomic() && vma.cachingL1 != CacheOpt::DEFAULT &&
1663 vma.cachingL1 != CacheOpt::UNCACHED) {
1664 err = "atomic L1 must be an uncached option";
1665 return false;
1666 } else {
1667 if (!encLdStVecCaching(p, vma.op, vma.cachingL1, vma.cachingL3, desc)) {
1668 err = "invalid cache-control combination";
1669 return false;
1670 }
1671 }
1672 //
1673 ////////////////////////////////////////
1674 // address size
1675 uint32_t asEnc = 0x0;
1676 switch (vma.addrSize) {
1677 case 16:
1678 asEnc = LSC_A16;
1679 break;
1680 case 32:
1681 asEnc = LSC_A32;
1682 break;
1683 case 64:
1684 asEnc = LSC_A64;
1685 break;
1686 default:
1687 err = "unsupported address size";
1688 return false;
1689 }
1690 if (isBlock2dTyped && vma.addrSize != 32) {
1691 err = "block2d.typed address size must be A32";
1692 return false;
1693 }
1694 if (isBlock2dUntyped && vma.addrSize != 64) {
1695 err = "block2d untyped address size must be A64";
1696 return false;
1697 }
1698 if (hasAddrSizeField) {
1699 desc.imm |= asEnc << 7;
1700 }
1701 //
1702 ////////////////////////////////////////
1703 // address type
1704 uint32_t atEnc = 0x0;
1705 switch (vma.addrType) {
1706 case AddrType::FLAT:
1707 atEnc = LSC_AT_FLAT;
1708 break;
1709 case AddrType::BSS:
1710 atEnc = LSC_AT_BSS;
1711 break;
1712 case AddrType::SS:
1713 atEnc = LSC_AT_SS;
1714 break;
1715 case AddrType::BTI:
1716 atEnc = LSC_AT_BTI;
1717 break;
1718 default:
1719 err = "unsupported address type";
1720 return false;
1721 }
1722 if (isBlock2dTyped && vma.addrType == AddrType::FLAT) {
1723 err = "block2d.typed forbids flat address";
1724 return false;
1725 }
1726 desc.imm |= atEnc << 29;
1727 //
1728 // store the surface
1729 if (vma.addrType != AddrType::FLAT) {
1730 // use exDesc
1731 if (vma.addrType == AddrType::BTI && !vma.addrSurface.isReg()) {
1732 exDesc = vma.addrSurface.imm << 24;
1733 } else {
1734 exDesc = vma.addrSurface;
1735 }
1736 }
1737 //
1738 if (vma.addrType != AddrType::FLAT && vma.sfid == SFID::SLM) {
1739 err = "SLM requires flat address type";
1740 return false;
1741 }
1742 //
1743 ////////////////////////////////////////
1744 // address immediate offset
1745 bool hasAddrImmOffset = vma.addrOffset != 0;
1746 hasAddrImmOffset |= vma.addrOffsetX != 0;
1747 hasAddrImmOffset |= vma.addrOffsetY != 0;
1748 if (hasAddrImmOffset) {
1749 if (p < Platform::XE2) {
1750 err = "address immediate offset not supported on this platform";
1751 return false;
1752 }
1753
1754 if (!encLdStVecImmOffset(p, vma, exImmOffDesc, exDesc, err))
1755 return false;
1756 } // else: addrOffset == 0
1757
1758 ////////////////////////////////////////
1759 // set the surface object
1760 if (vma.addrType == AddrType::FLAT) {
1761 // IR normalization
1762 if (!vma.addrSurface.isImm() || vma.addrSurface.imm != 0) {
1763 err = "malformed IR: flat address model must have surface = 0";
1764 return false;
1765 }
1766 }
1767
1768 // XeHPG+ have surface in ExDesc
1769 if (vma.addrType == AddrType::BTI && vma.addrSurface.isImm()) {
1770 // BTI takes the high byte
1771 if (vma.addrSurface.imm > 0xFF) {
1772 err = "surface index too large for BTI";
1773 return false;
1774 }
1775 exDesc.imm |= vma.addrSurface.imm << 24;
1776 } else if (vma.addrType != AddrType::FLAT) {
1777 uint32_t ZERO_MASK = 0xFFF;
1778 std::string highBit = "11";
1779 if (p >= Platform::XE2) {
1780 ZERO_MASK = 0x7FF;
1781 highBit = "10";
1782 }
1783
1784 // if BTI reg or BSS/SS reg/imm with just copy
1785 // BSS/SS with imm, value is already aligned
1786 if (vma.addrType != AddrType::BTI && vma.addrSurface.isImm() &&
1787 (vma.addrSurface.imm & ZERO_MASK) != 0) {
1788 err = "BSS/SS with immediate descriptor require "
1789 "ExDesc[" +
1790 highBit + ":0] to be 0";
1791 return false;
1792 }
1793 exDesc = vma.addrSurface;
1794 }
1795 //
1796 return true;
1797 }
1798
1799 bool iga::encodeDescriptorsLSC(Platform p, const VectorMessageArgs &vma,
1800 uint32_t &exImmOffDesc, SendDesc &exDesc,
1801 SendDesc &desc, std::string &err) {
1802 if (!sendOpSupportsSyntax(p, vma.op, vma.sfid)) {
1803 err = "unsupported message for SFID";
1804 return false;
1805 }
1806 return encLdStVec(p, vma, exImmOffDesc, exDesc, desc, err);
1807 }