mirror of
https://github.com/intel/intel-graphics-compiler.git
synced 2025-11-04 08:21:06 +08:00
378 lines
17 KiB
C++
378 lines
17 KiB
C++
/*========================== begin_copyright_notice ============================
|
|
|
|
Copyright (C) 2023 Intel Corporation
|
|
|
|
SPDX-License-Identifier: MIT
|
|
|
|
============================= end_copyright_notice ===========================*/
|
|
|
|
// A file containing the table of supported g4::MsgOp's for simple
|
|
// C Preprpocessor meta programming. Other files will #include this to
|
|
// create case statements, tables, whatnot. The typical use case will
|
|
// involve multiple #includes. Unlike other headers this file is expected
|
|
// to be #included multiple times.
|
|
//
|
|
// Near the top of the use file where needed one should #include it with no
|
|
// special processing.
|
|
// ... other headers
|
|
// #include "G4_MsgOpDefs.hpp"
|
|
// ... other headers
|
|
// ...
|
|
// This will cause the file to define various types needed by the table callback.
|
|
//
|
|
// Later in the file one can define various preprocessor callbacks.
|
|
//
|
|
// #define DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, ATTRS) SYNTAX,
|
|
// const char *opNames[] {
|
|
// #include "G4_MsgOpDefs.hpp" // expands to all the syntax symbols
|
|
// // undefs DEFINE_G4_MSGOP
|
|
// };
|
|
//
|
|
// The callback can be used multiple times.
|
|
//
|
|
// #define DEFINE_G4_MSGOP_LSC_LOAD(SYMBOL, SYNTAX, ENCODING, ATTRS) ENCODING,
|
|
// const int justLscLoadEncodings[] {
|
|
// #include "G4_MsgOpDefs.hpp"
|
|
// // expands to all the encodings of LSC_LOAD; drops the rest
|
|
// // the #include undefs DEFINE_G4_MSGOP_LSC_LOAD
|
|
// };
|
|
|
|
#ifndef G4_MSGOP_TYPES_DEFINED
|
|
#define G4_MSGOP_TYPES_DEFINED
|
|
// These are various bits used in symbolic definitions of message operations
|
|
// That enable one to create packed enumation definitions
|
|
// Messages have a "group" and "attributes".
|
|
//
|
|
// Groups roughly correspond to SFIDs messages are defined on.
|
|
// Attributes hold generic predicates corresponding to messages such as
|
|
// if a message has a data channel mask.
|
|
// Since, messages might target different SFIDs on different platforms
|
|
// extra scrutiny might be needed as messages get moved around.
|
|
static const int MSGOP_GROUP_LSC_LOAD = 0x001;
|
|
static const int MSGOP_GROUP_LSC_STORE = (MSGOP_GROUP_LSC_LOAD << 1);
|
|
static const int MSGOP_GROUP_LSC_ATOMIC = (MSGOP_GROUP_LSC_STORE << 1);
|
|
static const int MSGOP_GROUP_LSC_OTHER = (MSGOP_GROUP_LSC_ATOMIC << 1);
|
|
static const int MSGOP_GROUP_GTWY = (MSGOP_GROUP_LSC_OTHER << 1);
|
|
static const int MSGOP_GROUP_SMPL_NORMAL = (MSGOP_GROUP_GTWY << 1);
|
|
static const int MSGOP_GROUP_SMPL_GATHER = (MSGOP_GROUP_SMPL_NORMAL << 1);
|
|
static const int MSGOP_GROUP_SMPL_OTHER = (MSGOP_GROUP_SMPL_GATHER << 1);
|
|
static const int MSGOP_GROUP_RENDER = (MSGOP_GROUP_SMPL_OTHER << 1);
|
|
static const int MSGOP_GROUP_RTA = (MSGOP_GROUP_RENDER << 1);
|
|
static const int MSGOP_GROUP_BTD = (MSGOP_GROUP_RTA << 1);
|
|
static_assert((MSGOP_GROUP_BTD & ~0xFFF) == 0, "group field overflowed");
|
|
|
|
// e.g. load_quad, store_quad, ...
|
|
static const int MSGOP_ATTRS_EMPTY = 0x0000;
|
|
static const int MSGOP_ATTRS_HAS_CMASK = 0x0001;
|
|
static const int MSGOP_ATTRS_ATOMIC_UNARY = MSGOP_ATTRS_HAS_CMASK << 1;
|
|
static const int MSGOP_ATTRS_ATOMIC_BINARY = MSGOP_ATTRS_ATOMIC_UNARY << 1;
|
|
static const int MSGOP_ATTRS_ATOMIC_TERNARY = MSGOP_ATTRS_ATOMIC_BINARY << 1;
|
|
// other attributes here (NOTE: can overlap based on group)
|
|
#endif // G4_MSGOP_TYPES_DEFINED
|
|
|
|
// DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, GROUP, ATTRS)
|
|
// The top-level macro callback. The more specific variants cover to this.
|
|
// A user can define this to capture all messages or define lower level
|
|
// macros to filter based on group.
|
|
//
|
|
// * SYMBOL a symbol to use in an enum (e.g. LOAD)
|
|
// * SYNTAX a string to use in output (e.g. "load")
|
|
// * ENCODING a an integer encoding for for this operation (typically Desc[5:0])
|
|
// * GROUP a group ordinal value grouping this message; a bit set of 12b (0xXXX)
|
|
// * ATTRS a bitset of attributes (at least a byte)
|
|
#ifndef DEFINE_G4_MSGOP
|
|
#define DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, GROUP, ATTRS)
|
|
#endif
|
|
|
|
#ifndef DEFINE_G4_MSGOP_LSC_LOAD
|
|
#define DEFINE_G4_MSGOP_LSC_LOAD(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_LSC_LOAD, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_LOAD_GROUP
|
|
|
|
#ifndef DEFINE_G4_MSGOP_LSC_STORE
|
|
#define DEFINE_G4_MSGOP_LSC_STORE(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_LSC_STORE, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_LSC_STORE
|
|
|
|
#ifndef DEFINE_G4_MSGOP_LSC_ATOMIC
|
|
#define DEFINE_G4_MSGOP_LSC_ATOMIC(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_LSC_ATOMIC, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_LSC_ATOMIC
|
|
|
|
#ifndef DEFINE_G4_MSGOP_LSC_OTHER
|
|
#define DEFINE_G4_MSGOP_LSC_OTHER(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_LSC_OTHER, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_LSC_OTHER
|
|
|
|
#ifndef DEFINE_G4_MSGOP_GTWY
|
|
#define DEFINE_G4_MSGOP_GTWY(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_GTWY, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_GTWY
|
|
|
|
#ifndef DEFINE_G4_MSGOP_SMPL_NORMAL
|
|
#define DEFINE_G4_MSGOP_SMPL_NORMAL(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_SMPL_NORMAL, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_SMPL_NORMAL
|
|
|
|
#ifndef DEFINE_G4_MSGOP_SMPL_GATHER
|
|
#define DEFINE_G4_MSGOP_SMPL_GATHER(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_SMPL_GATHER, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_SMPL_GATHER
|
|
|
|
#ifndef DEFINE_G4_MSGOP_SMPL_OTHER
|
|
#define DEFINE_G4_MSGOP_SMPL_OTHER(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_SMPL_OTHER, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_SMPL_OTHER
|
|
|
|
#ifndef DEFINE_G4_MSGOP_RENDER
|
|
#define DEFINE_G4_MSGOP_RENDER(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_RENDER, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_RENDER
|
|
|
|
#ifndef DEFINE_G4_MSGOP_RTA
|
|
#define DEFINE_G4_MSGOP_RTA(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_RTA, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_RTA
|
|
|
|
#ifndef DEFINE_G4_MSGOP_BTD
|
|
#define DEFINE_G4_MSGOP_BTD(SYMBOL, SYNTAX, ENCODING, ATTRS) \
|
|
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_BTD, ATTRS)
|
|
#endif // DEFINE_G4_MSGOP_BTD
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// The callback table
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// LSC loads
|
|
DEFINE_G4_MSGOP_LSC_LOAD(LOAD, "load", 0x00,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_LSC_LOAD(LOAD_STRIDED, "load_strided", 0x01,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_LSC_LOAD(LOAD_QUAD, "load_quad", 0x02,
|
|
MSGOP_ATTRS_HAS_CMASK)
|
|
DEFINE_G4_MSGOP_LSC_LOAD(LOAD_QUAD_MSRT, "load_quad_msrt", 0x31,
|
|
MSGOP_ATTRS_HAS_CMASK)
|
|
DEFINE_G4_MSGOP_LSC_LOAD(LOAD_STATUS, "load_status", 0x1B,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_LSC_LOAD(LOAD_BLOCK2D, "load_block2d", 0x03,
|
|
MSGOP_ATTRS_EMPTY)
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// LSC stores
|
|
DEFINE_G4_MSGOP_LSC_STORE(STORE, "store", 0x04,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_LSC_STORE(STORE_STRIDED, "store_strided", 0x05,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_LSC_STORE(STORE_QUAD, "store_quad", 0x06,
|
|
MSGOP_ATTRS_HAS_CMASK)
|
|
DEFINE_G4_MSGOP_LSC_STORE(STORE_QUAD_MSRT, "store_quad_msrt", 0x32,
|
|
MSGOP_ATTRS_HAS_CMASK)
|
|
DEFINE_G4_MSGOP_LSC_STORE(STORE_BLOCK2D, "store_block2d", 0x07,
|
|
MSGOP_ATTRS_EMPTY)
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// LSC atomics
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_IINC, "atomic_iinc", 0x08,
|
|
MSGOP_ATTRS_ATOMIC_UNARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_IDEC, "atomic_idec", 0x09,
|
|
MSGOP_ATTRS_ATOMIC_UNARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_LOAD, "atomic_load", 0x0A,
|
|
MSGOP_ATTRS_ATOMIC_UNARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_STORE, "atomic_store", 0x0B,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_IADD, "atomic_iadd", 0x0C,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_ISUB, "atomic_isub", 0x0D,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
//
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_SMIN, "atomic_smin", 0x0E,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_SMAX, "atomic_smax", 0x0F,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_UMIN, "atomic_umin", 0x10,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_UMAX, "atomic_umax", 0x11,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_ICAS, "atomic_icas", 0x12,
|
|
MSGOP_ATTRS_ATOMIC_TERNARY)
|
|
//
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_FADD, "atomic_fadd", 0x13,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_FSUB, "atomic_fsub", 0x14,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_FMIN, "atomic_fmin", 0x15,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_FMAX, "atomic_fmax", 0x16,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_FCAS, "atomic_fcas", 0x17,
|
|
MSGOP_ATTRS_ATOMIC_TERNARY)
|
|
//
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_AND, "atomic_and", 0x18,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_OR, "atomic_or", 0x19,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_XOR, "atomic_xor", 0x1A,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
//
|
|
|
|
// setting this to binary as src0 is null and src1 is the data operand
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_ACADD, "atomic_acadd", 0x28,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_ACSUB, "atomic_acsub", 0x29,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_ACSTORE, "atomic_store", 0x2A,
|
|
MSGOP_ATTRS_ATOMIC_BINARY)
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// LSC other
|
|
DEFINE_G4_MSGOP_LSC_OTHER(RSI, "rsi", 0x1E,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_LSC_OTHER(FENCE, "fence", 0x1F,
|
|
MSGOP_ATTRS_EMPTY)
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// gateway ops
|
|
DEFINE_G4_MSGOP_GTWY(EOT, "eot", 0x00, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_GTWY(EOTR, "eotr", 0x0A, MSGOP_ATTRS_EMPTY)
|
|
//
|
|
DEFINE_G4_MSGOP_GTWY(BARRIER_SIGNAL, "barrier_signal", 0x04,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_GTWY(BARRIER_SIGNAL_NAMED, "barrier_signal_named", 0x05,
|
|
MSGOP_ATTRS_EMPTY)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// sampler ops
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE, "sample", 0x00, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_B, "sample_b", 0x01, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_L, "sample_l", 0x02, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_C, "sample_c", 0x03, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_D, "sample_d", 0x04, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_B_C, "sample_b_c", 0x05,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_L_C, "sample_l_c", 0x06,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_KILLPIX, "sample_killpix", 0x0C,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_D_C, "sample_d_c", 0x14, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_LZ, "sample_lz", 0x18, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_C_LZ, "sample_c_lz", 0x19,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_MLOD, "sample_mlod", 0x12,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_C_MLOD, "sample_c_mlod", 0x13,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_D_C_MLOD, "sample_d_c_mlod", 0x11,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO, "sample_po", 0x20, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_B, "sample_po_b", 0x21,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_L, "sample_po_l", 0x22,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_C, "sample_po_c", 0x23,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_D, "sample_po_d", 0x24,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_L_C, "sample_po_l_c", 0x26,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_LZ, "sample_po_lz", 0x38,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_C_LZ, "sample_po_c_lz", 0x39,
|
|
MSGOP_ATTRS_EMPTY)
|
|
////////////////////////////////
|
|
// gather 4 sampler ops
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4, "gather4", 0x08, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_C, "gather4_c", 0x10, MSGOP_ATTRS_EMPTY)
|
|
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_L, "gather4_l", 0x0D, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_B, "gather4_b", 0x0E, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_I, "gather4_i", 0x0F, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_I_C, "gather4_i_c", 0x15,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_L_C, "gather4_l_c", 0x17,
|
|
MSGOP_ATTRS_EMPTY)
|
|
//
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO, "gather4_po", 0x28,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_L, "gather4_po_l", 0x2D,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_B, "gather4_po_b", 0x2E,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_I, "gather4_po_i", 0x2F,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_C, "gather4_po_c", 0x30,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_I_C, "gather4_po_i_c", 0x35,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_L_C, "gather4_po_l_c", 0x37,
|
|
MSGOP_ATTRS_EMPTY)
|
|
////////////////////////////////
|
|
// other sampler messages
|
|
DEFINE_G4_MSGOP_SMPL_OTHER(LD, "ld", 0x07, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_OTHER(LOD, "lod", 0x09, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_OTHER(RESINFO, "resinfo", 0x0A, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_OTHER(SAMPLE_INFO, "sample_info", 0x0B,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_OTHER(LD_LZ, "ld_lz", 0x1A, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_OTHER(LD_2DMS_W, "ld_2dms_w", 0x1C, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_OTHER(LD_MCS, "ld_mcs", 0x1D, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_OTHER(SAMPLER_FLUSH, "sampler_flush", 0x1F,
|
|
MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_SMPL_OTHER(LD_L, "ld_l", 0x1B, MSGOP_ATTRS_EMPTY)
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// render target ops
|
|
DEFINE_G4_MSGOP_RENDER(READ, "read", 0x02, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_RENDER(WRITE, "write", 0x06, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_RENDER(DUAL_WRITE, "dual_write", 0x05, MSGOP_ATTRS_EMPTY)
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// btd ops and ray tracing
|
|
DEFINE_G4_MSGOP_RTA(TRACE_RAY, "trace_ray", 0x00, MSGOP_ATTRS_EMPTY)
|
|
//
|
|
DEFINE_G4_MSGOP_BTD(SPAWN, "spawn", 0x00, MSGOP_ATTRS_EMPTY)
|
|
DEFINE_G4_MSGOP_BTD(STACK_ID_RELEASE, "stack_id_release", 0x01,
|
|
MSGOP_ATTRS_EMPTY)
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// #undef anything that was defined, including by the #include'r so
|
|
// that the callback can be used again elsewhere.
|
|
#ifdef DEFINE_G4_MSGOP
|
|
#undef DEFINE_G4_MSGOP
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_LSC_LOAD
|
|
#undef DEFINE_G4_MSGOP_LSC_LOAD
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_LSC_STORE
|
|
#undef DEFINE_G4_MSGOP_LSC_STORE
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_LSC_ATOMIC
|
|
#undef DEFINE_G4_MSGOP_LSC_ATOMIC
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_LSC_OTHER
|
|
#undef DEFINE_G4_MSGOP_LSC_OTHER
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_GTWY
|
|
#undef DEFINE_G4_MSGOP_GTWY
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_SMPL_NORMAL
|
|
#undef DEFINE_G4_MSGOP_SMPL_NORMAL
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_SMPL_GATHER
|
|
#undef DEFINE_G4_MSGOP_SMPL_GATHER
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_SMPL_OTHER
|
|
#undef DEFINE_G4_MSGOP_SMPL_OTHER
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_RENDER
|
|
#undef DEFINE_G4_MSGOP_RENDER
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_RTA
|
|
#undef DEFINE_G4_MSGOP_RTA
|
|
#endif
|
|
#ifdef DEFINE_G4_MSGOP_BTD
|
|
#undef DEFINE_G4_MSGOP_BTD
|
|
#endif
|