Debian Codegraph @

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

raw
1 /*========================== begin_copyright_notice ============================
2
3 Copyright (C) 2020-2022 Intel Corporation
4
5 SPDX-License-Identifier: MIT
6
7 ============================= end_copyright_notice ===========================*/
8
9 #include "MessageDecoder.hpp"
10
11 #include <tuple>
12
13 using namespace iga;
14
15 struct MessageDecoderOther : MessageDecoderLegacy {
16 MessageDecoderOther(Platform _platform, SFID _sfid, ExecSize _execSize,
17 uint32_t exImmOffDesc, SendDesc _exDesc, SendDesc _desc,
18 DecodeResult &_result)
19 : MessageDecoderLegacy(_platform, _sfid, _execSize, exImmOffDesc, _exDesc,
20 _desc, _result) {}
21
22 void tryDecodeOther() {
23 switch (sfid) {
24 case SFID::GTWY:
25 tryDecodeGTWY();
26 break;
27 case SFID::RC:
28 if (platform() >= Platform::XE2) {
29 tryDecodeRC_XE2();
30 } else {
31 tryDecodeRC();
32 }
33 break;
34 case SFID::RTA:
35 tryDecodeRTA();
36 break;
37 case SFID::BTD:
38 tryDecodeBTD();
39 break;
40 case SFID::SMPL:
41 tryDecodeSMPL();
42 break;
43 case SFID::TS:
44 tryDecodeTS();
45 break;
46 case SFID::URB:
47 tryDecodeURB();
48 break;
49 default:
50 error(0, 0, "invalid sfid");
51 }
52 }
53
54 void tryDecodeGTWY();
55 void tryDecodeRC();
56 void tryDecodeRC_XE2();
57 void tryDecodeRTA();
58 void tryDecodeBTD();
59 void tryDecodeSMPL();
60 void tryDecodeTS();
61 void tryDecodeURB();
62
63 }; // MessageDecodeOther
64
65 void MessageDecoderOther::tryDecodeGTWY() {
66
67 struct GatewayElement {
68 uint32_t encoding;
69 SendOp op;
70 const char *type;
71 const char *preXeDoc, *pstXeDoc, *pstXe2Doc;
72 constexpr GatewayElement(uint32_t enc, SendOp snd, const char *ty,
73 const char *preXe, const char *pstXe,
74 const char *pstXe2)
75 : encoding(enc), op(snd), type(ty), preXeDoc(preXe), pstXeDoc(pstXe),
76 pstXe2Doc(pstXe2) {}
77 };
78 //
79 static constexpr GatewayElement GATEWAY_MESSAGES[]{
80 {0x0, SendOp::EOT, "MSD_EOT", nullptr, "54044", "57488"},
81 {0x1, SendOp::SIGNAL, "MSD_SIGNAL_EVENT", "33508", "47927", "57492"},
82 {0x2, SendOp::MONITOR, "MSD_MONITOR_EVENT", "33512", "47925", "57490"},
83 {0x3, SendOp::UNMONITOR, "MSD_MONITOR_NO_EVENT", "33513", "47926",
84 "57491"},
85 // no 0x5
86 {0x4, SendOp::SIGNAL_BARRIER, "MSD_BARRIER", "33524", "47924", "57489"},
87 {0x6, SendOp::WAIT, "MSD_WAIT_FOR_EVENT", "33514", "47928", "57493"},
88 {0x8, SendOp::SAVE_BARRIER, "MSD_SAVE_BARRIER", nullptr, nullptr,
89 "67045"},
90 {0x9, SendOp::RESTORE_BARRIER, "MSD_RESTORE_BARRIER", nullptr, nullptr,
91 "67049"},
92 {0xA, SendOp::EOTR, "MSD_END_OF_RESTORE", nullptr, nullptr, "67091"},
93 {0xB, SendOp::RESTORE_STACK, "MSD_RESTORE_BTD_STACK", nullptr, nullptr,
94 "68748"},
95 {0xC, SendOp::SIGNAL_SYSTEM_ROUTINE_BARRIER, "MSD_SIP_BARRIER", nullptr,
96 nullptr, "70574"},
97 };
98
99 const GatewayElement *ge = nullptr;
100 // Bit [3] is defined on later platforms to extend gateway encodings
101 // on prior platforms it's always MBZ at least
102 // (or stuff that didn't make it to production)
103 // So we can blindly pretend [3:0] is the opcode for all platforms.
104 uint32_t opBits = getDescBits(0, 4); // [3:0]
105 for (const auto &g : GATEWAY_MESSAGES) {
106 if (g.encoding == opBits) {
107 ge = &g;
108 break;
109 }
110 }
111 if (ge == nullptr) {
112 error(0, 4, "unsupported GTWY op");
113 return;
114 }
115 std::stringstream sym, desc;
116 const SendOpDefinition &sod = lookupSendOp(ge->op);
117 if (!sod.isValid()) {
118 // should be in the table
119 error(0, 4, "INTERNAL ERROR: cannot find GTWY op");
120 return;
121 }
122
123 sym << sod.mnemonic;
124 desc << sod.description;
125 int expectMlen = 0, expectRlen = 0;
126 if (sod.op == SendOp::EOT) {
127 if (platform() < Platform::XE_HPG) {
128 error(0, 4, "Gateway EOT not available on this platform");
129 }
130 expectMlen = 1;
131 }
132 const char *link = platform() >= Platform::XE2 ? ge->pstXe2Doc
133 : platform() >= Platform::XE ? ge->pstXeDoc
134 : ge->preXeDoc;
135 addDoc(DocRef::DESC, ge->type, link);
136
137 switch (sod.op) {
138 case SendOp::EOT:
139 addDoc(DocRef::SRC0, "GW_EOT_PAYLOAD",
140 platform() >= Platform::XE2 ? "70051" : nullptr);
141 expectMlen = 1;
142 break;
143 case SendOp::SIGNAL:
144 case SendOp::MONITOR: // C.f. MDP_EVENT
145 case SendOp::UNMONITOR: // C.f. MDP_NO_EVENT
146 case SendOp::WAIT: // C.f. MDP_Timeout
147 expectMlen = 1;
148 break;
149 case SendOp::SIGNAL_BARRIER: // C.f. MDP_Barrier
150 // XeHP+ no register is returned
151 expectRlen = platform() >= Platform::XE_HP ? 0 : 1;
152 if (platform() >= Platform::XE2) {
153 decodeDescBitField("ActiveThreadsOnly", 11,
154 "only active threads participate");
155 }
156 addDoc(DocRef::SRC0, "MDP_Barrier",
157 platform() >= Platform::XE2 ? "57499"
158 : platform() >= Platform::XE_HPG ? "54006"
159 : platform() >= Platform::XE ? "47931"
160 : "33523");
161 break;
162 case SendOp::SAVE_BARRIER:
163 addDoc(DocRef::DST, "MDP_SAVE_BARRIER", "70584");
164 addDoc(DocRef::SRC0, "SAVE_RESTORE_BAR_PAYLOAD", "67043");
165 expectRlen = 1;
166 expectMlen = 1;
167 break;
168 case SendOp::RESTORE_BARRIER:
169 addDoc(DocRef::SRC0, "SAVE_RESTORE_BAR_PAYLOAD", "67043");
170 expectMlen = 1;
171 break;
172 case SendOp::RESTORE_STACK:
173 addDoc(DocRef::SRC0, "STK_RSTR_PAYLOAD", "68749");
174 expectMlen = 1;
175 break;
176 case SendOp::EOTR:
177 addDoc(DocRef::SRC0, "EOR_PAYLOAD", "67738");
178 expectMlen = 1;
179 break;
180 case SendOp::SIGNAL_SYSTEM_ROUTINE_BARRIER:
181 addDoc(DocRef::DST, "MDP_SIP_BARRIER_RESPONSE", "70576");
182 addDoc(DocRef::SRC0, "GW_SIP_BARRIER_PAYLOAD", "71500");
183 expectRlen = 1;
184 expectMlen = 1;
185 break;
186 default:
187 break;
188 }
189
190
191 addField("GatewayOpcode", 0, 4, opBits, desc.str());
192 setSpecialOpX(sym.str(), desc.str(), sod.op, AddrType::INVALID, SendDesc(0),
193 expectMlen, // mlen
194 expectRlen, // rlen
195 MessageInfo::Attr::NONE);
196 decodeMDC_HF(); // all gateway messages forbid a header
197 }
198
199 void MessageDecoderOther::tryDecodeRC() {
200 // PSEUDO syntax
201 // rtw.{f16,f32}.{simd8,simd16,rep16,lo8ds,hi8ds}{.c}{.ps}{.lrts}{.sgh}
202 // rtr.{f32}.{simd8,simd16}{.ps}{.sgh}
203 std::stringstream sym;
204
205 static const uint32_t RT_READ = 0xD;
206 static const uint32_t RT_WRITE = 0xC;
207
208 std::string descSfx;
209 sym << "rt";
210 auto mt = getDescBits(14, 4);
211 switch (mt) {
212 case RT_WRITE:
213 sym << "w";
214 descSfx = "render target write";
215 break;
216 case RT_READ:
217 sym << "r";
218 descSfx = "render target read";
219 break;
220 default:
221 descSfx = "unknown render target op";
222 error(14, 4, "unsupported RC op");
223 }
224 addField("MessageTypeRC", 14, 4, mt, descSfx);
225
226 std::stringstream descs;
227 int bitSize =
228 decodeDescBitField("DataSize", 30, "FP32", "FP16") == 0 ? 32 : 16;
229 if (bitSize == 32) {
230 descs << "full-precision";
231 sym << ".f32";
232 } else {
233 descs << "half-precision";
234 sym << ".f16";
235 if (mt == RT_READ)
236 warning(30, 1, "half-precision not supported on render target read");
237 }
238 descs << " " << descSfx;
239
240 std::stringstream subopSymSs;
241 auto subOpBits = getDescBits(8, 3);
242 int execSize = 0;
243 switch (mt) {
244 case RT_WRITE:
245 switch (subOpBits) {
246 case 0x0:
247 execSize = DEFAULT_EXEC_SIZE;
248 subopSymSs << ".simd" << execSize;
249 descs << " SIMD" << execSize;
250 break;
251 case 0x1:
252 execSize = DEFAULT_EXEC_SIZE;
253 subopSymSs << ".rep" << execSize;
254 descs << " replicated SIMD" << execSize;
255 break;
256 case 0x2:
257 execSize = DEFAULT_EXEC_SIZE / 2;
258 subopSymSs << ".lo" << execSize << "ds";
259 descs << " of low SIMD" << execSize;
260 break;
261 case 0x3:
262 execSize = DEFAULT_EXEC_SIZE / 2;
263 subopSymSs << ".hi" << execSize << "ds";
264 descs << " of high SIMD" << execSize;
265 break;
266 case 0x4:
267 execSize = DEFAULT_EXEC_SIZE / 2;
268 subopSymSs << ".simd" << execSize;
269 descs << " SIMD" << execSize;
270 break;
271 default:
272 sym << ".???";
273 descs << "unknown write subop";
274 error(8, 3, "unknown write subop");
275 break;
276 }
277 break;
278 case RT_READ:
279 switch (subOpBits) {
280 case 0x0:
281 execSize = DEFAULT_EXEC_SIZE;
282 subopSymSs << ".simd" << execSize;
283 descs << " SIMD" << execSize;
284 break;
285 case 0x1:
286 execSize = DEFAULT_EXEC_SIZE / 2;
287 subopSymSs << ".simd" << execSize;
288 descs << " SIMD" << execSize;
289 break;
290 default:
291 sym << ".???";
292 descs << "unknown read subop";
293 error(8, 3, "unknown read subop");
294 break;
295 }
296 break;
297 default:
298 break;
299 }
300 addField("Subop", 8, 3, subOpBits, subopSymSs.str());
301 sym << subopSymSs.str();
302
303 if (mt == RT_WRITE) {
304 auto pc = decodeDescBitField("PerCoarsePixelPSOutputs", 18, "disabled",
305 "enabled");
306 if (pc) {
307 descs << " with Per-Coarse Pixel PS outputs enable";
308 sym << ".cpo";
309 }
310 }
311 auto ps = decodeDescBitField("PerSamplePS", 13, "disabled", "enabled");
312 if (ps) {
313 descs << " with Per-Sample Pixel PS outputs enable";
314 sym << ".psp";
315 }
316
317 if (mt == RT_WRITE) {
318 auto lrts =
319 decodeDescBitField("LastRenderTargetSelect", 12, "false", "true");
320 if (lrts) {
321 descs << "; last render target";
322 sym << ".lrts";
323 }
324 }
325
326 auto sgs =
327 decodeDescBitField("SlotGroupSelect", 11, "SLOTGRP_LO", "SLOTGRP_HI");
328 if (sgs) {
329 descs << " slot group high";
330 sym << ".sgh";
331 }
332
333 uint32_t surfaceIndex = 0;
334 (void)decodeDescField("BTS", 0, 8,
335 [&](std::stringstream &ss, uint32_t value) {
336 surfaceIndex = value;
337 ss << "surface " << value;
338 descs << " to surface " << value;
339 sym << ".bti[" << value << "]";
340 });
341
342 MessageInfo &mi = result.info;
343 mi.symbol = sym.str();
344 mi.description = descs.str();
345 mi.op = mt == RT_READ ? SendOp::RENDER_READ : SendOp::RENDER_WRITE;
346 mi.execWidth = execSize;
347 mi.elemSizeBitsMemory = mi.elemSizeBitsRegFile = bitSize;
348 mi.addrSizeBits = 0;
349 mi.surfaceId = surfaceIndex;
350 mi.attributeSet = MessageInfo::Attr::NONE;
351
352 decodeMDC_H2(); // all render target messages permit a dual-header
353 }
354 void MessageDecoderOther::tryDecodeRC_XE2() {
355 // PSEUDO syntax:
356 // {rtw,rtdw}{.mrcps},{.hdr,}{.psps,}{.lo16,hi16,}
357 // rtr{.hdr,}{.psps,}{.lo16,hi16,}
358 std::stringstream sym;
359
360 // message type
361 enum {
362 RT_READ = 0xD,
363 RT_WRITE = 0xC
364 };
365
366 // message subtype
367 enum {
368 ST_SIMD32_WRITE = 0x0,
369 ST_SIMD16_DWRITE = 0x2 // no name in BXML
370 };
371
372 // pick default SIMD size if it's not set
373 if (instExecSize == ExecSize::INVALID)
374 instExecSize = ExecSize::SIMD16;
375
376 std::string descSfx, stSfx;
377 sym << "rt";
378 const auto mt = getDescBits(14, 4);
379 const auto st = getDescBits(8, 2);
380 const auto isWr = mt == RT_WRITE;
381 const auto isDuWr = isWr && st == ST_SIMD16_DWRITE;
382 switch (mt) {
383 case RT_WRITE:
384 if (st == ST_SIMD16_DWRITE) {
385 stSfx = "SIMD16_DWRITE";
386 sym << "dw";
387 descSfx = "render write dual";
388 addDocs(DocRef::DESC, "MSD_RTW_SIMD16DS", "63908",
389 DocRef::EXDESC, nullptr, "57391",
390 DocRef::SRC0, "MH_RT", "57476",
391 DocRef::SRC1, "MDP_RTW_DS", "63914");
392 if (instExecSize == ExecSize::SIMD32)
393 error(14, 4, "dual write must be SIMD16");
394 } else if (st == ST_SIMD32_WRITE) {
395 stSfx = "SIMD32_WRITE";
396 sym << "w";
397 descSfx = "render write";
398 if (instExecSize == ExecSize::SIMD32)
399 addDocs(DocRef::DESC, "MSD_RTW_SIMD32", "65209",
400 DocRef::EXDESC, nullptr, "57391",
401 DocRef::SRC0, "MH_RT", "57476",
402 DocRef::SRC1, "MDP_RTW_SIMD32", "65198");
403 else
404 addDocs(DocRef::DESC, "MSD_RTW_SIMD16", "57384",
405 DocRef::EXDESC, nullptr, "57391",
406 DocRef::SRC0, "MH_RT", "57476",
407 DocRef::SRC1, "MDP_RTW", "63902");
408 }
409 break;
410 case RT_READ:
411 sym << "r";
412 descSfx = "render read";
413 if (instExecSize == ExecSize::SIMD32)
414 addDocs(DocRef::DESC, "MSD_RTR_SIMD32", "65211",
415 DocRef::EXDESC, nullptr, "57391",
416 DocRef::SRC0, "MH_RT", "57476");
417 else
418 addDocs(DocRef::DESC, "MSD_RTR_SIMD16", "57374",
419 DocRef::EXDESC, nullptr, "57391",
420 DocRef::SRC0, "MH_RT", "57476");
421 break;
422 default:
423 descSfx = "unknown render target op";
424 error(14, 4, "unsupported RC op");
425 }
426
427 addField("MessageTypeRC", 14, 4, mt, descSfx);
428 addField("RenderTargetMessageSubtype", 8, 2, st, stSfx);
429
430 std::stringstream descs;
431
432 int bitSize =
433 decodeDescBitField("DataSize", 30, "FP32", "FP16") == 0 ? 32 : 16;
434 if (bitSize != 32) {
435 warning(30, 1, "half-precision not supported");
436 }
437 descs << descSfx;
438
439 auto decodeBit =
440 [&](int off, const char *descField, const char *descSfx,
441 const char *symSfx) {
442 auto val = decodeDescBitField(descField, off, "Disabled", "Enabled");
443 if (val) {
444 descs << " " << descSfx;
445 sym << "." << symSfx;
446 }
447 return val;
448 };
449
450 // Desc[29] .mrcps - multirate coarse pixel shading
451 if (mt == RT_READ) {
452 decodeReserved(29, 1);
453 } else {
454 decodeBit(29, "MultiRateCPS", "multirate coarse pixel shading", "mrcps");
455 }
456
457 // Desc[19] .hdr - render target messages permit a header
458 if (decodeMDC_H()) {
459 sym << ".hdr";
460 }
461
462 // Desc[18] .pscps - per sample coarse pixel shading
463 if (mt == RT_READ) {
464 decodeReserved(18, 1);
465 } else {
466 decodeBit(18, "PerSampleOutCPS",
467 "per-sample outputs coarse pixel shading", "psocps");
468 }
469
470 // Desc[13] .psps - per sample pixel shading
471 decodeBit(13, "PerSamplePSEnable", "per-sample pixel shading", "psps");
472
473 // Desc[12] .lrts - last render target select
474 decodeBit(12, "LastRenderTargetSelect", "last render target select", "lrts");
475
476 // Desc[11] slot group select (.lo16|.hi16)
477 if (instExecSize != ExecSize::SIMD32) {
478 auto sgs = decodeDescBitField("SlotGroup", 11, "SG_LO", "SG_HI");
479 if (sgs) {
480 descs << " slot group " << (sgs ? "high16" : "low16");
481 sym << (sgs ? ".hi16" : ".lo16");
482 }
483 } else {
484 decodeReserved(11, 1);
485 }
486
487
488 uint32_t surfaceIndex = 0;
489 (void)decodeDescField("BTS", 0, 8,
490 [&](std::stringstream &ss, uint32_t value) {
491 surfaceIndex = value;
492 ss << "surface " << value;
493 descs << " to bti[" << value << "]";
494 sym << ".bti[" << value << "]";
495 });
496
497 // ExDesc[23:21] - render target index
498 if (mt == RT_READ) {
499 decodeExDescReserved(21, 3);
500 } else {
501 decodeExDescField("RenderTargetIndex", 21, 3,
502 [&](std::stringstream &ss, uint32_t val) {
503 sym << ".rti[" << val << "]";
504 descs << ".rti[" <<val << "]";
505 });
506 }
507
508
509 // ExDesc[20] - null render target
510 decodeExDescField("NullRenderTarget", 20, 1,
511 [&](std::stringstream &ss, uint32_t val) {
512 if (val)
513 sym << ".nullrt";
514 });
515
516 // message layout is
517 // COLORS_SIMD32 = R,R,G,G,B,B,A,A
518 // COLORS_SIMD16 = R,G,B,A
519 // RTW_SIMD16: [s0A][oM]{COLORS_SIMD16}[,SZ][,STENCIL]
520 // (4 to 8 total registers not counting possible header)
521 // RTW_DSIMD16: [oM,]{COLORS_SIMD16},{COLORS_SIMD16}[,SZ][,STENCIL]
522 // (8 to 11 total registers not counting possible header)
523 // RTW SIMD32: [s0A,s0A][,oM]{COLORS_SIMD32}[,SZ,SZ][,STENCIL,STENCIL]
524 // (8 to 15 total registers not counting possible header)
525 const auto phasePerParam =
526 (instExecSize == ExecSize::SIMD32 || isDuWr) ? 2 : 1;
527 int dataPhases = 4 * phasePerParam;
528
529 auto decodeExDescParam = [&](const char *field, int off, const char *sy,
530 int deltaPhases = 1) {
531 return decodeExDescField(field, off, 1,
532 [&](std::stringstream &ss, uint32_t val) {
533 if (val) {
534 sym << "." << sy;
535 ss << "Present";
536 dataPhases += deltaPhases;
537 descs << "." << sy;
538 } else {
539 ss << "Absent";
540 }
541 });
542 };
543
544 if (exDesc.isImm()) {
545 // decode bits [15:12] in parameter order
546 if (getDescBits(32 + 12, 4)) {
547 descs << " with ex params ";
548 }
549
550 // ExDesc[15] - src0 alpha present
551 auto s0a = decodeExDescParam("Src0AlphaPresent", 15, "s0a", phasePerParam);
552 if (s0a && isDuWr) {
553 error(15, 1, "Src0Alpha not permitted on render dual write");
554 }
555 // ExDesc[14] - stencil present
556 decodeExDescParam("StencilPresent", 14, "stncl", 1);
557 // ExDesc[13] - source depth
558 decodeExDescParam("SourceDepth", 13, "sz", phasePerParam);
559 // ExDesc[12] - omask
560 decodeExDescParam("OMask", 12, "om", 1);
561
562 // *** Comes directly from Src1.Len in EU bits ***
563 //
564 // ExDesc[10:6] - xlen
565 // decodeExDescField("ExtendedMessageLength", 6, 4,
566 // [&](std::stringstream &ss, uint32_t val) {
567 // ss << "src1.length is " << val << " registers";
568 // });
569 } // else reg exDesc probably shouldn't happen, but we can't see it if so
570
571 MessageInfo &mi = result.info;
572 mi.symbol = sym.str();
573 mi.description = descs.str();
574 mi.op = mt == RT_READ ? SendOp::RENDER_READ
575 : st == ST_SIMD16_DWRITE ? SendOp::RENDER_DWRITE
576 : SendOp::RENDER_WRITE;
577 mi.execWidth = int(instExecSize);
578 mi.elemSizeBitsMemory = mi.elemSizeBitsRegFile = 32;
579 mi.addrSizeBits = 0; // the addresses of render target are implicit
580 mi.surfaceId = surfaceIndex;
581 mi.attributeSet = MessageInfo::Attr::NONE;
582 // mi.dstLenBytes = 0;
583 // if (header)
584 // result.info.src0LenBytes = BITS_PER_REGISTER / 8;
585 // mi.src1LenBytes = dataPhases * BITS_PER_REGISTER / 8;
586 (void)dataPhases;
587 }
588
589 void MessageDecoderOther::tryDecodeRTA() {
590 const int TRACERAY_MSD = 0x00;
591
592 std::stringstream sym, descs;
593 int opBits = getDescBits(14, 4); // [17:14]
594 if (opBits == TRACERAY_MSD) {
595 int simd = decodeMDC_SM2(8);
596 if (platform() >= Platform::XE2 && simd != 16)
597 error(8, 1, "message must be SIMD16 on this platform");
598
599 addDoc(DocRef::DESC, "TRACERAY_MSD",
600 platform() >= Platform::XE2 ? "57495" : "47929");
601 if (instExecSize == ExecSize::SIMD8 && platform() <= Platform::XE_HPG) {
602 addDoc(DocRef::SRC0, "TRACE_RAY_SIMD8_PAYLOAD", "47938");
603 } else if (instExecSize == ExecSize::SIMD16) {
604 addDoc(DocRef::SRC0, "TRACE_RAY_SIMD16_PAYLOAD",
605 platform() >= Platform::XE2 ? "57508" : "47937");
606 }
607
608 // int mlen = getDescBits(25, 4); // [28:25]
609 sym << "trace_ray" << simd;
610 descs << "simd" << simd << " trace ray";
611
612 MessageInfo &mi = result.info;
613 mi.symbol = sym.str();
614 mi.description = descs.str();
615 mi.op = SendOp::TRACE_RAY;
616 // payload is 2 or 3 registers (SIMD8 vs SIMD16)
617 // #47937
618 // - "addr" the first with a uniform pointer to global data
619 // - "data" the second being ray payloads[7:0] (each 32b)
620 // - "data" if SIMD16, rays[15:6]
621 // we treat this as a SIMD1 operation (logically)
622 // containing SIMD data 32b elements
623 mi.execWidth = simd;
624 mi.elemSizeBitsRegFile = mi.elemSizeBitsMemory = 32;
625 mi.elemsPerAddr = 1;
626 //
627 mi.addrSizeBits = 64;
628 if (platform() >= Platform::XE_HPC) {
629 // XeHPC has a bit set at Msg[128] as well
630 mi.addrSizeBits = 129;
631 }
632 mi.addrType = AddrType::FLAT;
633 mi.surfaceId = 0;
634 mi.attributeSet = MessageInfo::Attr::NONE;
635 decodeMDC_HF();
636 } else {
637 error(14, 4, "unsupported RTA op");
638 }
639 }
640
641 void MessageDecoderOther::tryDecodeBTD() {
642 enum {
643 BTD_SPAWN = 0x1,
644 BTD_SPAWN_OVERDISPATCH = 0x2,
645 };
646
647 int simd = decodeMDC_SM2(8);
648 if (platform() >= Platform::XE_HPC && simd != 16)
649 error(8, 1, "message must be SIMD16 on this platform");
650 if (instExecSize == ExecSize::INVALID) {
651 instExecSize = ExecSize(simd);
652 }
653
654 std::stringstream sym, descs;
655 uint32_t opBits = getDescBits(14, 4); // [17:14]
656 addDoc(DocRef::DESC, "BTD_SPAWN_MSD", chooseDoc(nullptr, "47923", "57487"));
657 if (instExecSize == ExecSize::SIMD8 && platform() <= Platform::XE_HPG) {
658 addDoc(DocRef::SRC0, "SIMD8_BTD_SPAWN_PAYLOAD", "47936");
659 } else if (instExecSize == ExecSize::SIMD16) {
660 addDoc(DocRef::SRC0, "BTD_SIMD16_SPAWN_PAYLOAD",
661 platform() >= Platform::XE2 ? "57501" : "47930");
662 } else {
663 error(14, 4, "invalid execution size");
664 }
665
666 if (opBits == BTD_SPAWN) {
667 sym << "spawn" << simd;
668 descs << "bindless simd" << simd << " spawn thread";
669 } else if (opBits == BTD_SPAWN_OVERDISPATCH) {
670 sym << "spawn_overdispatch" << simd;
671 descs << "bindless simd" << simd << " spawn thread overdispatched";
672 } else {
673 error(14, 4, "invalid BTD op");
674 }
675
676 MessageInfo &mi = result.info;
677 mi.op = SendOp::SPAWN;
678 mi.description = descs.str();
679 mi.symbol = sym.str();
680 mi.execWidth = simd;
681
682 addField("MessageType", 14, 4, opBits, descs.str());
683 }
684
685 ///////////////////////////////////////////////////////////////////////////////
686 enum class SamplerSIMD {
687 INVALID = 0,
688 SIMD8,
689 SIMD16,
690 SIMD32,
691 SIMD32_64,
692 SIMD8H, // half precision parameters
693 SIMD16H, // half precision parameters
694 SIMD32H, // half precision parameters
695 SIMD8_INTRET, // with integer return XeHPG+
696 SIMD16_INTRET, // with integer return XeHPG+
697 };
698
699 ///////////////////////////////////////////////
700 // TGL ...
701 // 000 Reserved
702 // 001 SIMD8
703 // 010 SIMD16
704 // 011 SIMD32/64
705 // 100 Reserved
706 // 101 SIMD8H
707 // 110 SIMD16H
708 // 111 Reserved
709 //
710 ///////////////////////////////////////////////
711 // XeHPG+
712 // 000 SIMD8 + Integer Return
713 // 001 SIMD8
714 // 010 SIMD16
715 // 011 Reserved
716 // 100 SIMD16 + Integer Return
717 // 101 SIMD8H
718 // 110 SIMD16H
719 // 111 Reserved
720 //
721 ///////////////////////////////////////////////
722 // Xe2+
723 // 000 SIMD16 + Integer Return (not supported on XE2)
724 // 001 SIMD16
725 // 010 SIMD32
726 // 011 Reserved
727 // 100 SIMD16 + Integer Return (not supported on XE2)
728 // 101 SIMD16H
729 // 110 SIMD32H
730 // 111 Reserved
731
732 static SamplerSIMD decodeSimdSize(Platform p, uint32_t simdBits, int &simdSize,
733 std::stringstream &syms,
734 std::stringstream &descs) {
735 SamplerSIMD simdMode = SamplerSIMD::INVALID;
736 switch (simdBits) {
737 case 0:
738 if (p >= Platform::XE2) {
739 simdMode = SamplerSIMD::SIMD16_INTRET;
740 syms << "simd16_iret";
741 descs << "simd16 with integer return";
742 simdSize = 16;
743 break;
744 }
745 if (p >= Platform::XE_HPG) {
746 simdMode = SamplerSIMD::SIMD8_INTRET;
747 syms << "simd8_iret";
748 descs << "simd8 with integer return";
749 simdSize = 8;
750 break;
751 }
752 simdMode = SamplerSIMD::INVALID;
753 syms << "???";
754 descs << "unknown simd mode";
755 simdSize = 1;
756 return simdMode;
757 case 1:
758 if (p >= Platform::XE2) {
759 simdMode = SamplerSIMD::SIMD16;
760 simdSize = 16;
761 descs << "simd16";
762 syms << "simd16";
763 break;
764 }
765 simdMode = SamplerSIMD::SIMD8;
766 simdSize = 8;
767 descs << "simd8";
768 syms << "simd8";
769 break;
770 case 2:
771 if (p >= Platform::XE2) {
772 simdMode = SamplerSIMD::SIMD32;
773 simdSize = 32;
774 descs << "simd32";
775 syms << "simd32";
776 break;
777 }
778 simdMode = SamplerSIMD::SIMD16;
779 simdSize = 16;
780 descs << "simd16";
781 syms << "simd16";
782 break;
783 case 3:
784 if (p >= Platform::XE_HPG) {
785 simdMode = SamplerSIMD::INVALID;
786 syms << "???";
787 descs << "unknown simd mode";
788 simdSize = 1;
789 break;
790 }
791 simdMode = SamplerSIMD::SIMD32_64;
792 descs << "simd32/64";
793 syms << "simd32";
794 simdSize = 32;
795 break;
796 case 4:
797 if (p >= Platform::XE2) {
798 simdMode = SamplerSIMD::SIMD16_INTRET;
799 syms << "simd32_iret";
800 descs << "simd32 with integer return";
801 simdSize = 32;
802 break;
803 }
804 if (p >= Platform::XE_HPG) {
805 syms << "simd16_iret";
806 descs << "simd16 with integer return";
807 simdMode = SamplerSIMD::SIMD16_INTRET;
808 simdSize = 16;
809 break;
810 }
811 simdMode = SamplerSIMD::INVALID;
812 syms << "???";
813 descs << "unknown simd mode";
814 simdSize = 1;
815 break;
816 case 5:
817 if (p >= Platform::XE2) {
818 simdMode = SamplerSIMD::SIMD16H;
819 simdSize = 16;
820 syms << "simd16h";
821 descs << "simd16 with half precision parameters";
822 break;
823 }
824 simdMode = SamplerSIMD::SIMD8H;
825 simdSize = 8;
826 syms << "simd8h";
827 descs << "simd8 half with precision parameters";
828 break;
829 case 6:
830 if (p >= Platform::XE2) {
831 simdMode = SamplerSIMD::SIMD32H;
832 simdSize = 32;
833 syms << "simd32h";
834 descs << "simd32 with half precision parameters";
835 break;
836 }
837 simdMode = SamplerSIMD::SIMD16H;
838 syms << "simd16h";
839 descs << "simd16 with half precision parameters";
840 simdSize = 16;
841 break;
842 default:
843 break;
844 } // switch
845
846 return simdMode;
847 }
848
849 int SamplerMessageDescription::countParams() const {
850 int n = 0;
851 for (SamplerParam sp : params) {
852 if (sp == SamplerParam::NONE)
853 break;
854 }
855 return n;
856 }
857
858 std::string SamplerMessageDescription::describe(int srcsLen) const {
859 std::stringstream ss;
860 ss << mnemonic << ":" << describeParams(srcsLen);
861 return ss.str();
862 }
863 std::string SamplerMessageDescription::describeParams(int srcsLen) const {
864 std::stringstream ss;
865 bool first = true;
866 int n = 0;
867 for (SamplerParam sp : params) {
868 if (sp == SamplerParam::NONE)
869 break;
870 if (first) {
871 first = false;
872 } else {
873 ss << ",";
874 }
875 ss << ToSymbol(sp);
876 // for optional parameters
877 if (srcsLen >= 0 && ++n >= srcsLen)
878 break;
879 }
880 return ss.str();
881 }
882
883 std::string iga::ToSymbol(SamplerParam sp) {
884 switch (sp) {
885 case SamplerParam::AI:
886 return "ai";
887 case SamplerParam::BIAS:
888 return "bias";
889 case SamplerParam::BIAS_AI:
890 return "bias_ai";
891 case SamplerParam::DUDX:
892 return "dudx";
893 case SamplerParam::DUDY:
894 return "dudy";
895 case SamplerParam::DUMMY:
896 return "dummy";
897 case SamplerParam::DVDX:
898 return "dvdx";
899 case SamplerParam::DVDY:
900 return "dvdy";
901 case SamplerParam::LOD:
902 return "lod";
903 case SamplerParam::LOD_AI:
904 return "lod_ai";
905 case SamplerParam::MCS0:
906 return "mcs0";
907 case SamplerParam::MCS1:
908 return "mcs1";
909 case SamplerParam::MCS2:
910 return "mcs2";
911 case SamplerParam::MCS3:
912 return "mcs3";
913 case SamplerParam::MLOD:
914 return "mlod";
915 case SamplerParam::MLOD_R:
916 return "mlod_r";
917 case SamplerParam::R:
918 return "r";
919 case SamplerParam::REF:
920 return "ref";
921 case SamplerParam::SI:
922 return "si";
923 case SamplerParam::U:
924 return "u";
925 case SamplerParam::V:
926 return "v";
927 case SamplerParam::OFFUV_R:
928 return "offuv_r";
929 case SamplerParam::OFFUVR:
930 return "offuvr";
931 case SamplerParam::OFFUV:
932 return "offuv";
933 case SamplerParam::OFFUVR_R:
934 return "offuvr_r";
935 case SamplerParam::BIAS_OFFUVR:
936 return "bias_offuvr";
937 case SamplerParam::BIAS_OFFUV:
938 return "bias_offuv";
939 case SamplerParam::LOD_OFFUV:
940 return "lod_offuv";
941 default:
942 return "?";
943 }
944 }
945
946 static SamplerMessageDescription
947 lookupSamplerMessageInfoXe2(uint32_t samplerMessageType, SamplerSIMD simd) {
948 static constexpr SamplerMessageDescription INVALID(SendOp::INVALID,
949 "<<invalid>>", 0);
950
951 // if the message is fp16 (apparently they bake that into the "SIMD" size)
952 bool isFp16 = simd == SamplerSIMD::SIMD8H || simd == SamplerSIMD::SIMD16H ||
953 simd == SamplerSIMD::SIMD32H;
954 auto chooseBasedOnDataSize = [&](SamplerParam fp16, SamplerParam fp32) {
955 return isFp16 ? fp16 : fp32;
956 };
957 switch (samplerMessageType) {
958 case 0x00:
959 return SamplerMessageDescription(
960 SendOp::SAMPLE, "sample", 1, SamplerParam::U, SamplerParam::V,
961 SamplerParam::R, SamplerParam::AI, SamplerParam::MLOD);
962 case 0x01:
963 return SamplerMessageDescription(
964 SendOp::SAMPLE_B, "sample_b", 2,
965 chooseBasedOnDataSize(SamplerParam::BIAS, SamplerParam::BIAS_AI),
966 SamplerParam::U, SamplerParam::V, SamplerParam::R,
967 chooseBasedOnDataSize(SamplerParam::AI, SamplerParam::MLOD),
968 chooseBasedOnDataSize(SamplerParam::MLOD, SamplerParam::NONE));
969 case 0x02:
970 return SamplerMessageDescription(
971 SendOp::SAMPLE_L, "sample_l", 2,
972 chooseBasedOnDataSize(SamplerParam::LOD, SamplerParam::LOD_AI),
973 SamplerParam::U, SamplerParam::V, SamplerParam::R,
974 chooseBasedOnDataSize(SamplerParam::AI, SamplerParam::NONE));
975 case 0x03:
976 return SamplerMessageDescription(
977 SendOp::SAMPLE_C, "sample_c", 2, SamplerParam::REF, SamplerParam::U,
978 SamplerParam::V, SamplerParam::R, SamplerParam::AI, SamplerParam::MLOD);
979 case 0x04:
980 return SamplerMessageDescription(
981 SendOp::SAMPLE_D, "sample_d", 2, SamplerParam::U, SamplerParam::DUDX,
982 SamplerParam::DUDY, SamplerParam::V, SamplerParam::DVDX,
983 SamplerParam::DVDY, SamplerParam::R, SamplerParam::MLOD);
984 case 0x05:
985 return SamplerMessageDescription(
986 SendOp::SAMPLE_B_C, "sample_b_c", 3, SamplerParam::REF,
987 chooseBasedOnDataSize(SamplerParam::BIAS, SamplerParam::BIAS_AI),
988 SamplerParam::U, SamplerParam::V, SamplerParam::R,
989 chooseBasedOnDataSize(SamplerParam::AI, SamplerParam::MLOD),
990 chooseBasedOnDataSize(SamplerParam::MLOD, SamplerParam::NONE));
991 case 0x06:
992 return SamplerMessageDescription(
993 SendOp::SAMPLE_L_C, "sample_l_c", 3, SamplerParam::REF,
994 chooseBasedOnDataSize(SamplerParam::LOD, SamplerParam::LOD_AI),
995 SamplerParam::U, SamplerParam::V, SamplerParam::R,
996 chooseBasedOnDataSize(SamplerParam::AI, SamplerParam::NONE));
997 case 0x07:
998 return SamplerMessageDescription(SendOp::LD, "sampler_ld", 1,
999 SamplerParam::U, SamplerParam::V,
1000 SamplerParam::LOD, SamplerParam::R);
1001 case 0x08:
1002 case 0x09:
1003 return SamplerMessageDescription(
1004 samplerMessageType == 0x08 ? SendOp::GATHER4 : SendOp::SAMPLE_LOD,
1005 samplerMessageType == 0x08 ? "gather4" : "sampler_lod", 1,
1006 SamplerParam::U, SamplerParam::V, SamplerParam::R, SamplerParam::AI);
1007 case 0x0A:
1008 return SamplerMessageDescription(SendOp::SAMPLE_RESINFO, "sampler_resinfo",
1009 1, SamplerParam::LOD);
1010 case 0x0B:
1011 return SamplerMessageDescription(SendOp::SAMPLE_INFO, "sample_info", 0,
1012 SamplerParam::DUMMY);
1013 case 0x0C:
1014 return SamplerMessageDescription(SendOp::SAMPLE_KILLPIX, "sampler_killpix",
1015 1, SamplerParam::U, SamplerParam::V,
1016 SamplerParam::R);
1017 case 0x0D:
1018 return SamplerMessageDescription(
1019 SendOp::GATHER4_L, "gather4_l", 2,
1020 chooseBasedOnDataSize(SamplerParam::LOD, SamplerParam::LOD_AI),
1021 SamplerParam::U, SamplerParam::V, SamplerParam::R,
1022 chooseBasedOnDataSize(SamplerParam::AI, SamplerParam::NONE));
1023 case 0x0E:
1024 return SamplerMessageDescription(
1025 SendOp::GATHER4_B, "gather4_b", 2,
1026 chooseBasedOnDataSize(SamplerParam::BIAS, SamplerParam::BIAS_AI),
1027 SamplerParam::U, SamplerParam::V, SamplerParam::R,
1028 chooseBasedOnDataSize(SamplerParam::AI, SamplerParam::NONE));
1029 case 0x0F:
1030 return SamplerMessageDescription(SendOp::GATHER4_I, "gather_i", 1,
1031 SamplerParam::U, SamplerParam::V,
1032 SamplerParam::R, SamplerParam::AI);
1033 case 0x10:
1034 return SamplerMessageDescription(
1035 SendOp::GATHER4_C, "gather4_c", 2, SamplerParam::REF, SamplerParam::U,
1036 SamplerParam::V, SamplerParam::R, SamplerParam::AI);
1037 case 0x11:
1038 return SamplerMessageDescription(SendOp::SAMPLE_D_C_MLOD, "sample_d_c_mlod",
1039 4, SamplerParam::REF, SamplerParam::U,
1040 SamplerParam::DUDX, SamplerParam::DUDY,
1041 SamplerParam::V, SamplerParam::DVDX,
1042 SamplerParam::DVDY, SamplerParam::MLOD_R);
1043 case 0x12:
1044 return SamplerMessageDescription(
1045 SendOp::SAMPLE_MLOD, "sample_mlod", 1, SamplerParam::MLOD,
1046 SamplerParam::U, SamplerParam::V, SamplerParam::R, SamplerParam::AI);
1047 case 0x13:
1048 return SamplerMessageDescription(SendOp::SAMPLE_C_MLOD, "sample_c_mlod", 3,
1049 SamplerParam::MLOD, SamplerParam::REF,
1050 SamplerParam::U, SamplerParam::V,
1051 SamplerParam::R, SamplerParam::AI);
1052 case 0x14:
1053 return SamplerMessageDescription(
1054 SendOp::SAMPLE_D_C, "sample_d_c", 4, SamplerParam::REF, SamplerParam::U,
1055 SamplerParam::DUDX, SamplerParam::DUDY, SamplerParam::V,
1056 SamplerParam::DVDX, SamplerParam::DVDY, SamplerParam::R);
1057 case 0x15:
1058 return SamplerMessageDescription(
1059 SendOp::GATHER4_I_C, "gather4_i_c", 2, SamplerParam::REF,
1060 SamplerParam::U, SamplerParam::V, SamplerParam::R, SamplerParam::AI);
1061 //////////////////////////////////
1062 // case 0x16: gap
1063 case 0x17:
1064 return SamplerMessageDescription(
1065 SendOp::GATHER4_L_C, "gather4_l_c", 3, SamplerParam::REF,
1066 chooseBasedOnDataSize(SamplerParam::LOD, SamplerParam::LOD_AI),
1067 SamplerParam::U, SamplerParam::V, SamplerParam::R,
1068 chooseBasedOnDataSize(SamplerParam::AI, SamplerParam::NONE));
1069 case 0x18:
1070 return SamplerMessageDescription(SendOp::SAMPLE_LZ, "sample_lz", 1,
1071 SamplerParam::U, SamplerParam::V,
1072 SamplerParam::R, SamplerParam::AI);
1073 case 0x19:
1074 return SamplerMessageDescription(
1075 SendOp::SAMPLE_C_LZ, "sample_c_lz", 2, SamplerParam::REF,
1076 SamplerParam::U, SamplerParam::V, SamplerParam::R, SamplerParam::AI);
1077 case 0x1A:
1078 return SamplerMessageDescription(SendOp::LD_LZ, "ld_lz", 1,
1079 SamplerParam::U, SamplerParam::V,
1080 SamplerParam::R);
1081 case 0x1B:
1082 return SamplerMessageDescription(SendOp::SAMPLE_LD_L, "ld_l", 1,
1083 SamplerParam::U, SamplerParam::V,
1084 SamplerParam::R, SamplerParam::LOD);
1085 case 0x1C:
1086 return SamplerMessageDescription(
1087 SendOp::LD_2DMS_W, "ld2dms_w", 1, SamplerParam::SI,
1088 SamplerParam::MCS0, SamplerParam::MCS1, SamplerParam::MCS2,
1089 SamplerParam::MCS3, SamplerParam::U, SamplerParam::V, SamplerParam::R);
1090 case 0x1D:
1091 return SamplerMessageDescription(SendOp::LD_MCS, "ld_mcs", 1,
1092 SamplerParam::U, SamplerParam::V,
1093 SamplerParam::R);
1094 case 0x1F:
1095 return SamplerMessageDescription(SendOp::SAMPLE_FLUSH, "cache_flush", 0,
1096 SamplerParam::DUMMY);
1097
1098 case 0x20:
1099 return SamplerMessageDescription(
1100 SendOp::SAMPLE_PO, "sample_po", 3, SamplerParam::U, SamplerParam::V,
1101 SamplerParam::R, SamplerParam::OFFUVR, SamplerParam::MLOD);
1102 case 0x21:
1103 return SamplerMessageDescription(
1104 SendOp::SAMPLE_PO_B, "sample_po_b", 2, SamplerParam::BIAS_OFFUVR,
1105 SamplerParam::U, SamplerParam::V, SamplerParam::R, SamplerParam::MLOD);
1106 case 0x22:
1107 return SamplerMessageDescription(SendOp::SAMPLE_PO_L, "sample_po_l", 2,
1108 SamplerParam::LOD_OFFUV, SamplerParam::U,
1109 SamplerParam::R, SamplerParam::V);
1110 case 0x23:
1111 return SamplerMessageDescription(SendOp::SAMPLE_PO_C, "sample_po_c", 4,
1112 SamplerParam::REF, SamplerParam::U,
1113 SamplerParam::V, SamplerParam::OFFUV_R,
1114 SamplerParam::MLOD);
1115 case 0x24:
1116 return SamplerMessageDescription(
1117 SendOp::SAMPLE_PO_D, "sample_po_d", 7, SamplerParam::U,
1118 SamplerParam::DUDX, SamplerParam::DUDY, SamplerParam::V,
1119 SamplerParam::DVDX, SamplerParam::DVDY, SamplerParam::OFFUVR_R,
1120 SamplerParam::MLOD);
1121 case 0x25:
1122 return SamplerMessageDescription(SendOp::SAMPLE_PO_B_C, "sample_po_b_c", 3,
1123 SamplerParam::REF, SamplerParam::BIAS_OFFUVR,
1124 SamplerParam::U, SamplerParam::V,
1125 SamplerParam::R, SamplerParam::MLOD);
1126 case 0x26:
1127 return SamplerMessageDescription(SendOp::SAMPLE_PO_L_C, "sample_po_l_c", 3,
1128 SamplerParam::REF, SamplerParam::LOD_OFFUV,
1129 SamplerParam::U, SamplerParam::V,
1130 SamplerParam::R);
1131 // case 0x27: missing
1132 case 0x28:
1133 return SamplerMessageDescription(SendOp::GATHER4_PO, "gather4_po", 4,
1134 SamplerParam::U, SamplerParam::V,
1135 SamplerParam::R, SamplerParam::OFFUV);
1136 // case 0x29..0x2C: missing
1137 case 0x2D:
1138 return SamplerMessageDescription(SendOp::GATHER4_PO_L, "gather4_po_l", 2,
1139 SamplerParam::LOD_OFFUV, SamplerParam::U,
1140 SamplerParam::V, SamplerParam::R);
1141 case 0x2E:
1142 return SamplerMessageDescription(SendOp::GATHER4_PO_B, "gather4_po_b", 2,
1143 SamplerParam::BIAS_OFFUV, SamplerParam::V,
1144 SamplerParam::R);
1145 case 0x2F:
1146 return SamplerMessageDescription(SendOp::GATHER4_PO_I, "gather4_po_i", 4,
1147 SamplerParam::U, SamplerParam::V,
1148 SamplerParam::R, SamplerParam::OFFUV);
1149 case 0x30:
1150 return SamplerMessageDescription(SendOp::GATHER4_PO_I_C, "gather4_po_c",
1151 4, SamplerParam::REF, SamplerParam::U,
1152 SamplerParam::V, SamplerParam::OFFUV_R);
1153 // case 0x31...0x33: missing
1154 case 0x34:
1155 return SamplerMessageDescription(SendOp::SAMPLE_PO_D_C, "sample_po_d_c", 8,
1156 SamplerParam::REF, SamplerParam::U,
1157 SamplerParam::DUDX, SamplerParam::DUDY, SamplerParam::V,
1158 SamplerParam::DVDX, SamplerParam::DVDY, SamplerParam::OFFUV_R);
1159 case 0x35:
1160 return SamplerMessageDescription(SendOp::GATHER4_PO_I_C, "gather4_po_i_c",
1161 4, SamplerParam::REF, SamplerParam::U,
1162 SamplerParam::V, SamplerParam::OFFUV_R);
1163 // case 0x36: missing
1164 case 0x37:
1165 return SamplerMessageDescription(SendOp::GATHER4_PO_L_C, "gather4_po_l_c",
1166 3, SamplerParam::REF,
1167 SamplerParam::LOD_OFFUV, SamplerParam::U,
1168 SamplerParam::V, SamplerParam::R);
1169 case 0x38:
1170 return SamplerMessageDescription(SendOp::SAMPLE_PO_LZ, "sample_po_lz", 4,
1171 SamplerParam::U, SamplerParam::V,
1172 SamplerParam::R, SamplerParam::OFFUVR);
1173 case 0x39:
1174 return SamplerMessageDescription(SendOp::SAMPLE_PO_C_LZ, "sample_po_c_lz",
1175 4, SamplerParam::REF, SamplerParam::U,
1176 SamplerParam::V, SamplerParam::OFFUV_R);
1177 default:
1178 break;
1179 }
1180 return INVALID;
1181 }
1182
1183 SamplerMessageDescription
1184 iga::LookupSamplerMessageDescription(uint32_t smplOpEnc, int execSize,
1185 bool isFp16) {
1186 auto simd = execSize ? SamplerSIMD::SIMD32
1187 : isFp16 ? SamplerSIMD::SIMD16H
1188 : SamplerSIMD::SIMD16;
1189 const auto sms = lookupSamplerMessageInfoXe2(smplOpEnc, simd);
1190 return sms;
1191 }
1192
1193 static void decodeSendMessage(uint32_t opBits, SamplerSIMD simdMode,
1194 SendOp &sendOp, std::string &symbol,
1195 std::string &desc, int &params) {
1196 if (simdMode != SamplerSIMD::SIMD32_64) {
1197 switch (opBits) {
1198 case 0x00:
1199 symbol = "sample";
1200 desc = "sample";
1201 params = 4;
1202 break;
1203 case 0x01:
1204 symbol = "sample_b";
1205 desc = "sample+LOD bias";
1206 params = 5;
1207 break;
1208 case 0x02:
1209 symbol = "sample_l";
1210 desc = "sample override LOD";
1211 params = 5;
1212 break;
1213 case 0x03:
1214 symbol = "sample_c";
1215 desc = "sample compare";
1216 params = 5;
1217 break;
1218 case 0x04:
1219 symbol = "sample_d";
1220 desc = "sample gradient";
1221 params = 10;
1222 break;
1223 case 0x05:
1224 symbol = "sample_b_c";
1225 desc = "sample compare+LOD bias";
1226 params = 6;
1227 break;
1228 case 0x06:
1229 symbol = "sample_l_c";
1230 desc = "sample compare+override LOD";
1231 params = 6;
1232 break;
1233 case 0x07:
1234 symbol = "sample_ld";
1235 desc = "sample load";
1236 params = 4;
1237 break;
1238 case 0x08:
1239 symbol = "sample_gather4";
1240 desc = "sample gather4";
1241 params = 4;
1242 break;
1243 case 0x09:
1244 symbol = "sample_lod";
1245 desc = "sample override lod";
1246 params = 4;
1247 break;
1248 case 0x0A:
1249 symbol = "sample_resinfo";
1250 desc = "sample res info";
1251 params = 1;
1252 break;
1253 case 0x0B:
1254 symbol = "sample_info";
1255 desc = "sample info";
1256 params = 0;
1257 break;
1258 case 0x0C:
1259 symbol = "sample_killpix";
1260 desc = "sample+killpix";
1261 params = 3;
1262 break;
1263 case 0x10:
1264 symbol = "sample_gather4_c";
1265 desc = "sample gather4+compare";
1266 params = 5;
1267 break;
1268 case 0x11:
1269 symbol = "sample_gather4_po";
1270 desc = "sample gather4+pixel offset";
1271 params = 5;
1272 break;
1273 case 0x12:
1274 symbol = "sample_gather4_po_c";
1275 desc = "sample gather4 pixel offset+compare";
1276 params = 6;
1277 break;
1278 // case 0x13: //skipped
1279 case 0x14:
1280 symbol = "sample_d_c";
1281 desc = "sample derivatives+compare";
1282 params = 11;
1283 break;
1284 case 0x16:
1285 symbol = "sample_min";
1286 desc = "sample min";
1287 params = 2;
1288 break;
1289 case 0x17:
1290 symbol = "sample_max";
1291 desc = "sample max";
1292 params = 2;
1293 break;
1294 case 0x18:
1295 symbol = "sample_lz";
1296 desc = "sample with lod forced to 0";
1297 params = 4;
1298 break;
1299 case 0x19:
1300 symbol = "sample_c_lz";
1301 desc = "sample compare+with lod forced to 0";
1302 params = 5;
1303 break;
1304 case 0x1A:
1305 symbol = "sample_ld_lz";
1306 desc = "sample load with lod forced to 0";
1307 params = 3;
1308 break;
1309 // case 0x1B:
1310 case 0x1C:
1311 symbol = "sample_ld2dms_w";
1312 desc = "sample ld2 multi-sample wide";
1313 params = 7;
1314 break;
1315 case 0x1D:
1316 symbol = "sample_ld_mcs";
1317 desc = "sample load mcs auxiliary data";
1318 params = 4;
1319 break;
1320 case 0x1E:
1321 symbol = "sample_ld2dms";
1322 desc = "sample load multi-sample";
1323 params = 6;
1324 break;
1325 case 0x1F:
1326 symbol = "sample_ld2ds";
1327 desc = "sample multi-sample without mcs";
1328 params = 6;
1329 break;
1330 default:
1331 symbol = std::to_string(opBits) + "?";
1332 desc = "?";
1333 break;
1334 }
1335 } else {
1336 switch (opBits) {
1337 case 0x00:
1338 symbol = "sample_unorm";
1339 desc = "sample unorm";
1340 params = 4; // relatively sure
1341 break;
1342 case 0x02:
1343 symbol = "sample_unorm_killpix";
1344 desc = "sample unorm+killpix";
1345 params = 4; // no idea???
1346 break;
1347 case 0x08:
1348 symbol = "sample_deinterlace";
1349 desc = "sample deinterlace";
1350 params = 4; // no idea???
1351 break;
1352 case 0x0C:
1353 // yes: this appears to be replicated
1354 symbol = "sample_unorm_media";
1355 desc = "sample unorm for media";
1356 params = 4; // no idea???
1357 break;
1358 case 0x0A:
1359 // yes: this appears to be replicated
1360 symbol = "sample_unorm_killpix_media";
1361 desc = "sample unorm+killpix for media";
1362 params = 4; // no idea???
1363 break;
1364 case 0x0B:
1365 symbol = "sample_8x8";
1366 desc = "sample 8x8";
1367 params = 4; // no idea???
1368 break;
1369 case 0x1F:
1370 symbol = "sample_flush";
1371 desc = "sampler cache flush";
1372 params = 0; // certain
1373 break;
1374 default:
1375 symbol = std::to_string(opBits) + "?";
1376 desc = "?";
1377 sendOp = SendOp::INVALID;
1378 break;
1379 }
1380 }
1381 }
1382
1383 void MessageDecoderOther::tryDecodeSMPL() {
1384 setDoc("12484", "43860", "57022");
1385 std::stringstream syms, descs;
1386
1387 auto simd2 = decodeDescBitField("SIMD[2]", 29, "", "");
1388 auto simd01 = getDescBits(17, 2);
1389 uint32_t simdBits = simd01 | (simd2 << 2);
1390 int simdSize = 0;
1391 const SamplerSIMD simdMode =
1392 decodeSimdSize(platform(), simdBits, simdSize, syms, descs);
1393 if (simdMode == SamplerSIMD::INVALID) {
1394 error(17, 2, "invalid SIMD mode");
1395 }
1396 addField("SIMD[1:0]", 17, 2, simd01, descs.str());
1397
1398 bool is16bData = decodeDescBitField("ReturnFormat", 30, "32b", "16b") != 0;
1399 if (is16bData) {
1400 syms << "_16";
1401 descs << " 16b";
1402 }
1403 syms << "_";
1404 descs << " ";
1405
1406 SendOp sendOp = SendOp::SAMPLE;
1407 int params = 0;
1408 std::string symbol, desc;
1409 auto opBits = getDescBits(12, 5);
1410 // check if bit 31 is set for sampler messages with positional offsets
1411 opBits |= getDescBits(31, 1) << 5;
1412 if (platform() >= Platform::XE2) {
1413 auto msg = lookupSamplerMessageInfoXe2(opBits, simdMode);
1414 (void)addField("SamplerMessageType", 12, 5, opBits, msg.mnemonic);
1415 desc = msg.describe(-1);
1416 params = msg.countParams();
1417 } else {
1418 decodeSendMessage(opBits, simdMode, sendOp, symbol, desc, params);
1419 }
1420 syms << symbol;
1421
1422 (void)addField("SamplerMessageType", 12, 5, opBits, desc);
1423 descs << desc;
1424
1425 auto six = decodeDescField(
1426 "SamplerIndex", 8, 4,
1427 [&](std::stringstream &ss, uint32_t six) { ss << "sampler " << six; });
1428 descs << " using sampler index " << six;
1429 syms << "[" << six << "," << decodeBTI(32) << "]";
1430
1431 setScatterGatherOp(syms.str(), descs.str(), sendOp, AddrType::INVALID,
1432 getDescBits(0, 8), 32, is16bData ? 16 : 32, params,
1433 simdSize, MessageInfo::Attr::NONE);
1434 decodeMDC_H(); // header is optional in the sampler
1435 }
1436
1437 void MessageDecoderOther::tryDecodeTS() {
1438 if (getDescBits(0, 3) == 0) {
1439 setSpecialOpX("eot", "end of thread", SendOp::EOT, AddrType::FLAT, 0,
1440 1, // mlen
1441 0, // rlen
1442 MessageInfo::Attr::NONE);
1443 } else {
1444 error(0, 32, "unsupported TS op");
1445 }
1446 }
1447
1448 void MessageDecoderOther::tryDecodeURB() {
1449 std::stringstream sym, descs;
1450 SendOp op;
1451 int simd = DEFAULT_EXEC_SIZE / 2;
1452 int addrSize = 32;
1453 int dataSize = 32; // MH_URB_HANDLE has this an array of MHC_URB_HANDLE
1454 auto opBits = getDescBits(0, 4); // [3:0]
1455 auto chMaskPresent = getDescBit(15) != 0; // [15]
1456 auto decodeGUO = [&]() {
1457 return decodeDescField("GlobalUrbOffset", 4, 11,
1458 [&](std::stringstream &ss, uint32_t val) {
1459 ss << val << " (in owords)";
1460 }); // [14:4]
1461 };
1462 auto decodePSO = [&]() {
1463 return decodeDescBitField("PerSlotOffsetPresent", 17,
1464 "per-slot offset in payload") != 0;
1465 };
1466 int rlen = getDescBits(20, 5);
1467 // int mlen = getDescBits(25,4);
1468 int xlen = getDescBits(32 + 6, 5);
1469 int elemsPerAddr = 1;
1470 int off = 0;
1471 switch (opBits) {
1472 case 7:
1473 op = SendOp::STORE;
1474 off = 8 * decodeGUO();
1475 addField("ChannelMaskEnable", 15, 1, getDescBit(15),
1476 chMaskPresent ? "enabled" : "disabled");
1477 sym << "MSDUW_DWS";
1478 descs << "urb dword ";
1479 if (chMaskPresent)
1480 descs << "masked ";
1481 descs << "write";
1482 if (decodePSO())
1483 descs << " with per-slot offset enabled";
1484 // "SIMD8 URB Dword Read message. Reads 1..8 Dwords, based on RLEN."
1485 elemsPerAddr = xlen != 0 ? xlen : 1;
1486 setDoc(chMaskPresent ? "44779" : "44778");
1487 decodeMDC_HR();
1488 break;
1489 case 8:
1490 op = SendOp::LOAD;
1491 off = 8 * decodeGUO();
1492 sym << "MSDUR_DWS";
1493 descs << "urb dword read";
1494 if (decodePSO())
1495 descs << " with per-slot offset enabled";
1496 elemsPerAddr = rlen;
1497 setDoc("44777");
1498 decodeMDC_HR();
1499 break;
1500 case 9:
1501 op = SendOp::FENCE;
1502 sym << "MSD_URBFENCE";
1503 descs << "urb fence";
1504 simd = 1;
1505 dataSize = 0;
1506 setDoc("53422");
1507 break;
1508 default:
1509 error(0, 4, "unsupported URB op");
1510 return;
1511 }
1512 addField("URBOpcode", 0, 4, opBits, sym.str() + " (" + descs.str() + ")");
1513
1514 setScatterGatherOp(sym.str(), descs.str(), op, AddrType::FLAT, 0, addrSize,
1515 dataSize, elemsPerAddr, simd, MessageInfo::Attr::NONE);
1516 if (opBits == 7 || opBits == 8)
1517 result.info.immediateOffset = off;
1518 }
1519
1520 ///////////////////////////////////////////////////////////////////////////////
1521 void iga::decodeDescriptorsOther(Platform platform, SFID sfid,
1522 ExecSize _execSize, uint32_t exImmOffDesc,
1523 SendDesc exDesc, SendDesc desc,
1524 DecodeResult &result) {
1525 MessageDecoderOther mdo(platform, sfid, _execSize, exImmOffDesc, exDesc, desc,
1526 result);
1527 mdo.tryDecodeOther();
1528 }