?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
quartz: Clarify debug strings.
[wine.git] / dlls / wined3d / shader_sm4.c
blob520e3c63a1a2ac86eae51466fe9f9b965730984d
1 /*
2 * Copyright 2009 Henri Verbeet for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "config.h"
20 #include "wine/port.h"
21
22 #include "wined3d_private.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
25 WINE_DECLARE_DEBUG_CHANNEL(d3d_bytecode);
26
27 #define WINED3D_SM4_INSTRUCTION_MODIFIER (0x1u << 31)
28
29 #define WINED3D_SM4_MODIFIER_AOFFIMMI 0x1
30 #define WINED3D_SM4_AOFFIMMI_U_SHIFT 9
31 #define WINED3D_SM4_AOFFIMMI_U_MASK (0xfu << WINED3D_SM4_AOFFIMMI_U_SHIFT)
32 #define WINED3D_SM4_AOFFIMMI_V_SHIFT 13
33 #define WINED3D_SM4_AOFFIMMI_V_MASK (0xfu << WINED3D_SM4_AOFFIMMI_V_SHIFT)
34 #define WINED3D_SM4_AOFFIMMI_W_SHIFT 17
35 #define WINED3D_SM4_AOFFIMMI_W_MASK (0xfu << WINED3D_SM4_AOFFIMMI_W_SHIFT)
36
37 #define WINED3D_SM4_INSTRUCTION_LENGTH_SHIFT 24
38 #define WINED3D_SM4_INSTRUCTION_LENGTH_MASK (0x1fu << WINED3D_SM4_INSTRUCTION_LENGTH_SHIFT)
39
40 #define WINED3D_SM4_INSTRUCTION_FLAGS_SHIFT 11
41 #define WINED3D_SM4_INSTRUCTION_FLAGS_MASK (0x7u << WINED3D_SM4_INSTRUCTION_FLAGS_SHIFT)
42
43 #define WINED3D_SM4_RESOURCE_TYPE_SHIFT 11
44 #define WINED3D_SM4_RESOURCE_TYPE_MASK (0xfu << WINED3D_SM4_RESOURCE_TYPE_SHIFT)
45
46 #define WINED3D_SM4_PRIMITIVE_TYPE_SHIFT 11
47 #define WINED3D_SM4_PRIMITIVE_TYPE_MASK (0x7u << WINED3D_SM4_PRIMITIVE_TYPE_SHIFT)
48
49 #define WINED3D_SM4_INDEX_TYPE_SHIFT 11
50 #define WINED3D_SM4_INDEX_TYPE_MASK (0x1u << WINED3D_SM4_INDEX_TYPE_SHIFT)
51
52 #define WINED3D_SM4_SAMPLER_MODE_SHIFT 11
53 #define WINED3D_SM4_SAMPLER_MODE_MASK (0xfu << WINED3D_SM4_SAMPLER_MODE_SHIFT)
54
55 #define WINED3D_SM4_SHADER_DATA_TYPE_SHIFT 11
56 #define WINED3D_SM4_SHADER_DATA_TYPE_MASK (0xfu << WINED3D_SM4_SHADER_DATA_TYPE_SHIFT)
57
58 #define WINED3D_SM4_INTERPOLATION_MODE_SHIFT 11
59 #define WINED3D_SM4_INTERPOLATION_MODE_MASK (0xfu << WINED3D_SM4_INTERPOLATION_MODE_SHIFT)
60
61 #define WINED3D_SM4_GLOBAL_FLAGS_SHIFT 11
62 #define WINED3D_SM4_GLOBAL_FLAGS_MASK (0xffu << WINED3D_SM4_GLOBAL_FLAGS_SHIFT)
63
64 #define WINED3D_SM5_CONTROL_POINT_COUNT_SHIFT 11
65 #define WINED3D_SM5_CONTROL_POINT_COUNT_MASK (0xffu << WINED3D_SM5_CONTROL_POINT_COUNT_SHIFT)
66
67 #define WINED3D_SM5_TESSELLATOR_SHIFT 11
68 #define WINED3D_SM5_TESSELLATOR_MASK (0xfu << WINED3D_SM5_TESSELLATOR_SHIFT)
69
70 #define WINED3D_SM4_OPCODE_MASK 0xff
71
72 #define WINED3D_SM4_REGISTER_MODIFIER (0x1u << 31)
73
74 #define WINED3D_SM4_ADDRESSING_SHIFT1 25
75 #define WINED3D_SM4_ADDRESSING_MASK1 (0x3u << WINED3D_SM4_ADDRESSING_SHIFT1)
76
77 #define WINED3D_SM4_ADDRESSING_SHIFT0 22
78 #define WINED3D_SM4_ADDRESSING_MASK0 (0x3u << WINED3D_SM4_ADDRESSING_SHIFT0)
79
80 #define WINED3D_SM4_REGISTER_ORDER_SHIFT 20
81 #define WINED3D_SM4_REGISTER_ORDER_MASK (0x3u << WINED3D_SM4_REGISTER_ORDER_SHIFT)
82
83 #define WINED3D_SM4_REGISTER_TYPE_SHIFT 12
84 #define WINED3D_SM4_REGISTER_TYPE_MASK (0xffu << WINED3D_SM4_REGISTER_TYPE_SHIFT)
85
86 #define WINED3D_SM4_SWIZZLE_TYPE_SHIFT 2
87 #define WINED3D_SM4_SWIZZLE_TYPE_MASK (0x3u << WINED3D_SM4_SWIZZLE_TYPE_SHIFT)
88
89 #define WINED3D_SM4_IMMCONST_TYPE_SHIFT 0
90 #define WINED3D_SM4_IMMCONST_TYPE_MASK (0x3u << WINED3D_SM4_IMMCONST_TYPE_SHIFT)
91
92 #define WINED3D_SM4_WRITEMASK_SHIFT 4
93 #define WINED3D_SM4_WRITEMASK_MASK (0xfu << WINED3D_SM4_WRITEMASK_SHIFT)
94
95 #define WINED3D_SM4_SWIZZLE_SHIFT 4
96 #define WINED3D_SM4_SWIZZLE_MASK (0xffu << WINED3D_SM4_SWIZZLE_SHIFT)
97
98 #define WINED3D_SM4_VERSION_MAJOR(version) (((version) >> 4) & 0xf)
99 #define WINED3D_SM4_VERSION_MINOR(version) (((version) >> 0) & 0xf)
100
101 #define WINED3D_SM4_ADDRESSING_RELATIVE 0x2
102 #define WINED3D_SM4_ADDRESSING_OFFSET 0x1
103
104 #define WINED3D_SM4_INSTRUCTION_FLAG_SATURATE 0x4
105
106 #define WINED3D_SM4_CONDITIONAL_NZ (0x1u << 18)
107
108 enum wined3d_sm4_opcode
109 {
110 WINED3D_SM4_OP_ADD = 0x00,
111 WINED3D_SM4_OP_AND = 0x01,
112 WINED3D_SM4_OP_BREAK = 0x02,
113 WINED3D_SM4_OP_BREAKC = 0x03,
114 WINED3D_SM4_OP_CASE = 0x06,
115 WINED3D_SM4_OP_CONTINUE = 0x07,
116 WINED3D_SM4_OP_CUT = 0x09,
117 WINED3D_SM4_OP_DEFAULT = 0x0a,
118 WINED3D_SM4_OP_DERIV_RTX = 0x0b,
119 WINED3D_SM4_OP_DERIV_RTY = 0x0c,
120 WINED3D_SM4_OP_DISCARD = 0x0d,
121 WINED3D_SM4_OP_DIV = 0x0e,
122 WINED3D_SM4_OP_DP2 = 0x0f,
123 WINED3D_SM4_OP_DP3 = 0x10,
124 WINED3D_SM4_OP_DP4 = 0x11,
125 WINED3D_SM4_OP_ELSE = 0x12,
126 WINED3D_SM4_OP_EMIT = 0x13,
127 WINED3D_SM4_OP_ENDIF = 0x15,
128 WINED3D_SM4_OP_ENDLOOP = 0x16,
129 WINED3D_SM4_OP_ENDSWITCH = 0x17,
130 WINED3D_SM4_OP_EQ = 0x18,
131 WINED3D_SM4_OP_EXP = 0x19,
132 WINED3D_SM4_OP_FRC = 0x1a,
133 WINED3D_SM4_OP_FTOI = 0x1b,
134 WINED3D_SM4_OP_FTOU = 0x1c,
135 WINED3D_SM4_OP_GE = 0x1d,
136 WINED3D_SM4_OP_IADD = 0x1e,
137 WINED3D_SM4_OP_IF = 0x1f,
138 WINED3D_SM4_OP_IEQ = 0x20,
139 WINED3D_SM4_OP_IGE = 0x21,
140 WINED3D_SM4_OP_ILT = 0x22,
141 WINED3D_SM4_OP_IMAD = 0x23,
142 WINED3D_SM4_OP_IMAX = 0x24,
143 WINED3D_SM4_OP_IMIN = 0x25,
144 WINED3D_SM4_OP_IMUL = 0x26,
145 WINED3D_SM4_OP_INE = 0x27,
146 WINED3D_SM4_OP_INEG = 0x28,
147 WINED3D_SM4_OP_ISHL = 0x29,
148 WINED3D_SM4_OP_ISHR = 0x2a,
149 WINED3D_SM4_OP_ITOF = 0x2b,
150 WINED3D_SM4_OP_LD = 0x2d,
151 WINED3D_SM4_OP_LD2DMS = 0x2e,
152 WINED3D_SM4_OP_LOG = 0x2f,
153 WINED3D_SM4_OP_LOOP = 0x30,
154 WINED3D_SM4_OP_LT = 0x31,
155 WINED3D_SM4_OP_MAD = 0x32,
156 WINED3D_SM4_OP_MIN = 0x33,
157 WINED3D_SM4_OP_MAX = 0x34,
158 WINED3D_SM4_OP_SHADER_DATA = 0x35,
159 WINED3D_SM4_OP_MOV = 0x36,
160 WINED3D_SM4_OP_MOVC = 0x37,
161 WINED3D_SM4_OP_MUL = 0x38,
162 WINED3D_SM4_OP_NE = 0x39,
163 WINED3D_SM4_OP_NOT = 0x3b,
164 WINED3D_SM4_OP_OR = 0x3c,
165 WINED3D_SM4_OP_RESINFO = 0x3d,
166 WINED3D_SM4_OP_RET = 0x3e,
167 WINED3D_SM4_OP_ROUND_NE = 0x40,
168 WINED3D_SM4_OP_ROUND_NI = 0x41,
169 WINED3D_SM4_OP_ROUND_PI = 0x42,
170 WINED3D_SM4_OP_ROUND_Z = 0x43,
171 WINED3D_SM4_OP_RSQ = 0x44,
172 WINED3D_SM4_OP_SAMPLE = 0x45,
173 WINED3D_SM4_OP_SAMPLE_C = 0x46,
174 WINED3D_SM4_OP_SAMPLE_C_LZ = 0x47,
175 WINED3D_SM4_OP_SAMPLE_LOD = 0x48,
176 WINED3D_SM4_OP_SAMPLE_GRAD = 0x49,
177 WINED3D_SM4_OP_SAMPLE_B = 0x4a,
178 WINED3D_SM4_OP_SQRT = 0x4b,
179 WINED3D_SM4_OP_SWITCH = 0x4c,
180 WINED3D_SM4_OP_SINCOS = 0x4d,
181 WINED3D_SM4_OP_UDIV = 0x4e,
182 WINED3D_SM4_OP_ULT = 0x4f,
183 WINED3D_SM4_OP_UGE = 0x50,
184 WINED3D_SM4_OP_UMAX = 0x53,
185 WINED3D_SM4_OP_UMIN = 0x54,
186 WINED3D_SM4_OP_USHR = 0x55,
187 WINED3D_SM4_OP_UTOF = 0x56,
188 WINED3D_SM4_OP_XOR = 0x57,
189 WINED3D_SM4_OP_DCL_RESOURCE = 0x58,
190 WINED3D_SM4_OP_DCL_CONSTANT_BUFFER = 0x59,
191 WINED3D_SM4_OP_DCL_SAMPLER = 0x5a,
192 WINED3D_SM4_OP_DCL_OUTPUT_TOPOLOGY = 0x5c,
193 WINED3D_SM4_OP_DCL_INPUT_PRIMITIVE = 0x5d,
194 WINED3D_SM4_OP_DCL_VERTICES_OUT = 0x5e,
195 WINED3D_SM4_OP_DCL_INPUT = 0x5f,
196 WINED3D_SM4_OP_DCL_INPUT_SGV = 0x60,
197 WINED3D_SM4_OP_DCL_INPUT_SIV = 0x61,
198 WINED3D_SM4_OP_DCL_INPUT_PS = 0x62,
199 WINED3D_SM4_OP_DCL_INPUT_PS_SGV = 0x63,
200 WINED3D_SM4_OP_DCL_INPUT_PS_SIV = 0x64,
201 WINED3D_SM4_OP_DCL_OUTPUT = 0x65,
202 WINED3D_SM4_OP_DCL_OUTPUT_SIV = 0x67,
203 WINED3D_SM4_OP_DCL_TEMPS = 0x68,
204 WINED3D_SM4_OP_DCL_INDEXABLE_TEMP = 0x69,
205 WINED3D_SM4_OP_DCL_GLOBAL_FLAGS = 0x6a,
206 WINED3D_SM4_OP_LOD = 0x6c,
207 WINED3D_SM4_OP_GATHER4 = 0x6d,
208 WINED3D_SM4_OP_SAMPLE_POS = 0x6e,
209 WINED3D_SM4_OP_SAMPLE_INFO = 0x6f,
210 WINED3D_SM5_OP_HS_DECLS = 0x71,
211 WINED3D_SM5_OP_HS_CONTROL_POINT_PHASE = 0x72,
212 WINED3D_SM5_OP_HS_FORK_PHASE = 0x73,
213 WINED3D_SM5_OP_HS_JOIN_PHASE = 0x74,
214 WINED3D_SM5_OP_EMIT_STREAM = 0x75,
215 WINED3D_SM5_OP_CUT_STREAM = 0x76,
216 WINED3D_SM5_OP_BUFINFO = 0x79,
217 WINED3D_SM5_OP_DERIV_RTX_COARSE = 0x7a,
218 WINED3D_SM5_OP_DERIV_RTX_FINE = 0x7b,
219 WINED3D_SM5_OP_DERIV_RTY_COARSE = 0x7c,
220 WINED3D_SM5_OP_DERIV_RTY_FINE = 0x7d,
221 WINED3D_SM5_OP_GATHER4_C = 0x7e,
222 WINED3D_SM5_OP_RCP = 0x81,
223 WINED3D_SM5_OP_UBFE = 0x8a,
224 WINED3D_SM5_OP_BFI = 0x8c,
225 WINED3D_SM5_OP_BFREV = 0x8d,
226 WINED3D_SM5_OP_SWAPC = 0x8e,
227 WINED3D_SM5_OP_DCL_STREAM = 0x8f,
228 WINED3D_SM5_OP_DCL_INPUT_CONTROL_POINT_COUNT = 0x93,
229 WINED3D_SM5_OP_DCL_OUTPUT_CONTROL_POINT_COUNT = 0x94,
230 WINED3D_SM5_OP_DCL_TESSELLATOR_DOMAIN = 0x95,
231 WINED3D_SM5_OP_DCL_TESSELLATOR_PARTITIONING = 0x96,
232 WINED3D_SM5_OP_DCL_TESSELLATOR_OUTPUT_PRIMITIVE = 0x97,
233 WINED3D_SM5_OP_DCL_HS_MAX_TESSFACTOR = 0x98,
234 WINED3D_SM5_OP_DCL_HS_FORK_PHASE_INSTANCE_COUNT = 0x99,
235 WINED3D_SM5_OP_DCL_THREAD_GROUP = 0x9b,
236 WINED3D_SM5_OP_DCL_UAV_TYPED = 0x9c,
237 WINED3D_SM5_OP_DCL_TGSM_RAW = 0x9f,
238 WINED3D_SM5_OP_DCL_TGSM_STRUCTURED = 0xa0,
239 WINED3D_SM5_OP_DCL_RESOURCE_STRUCTURED = 0xa2,
240 WINED3D_SM5_OP_LD_UAV_TYPED = 0xa3,
241 WINED3D_SM5_OP_STORE_UAV_TYPED = 0xa4,
242 WINED3D_SM5_OP_LD_RAW = 0xa5,
243 WINED3D_SM5_OP_STORE_RAW = 0xa6,
244 WINED3D_SM5_OP_LD_STRUCTURED = 0xa7,
245 WINED3D_SM5_OP_STORE_STRUCTURED = 0xa8,
246 WINED3D_SM5_OP_IMM_ATOMIC_ALLOC = 0xb2,
247 WINED3D_SM5_OP_IMM_ATOMIC_CONSUME = 0xb3,
248 };
249
250 enum wined3d_sm4_register_type
251 {
252 WINED3D_SM4_RT_TEMP = 0x00,
253 WINED3D_SM4_RT_INPUT = 0x01,
254 WINED3D_SM4_RT_OUTPUT = 0x02,
255 WINED3D_SM4_RT_INDEXABLE_TEMP = 0x03,
256 WINED3D_SM4_RT_IMMCONST = 0x04,
257 WINED3D_SM4_RT_SAMPLER = 0x06,
258 WINED3D_SM4_RT_RESOURCE = 0x07,
259 WINED3D_SM4_RT_CONSTBUFFER = 0x08,
260 WINED3D_SM4_RT_IMMCONSTBUFFER = 0x09,
261 WINED3D_SM4_RT_PRIMID = 0x0b,
262 WINED3D_SM4_RT_DEPTHOUT = 0x0c,
263 WINED3D_SM4_RT_NULL = 0x0d,
264 WINED3D_SM5_RT_STREAM = 0x10,
265 WINED3D_SM5_RT_OUTPUT_CONTROL_POINT_ID = 0x16,
266 WINED3D_SM5_RT_FORK_INSTANCE_ID = 0x17,
267 WINED3D_SM5_RT_INPUT_CONTROL_POINT = 0x19,
268 WINED3D_SM5_RT_OUTPUT_CONTROL_POINT = 0x1a,
269 WINED3D_SM5_RT_PATCH_CONSTANT_DATA = 0x1b,
270 WINED3D_SM5_RT_DOMAIN_LOCATION = 0x1c,
271 WINED3D_SM5_RT_UAV = 0x1e,
272 WINED3D_SM5_RT_SHARED_MEMORY = 0x1f,
273 WINED3D_SM5_RT_THREAD_ID = 0x20,
274 WINED3D_SM5_RT_THREAD_GROUP_ID = 0x21,
275 WINED3D_SM5_RT_LOCAL_THREAD_ID = 0x22,
276 WINED3D_SM5_RT_LOCAL_THREAD_INDEX = 0x24,
277 };
278
279 enum wined3d_sm4_output_primitive_type
280 {
281 WINED3D_SM4_OUTPUT_PT_POINTLIST = 0x1,
282 WINED3D_SM4_OUTPUT_PT_LINELIST = 0x3,
283 WINED3D_SM4_OUTPUT_PT_TRIANGLESTRIP = 0x5,
284 };
285
286 enum wined3d_sm4_input_primitive_type
287 {
288 WINED3D_SM4_INPUT_PT_POINT = 0x1,
289 WINED3D_SM4_INPUT_PT_LINE = 0x2,
290 WINED3D_SM4_INPUT_PT_TRIANGLE = 0x3,
291 WINED3D_SM4_INPUT_PT_LINEADJ = 0x6,
292 WINED3D_SM4_INPUT_PT_TRIANGLEADJ = 0x7,
293 };
294
295 enum wined3d_sm4_swizzle_type
296 {
297 WINED3D_SM4_SWIZZLE_NONE = 0x0,
298 WINED3D_SM4_SWIZZLE_VEC4 = 0x1,
299 WINED3D_SM4_SWIZZLE_SCALAR = 0x2,
300 };
301
302 enum wined3d_sm4_immconst_type
303 {
304 WINED3D_SM4_IMMCONST_SCALAR = 0x1,
305 WINED3D_SM4_IMMCONST_VEC4 = 0x2,
306 };
307
308 enum wined3d_sm4_resource_type
309 {
310 WINED3D_SM4_RESOURCE_BUFFER = 0x1,
311 WINED3D_SM4_RESOURCE_TEXTURE_1D = 0x2,
312 WINED3D_SM4_RESOURCE_TEXTURE_2D = 0x3,
313 WINED3D_SM4_RESOURCE_TEXTURE_2DMS = 0x4,
314 WINED3D_SM4_RESOURCE_TEXTURE_3D = 0x5,
315 WINED3D_SM4_RESOURCE_TEXTURE_CUBE = 0x6,
316 WINED3D_SM4_RESOURCE_TEXTURE_1DARRAY = 0x7,
317 WINED3D_SM4_RESOURCE_TEXTURE_2DARRAY = 0x8,
318 WINED3D_SM4_RESOURCE_TEXTURE_2DMSARRAY = 0x9,
319 };
320
321 enum wined3d_sm4_data_type
322 {
323 WINED3D_SM4_DATA_UNORM = 0x1,
324 WINED3D_SM4_DATA_SNORM = 0x2,
325 WINED3D_SM4_DATA_INT = 0x3,
326 WINED3D_SM4_DATA_UINT = 0x4,
327 WINED3D_SM4_DATA_FLOAT = 0x5,
328 };
329
330 enum wined3d_sm4_sampler_mode
331 {
332 WINED3D_SM4_SAMPLER_DEFAULT = 0x0,
333 WINED3D_SM4_SAMPLER_COMPARISON = 0x1,
334 };
335
336 enum wined3d_sm4_shader_data_type
337 {
338 WINED3D_SM4_SHADER_DATA_IMMEDIATE_CONSTANT_BUFFER = 0x3,
339 WINED3D_SM4_SHADER_DATA_MESSAGE = 0x4,
340 };
341
342 struct wined3d_shader_src_param_entry
343 {
344 struct list entry;
345 struct wined3d_shader_src_param param;
346 };
347
348 struct wined3d_sm4_data
349 {
350 struct wined3d_shader_version shader_version;
351 const DWORD *end;
352
353 unsigned int output_map[MAX_REG_OUTPUT];
354
355 struct wined3d_shader_src_param src_param[5];
356 struct wined3d_shader_dst_param dst_param[2];
357 struct list src_free;
358 struct list src;
359 struct wined3d_shader_immediate_constant_buffer icb;
360 };
361
362 struct wined3d_sm4_opcode_info
363 {
364 enum wined3d_sm4_opcode opcode;
365 enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx;
366 const char *dst_info;
367 const char *src_info;
368 void (*read_opcode_func)(struct wined3d_shader_instruction *ins,
369 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
370 struct wined3d_sm4_data *priv);
371 };
372
373 static const enum wined3d_primitive_type output_primitive_type_table[] =
374 {
375 /* UNKNOWN */ WINED3D_PT_UNDEFINED,
376 /* WINED3D_SM4_OUTPUT_PT_POINTLIST */ WINED3D_PT_POINTLIST,
377 /* UNKNOWN */ WINED3D_PT_UNDEFINED,
378 /* WINED3D_SM4_OUTPUT_PT_LINELIST */ WINED3D_PT_LINELIST,
379 /* UNKNOWN */ WINED3D_PT_UNDEFINED,
380 /* WINED3D_SM4_OUTPUT_PT_TRIANGLESTRIP */ WINED3D_PT_TRIANGLESTRIP,
381 };
382
383 static const enum wined3d_primitive_type input_primitive_type_table[] =
384 {
385 /* UNKNOWN */ WINED3D_PT_UNDEFINED,
386 /* WINED3D_SM4_INPUT_PT_POINT */ WINED3D_PT_POINTLIST,
387 /* WINED3D_SM4_INPUT_PT_LINE */ WINED3D_PT_LINELIST,
388 /* WINED3D_SM4_INPUT_PT_TRIANGLE */ WINED3D_PT_TRIANGLELIST,
389 /* UNKNOWN */ WINED3D_PT_UNDEFINED,
390 /* UNKNOWN */ WINED3D_PT_UNDEFINED,
391 /* WINED3D_SM4_INPUT_PT_LINEADJ */ WINED3D_PT_LINELIST_ADJ,
392 /* WINED3D_SM4_INPUT_PT_TRIANGLEADJ */ WINED3D_PT_TRIANGLELIST_ADJ,
393 };
394
395 static const enum wined3d_shader_resource_type resource_type_table[] =
396 {
397 /* 0 */ WINED3D_SHADER_RESOURCE_NONE,
398 /* WINED3D_SM4_RESOURCE_BUFFER */ WINED3D_SHADER_RESOURCE_BUFFER,
399 /* WINED3D_SM4_RESOURCE_TEXTURE_1D */ WINED3D_SHADER_RESOURCE_TEXTURE_1D,
400 /* WINED3D_SM4_RESOURCE_TEXTURE_2D */ WINED3D_SHADER_RESOURCE_TEXTURE_2D,
401 /* WINED3D_SM4_RESOURCE_TEXTURE_2DMS */ WINED3D_SHADER_RESOURCE_TEXTURE_2DMS,
402 /* WINED3D_SM4_RESOURCE_TEXTURE_3D */ WINED3D_SHADER_RESOURCE_TEXTURE_3D,
403 /* WINED3D_SM4_RESOURCE_TEXTURE_CUBE */ WINED3D_SHADER_RESOURCE_TEXTURE_CUBE,
404 /* WINED3D_SM4_RESOURCE_TEXTURE_1DARRAY */ WINED3D_SHADER_RESOURCE_TEXTURE_1DARRAY,
405 /* WINED3D_SM4_RESOURCE_TEXTURE_2DARRAY */ WINED3D_SHADER_RESOURCE_TEXTURE_2DARRAY,
406 /* WINED3D_SM4_RESOURCE_TEXTURE_2DMSARRAY */ WINED3D_SHADER_RESOURCE_TEXTURE_2DMSARRAY,
407 };
408
409 static const enum wined3d_data_type data_type_table[] =
410 {
411 /* 0 */ WINED3D_DATA_FLOAT,
412 /* WINED3D_SM4_DATA_UNORM */ WINED3D_DATA_UNORM,
413 /* WINED3D_SM4_DATA_SNORM */ WINED3D_DATA_SNORM,
414 /* WINED3D_SM4_DATA_INT */ WINED3D_DATA_INT,
415 /* WINED3D_SM4_DATA_UINT */ WINED3D_DATA_UINT,
416 /* WINED3D_SM4_DATA_FLOAT */ WINED3D_DATA_FLOAT,
417 };
418
419 static BOOL shader_sm4_read_src_param(struct wined3d_sm4_data *priv, const DWORD **ptr,
420 enum wined3d_data_type data_type, struct wined3d_shader_src_param *src_param);
421 static BOOL shader_sm4_read_dst_param(struct wined3d_sm4_data *priv, const DWORD **ptr,
422 enum wined3d_data_type data_type, struct wined3d_shader_dst_param *dst_param);
423
424 static void shader_sm4_read_conditional_op(struct wined3d_shader_instruction *ins,
425 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
426 struct wined3d_sm4_data *priv)
427 {
428 shader_sm4_read_src_param(priv, &tokens, WINED3D_DATA_UINT, &priv->src_param[0]);
429 ins->flags = (opcode_token & WINED3D_SM4_CONDITIONAL_NZ) ?
430 WINED3D_SHADER_CONDITIONAL_OP_NZ : WINED3D_SHADER_CONDITIONAL_OP_Z;
431 }
432
433 static void shader_sm4_read_shader_data(struct wined3d_shader_instruction *ins,
434 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
435 struct wined3d_sm4_data *priv)
436 {
437 enum wined3d_sm4_shader_data_type type;
438 unsigned int icb_size;
439
440 type = (opcode_token & WINED3D_SM4_SHADER_DATA_TYPE_MASK) >> WINED3D_SM4_SHADER_DATA_TYPE_SHIFT;
441 if (type != WINED3D_SM4_SHADER_DATA_IMMEDIATE_CONSTANT_BUFFER)
442 {
443 FIXME("Unhandled shader data type %#x.\n", type);
444 ins->handler_idx = WINED3DSIH_TABLE_SIZE;
445 return;
446 }
447
448 ++tokens;
449 icb_size = token_count - 1;
450 if (icb_size % 4 || icb_size > MAX_IMMEDIATE_CONSTANT_BUFFER_SIZE)
451 {
452 FIXME("Unexpected immediate constant buffer size %u.\n", icb_size);
453 ins->handler_idx = WINED3DSIH_TABLE_SIZE;
454 return;
455 }
456
457 priv->icb.vec4_count = icb_size / 4;
458 memcpy(priv->icb.data, tokens, sizeof(*tokens) * icb_size);
459 ins->declaration.icb = &priv->icb;
460 }
461
462 static void shader_sm4_read_dcl_resource(struct wined3d_shader_instruction *ins,
463 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
464 struct wined3d_sm4_data *priv)
465 {
466 enum wined3d_sm4_resource_type resource_type;
467 enum wined3d_sm4_data_type data_type;
468 enum wined3d_data_type reg_data_type;
469 DWORD components;
470
471 resource_type = (opcode_token & WINED3D_SM4_RESOURCE_TYPE_MASK) >> WINED3D_SM4_RESOURCE_TYPE_SHIFT;
472 if (!resource_type || (resource_type >= ARRAY_SIZE(resource_type_table)))
473 {
474 FIXME("Unhandled resource type %#x.\n", resource_type);
475 ins->declaration.semantic.resource_type = WINED3D_SHADER_RESOURCE_NONE;
476 }
477 else
478 {
479 ins->declaration.semantic.resource_type = resource_type_table[resource_type];
480 }
481 reg_data_type = opcode == WINED3D_SM4_OP_DCL_RESOURCE ? WINED3D_DATA_RESOURCE : WINED3D_DATA_UAV;
482 shader_sm4_read_dst_param(priv, &tokens, reg_data_type, &ins->declaration.semantic.reg);
483
484 components = *tokens++;
485 if ((components & 0xfff0) != (components & 0xf) * 0x1110)
486 FIXME("Components (%#x) have different data types.\n", components);
487 data_type = components & 0xf;
488
489 if (!data_type || (data_type >= ARRAY_SIZE(data_type_table)))
490 {
491 FIXME("Unhandled data type %#x.\n", data_type);
492 ins->declaration.semantic.resource_data_type = WINED3D_DATA_FLOAT;
493 }
494 else
495 {
496 ins->declaration.semantic.resource_data_type = data_type_table[data_type];
497 }
498 }
499
500 static void shader_sm4_read_dcl_constant_buffer(struct wined3d_shader_instruction *ins,
501 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
502 struct wined3d_sm4_data *priv)
503 {
504 shader_sm4_read_src_param(priv, &tokens, WINED3D_DATA_FLOAT, &ins->declaration.src);
505 if (opcode_token & WINED3D_SM4_INDEX_TYPE_MASK)
506 ins->flags |= WINED3DSI_INDEXED_DYNAMIC;
507 }
508
509 static void shader_sm4_read_dcl_sampler(struct wined3d_shader_instruction *ins,
510 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
511 struct wined3d_sm4_data *priv)
512 {
513 ins->flags = (opcode_token & WINED3D_SM4_SAMPLER_MODE_MASK) >> WINED3D_SM4_SAMPLER_MODE_SHIFT;
514 if (ins->flags & ~WINED3D_SM4_SAMPLER_COMPARISON)
515 FIXME("Unhandled sampler mode %#x.\n", ins->flags);
516 shader_sm4_read_dst_param(priv, &tokens, WINED3D_DATA_SAMPLER, &ins->declaration.dst);
517 }
518
519 static void shader_sm4_read_dcl_output_topology(struct wined3d_shader_instruction *ins,
520 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
521 struct wined3d_sm4_data *priv)
522 {
523 enum wined3d_sm4_output_primitive_type primitive_type;
524
525 primitive_type = (opcode_token & WINED3D_SM4_PRIMITIVE_TYPE_MASK) >> WINED3D_SM4_PRIMITIVE_TYPE_SHIFT;
526 if (primitive_type >= sizeof(output_primitive_type_table) / sizeof(*output_primitive_type_table))
527 {
528 FIXME("Unhandled output primitive type %#x.\n", primitive_type);
529 ins->declaration.primitive_type = WINED3D_PT_UNDEFINED;
530 }
531 else
532 {
533 ins->declaration.primitive_type = output_primitive_type_table[primitive_type];
534 }
535 }
536
537 static void shader_sm4_read_dcl_input_primitive(struct wined3d_shader_instruction *ins,
538 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
539 struct wined3d_sm4_data *priv)
540 {
541 enum wined3d_sm4_input_primitive_type primitive_type;
542
543 primitive_type = (opcode_token & WINED3D_SM4_PRIMITIVE_TYPE_MASK) >> WINED3D_SM4_PRIMITIVE_TYPE_SHIFT;
544 if (primitive_type >= sizeof(input_primitive_type_table) / sizeof(*input_primitive_type_table))
545 {
546 FIXME("Unhandled input primitive type %#x.\n", primitive_type);
547 ins->declaration.primitive_type = WINED3D_PT_UNDEFINED;
548 }
549 else
550 {
551 ins->declaration.primitive_type = input_primitive_type_table[primitive_type];
552 }
553 }
554
555 static void shader_sm4_read_declaration_count(struct wined3d_shader_instruction *ins,
556 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
557 struct wined3d_sm4_data *priv)
558 {
559 ins->declaration.count = *tokens;
560 }
561
562 static void shader_sm4_read_declaration_dst(struct wined3d_shader_instruction *ins,
563 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
564 struct wined3d_sm4_data *priv)
565 {
566 shader_sm4_read_dst_param(priv, &tokens, WINED3D_DATA_FLOAT, &ins->declaration.dst);
567 }
568
569 static void shader_sm4_read_declaration_register_semantic(struct wined3d_shader_instruction *ins,
570 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
571 struct wined3d_sm4_data *priv)
572 {
573 shader_sm4_read_dst_param(priv, &tokens, WINED3D_DATA_FLOAT, &ins->declaration.register_semantic.reg);
574 ins->declaration.register_semantic.sysval_semantic = *tokens;
575 }
576
577 static void shader_sm4_read_dcl_input_ps(struct wined3d_shader_instruction *ins,
578 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
579 struct wined3d_sm4_data *priv)
580 {
581 ins->flags = (opcode_token & WINED3D_SM4_INTERPOLATION_MODE_MASK) >> WINED3D_SM4_INTERPOLATION_MODE_SHIFT;
582 shader_sm4_read_dst_param(priv, &tokens, WINED3D_DATA_FLOAT, &ins->declaration.dst);
583 }
584
585 static void shader_sm4_read_dcl_input_ps_siv(struct wined3d_shader_instruction *ins,
586 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
587 struct wined3d_sm4_data *priv)
588 {
589 ins->flags = (opcode_token & WINED3D_SM4_INTERPOLATION_MODE_MASK) >> WINED3D_SM4_INTERPOLATION_MODE_SHIFT;
590 shader_sm4_read_dst_param(priv, &tokens, WINED3D_DATA_FLOAT, &ins->declaration.register_semantic.reg);
591 ins->declaration.register_semantic.sysval_semantic = *tokens;
592 }
593
594 static void shader_sm4_read_dcl_indexable_temp(struct wined3d_shader_instruction *ins,
595 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
596 struct wined3d_sm4_data *priv)
597 {
598 ins->declaration.indexable_temp.register_idx = *tokens++;
599 ins->declaration.indexable_temp.register_size = *tokens++;
600 ins->declaration.indexable_temp.component_count = *tokens;
601 }
602
603 static void shader_sm4_read_dcl_global_flags(struct wined3d_shader_instruction *ins,
604 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
605 struct wined3d_sm4_data *priv)
606 {
607 ins->flags = (opcode_token & WINED3D_SM4_GLOBAL_FLAGS_MASK) >> WINED3D_SM4_GLOBAL_FLAGS_SHIFT;
608 }
609
610 static void shader_sm5_read_control_point_count(struct wined3d_shader_instruction *ins,
611 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
612 struct wined3d_sm4_data *priv)
613 {
614 ins->declaration.count = (opcode_token & WINED3D_SM5_CONTROL_POINT_COUNT_MASK)
615 >> WINED3D_SM5_CONTROL_POINT_COUNT_SHIFT;
616 }
617
618 static void shader_sm5_read_dcl_tessellator_domain(struct wined3d_shader_instruction *ins,
619 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
620 struct wined3d_sm4_data *priv)
621 {
622 ins->declaration.tessellator_domain = (opcode_token & WINED3D_SM5_TESSELLATOR_MASK)
623 >> WINED3D_SM5_TESSELLATOR_SHIFT;
624 }
625
626 static void shader_sm5_read_dcl_tessellator_partitioning(struct wined3d_shader_instruction *ins,
627 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
628 struct wined3d_sm4_data *priv)
629 {
630 ins->declaration.tessellator_partitioning = (opcode_token & WINED3D_SM5_TESSELLATOR_MASK)
631 >> WINED3D_SM5_TESSELLATOR_SHIFT;
632 }
633
634 static void shader_sm5_read_dcl_tessellator_output_primitive(struct wined3d_shader_instruction *ins,
635 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
636 struct wined3d_sm4_data *priv)
637 {
638 ins->declaration.tessellator_output_primitive = (opcode_token & WINED3D_SM5_TESSELLATOR_MASK)
639 >> WINED3D_SM5_TESSELLATOR_SHIFT;
640 }
641
642 static void shader_sm5_read_dcl_hs_max_tessfactor(struct wined3d_shader_instruction *ins,
643 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
644 struct wined3d_sm4_data *priv)
645 {
646 ins->declaration.max_tessellation_factor = *(float *)tokens;
647 }
648
649 static void shader_sm5_read_dcl_thread_group(struct wined3d_shader_instruction *ins,
650 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
651 struct wined3d_sm4_data *priv)
652 {
653 ins->declaration.thread_group_size.x = *tokens++;
654 ins->declaration.thread_group_size.y = *tokens++;
655 ins->declaration.thread_group_size.z = *tokens++;
656 }
657
658 static void shader_sm5_read_dcl_tgsm_raw(struct wined3d_shader_instruction *ins,
659 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
660 struct wined3d_sm4_data *priv)
661 {
662 shader_sm4_read_dst_param(priv, &tokens, WINED3D_DATA_FLOAT, &ins->declaration.tgsm_raw.reg);
663 ins->declaration.tgsm_raw.byte_count = *tokens;
664 }
665
666 static void shader_sm5_read_dcl_tgsm_structured(struct wined3d_shader_instruction *ins,
667 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
668 struct wined3d_sm4_data *priv)
669 {
670 shader_sm4_read_dst_param(priv, &tokens, WINED3D_DATA_FLOAT, &ins->declaration.tgsm_structured.reg);
671 ins->declaration.tgsm_structured.byte_stride = *tokens++;
672 ins->declaration.tgsm_structured.structure_count = *tokens;
673 }
674
675 static void shader_sm5_read_dcl_resource_structured(struct wined3d_shader_instruction *ins,
676 DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count,
677 struct wined3d_sm4_data *priv)
678 {
679 shader_sm4_read_dst_param(priv, &tokens, WINED3D_DATA_RESOURCE, &ins->declaration.structured_resource.reg);
680 ins->declaration.structured_resource.byte_stride = *tokens;
681 }
682
683 /*
684 * f -> WINED3D_DATA_FLOAT
685 * i -> WINED3D_DATA_INT
686 * u -> WINED3D_DATA_UINT
687 * R -> WINED3D_DATA_RESOURCE
688 * S -> WINED3D_DATA_SAMPLER
689 * U -> WINED3D_DATA_UAV
690 */
691 static const struct wined3d_sm4_opcode_info opcode_table[] =
692 {
693 {WINED3D_SM4_OP_ADD, WINED3DSIH_ADD, "f", "ff"},
694 {WINED3D_SM4_OP_AND, WINED3DSIH_AND, "u", "uu"},
695 {WINED3D_SM4_OP_BREAK, WINED3DSIH_BREAK, "", ""},
696 {WINED3D_SM4_OP_BREAKC, WINED3DSIH_BREAKP, "", "u",
697 shader_sm4_read_conditional_op},
698 {WINED3D_SM4_OP_CASE, WINED3DSIH_CASE, "", "u"},
699 {WINED3D_SM4_OP_CONTINUE, WINED3DSIH_CONTINUE, "", ""},
700 {WINED3D_SM4_OP_CUT, WINED3DSIH_CUT, "", ""},
701 {WINED3D_SM4_OP_DEFAULT, WINED3DSIH_DEFAULT, "", ""},
702 {WINED3D_SM4_OP_DERIV_RTX, WINED3DSIH_DSX, "f", "f"},
703 {WINED3D_SM4_OP_DERIV_RTY, WINED3DSIH_DSY, "f", "f"},
704 {WINED3D_SM4_OP_DISCARD, WINED3DSIH_TEXKILL, "", "u"},
705 {WINED3D_SM4_OP_DIV, WINED3DSIH_DIV, "f", "ff"},
706 {WINED3D_SM4_OP_DP2, WINED3DSIH_DP2, "f", "ff"},
707 {WINED3D_SM4_OP_DP3, WINED3DSIH_DP3, "f", "ff"},
708 {WINED3D_SM4_OP_DP4, WINED3DSIH_DP4, "f", "ff"},
709 {WINED3D_SM4_OP_ELSE, WINED3DSIH_ELSE, "", ""},
710 {WINED3D_SM4_OP_EMIT, WINED3DSIH_EMIT, "", ""},
711 {WINED3D_SM4_OP_ENDIF, WINED3DSIH_ENDIF, "", ""},
712 {WINED3D_SM4_OP_ENDLOOP, WINED3DSIH_ENDLOOP, "", ""},
713 {WINED3D_SM4_OP_ENDSWITCH, WINED3DSIH_ENDSWITCH, "", ""},
714 {WINED3D_SM4_OP_EQ, WINED3DSIH_EQ, "u", "ff"},
715 {WINED3D_SM4_OP_EXP, WINED3DSIH_EXP, "f", "f"},
716 {WINED3D_SM4_OP_FRC, WINED3DSIH_FRC, "f", "f"},
717 {WINED3D_SM4_OP_FTOI, WINED3DSIH_FTOI, "i", "f"},
718 {WINED3D_SM4_OP_FTOU, WINED3DSIH_FTOU, "u", "f"},
719 {WINED3D_SM4_OP_GE, WINED3DSIH_GE, "u", "ff"},
720 {WINED3D_SM4_OP_IADD, WINED3DSIH_IADD, "i", "ii"},
721 {WINED3D_SM4_OP_IF, WINED3DSIH_IF, "", "u",
722 shader_sm4_read_conditional_op},
723 {WINED3D_SM4_OP_IEQ, WINED3DSIH_IEQ, "u", "ii"},
724 {WINED3D_SM4_OP_IGE, WINED3DSIH_IGE, "u", "ii"},
725 {WINED3D_SM4_OP_ILT, WINED3DSIH_ILT, "u", "ii"},
726 {WINED3D_SM4_OP_IMAD, WINED3DSIH_IMAD, "i", "iii"},
727 {WINED3D_SM4_OP_IMAX, WINED3DSIH_IMAX, "i", "ii"},
728 {WINED3D_SM4_OP_IMIN, WINED3DSIH_IMIN, "i", "ii"},
729 {WINED3D_SM4_OP_IMUL, WINED3DSIH_IMUL, "ii", "ii"},
730 {WINED3D_SM4_OP_INE, WINED3DSIH_INE, "u", "ii"},
731 {WINED3D_SM4_OP_INEG, WINED3DSIH_INEG, "i", "i"},
732 {WINED3D_SM4_OP_ISHL, WINED3DSIH_ISHL, "i", "ii"},
733 {WINED3D_SM4_OP_ISHR, WINED3DSIH_ISHR, "i", "ii"},
734 {WINED3D_SM4_OP_ITOF, WINED3DSIH_ITOF, "f", "i"},
735 {WINED3D_SM4_OP_LD, WINED3DSIH_LD, "u", "iR"},
736 {WINED3D_SM4_OP_LD2DMS, WINED3DSIH_LD2DMS, "u", "iRi"},
737 {WINED3D_SM4_OP_LOG, WINED3DSIH_LOG, "f", "f"},
738 {WINED3D_SM4_OP_LOOP, WINED3DSIH_LOOP, "", ""},
739 {WINED3D_SM4_OP_LT, WINED3DSIH_LT, "u", "ff"},
740 {WINED3D_SM4_OP_MAD, WINED3DSIH_MAD, "f", "fff"},
741 {WINED3D_SM4_OP_MIN, WINED3DSIH_MIN, "f", "ff"},
742 {WINED3D_SM4_OP_MAX, WINED3DSIH_MAX, "f", "ff"},
743 {WINED3D_SM4_OP_SHADER_DATA, WINED3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER, "", "",
744 shader_sm4_read_shader_data},
745 {WINED3D_SM4_OP_MOV, WINED3DSIH_MOV, "f", "f"},
746 {WINED3D_SM4_OP_MOVC, WINED3DSIH_MOVC, "f", "uff"},
747 {WINED3D_SM4_OP_MUL, WINED3DSIH_MUL, "f", "ff"},
748 {WINED3D_SM4_OP_NE, WINED3DSIH_NE, "u", "ff"},
749 {WINED3D_SM4_OP_NOT, WINED3DSIH_NOT, "u", "u"},
750 {WINED3D_SM4_OP_OR, WINED3DSIH_OR, "u", "uu"},
751 {WINED3D_SM4_OP_RESINFO, WINED3DSIH_RESINFO, "f", "iR"},
752 {WINED3D_SM4_OP_RET, WINED3DSIH_RET, "", ""},
753 {WINED3D_SM4_OP_ROUND_NE, WINED3DSIH_ROUND_NE, "f", "f"},
754 {WINED3D_SM4_OP_ROUND_NI, WINED3DSIH_ROUND_NI, "f", "f"},
755 {WINED3D_SM4_OP_ROUND_PI, WINED3DSIH_ROUND_PI, "f", "f"},
756 {WINED3D_SM4_OP_ROUND_Z, WINED3DSIH_ROUND_Z, "f", "f"},
757 {WINED3D_SM4_OP_RSQ, WINED3DSIH_RSQ, "f", "f"},
758 {WINED3D_SM4_OP_SAMPLE, WINED3DSIH_SAMPLE, "u", "fRS"},
759 {WINED3D_SM4_OP_SAMPLE_C, WINED3DSIH_SAMPLE_C, "f", "fRSf"},
760 {WINED3D_SM4_OP_SAMPLE_C_LZ, WINED3DSIH_SAMPLE_C_LZ, "f", "fRSf"},
761 {WINED3D_SM4_OP_SAMPLE_LOD, WINED3DSIH_SAMPLE_LOD, "u", "fRSf"},
762 {WINED3D_SM4_OP_SAMPLE_GRAD, WINED3DSIH_SAMPLE_GRAD, "u", "fRSff"},
763 {WINED3D_SM4_OP_SAMPLE_B, WINED3DSIH_SAMPLE_B, "u", "fRSf"},
764 {WINED3D_SM4_OP_SQRT, WINED3DSIH_SQRT, "f", "f"},
765 {WINED3D_SM4_OP_SWITCH, WINED3DSIH_SWITCH, "", "u"},
766 {WINED3D_SM4_OP_SINCOS, WINED3DSIH_SINCOS, "ff", "f"},
767 {WINED3D_SM4_OP_UDIV, WINED3DSIH_UDIV, "uu", "uu"},
768 {WINED3D_SM4_OP_ULT, WINED3DSIH_ULT, "u", "uu"},
769 {WINED3D_SM4_OP_UGE, WINED3DSIH_UGE, "u", "uu"},
770 {WINED3D_SM4_OP_UMAX, WINED3DSIH_UMAX, "u", "uu"},
771 {WINED3D_SM4_OP_UMIN, WINED3DSIH_UMIN, "u", "uu"},
772 {WINED3D_SM4_OP_USHR, WINED3DSIH_USHR, "u", "uu"},
773 {WINED3D_SM4_OP_UTOF, WINED3DSIH_UTOF, "f", "u"},
774 {WINED3D_SM4_OP_XOR, WINED3DSIH_XOR, "u", "uu"},
775 {WINED3D_SM4_OP_DCL_RESOURCE, WINED3DSIH_DCL, "R", "",
776 shader_sm4_read_dcl_resource},
777 {WINED3D_SM4_OP_DCL_CONSTANT_BUFFER, WINED3DSIH_DCL_CONSTANT_BUFFER, "", "",
778 shader_sm4_read_dcl_constant_buffer},
779 {WINED3D_SM4_OP_DCL_SAMPLER, WINED3DSIH_DCL_SAMPLER, "", "",
780 shader_sm4_read_dcl_sampler},
781 {WINED3D_SM4_OP_DCL_OUTPUT_TOPOLOGY, WINED3DSIH_DCL_OUTPUT_TOPOLOGY, "", "",
782 shader_sm4_read_dcl_output_topology},
783 {WINED3D_SM4_OP_DCL_INPUT_PRIMITIVE, WINED3DSIH_DCL_INPUT_PRIMITIVE, "", "",
784 shader_sm4_read_dcl_input_primitive},
785 {WINED3D_SM4_OP_DCL_VERTICES_OUT, WINED3DSIH_DCL_VERTICES_OUT, "", "",
786 shader_sm4_read_declaration_count},
787 {WINED3D_SM4_OP_DCL_INPUT, WINED3DSIH_DCL_INPUT, "", "",
788 shader_sm4_read_declaration_dst},
789 {WINED3D_SM4_OP_DCL_INPUT_SGV, WINED3DSIH_DCL_INPUT_SGV, "", "",
790 shader_sm4_read_declaration_register_semantic},
791 {WINED3D_SM4_OP_DCL_INPUT_SIV, WINED3DSIH_DCL_INPUT_SIV, "", "",
792 shader_sm4_read_declaration_register_semantic},
793 {WINED3D_SM4_OP_DCL_INPUT_PS, WINED3DSIH_DCL_INPUT_PS, "", "",
794 shader_sm4_read_dcl_input_ps},
795 {WINED3D_SM4_OP_DCL_INPUT_PS_SGV, WINED3DSIH_DCL_INPUT_PS_SGV, "", "",
796 shader_sm4_read_declaration_register_semantic},
797 {WINED3D_SM4_OP_DCL_INPUT_PS_SIV, WINED3DSIH_DCL_INPUT_PS_SIV, "", "",
798 shader_sm4_read_dcl_input_ps_siv},
799 {WINED3D_SM4_OP_DCL_OUTPUT, WINED3DSIH_DCL_OUTPUT, "", "",
800 shader_sm4_read_declaration_dst},
801 {WINED3D_SM4_OP_DCL_OUTPUT_SIV, WINED3DSIH_DCL_OUTPUT_SIV, "", "",
802 shader_sm4_read_declaration_register_semantic},
803 {WINED3D_SM4_OP_DCL_TEMPS, WINED3DSIH_DCL_TEMPS, "", "",
804 shader_sm4_read_declaration_count},
805 {WINED3D_SM4_OP_DCL_INDEXABLE_TEMP, WINED3DSIH_DCL_INDEXABLE_TEMP, "", "",
806 shader_sm4_read_dcl_indexable_temp},
807 {WINED3D_SM4_OP_DCL_GLOBAL_FLAGS, WINED3DSIH_DCL_GLOBAL_FLAGS, "", "",
808 shader_sm4_read_dcl_global_flags},
809 {WINED3D_SM4_OP_LOD, WINED3DSIH_LOD, "f", "fRS"},
810 {WINED3D_SM4_OP_GATHER4, WINED3DSIH_GATHER4, "u", "fRS"},
811 {WINED3D_SM4_OP_SAMPLE_POS, WINED3DSIH_SAMPLE_POS, "f", "Ru"},
812 {WINED3D_SM4_OP_SAMPLE_INFO, WINED3DSIH_SAMPLE_INFO, "f", "R"},
813 {WINED3D_SM5_OP_HS_DECLS, WINED3DSIH_HS_DECLS, "", ""},
814 {WINED3D_SM5_OP_HS_CONTROL_POINT_PHASE, WINED3DSIH_HS_CONTROL_POINT_PHASE, "", ""},
815 {WINED3D_SM5_OP_HS_FORK_PHASE, WINED3DSIH_HS_FORK_PHASE, "", ""},
816 {WINED3D_SM5_OP_HS_JOIN_PHASE, WINED3DSIH_HS_JOIN_PHASE, "", ""},
817 {WINED3D_SM5_OP_EMIT_STREAM, WINED3DSIH_EMIT_STREAM, "", "f"},
818 {WINED3D_SM5_OP_CUT_STREAM, WINED3DSIH_CUT_STREAM, "", "f"},
819 {WINED3D_SM5_OP_BUFINFO, WINED3DSIH_BUFINFO, "i", "U"},
820 {WINED3D_SM5_OP_DERIV_RTX_COARSE, WINED3DSIH_DSX_COARSE, "f", "f"},
821 {WINED3D_SM5_OP_DERIV_RTX_FINE, WINED3DSIH_DSX_FINE, "f", "f"},
822 {WINED3D_SM5_OP_DERIV_RTY_COARSE, WINED3DSIH_DSY_COARSE, "f", "f"},
823 {WINED3D_SM5_OP_DERIV_RTY_FINE, WINED3DSIH_DSY_FINE, "f", "f"},
824 {WINED3D_SM5_OP_GATHER4_C, WINED3DSIH_GATHER4_C, "f", "fRSf"},
825 {WINED3D_SM5_OP_RCP, WINED3DSIH_RCP, "f", "f"},
826 {WINED3D_SM5_OP_UBFE, WINED3DSIH_UBFE, "u", "iiu"},
827 {WINED3D_SM5_OP_BFI, WINED3DSIH_BFI, "u", "iiuu"},
828 {WINED3D_SM5_OP_BFREV, WINED3DSIH_BFREV, "u", "u"},
829 {WINED3D_SM5_OP_SWAPC, WINED3DSIH_SWAPC, "ff", "uff"},
830 {WINED3D_SM5_OP_DCL_STREAM, WINED3DSIH_DCL_STREAM, "", "f"},
831 {WINED3D_SM5_OP_DCL_INPUT_CONTROL_POINT_COUNT, WINED3DSIH_DCL_INPUT_CONTROL_POINT_COUNT, "", "",
832 shader_sm5_read_control_point_count},
833 {WINED3D_SM5_OP_DCL_OUTPUT_CONTROL_POINT_COUNT, WINED3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT, "", "",
834 shader_sm5_read_control_point_count},
835 {WINED3D_SM5_OP_DCL_TESSELLATOR_DOMAIN, WINED3DSIH_DCL_TESSELLATOR_DOMAIN, "", "",
836 shader_sm5_read_dcl_tessellator_domain},
837 {WINED3D_SM5_OP_DCL_TESSELLATOR_PARTITIONING, WINED3DSIH_DCL_TESSELLATOR_PARTITIONING, "", "",
838 shader_sm5_read_dcl_tessellator_partitioning},
839 {WINED3D_SM5_OP_DCL_TESSELLATOR_OUTPUT_PRIMITIVE, WINED3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE, "", "",
840 shader_sm5_read_dcl_tessellator_output_primitive},
841 {WINED3D_SM5_OP_DCL_HS_MAX_TESSFACTOR, WINED3DSIH_DCL_HS_MAX_TESSFACTOR, "", "",
842 shader_sm5_read_dcl_hs_max_tessfactor},
843 {WINED3D_SM5_OP_DCL_HS_FORK_PHASE_INSTANCE_COUNT, WINED3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT, "", "",
844 shader_sm4_read_declaration_count},
845 {WINED3D_SM5_OP_DCL_THREAD_GROUP, WINED3DSIH_DCL_THREAD_GROUP, "", "",
846 shader_sm5_read_dcl_thread_group},
847 {WINED3D_SM5_OP_DCL_UAV_TYPED, WINED3DSIH_DCL_UAV_TYPED, "", "",
848 shader_sm4_read_dcl_resource},
849 {WINED3D_SM5_OP_DCL_TGSM_RAW, WINED3DSIH_DCL_TGSM_RAW, "", "",
850 shader_sm5_read_dcl_tgsm_raw},
851 {WINED3D_SM5_OP_DCL_TGSM_STRUCTURED, WINED3DSIH_DCL_TGSM_STRUCTURED, "", "",
852 shader_sm5_read_dcl_tgsm_structured},
853 {WINED3D_SM5_OP_DCL_RESOURCE_STRUCTURED, WINED3DSIH_DCL_RESOURCE_STRUCTURED, "", "",
854 shader_sm5_read_dcl_resource_structured},
855 {WINED3D_SM5_OP_LD_UAV_TYPED, WINED3DSIH_LD_UAV_TYPED, "u", "iU"},
856 {WINED3D_SM5_OP_STORE_UAV_TYPED, WINED3DSIH_STORE_UAV_TYPED, "U", "iu"},
857 {WINED3D_SM5_OP_LD_RAW, WINED3DSIH_LD_RAW, "u", "iU"},
858 {WINED3D_SM5_OP_STORE_RAW, WINED3DSIH_STORE_RAW, "U", "iu"},
859 {WINED3D_SM5_OP_LD_STRUCTURED, WINED3DSIH_LD_STRUCTURED, "u", "uuR"},
860 {WINED3D_SM5_OP_STORE_STRUCTURED, WINED3DSIH_STORE_STRUCTURED, "U", "iiu"},
861 {WINED3D_SM5_OP_IMM_ATOMIC_ALLOC, WINED3DSIH_IMM_ATOMIC_ALLOC, "u", "U"},
862 {WINED3D_SM5_OP_IMM_ATOMIC_CONSUME, WINED3DSIH_IMM_ATOMIC_CONSUME, "u", "U"},
863 };
864
865 static const enum wined3d_shader_register_type register_type_table[] =
866 {
867 /* WINED3D_SM4_RT_TEMP */ WINED3DSPR_TEMP,
868 /* WINED3D_SM4_RT_INPUT */ WINED3DSPR_INPUT,
869 /* WINED3D_SM4_RT_OUTPUT */ WINED3DSPR_OUTPUT,
870 /* WINED3D_SM4_RT_INDEXABLE_TEMP */ WINED3DSPR_IDXTEMP,
871 /* WINED3D_SM4_RT_IMMCONST */ WINED3DSPR_IMMCONST,
872 /* UNKNOWN */ ~0u,
873 /* WINED3D_SM4_RT_SAMPLER */ WINED3DSPR_SAMPLER,
874 /* WINED3D_SM4_RT_RESOURCE */ WINED3DSPR_RESOURCE,
875 /* WINED3D_SM4_RT_CONSTBUFFER */ WINED3DSPR_CONSTBUFFER,
876 /* WINED3D_SM4_RT_IMMCONSTBUFFER */ WINED3DSPR_IMMCONSTBUFFER,
877 /* UNKNOWN */ ~0u,
878 /* WINED3D_SM4_RT_PRIMID */ WINED3DSPR_PRIMID,
879 /* WINED3D_SM4_RT_DEPTHOUT */ WINED3DSPR_DEPTHOUT,
880 /* WINED3D_SM4_RT_NULL */ WINED3DSPR_NULL,
881 /* UNKNOWN */ ~0u,
882 /* UNKNOWN */ ~0u,
883 /* WINED3D_SM5_RT_STREAM */ WINED3DSPR_STREAM,
884 /* UNKNOWN */ ~0u,
885 /* UNKNOWN */ ~0u,
886 /* UNKNOWN */ ~0u,
887 /* UNKNOWN */ ~0u,
888 /* UNKNOWN */ ~0u,
889 /* WINED3D_SM5_RT_OUTPUT_CONTROL_POINT_ID */ WINED3DSPR_OUTPOINTID,
890 /* WINED3D_SM5_RT_FORK_INSTANCE_ID */ WINED3DSPR_FORKINSTID,
891 /* UNKNOWN */ ~0u,
892 /* WINED3D_SM5_RT_INPUT_CONTROL_POINT */ WINED3DSPR_INCONTROLPOINT,
893 /* WINED3D_SM5_RT_OUTPUT_CONTROL_POINT */ WINED3DSPR_OUTCONTROLPOINT,
894 /* WINED3D_SM5_RT_PATCH_CONSTANT_DATA */ WINED3DSPR_PATCHCONST,
895 /* WINED3D_SM5_RT_DOMAIN_LOCATION */ WINED3DSPR_TESSCOORD,
896 /* UNKNOWN */ ~0u,
897 /* WINED3D_SM5_RT_UAV */ WINED3DSPR_UAV,
898 /* WINED3D_SM5_RT_SHARED_MEMORY */ WINED3DSPR_GROUPSHAREDMEM,
899 /* WINED3D_SM5_RT_THREAD_ID */ WINED3DSPR_THREADID,
900 /* WINED3D_SM5_RT_THREAD_GROUP_ID */ WINED3DSPR_THREADGROUPID,
901 /* WINED3D_SM5_RT_LOCAL_THREAD_ID */ WINED3DSPR_LOCALTHREADID,
902 /* UNKNOWN */ ~0u,
903 /* WINED3D_SM5_RT_LOCAL_THREAD_INDEX */ WINED3DSPR_LOCALTHREADINDEX,
904 };
905
906 static const struct wined3d_sm4_opcode_info *get_opcode_info(enum wined3d_sm4_opcode opcode)
907 {
908 unsigned int i;
909
910 for (i = 0; i < sizeof(opcode_table) / sizeof(*opcode_table); ++i)
911 {
912 if (opcode == opcode_table[i].opcode) return &opcode_table[i];
913 }
914
915 return NULL;
916 }
917
918 static void map_register(const struct wined3d_sm4_data *priv, struct wined3d_shader_register *reg)
919 {
920 switch (priv->shader_version.type)
921 {
922 case WINED3D_SHADER_TYPE_PIXEL:
923 if (reg->type == WINED3DSPR_OUTPUT)
924 {
925 unsigned int reg_idx = reg->idx[0].offset;
926
927 if (reg_idx >= ARRAY_SIZE(priv->output_map))
928 {
929 ERR("Invalid output index %u.\n", reg_idx);
930 break;
931 }
932
933 reg->type = WINED3DSPR_COLOROUT;
934 reg->idx[0].offset = priv->output_map[reg_idx];
935 }
936 break;
937
938 default:
939 break;
940 }
941 }
942
943 static enum wined3d_data_type map_data_type(char t)
944 {
945 switch (t)
946 {
947 case 'f':
948 return WINED3D_DATA_FLOAT;
949 case 'i':
950 return WINED3D_DATA_INT;
951 case 'u':
952 return WINED3D_DATA_UINT;
953 case 'R':
954 return WINED3D_DATA_RESOURCE;
955 case 'S':
956 return WINED3D_DATA_SAMPLER;
957 case 'U':
958 return WINED3D_DATA_UAV;
959 default:
960 ERR("Invalid data type '%c'.\n", t);
961 return WINED3D_DATA_FLOAT;
962 }
963 }
964
965 static void *shader_sm4_init(const DWORD *byte_code, const struct wined3d_shader_signature *output_signature)
966 {
967 struct wined3d_sm4_data *priv;
968 unsigned int i;
969
970 if (!(priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv))))
971 {
972 ERR("Failed to allocate private data\n");
973 return NULL;
974 }
975
976 memset(priv->output_map, 0xff, sizeof(priv->output_map));
977 for (i = 0; i < output_signature->element_count; ++i)
978 {
979 struct wined3d_shader_signature_element *e = &output_signature->elements[i];
980
981 if (e->register_idx >= ARRAY_SIZE(priv->output_map))
982 {
983 WARN("Invalid output index %u.\n", e->register_idx);
984 continue;
985 }
986
987 priv->output_map[e->register_idx] = e->semantic_idx;
988 }
989
990 list_init(&priv->src_free);
991 list_init(&priv->src);
992
993 return priv;
994 }
995
996 static void shader_sm4_free(void *data)
997 {
998 struct wined3d_shader_src_param_entry *e1, *e2;
999 struct wined3d_sm4_data *priv = data;
1000
1001 list_move_head(&priv->src_free, &priv->src);
1002 LIST_FOR_EACH_ENTRY_SAFE(e1, e2, &priv->src_free, struct wined3d_shader_src_param_entry, entry)
1003 {
1004 HeapFree(GetProcessHeap(), 0, e1);
1005 }
1006 HeapFree(GetProcessHeap(), 0, priv);
1007 }
1008
1009 static struct wined3d_shader_src_param *get_src_param(struct wined3d_sm4_data *priv)
1010 {
1011 struct wined3d_shader_src_param_entry *e;
1012 struct list *elem;
1013
1014 if (!list_empty(&priv->src_free))
1015 {
1016 elem = list_head(&priv->src_free);
1017 list_remove(elem);
1018 }
1019 else
1020 {
1021 if (!(e = HeapAlloc(GetProcessHeap(), 0, sizeof(*e))))
1022 return NULL;
1023 elem = &e->entry;
1024 }
1025
1026 list_add_tail(&priv->src, elem);
1027 e = LIST_ENTRY(elem, struct wined3d_shader_src_param_entry, entry);
1028 return &e->param;
1029 }
1030
1031 static void shader_sm4_read_header(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version)
1032 {
1033 struct wined3d_sm4_data *priv = data;
1034 DWORD version_token;
1035
1036 priv->end = *ptr;
1037
1038 version_token = *(*ptr)++;
1039 TRACE("Version: 0x%08x.\n", version_token);
1040
1041 TRACE("Token count: %u.\n", **ptr);
1042 priv->end += *(*ptr)++;
1043
1044 switch (version_token >> 16)
1045 {
1046 case WINED3D_SM4_PS:
1047 priv->shader_version.type = WINED3D_SHADER_TYPE_PIXEL;
1048 break;
1049
1050 case WINED3D_SM4_VS:
1051 priv->shader_version.type = WINED3D_SHADER_TYPE_VERTEX;
1052 break;
1053
1054 case WINED3D_SM4_GS:
1055 priv->shader_version.type = WINED3D_SHADER_TYPE_GEOMETRY;
1056 break;
1057
1058 case WINED3D_SM5_HS:
1059 priv->shader_version.type = WINED3D_SHADER_TYPE_HULL;
1060 break;
1061
1062 case WINED3D_SM5_DS:
1063 priv->shader_version.type = WINED3D_SHADER_TYPE_DOMAIN;
1064 break;
1065
1066 case WINED3D_SM5_CS:
1067 priv->shader_version.type = WINED3D_SHADER_TYPE_COMPUTE;
1068 break;
1069
1070 default:
1071 FIXME("Unrecognized shader type %#x.\n", version_token >> 16);
1072 }
1073 priv->shader_version.major = WINED3D_SM4_VERSION_MAJOR(version_token);
1074 priv->shader_version.minor = WINED3D_SM4_VERSION_MINOR(version_token);
1075
1076 *shader_version = priv->shader_version;
1077 }
1078
1079 static BOOL shader_sm4_read_reg_idx(struct wined3d_sm4_data *priv, const DWORD **ptr,
1080 DWORD addressing, struct wined3d_shader_register_index *reg_idx)
1081 {
1082 if (addressing & WINED3D_SM4_ADDRESSING_RELATIVE)
1083 {
1084 struct wined3d_shader_src_param *rel_addr = get_src_param(priv);
1085
1086 if (!(reg_idx->rel_addr = rel_addr))
1087 {
1088 ERR("Failed to get src param for relative addressing.\n");
1089 return FALSE;
1090 }
1091
1092 if (addressing & WINED3D_SM4_ADDRESSING_OFFSET)
1093 reg_idx->offset = *(*ptr)++;
1094 else
1095 reg_idx->offset = 0;
1096 shader_sm4_read_src_param(priv, ptr, WINED3D_DATA_INT, rel_addr);
1097 }
1098 else
1099 {
1100 reg_idx->rel_addr = NULL;
1101 reg_idx->offset = *(*ptr)++;
1102 }
1103
1104 return TRUE;
1105 }
1106
1107 static BOOL shader_sm4_read_param(struct wined3d_sm4_data *priv, const DWORD **ptr,
1108 enum wined3d_data_type data_type, struct wined3d_shader_register *param,
1109 enum wined3d_shader_src_modifier *modifier)
1110 {
1111 enum wined3d_sm4_register_type register_type;
1112 DWORD token = *(*ptr)++;
1113 DWORD order;
1114
1115 register_type = (token & WINED3D_SM4_REGISTER_TYPE_MASK) >> WINED3D_SM4_REGISTER_TYPE_SHIFT;
1116 if (register_type >= sizeof(register_type_table) / sizeof(*register_type_table)
1117 || register_type_table[register_type] == ~0u)
1118 {
1119 FIXME("Unhandled register type %#x.\n", register_type);
1120 param->type = WINED3DSPR_TEMP;
1121 }
1122 else
1123 {
1124 param->type = register_type_table[register_type];
1125 }
1126 param->data_type = data_type;
1127
1128 if (token & WINED3D_SM4_REGISTER_MODIFIER)
1129 {
1130 DWORD m = *(*ptr)++;
1131
1132 switch (m)
1133 {
1134 case 0x41:
1135 *modifier = WINED3DSPSM_NEG;
1136 break;
1137
1138 case 0x81:
1139 *modifier = WINED3DSPSM_ABS;
1140 break;
1141
1142 case 0xc1:
1143 *modifier = WINED3DSPSM_ABSNEG;
1144 break;
1145
1146 default:
1147 FIXME("Skipping modifier 0x%08x.\n", m);
1148 *modifier = WINED3DSPSM_NONE;
1149 break;
1150 }
1151 }
1152 else
1153 {
1154 *modifier = WINED3DSPSM_NONE;
1155 }
1156
1157 order = (token & WINED3D_SM4_REGISTER_ORDER_MASK) >> WINED3D_SM4_REGISTER_ORDER_SHIFT;
1158
1159 if (order < 1)
1160 param->idx[0].offset = ~0U;
1161 else
1162 {
1163 DWORD addressing = (token & WINED3D_SM4_ADDRESSING_MASK0) >> WINED3D_SM4_ADDRESSING_SHIFT0;
1164 if (!(shader_sm4_read_reg_idx(priv, ptr, addressing, &param->idx[0])))
1165 {
1166 ERR("Failed to read register index.\n");
1167 return FALSE;
1168 }
1169 }
1170
1171 if (order < 2)
1172 param->idx[1].offset = ~0U;
1173 else
1174 {
1175 DWORD addressing = (token & WINED3D_SM4_ADDRESSING_MASK1) >> WINED3D_SM4_ADDRESSING_SHIFT1;
1176 if (!(shader_sm4_read_reg_idx(priv, ptr, addressing, &param->idx[1])))
1177 {
1178 ERR("Failed to read register index.\n");
1179 return FALSE;
1180 }
1181 }
1182
1183 if (order > 2)
1184 FIXME("Unhandled order %u.\n", order);
1185
1186 if (register_type == WINED3D_SM4_RT_IMMCONST)
1187 {
1188 enum wined3d_sm4_immconst_type immconst_type =
1189 (token & WINED3D_SM4_IMMCONST_TYPE_MASK) >> WINED3D_SM4_IMMCONST_TYPE_SHIFT;
1190
1191 switch (immconst_type)
1192 {
1193 case WINED3D_SM4_IMMCONST_SCALAR:
1194 param->immconst_type = WINED3D_IMMCONST_SCALAR;
1195 memcpy(param->immconst_data, *ptr, 1 * sizeof(DWORD));
1196 *ptr += 1;
1197 break;
1198
1199 case WINED3D_SM4_IMMCONST_VEC4:
1200 param->immconst_type = WINED3D_IMMCONST_VEC4;
1201 memcpy(param->immconst_data, *ptr, 4 * sizeof(DWORD));
1202 *ptr += 4;
1203 break;
1204
1205 default:
1206 FIXME("Unhandled immediate constant type %#x.\n", immconst_type);
1207 break;
1208 }
1209 }
1210
1211 map_register(priv, param);
1212
1213 return TRUE;
1214 }
1215
1216 static BOOL shader_sm4_read_src_param(struct wined3d_sm4_data *priv, const DWORD **ptr,
1217 enum wined3d_data_type data_type, struct wined3d_shader_src_param *src_param)
1218 {
1219 DWORD token = **ptr;
1220
1221 if (!shader_sm4_read_param(priv, ptr, data_type, &src_param->reg, &src_param->modifiers))
1222 {
1223 ERR("Failed to read parameter.\n");
1224 return FALSE;
1225 }
1226
1227 if (src_param->reg.type == WINED3DSPR_IMMCONST)
1228 {
1229 src_param->swizzle = WINED3DSP_NOSWIZZLE;
1230 }
1231 else
1232 {
1233 enum wined3d_sm4_swizzle_type swizzle_type =
1234 (token & WINED3D_SM4_SWIZZLE_TYPE_MASK) >> WINED3D_SM4_SWIZZLE_TYPE_SHIFT;
1235
1236 switch (swizzle_type)
1237 {
1238 case WINED3D_SM4_SWIZZLE_NONE:
1239 src_param->swizzle = WINED3DSP_NOSWIZZLE;
1240 break;
1241
1242 case WINED3D_SM4_SWIZZLE_SCALAR:
1243 src_param->swizzle = (token & WINED3D_SM4_SWIZZLE_MASK) >> WINED3D_SM4_SWIZZLE_SHIFT;
1244 src_param->swizzle = (src_param->swizzle & 0x3) * 0x55;
1245 break;
1246
1247 case WINED3D_SM4_SWIZZLE_VEC4:
1248 src_param->swizzle = (token & WINED3D_SM4_SWIZZLE_MASK) >> WINED3D_SM4_SWIZZLE_SHIFT;
1249 break;
1250
1251 default:
1252 FIXME("Unhandled swizzle type %#x.\n", swizzle_type);
1253 break;
1254 }
1255 }
1256
1257 return TRUE;
1258 }
1259
1260 static BOOL shader_sm4_read_dst_param(struct wined3d_sm4_data *priv, const DWORD **ptr,
1261 enum wined3d_data_type data_type, struct wined3d_shader_dst_param *dst_param)
1262 {
1263 enum wined3d_shader_src_modifier modifier;
1264 DWORD token = **ptr;
1265
1266 if (!shader_sm4_read_param(priv, ptr, data_type, &dst_param->reg, &modifier))
1267 {
1268 ERR("Failed to read parameter.\n");
1269 return FALSE;
1270 }
1271
1272 if (modifier != WINED3DSPSM_NONE)
1273 {
1274 ERR("Invalid source modifier %#x on destination register.\n", modifier);
1275 return FALSE;
1276 }
1277
1278 dst_param->write_mask = (token & WINED3D_SM4_WRITEMASK_MASK) >> WINED3D_SM4_WRITEMASK_SHIFT;
1279 dst_param->modifiers = 0;
1280 dst_param->shift = 0;
1281
1282 return TRUE;
1283 }
1284
1285 static void shader_sm4_read_instruction_modifier(DWORD modifier, struct wined3d_shader_instruction *ins)
1286 {
1287 static const DWORD recognized_bits = WINED3D_SM4_INSTRUCTION_MODIFIER
1288 | WINED3D_SM4_MODIFIER_AOFFIMMI
1289 | WINED3D_SM4_AOFFIMMI_U_MASK
1290 | WINED3D_SM4_AOFFIMMI_V_MASK
1291 | WINED3D_SM4_AOFFIMMI_W_MASK;
1292
1293 if (modifier & ~recognized_bits)
1294 {
1295 FIXME("Unhandled modifier 0x%08x.\n", modifier);
1296 }
1297 else
1298 {
1299 /* Bit fields are used for sign extension */
1300 struct
1301 {
1302 int u : 4;
1303 int v : 4;
1304 int w : 4;
1305 }
1306 aoffimmi;
1307 aoffimmi.u = (modifier & WINED3D_SM4_AOFFIMMI_U_MASK) >> WINED3D_SM4_AOFFIMMI_U_SHIFT;
1308 aoffimmi.v = (modifier & WINED3D_SM4_AOFFIMMI_V_MASK) >> WINED3D_SM4_AOFFIMMI_V_SHIFT;
1309 aoffimmi.w = (modifier & WINED3D_SM4_AOFFIMMI_W_MASK) >> WINED3D_SM4_AOFFIMMI_W_SHIFT;
1310 ins->texel_offset.u = aoffimmi.u;
1311 ins->texel_offset.v = aoffimmi.v;
1312 ins->texel_offset.w = aoffimmi.w;
1313 }
1314 }
1315
1316 static void shader_sm4_read_instruction(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins)
1317 {
1318 const struct wined3d_sm4_opcode_info *opcode_info;
1319 DWORD opcode_token, opcode, previous_token;
1320 struct wined3d_sm4_data *priv = data;
1321 unsigned int i, len;
1322 const DWORD *p;
1323
1324 list_move_head(&priv->src_free, &priv->src);
1325
1326 opcode_token = *(*ptr)++;
1327 opcode = opcode_token & WINED3D_SM4_OPCODE_MASK;
1328
1329 len = ((opcode_token & WINED3D_SM4_INSTRUCTION_LENGTH_MASK) >> WINED3D_SM4_INSTRUCTION_LENGTH_SHIFT);
1330 if (!len)
1331 len = **ptr;
1332 --len;
1333
1334 if (TRACE_ON(d3d_bytecode))
1335 {
1336 TRACE_(d3d_bytecode)("[ %08x ", opcode_token);
1337 for (i = 0; i < len; ++i)
1338 {
1339 TRACE_(d3d_bytecode)("%08x ", (*ptr)[i]);
1340 }
1341 TRACE_(d3d_bytecode)("]\n");
1342 }
1343
1344 if (!(opcode_info = get_opcode_info(opcode)))
1345 {
1346 FIXME("Unrecognized opcode %#x, opcode_token 0x%08x.\n", opcode, opcode_token);
1347 ins->handler_idx = WINED3DSIH_TABLE_SIZE;
1348 *ptr += len;
1349 return;
1350 }
1351
1352 ins->handler_idx = opcode_info->handler_idx;
1353 ins->flags = 0;
1354 ins->coissue = 0;
1355 ins->predicate = NULL;
1356 ins->dst_count = strlen(opcode_info->dst_info);
1357 ins->dst = priv->dst_param;
1358 ins->src_count = strlen(opcode_info->src_info);
1359 ins->src = priv->src_param;
1360 memset(&ins->texel_offset, 0, sizeof(ins->texel_offset));
1361
1362 p = *ptr;
1363 *ptr += len;
1364
1365 previous_token = opcode_token;
1366 while (previous_token & WINED3D_SM4_INSTRUCTION_MODIFIER)
1367 shader_sm4_read_instruction_modifier(previous_token = *p++, ins);
1368
1369 if (opcode_info->read_opcode_func)
1370 {
1371 opcode_info->read_opcode_func(ins, opcode, opcode_token, p, len, priv);
1372 }
1373 else
1374 {
1375 enum wined3d_shader_dst_modifier instruction_dst_modifier = WINED3DSPDM_NONE;
1376
1377 ins->flags = (opcode_token & WINED3D_SM4_INSTRUCTION_FLAGS_MASK) >> WINED3D_SM4_INSTRUCTION_FLAGS_SHIFT;
1378
1379 if (ins->flags & WINED3D_SM4_INSTRUCTION_FLAG_SATURATE)
1380 {
1381 ins->flags &= ~WINED3D_SM4_INSTRUCTION_FLAG_SATURATE;
1382 instruction_dst_modifier = WINED3DSPDM_SATURATE;
1383 }
1384
1385 for (i = 0; i < ins->dst_count; ++i)
1386 {
1387 if (!(shader_sm4_read_dst_param(priv, &p, map_data_type(opcode_info->dst_info[i]), &priv->dst_param[i])))
1388 {
1389 ins->handler_idx = WINED3DSIH_TABLE_SIZE;
1390 return;
1391 }
1392 priv->dst_param[i].modifiers |= instruction_dst_modifier;
1393 }
1394
1395 for (i = 0; i < ins->src_count; ++i)
1396 {
1397 if (!(shader_sm4_read_src_param(priv, &p, map_data_type(opcode_info->src_info[i]), &priv->src_param[i])))
1398 {
1399 ins->handler_idx = WINED3DSIH_TABLE_SIZE;
1400 return;
1401 }
1402 }
1403 }
1404 }
1405
1406 static BOOL shader_sm4_is_end(void *data, const DWORD **ptr)
1407 {
1408 struct wined3d_sm4_data *priv = data;
1409 return *ptr == priv->end;
1410 }
1411
1412 const struct wined3d_shader_frontend sm4_shader_frontend =
1413 {
1414 shader_sm4_init,
1415 shader_sm4_free,
1416 shader_sm4_read_header,
1417 shader_sm4_read_instruction,
1418 shader_sm4_is_end,
1419 };
Windows API implementation