projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
i965: Normalize cubemap coordinates like is done in the Mesa IR path.
[mesa.git] / src / mesa / drivers / dri / i965 / brw_eu_emit.c
1 /*
2 Copyright (C) Intel Corp. 2006. All Rights Reserved.
3 Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
4 develop this 3D driver.
5
6 Permission is hereby granted, free of charge, to any person obtaining
7 a copy of this software and associated documentation files (the
8 "Software"), to deal in the Software without restriction, including
9 without limitation the rights to use, copy, modify, merge, publish,
10 distribute, sublicense, and/or sell copies of the Software, and to
11 permit persons to whom the Software is furnished to do so, subject to
12 the following conditions:
13
14 The above copyright notice and this permission notice (including the
15 next paragraph) shall be included in all copies or substantial
16 portions of the Software.
17
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25
26 **********************************************************************/
27 /*
28 * Authors:
29 * Keith Whitwell <keith@tungstengraphics.com>
30 */
31
32
33 #include "brw_context.h"
34 #include "brw_defines.h"
35 #include "brw_eu.h"
36
37
38
39
40 /***********************************************************************
41 * Internal helper for constructing instructions
42 */
43
44 static void guess_execution_size( struct brw_instruction *insn,
45 struct brw_reg reg )
46 {
47 if (reg.width == BRW_WIDTH_8 &&
48 insn->header.compression_control == BRW_COMPRESSION_COMPRESSED)
49 insn->header.execution_size = BRW_EXECUTE_16;
50 else
51 insn->header.execution_size = reg.width; /* note - definitions are compatible */
52 }
53
54
55 static void brw_set_dest( struct brw_instruction *insn,
56 struct brw_reg dest )
57 {
58 if (dest.file != BRW_ARCHITECTURE_REGISTER_FILE &&
59 dest.file != BRW_MESSAGE_REGISTER_FILE)
60 assert(dest.nr < 128);
61
62 insn->bits1.da1.dest_reg_file = dest.file;
63 insn->bits1.da1.dest_reg_type = dest.type;
64 insn->bits1.da1.dest_address_mode = dest.address_mode;
65
66 if (dest.address_mode == BRW_ADDRESS_DIRECT) {
67 insn->bits1.da1.dest_reg_nr = dest.nr;
68
69 if (insn->header.access_mode == BRW_ALIGN_1) {
70 insn->bits1.da1.dest_subreg_nr = dest.subnr;
71 if (dest.hstride == BRW_HORIZONTAL_STRIDE_0)
72 dest.hstride = BRW_HORIZONTAL_STRIDE_1;
73 insn->bits1.da1.dest_horiz_stride = dest.hstride;
74 }
75 else {
76 insn->bits1.da16.dest_subreg_nr = dest.subnr / 16;
77 insn->bits1.da16.dest_writemask = dest.dw1.bits.writemask;
78 /* even ignored in da16, still need to set as '01' */
79 insn->bits1.da16.dest_horiz_stride = 1;
80 }
81 }
82 else {
83 insn->bits1.ia1.dest_subreg_nr = dest.subnr;
84
85 /* These are different sizes in align1 vs align16:
86 */
87 if (insn->header.access_mode == BRW_ALIGN_1) {
88 insn->bits1.ia1.dest_indirect_offset = dest.dw1.bits.indirect_offset;
89 if (dest.hstride == BRW_HORIZONTAL_STRIDE_0)
90 dest.hstride = BRW_HORIZONTAL_STRIDE_1;
91 insn->bits1.ia1.dest_horiz_stride = dest.hstride;
92 }
93 else {
94 insn->bits1.ia16.dest_indirect_offset = dest.dw1.bits.indirect_offset;
95 /* even ignored in da16, still need to set as '01' */
96 insn->bits1.ia16.dest_horiz_stride = 1;
97 }
98 }
99
100 /* NEW: Set the execution size based on dest.width and
101 * insn->compression_control:
102 */
103 guess_execution_size(insn, dest);
104 }
105
106 extern int reg_type_size[];
107
108 static void
109 validate_reg(struct brw_instruction *insn, struct brw_reg reg)
110 {
111 int hstride_for_reg[] = {0, 1, 2, 4};
112 int vstride_for_reg[] = {0, 1, 2, 4, 8, 16, 32, 64, 128, 256};
113 int width_for_reg[] = {1, 2, 4, 8, 16};
114 int execsize_for_reg[] = {1, 2, 4, 8, 16};
115 int width, hstride, vstride, execsize;
116
117 if (reg.file == BRW_IMMEDIATE_VALUE) {
118 /* 3.3.6: Region Parameters. Restriction: Immediate vectors
119 * mean the destination has to be 128-bit aligned and the
120 * destination horiz stride has to be a word.
121 */
122 if (reg.type == BRW_REGISTER_TYPE_V) {
123 assert(hstride_for_reg[insn->bits1.da1.dest_horiz_stride] *
124 reg_type_size[insn->bits1.da1.dest_reg_type] == 2);
125 }
126
127 return;
128 }
129
130 if (reg.file == BRW_ARCHITECTURE_REGISTER_FILE &&
131 reg.file == BRW_ARF_NULL)
132 return;
133
134 assert(reg.hstride >= 0 && reg.hstride < Elements(hstride_for_reg));
135 hstride = hstride_for_reg[reg.hstride];
136
137 if (reg.vstride == 0xf) {
138 vstride = -1;
139 } else {
140 assert(reg.vstride >= 0 && reg.vstride < Elements(vstride_for_reg));
141 vstride = vstride_for_reg[reg.vstride];
142 }
143
144 assert(reg.width >= 0 && reg.width < Elements(width_for_reg));
145 width = width_for_reg[reg.width];
146
147 assert(insn->header.execution_size >= 0 &&
148 insn->header.execution_size < Elements(execsize_for_reg));
149 execsize = execsize_for_reg[insn->header.execution_size];
150
151 /* Restrictions from 3.3.10: Register Region Restrictions. */
152 /* 3. */
153 assert(execsize >= width);
154
155 /* 4. */
156 if (execsize == width && hstride != 0) {
157 assert(vstride == -1 || vstride == width * hstride);
158 }
159
160 /* 5. */
161 if (execsize == width && hstride == 0) {
162 /* no restriction on vstride. */
163 }
164
165 /* 6. */
166 if (width == 1) {
167 assert(hstride == 0);
168 }
169
170 /* 7. */
171 if (execsize == 1 && width == 1) {
172 assert(hstride == 0);
173 assert(vstride == 0);
174 }
175
176 /* 8. */
177 if (vstride == 0 && hstride == 0) {
178 assert(width == 1);
179 }
180
181 /* 10. Check destination issues. */
182 }
183
184 static void brw_set_src0( struct brw_instruction *insn,
185 struct brw_reg reg )
186 {
187 if (reg.type != BRW_ARCHITECTURE_REGISTER_FILE)
188 assert(reg.nr < 128);
189
190 validate_reg(insn, reg);
191
192 insn->bits1.da1.src0_reg_file = reg.file;
193 insn->bits1.da1.src0_reg_type = reg.type;
194 insn->bits2.da1.src0_abs = reg.abs;
195 insn->bits2.da1.src0_negate = reg.negate;
196 insn->bits2.da1.src0_address_mode = reg.address_mode;
197
198 if (reg.file == BRW_IMMEDIATE_VALUE) {
199 insn->bits3.ud = reg.dw1.ud;
200
201 /* Required to set some fields in src1 as well:
202 */
203 insn->bits1.da1.src1_reg_file = 0; /* arf */
204 insn->bits1.da1.src1_reg_type = reg.type;
205 }
206 else
207 {
208 if (reg.address_mode == BRW_ADDRESS_DIRECT) {
209 if (insn->header.access_mode == BRW_ALIGN_1) {
210 insn->bits2.da1.src0_subreg_nr = reg.subnr;
211 insn->bits2.da1.src0_reg_nr = reg.nr;
212 }
213 else {
214 insn->bits2.da16.src0_subreg_nr = reg.subnr / 16;
215 insn->bits2.da16.src0_reg_nr = reg.nr;
216 }
217 }
218 else {
219 insn->bits2.ia1.src0_subreg_nr = reg.subnr;
220
221 if (insn->header.access_mode == BRW_ALIGN_1) {
222 insn->bits2.ia1.src0_indirect_offset = reg.dw1.bits.indirect_offset;
223 }
224 else {
225 insn->bits2.ia16.src0_subreg_nr = reg.dw1.bits.indirect_offset;
226 }
227 }
228
229 if (insn->header.access_mode == BRW_ALIGN_1) {
230 if (reg.width == BRW_WIDTH_1 &&
231 insn->header.execution_size == BRW_EXECUTE_1) {
232 insn->bits2.da1.src0_horiz_stride = BRW_HORIZONTAL_STRIDE_0;
233 insn->bits2.da1.src0_width = BRW_WIDTH_1;
234 insn->bits2.da1.src0_vert_stride = BRW_VERTICAL_STRIDE_0;
235 }
236 else {
237 insn->bits2.da1.src0_horiz_stride = reg.hstride;
238 insn->bits2.da1.src0_width = reg.width;
239 insn->bits2.da1.src0_vert_stride = reg.vstride;
240 }
241 }
242 else {
243 insn->bits2.da16.src0_swz_x = BRW_GET_SWZ(reg.dw1.bits.swizzle, BRW_CHANNEL_X);
244 insn->bits2.da16.src0_swz_y = BRW_GET_SWZ(reg.dw1.bits.swizzle, BRW_CHANNEL_Y);
245 insn->bits2.da16.src0_swz_z = BRW_GET_SWZ(reg.dw1.bits.swizzle, BRW_CHANNEL_Z);
246 insn->bits2.da16.src0_swz_w = BRW_GET_SWZ(reg.dw1.bits.swizzle, BRW_CHANNEL_W);
247
248 /* This is an oddity of the fact we're using the same
249 * descriptions for registers in align_16 as align_1:
250 */
251 if (reg.vstride == BRW_VERTICAL_STRIDE_8)
252 insn->bits2.da16.src0_vert_stride = BRW_VERTICAL_STRIDE_4;
253 else
254 insn->bits2.da16.src0_vert_stride = reg.vstride;
255 }
256 }
257 }
258
259
260 void brw_set_src1( struct brw_instruction *insn,
261 struct brw_reg reg )
262 {
263 assert(reg.file != BRW_MESSAGE_REGISTER_FILE);
264
265 assert(reg.nr < 128);
266
267 validate_reg(insn, reg);
268
269 insn->bits1.da1.src1_reg_file = reg.file;
270 insn->bits1.da1.src1_reg_type = reg.type;
271 insn->bits3.da1.src1_abs = reg.abs;
272 insn->bits3.da1.src1_negate = reg.negate;
273
274 /* Only src1 can be immediate in two-argument instructions.
275 */
276 assert(insn->bits1.da1.src0_reg_file != BRW_IMMEDIATE_VALUE);
277
278 if (reg.file == BRW_IMMEDIATE_VALUE) {
279 insn->bits3.ud = reg.dw1.ud;
280 }
281 else {
282 /* This is a hardware restriction, which may or may not be lifted
283 * in the future:
284 */
285 assert (reg.address_mode == BRW_ADDRESS_DIRECT);
286 /* assert (reg.file == BRW_GENERAL_REGISTER_FILE); */
287
288 if (insn->header.access_mode == BRW_ALIGN_1) {
289 insn->bits3.da1.src1_subreg_nr = reg.subnr;
290 insn->bits3.da1.src1_reg_nr = reg.nr;
291 }
292 else {
293 insn->bits3.da16.src1_subreg_nr = reg.subnr / 16;
294 insn->bits3.da16.src1_reg_nr = reg.nr;
295 }
296
297 if (insn->header.access_mode == BRW_ALIGN_1) {
298 if (reg.width == BRW_WIDTH_1 &&
299 insn->header.execution_size == BRW_EXECUTE_1) {
300 insn->bits3.da1.src1_horiz_stride = BRW_HORIZONTAL_STRIDE_0;
301 insn->bits3.da1.src1_width = BRW_WIDTH_1;
302 insn->bits3.da1.src1_vert_stride = BRW_VERTICAL_STRIDE_0;
303 }
304 else {
305 insn->bits3.da1.src1_horiz_stride = reg.hstride;
306 insn->bits3.da1.src1_width = reg.width;
307 insn->bits3.da1.src1_vert_stride = reg.vstride;
308 }
309 }
310 else {
311 insn->bits3.da16.src1_swz_x = BRW_GET_SWZ(reg.dw1.bits.swizzle, BRW_CHANNEL_X);
312 insn->bits3.da16.src1_swz_y = BRW_GET_SWZ(reg.dw1.bits.swizzle, BRW_CHANNEL_Y);
313 insn->bits3.da16.src1_swz_z = BRW_GET_SWZ(reg.dw1.bits.swizzle, BRW_CHANNEL_Z);
314 insn->bits3.da16.src1_swz_w = BRW_GET_SWZ(reg.dw1.bits.swizzle, BRW_CHANNEL_W);
315
316 /* This is an oddity of the fact we're using the same
317 * descriptions for registers in align_16 as align_1:
318 */
319 if (reg.vstride == BRW_VERTICAL_STRIDE_8)
320 insn->bits3.da16.src1_vert_stride = BRW_VERTICAL_STRIDE_4;
321 else
322 insn->bits3.da16.src1_vert_stride = reg.vstride;
323 }
324 }
325 }
326
327
328
329 static void brw_set_math_message( struct brw_context *brw,
330 struct brw_instruction *insn,
331 GLuint msg_length,
332 GLuint response_length,
333 GLuint function,
334 GLuint integer_type,
335 GLboolean low_precision,
336 GLboolean saturate,
337 GLuint dataType )
338 {
339 struct intel_context *intel = &brw->intel;
340 brw_set_src1(insn, brw_imm_d(0));
341
342 if (intel->gen == 5) {
343 insn->bits3.math_gen5.function = function;
344 insn->bits3.math_gen5.int_type = integer_type;
345 insn->bits3.math_gen5.precision = low_precision;
346 insn->bits3.math_gen5.saturate = saturate;
347 insn->bits3.math_gen5.data_type = dataType;
348 insn->bits3.math_gen5.snapshot = 0;
349 insn->bits3.math_gen5.header_present = 0;
350 insn->bits3.math_gen5.response_length = response_length;
351 insn->bits3.math_gen5.msg_length = msg_length;
352 insn->bits3.math_gen5.end_of_thread = 0;
353 insn->bits2.send_gen5.sfid = BRW_MESSAGE_TARGET_MATH;
354 insn->bits2.send_gen5.end_of_thread = 0;
355 } else {
356 insn->bits3.math.function = function;
357 insn->bits3.math.int_type = integer_type;
358 insn->bits3.math.precision = low_precision;
359 insn->bits3.math.saturate = saturate;
360 insn->bits3.math.data_type = dataType;
361 insn->bits3.math.response_length = response_length;
362 insn->bits3.math.msg_length = msg_length;
363 insn->bits3.math.msg_target = BRW_MESSAGE_TARGET_MATH;
364 insn->bits3.math.end_of_thread = 0;
365 }
366 }
367
368
369 static void brw_set_ff_sync_message(struct brw_context *brw,
370 struct brw_instruction *insn,
371 GLboolean allocate,
372 GLuint response_length,
373 GLboolean end_of_thread)
374 {
375 struct intel_context *intel = &brw->intel;
376 brw_set_src1(insn, brw_imm_d(0));
377
378 insn->bits3.urb_gen5.opcode = 1; /* FF_SYNC */
379 insn->bits3.urb_gen5.offset = 0; /* Not used by FF_SYNC */
380 insn->bits3.urb_gen5.swizzle_control = 0; /* Not used by FF_SYNC */
381 insn->bits3.urb_gen5.allocate = allocate;
382 insn->bits3.urb_gen5.used = 0; /* Not used by FF_SYNC */
383 insn->bits3.urb_gen5.complete = 0; /* Not used by FF_SYNC */
384 insn->bits3.urb_gen5.header_present = 1;
385 insn->bits3.urb_gen5.response_length = response_length; /* may be 1 or 0 */
386 insn->bits3.urb_gen5.msg_length = 1;
387 insn->bits3.urb_gen5.end_of_thread = end_of_thread;
388 if (intel->gen >= 6) {
389 insn->header.destreg__conditionalmod = BRW_MESSAGE_TARGET_URB;
390 } else {
391 insn->bits2.send_gen5.sfid = BRW_MESSAGE_TARGET_URB;
392 insn->bits2.send_gen5.end_of_thread = end_of_thread;
393 }
394 }
395
396 static void brw_set_urb_message( struct brw_context *brw,
397 struct brw_instruction *insn,
398 GLboolean allocate,
399 GLboolean used,
400 GLuint msg_length,
401 GLuint response_length,
402 GLboolean end_of_thread,
403 GLboolean complete,
404 GLuint offset,
405 GLuint swizzle_control )
406 {
407 struct intel_context *intel = &brw->intel;
408 brw_set_src1(insn, brw_imm_d(0));
409
410 if (intel->gen >= 5) {
411 insn->bits3.urb_gen5.opcode = 0; /* ? */
412 insn->bits3.urb_gen5.offset = offset;
413 insn->bits3.urb_gen5.swizzle_control = swizzle_control;
414 insn->bits3.urb_gen5.allocate = allocate;
415 insn->bits3.urb_gen5.used = used; /* ? */
416 insn->bits3.urb_gen5.complete = complete;
417 insn->bits3.urb_gen5.header_present = 1;
418 insn->bits3.urb_gen5.response_length = response_length;
419 insn->bits3.urb_gen5.msg_length = msg_length;
420 insn->bits3.urb_gen5.end_of_thread = end_of_thread;
421 if (intel->gen >= 6) {
422 /* For SNB, the SFID bits moved to the condmod bits, and
423 * EOT stayed in bits3 above. Does the EOT bit setting
424 * below on Ironlake even do anything?
425 */
426 insn->header.destreg__conditionalmod = BRW_MESSAGE_TARGET_URB;
427 } else {
428 insn->bits2.send_gen5.sfid = BRW_MESSAGE_TARGET_URB;
429 insn->bits2.send_gen5.end_of_thread = end_of_thread;
430 }
431 } else {
432 insn->bits3.urb.opcode = 0; /* ? */
433 insn->bits3.urb.offset = offset;
434 insn->bits3.urb.swizzle_control = swizzle_control;
435 insn->bits3.urb.allocate = allocate;
436 insn->bits3.urb.used = used; /* ? */
437 insn->bits3.urb.complete = complete;
438 insn->bits3.urb.response_length = response_length;
439 insn->bits3.urb.msg_length = msg_length;
440 insn->bits3.urb.msg_target = BRW_MESSAGE_TARGET_URB;
441 insn->bits3.urb.end_of_thread = end_of_thread;
442 }
443 }
444
445 static void brw_set_dp_write_message( struct brw_context *brw,
446 struct brw_instruction *insn,
447 GLuint binding_table_index,
448 GLuint msg_control,
449 GLuint msg_type,
450 GLuint msg_length,
451 GLboolean header_present,
452 GLuint pixel_scoreboard_clear,
453 GLuint response_length,
454 GLuint end_of_thread,
455 GLuint send_commit_msg)
456 {
457 struct intel_context *intel = &brw->intel;
458 brw_set_src1(insn, brw_imm_ud(0));
459
460 if (intel->gen >= 6) {
461 insn->bits3.dp_render_cache.binding_table_index = binding_table_index;
462 insn->bits3.dp_render_cache.msg_control = msg_control;
463 insn->bits3.dp_render_cache.pixel_scoreboard_clear = pixel_scoreboard_clear;
464 insn->bits3.dp_render_cache.msg_type = msg_type;
465 insn->bits3.dp_render_cache.send_commit_msg = send_commit_msg;
466 insn->bits3.dp_render_cache.header_present = header_present;
467 insn->bits3.dp_render_cache.response_length = response_length;
468 insn->bits3.dp_render_cache.msg_length = msg_length;
469 insn->bits3.dp_render_cache.end_of_thread = end_of_thread;
470 insn->header.destreg__conditionalmod = BRW_MESSAGE_TARGET_DATAPORT_WRITE;
471 /* XXX really need below? */
472 insn->bits2.send_gen5.sfid = BRW_MESSAGE_TARGET_DATAPORT_WRITE;
473 insn->bits2.send_gen5.end_of_thread = end_of_thread;
474 } else if (intel->gen == 5) {
475 insn->bits3.dp_write_gen5.binding_table_index = binding_table_index;
476 insn->bits3.dp_write_gen5.msg_control = msg_control;
477 insn->bits3.dp_write_gen5.pixel_scoreboard_clear = pixel_scoreboard_clear;
478 insn->bits3.dp_write_gen5.msg_type = msg_type;
479 insn->bits3.dp_write_gen5.send_commit_msg = send_commit_msg;
480 insn->bits3.dp_write_gen5.header_present = header_present;
481 insn->bits3.dp_write_gen5.response_length = response_length;
482 insn->bits3.dp_write_gen5.msg_length = msg_length;
483 insn->bits3.dp_write_gen5.end_of_thread = end_of_thread;
484 insn->bits2.send_gen5.sfid = BRW_MESSAGE_TARGET_DATAPORT_WRITE;
485 insn->bits2.send_gen5.end_of_thread = end_of_thread;
486 } else {
487 insn->bits3.dp_write.binding_table_index = binding_table_index;
488 insn->bits3.dp_write.msg_control = msg_control;
489 insn->bits3.dp_write.pixel_scoreboard_clear = pixel_scoreboard_clear;
490 insn->bits3.dp_write.msg_type = msg_type;
491 insn->bits3.dp_write.send_commit_msg = send_commit_msg;
492 insn->bits3.dp_write.response_length = response_length;
493 insn->bits3.dp_write.msg_length = msg_length;
494 insn->bits3.dp_write.msg_target = BRW_MESSAGE_TARGET_DATAPORT_WRITE;
495 insn->bits3.dp_write.end_of_thread = end_of_thread;
496 }
497 }
498
499 static void brw_set_dp_read_message( struct brw_context *brw,
500 struct brw_instruction *insn,
501 GLuint binding_table_index,
502 GLuint msg_control,
503 GLuint msg_type,
504 GLuint target_cache,
505 GLuint msg_length,
506 GLuint response_length,
507 GLuint end_of_thread )
508 {
509 struct intel_context *intel = &brw->intel;
510 brw_set_src1(insn, brw_imm_d(0));
511
512 if (intel->gen == 5) {
513 insn->bits3.dp_read_gen5.binding_table_index = binding_table_index;
514 insn->bits3.dp_read_gen5.msg_control = msg_control;
515 insn->bits3.dp_read_gen5.msg_type = msg_type;
516 insn->bits3.dp_read_gen5.target_cache = target_cache;
517 insn->bits3.dp_read_gen5.header_present = 1;
518 insn->bits3.dp_read_gen5.response_length = response_length;
519 insn->bits3.dp_read_gen5.msg_length = msg_length;
520 insn->bits3.dp_read_gen5.pad1 = 0;
521 insn->bits3.dp_read_gen5.end_of_thread = end_of_thread;
522 insn->bits2.send_gen5.sfid = BRW_MESSAGE_TARGET_DATAPORT_READ;
523 insn->bits2.send_gen5.end_of_thread = end_of_thread;
524 } else {
525 insn->bits3.dp_read.binding_table_index = binding_table_index; /*0:7*/
526 insn->bits3.dp_read.msg_control = msg_control; /*8:11*/
527 insn->bits3.dp_read.msg_type = msg_type; /*12:13*/
528 insn->bits3.dp_read.target_cache = target_cache; /*14:15*/
529 insn->bits3.dp_read.response_length = response_length; /*16:19*/
530 insn->bits3.dp_read.msg_length = msg_length; /*20:23*/
531 insn->bits3.dp_read.msg_target = BRW_MESSAGE_TARGET_DATAPORT_READ; /*24:27*/
532 insn->bits3.dp_read.pad1 = 0; /*28:30*/
533 insn->bits3.dp_read.end_of_thread = end_of_thread; /*31*/
534 }
535 }
536
537 static void brw_set_sampler_message(struct brw_context *brw,
538 struct brw_instruction *insn,
539 GLuint binding_table_index,
540 GLuint sampler,
541 GLuint msg_type,
542 GLuint response_length,
543 GLuint msg_length,
544 GLboolean eot,
545 GLuint header_present,
546 GLuint simd_mode)
547 {
548 struct intel_context *intel = &brw->intel;
549 assert(eot == 0);
550 brw_set_src1(insn, brw_imm_d(0));
551
552 if (intel->gen >= 5) {
553 insn->bits3.sampler_gen5.binding_table_index = binding_table_index;
554 insn->bits3.sampler_gen5.sampler = sampler;
555 insn->bits3.sampler_gen5.msg_type = msg_type;
556 insn->bits3.sampler_gen5.simd_mode = simd_mode;
557 insn->bits3.sampler_gen5.header_present = header_present;
558 insn->bits3.sampler_gen5.response_length = response_length;
559 insn->bits3.sampler_gen5.msg_length = msg_length;
560 insn->bits3.sampler_gen5.end_of_thread = eot;
561 if (intel->gen >= 6)
562 insn->header.destreg__conditionalmod = BRW_MESSAGE_TARGET_SAMPLER;
563 else {
564 insn->bits2.send_gen5.sfid = BRW_MESSAGE_TARGET_SAMPLER;
565 insn->bits2.send_gen5.end_of_thread = eot;
566 }
567 } else if (intel->is_g4x) {
568 insn->bits3.sampler_g4x.binding_table_index = binding_table_index;
569 insn->bits3.sampler_g4x.sampler = sampler;
570 insn->bits3.sampler_g4x.msg_type = msg_type;
571 insn->bits3.sampler_g4x.response_length = response_length;
572 insn->bits3.sampler_g4x.msg_length = msg_length;
573 insn->bits3.sampler_g4x.end_of_thread = eot;
574 insn->bits3.sampler_g4x.msg_target = BRW_MESSAGE_TARGET_SAMPLER;
575 } else {
576 insn->bits3.sampler.binding_table_index = binding_table_index;
577 insn->bits3.sampler.sampler = sampler;
578 insn->bits3.sampler.msg_type = msg_type;
579 insn->bits3.sampler.return_format = BRW_SAMPLER_RETURN_FORMAT_FLOAT32;
580 insn->bits3.sampler.response_length = response_length;
581 insn->bits3.sampler.msg_length = msg_length;
582 insn->bits3.sampler.end_of_thread = eot;
583 insn->bits3.sampler.msg_target = BRW_MESSAGE_TARGET_SAMPLER;
584 }
585 }
586
587
588
589 static struct brw_instruction *next_insn( struct brw_compile *p,
590 GLuint opcode )
591 {
592 struct brw_instruction *insn;
593
594 assert(p->nr_insn + 1 < BRW_EU_MAX_INSN);
595
596 insn = &p->store[p->nr_insn++];
597 memcpy(insn, p->current, sizeof(*insn));
598
599 /* Reset this one-shot flag:
600 */
601
602 if (p->current->header.destreg__conditionalmod) {
603 p->current->header.destreg__conditionalmod = 0;
604 p->current->header.predicate_control = BRW_PREDICATE_NORMAL;
605 }
606
607 insn->header.opcode = opcode;
608 return insn;
609 }
610
611
612 static struct brw_instruction *brw_alu1( struct brw_compile *p,
613 GLuint opcode,
614 struct brw_reg dest,
615 struct brw_reg src )
616 {
617 struct brw_instruction *insn = next_insn(p, opcode);
618 brw_set_dest(insn, dest);
619 brw_set_src0(insn, src);
620 return insn;
621 }
622
623 static struct brw_instruction *brw_alu2(struct brw_compile *p,
624 GLuint opcode,
625 struct brw_reg dest,
626 struct brw_reg src0,
627 struct brw_reg src1 )
628 {
629 struct brw_instruction *insn = next_insn(p, opcode);
630 brw_set_dest(insn, dest);
631 brw_set_src0(insn, src0);
632 brw_set_src1(insn, src1);
633 return insn;
634 }
635
636
637 /***********************************************************************
638 * Convenience routines.
639 */
640 #define ALU1(OP) \
641 struct brw_instruction *brw_##OP(struct brw_compile *p, \
642 struct brw_reg dest, \
643 struct brw_reg src0) \
644 { \
645 return brw_alu1(p, BRW_OPCODE_##OP, dest, src0); \
646 }
647
648 #define ALU2(OP) \
649 struct brw_instruction *brw_##OP(struct brw_compile *p, \
650 struct brw_reg dest, \
651 struct brw_reg src0, \
652 struct brw_reg src1) \
653 { \
654 return brw_alu2(p, BRW_OPCODE_##OP, dest, src0, src1); \
655 }
656
657
658 ALU1(MOV)
659 ALU2(SEL)
660 ALU1(NOT)
661 ALU2(AND)
662 ALU2(OR)
663 ALU2(XOR)
664 ALU2(SHR)
665 ALU2(SHL)
666 ALU2(RSR)
667 ALU2(RSL)
668 ALU2(ASR)
669 ALU1(FRC)
670 ALU1(RNDD)
671 ALU1(RNDZ)
672 ALU2(MAC)
673 ALU2(MACH)
674 ALU1(LZD)
675 ALU2(DP4)
676 ALU2(DPH)
677 ALU2(DP3)
678 ALU2(DP2)
679 ALU2(LINE)
680 ALU2(PLN)
681
682 struct brw_instruction *brw_ADD(struct brw_compile *p,
683 struct brw_reg dest,
684 struct brw_reg src0,
685 struct brw_reg src1)
686 {
687 /* 6.2.2: add */
688 if (src0.type == BRW_REGISTER_TYPE_F ||
689 (src0.file == BRW_IMMEDIATE_VALUE &&
690 src0.type == BRW_REGISTER_TYPE_VF)) {
691 assert(src1.type != BRW_REGISTER_TYPE_UD);
692 assert(src1.type != BRW_REGISTER_TYPE_D);
693 }
694
695 if (src1.type == BRW_REGISTER_TYPE_F ||
696 (src1.file == BRW_IMMEDIATE_VALUE &&
697 src1.type == BRW_REGISTER_TYPE_VF)) {
698 assert(src0.type != BRW_REGISTER_TYPE_UD);
699 assert(src0.type != BRW_REGISTER_TYPE_D);
700 }
701
702 return brw_alu2(p, BRW_OPCODE_ADD, dest, src0, src1);
703 }
704
705 struct brw_instruction *brw_MUL(struct brw_compile *p,
706 struct brw_reg dest,
707 struct brw_reg src0,
708 struct brw_reg src1)
709 {
710 /* 6.32.38: mul */
711 if (src0.type == BRW_REGISTER_TYPE_D ||
712 src0.type == BRW_REGISTER_TYPE_UD ||
713 src1.type == BRW_REGISTER_TYPE_D ||
714 src1.type == BRW_REGISTER_TYPE_UD) {
715 assert(dest.type != BRW_REGISTER_TYPE_F);
716 }
717
718 if (src0.type == BRW_REGISTER_TYPE_F ||
719 (src0.file == BRW_IMMEDIATE_VALUE &&
720 src0.type == BRW_REGISTER_TYPE_VF)) {
721 assert(src1.type != BRW_REGISTER_TYPE_UD);
722 assert(src1.type != BRW_REGISTER_TYPE_D);
723 }
724
725 if (src1.type == BRW_REGISTER_TYPE_F ||
726 (src1.file == BRW_IMMEDIATE_VALUE &&
727 src1.type == BRW_REGISTER_TYPE_VF)) {
728 assert(src0.type != BRW_REGISTER_TYPE_UD);
729 assert(src0.type != BRW_REGISTER_TYPE_D);
730 }
731
732 assert(src0.file != BRW_ARCHITECTURE_REGISTER_FILE ||
733 src0.nr != BRW_ARF_ACCUMULATOR);
734 assert(src1.file != BRW_ARCHITECTURE_REGISTER_FILE ||
735 src1.nr != BRW_ARF_ACCUMULATOR);
736
737 return brw_alu2(p, BRW_OPCODE_MUL, dest, src0, src1);
738 }
739
740
741 void brw_NOP(struct brw_compile *p)
742 {
743 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_NOP);
744 brw_set_dest(insn, retype(brw_vec4_grf(0,0), BRW_REGISTER_TYPE_UD));
745 brw_set_src0(insn, retype(brw_vec4_grf(0,0), BRW_REGISTER_TYPE_UD));
746 brw_set_src1(insn, brw_imm_ud(0x0));
747 }
748
749
750
751
752
753 /***********************************************************************
754 * Comparisons, if/else/endif
755 */
756
757 struct brw_instruction *brw_JMPI(struct brw_compile *p,
758 struct brw_reg dest,
759 struct brw_reg src0,
760 struct brw_reg src1)
761 {
762 struct brw_instruction *insn = brw_alu2(p, BRW_OPCODE_JMPI, dest, src0, src1);
763
764 insn->header.execution_size = 1;
765 insn->header.compression_control = BRW_COMPRESSION_NONE;
766 insn->header.mask_control = BRW_MASK_DISABLE;
767
768 p->current->header.predicate_control = BRW_PREDICATE_NONE;
769
770 return insn;
771 }
772
773 /* EU takes the value from the flag register and pushes it onto some
774 * sort of a stack (presumably merging with any flag value already on
775 * the stack). Within an if block, the flags at the top of the stack
776 * control execution on each channel of the unit, eg. on each of the
777 * 16 pixel values in our wm programs.
778 *
779 * When the matching 'else' instruction is reached (presumably by
780 * countdown of the instruction count patched in by our ELSE/ENDIF
781 * functions), the relevent flags are inverted.
782 *
783 * When the matching 'endif' instruction is reached, the flags are
784 * popped off. If the stack is now empty, normal execution resumes.
785 *
786 * No attempt is made to deal with stack overflow (14 elements?).
787 */
788 struct brw_instruction *brw_IF(struct brw_compile *p, GLuint execute_size)
789 {
790 struct intel_context *intel = &p->brw->intel;
791 struct brw_instruction *insn;
792
793 if (p->single_program_flow) {
794 assert(execute_size == BRW_EXECUTE_1);
795
796 insn = next_insn(p, BRW_OPCODE_ADD);
797 insn->header.predicate_inverse = 1;
798 } else {
799 insn = next_insn(p, BRW_OPCODE_IF);
800 }
801
802 /* Override the defaults for this instruction:
803 */
804 if (intel->gen < 6) {
805 brw_set_dest(insn, brw_ip_reg());
806 brw_set_src0(insn, brw_ip_reg());
807 brw_set_src1(insn, brw_imm_d(0x0));
808 } else {
809 brw_set_dest(insn, brw_imm_w(0));
810 brw_set_src0(insn, brw_null_reg());
811 brw_set_src1(insn, brw_null_reg());
812 }
813
814 insn->header.execution_size = execute_size;
815 insn->header.compression_control = BRW_COMPRESSION_NONE;
816 insn->header.predicate_control = BRW_PREDICATE_NORMAL;
817 insn->header.mask_control = BRW_MASK_ENABLE;
818 if (!p->single_program_flow)
819 insn->header.thread_control = BRW_THREAD_SWITCH;
820
821 p->current->header.predicate_control = BRW_PREDICATE_NONE;
822
823 return insn;
824 }
825
826
827 struct brw_instruction *brw_ELSE(struct brw_compile *p,
828 struct brw_instruction *if_insn)
829 {
830 struct intel_context *intel = &p->brw->intel;
831 struct brw_instruction *insn;
832 GLuint br = 1;
833
834 /* jump count is for 64bit data chunk each, so one 128bit
835 instruction requires 2 chunks. */
836 if (intel->gen >= 5)
837 br = 2;
838
839 if (p->single_program_flow) {
840 insn = next_insn(p, BRW_OPCODE_ADD);
841 } else {
842 insn = next_insn(p, BRW_OPCODE_ELSE);
843 }
844
845 if (intel->gen < 6) {
846 brw_set_dest(insn, brw_ip_reg());
847 brw_set_src0(insn, brw_ip_reg());
848 brw_set_src1(insn, brw_imm_d(0x0));
849 } else {
850 brw_set_dest(insn, brw_imm_w(0));
851 brw_set_src0(insn, brw_null_reg());
852 brw_set_src1(insn, brw_null_reg());
853 }
854
855 insn->header.compression_control = BRW_COMPRESSION_NONE;
856 insn->header.execution_size = if_insn->header.execution_size;
857 insn->header.mask_control = BRW_MASK_ENABLE;
858 if (!p->single_program_flow)
859 insn->header.thread_control = BRW_THREAD_SWITCH;
860
861 /* Patch the if instruction to point at this instruction.
862 */
863 if (p->single_program_flow) {
864 assert(if_insn->header.opcode == BRW_OPCODE_ADD);
865
866 if_insn->bits3.ud = (insn - if_insn + 1) * 16;
867 } else {
868 assert(if_insn->header.opcode == BRW_OPCODE_IF);
869
870 if (intel->gen < 6) {
871 if_insn->bits3.if_else.jump_count = br * (insn - if_insn);
872 if_insn->bits3.if_else.pop_count = 0;
873 if_insn->bits3.if_else.pad0 = 0;
874 } else {
875 if_insn->bits1.branch_gen6.jump_count = br * (insn - if_insn + 1);
876 }
877 }
878
879 return insn;
880 }
881
882 void brw_ENDIF(struct brw_compile *p,
883 struct brw_instruction *patch_insn)
884 {
885 struct intel_context *intel = &p->brw->intel;
886 GLuint br = 1;
887
888 if (intel->gen >= 5)
889 br = 2;
890
891 if (p->single_program_flow) {
892 /* In single program flow mode, there's no need to execute an ENDIF,
893 * since we don't need to do any stack operations, and if we're executing
894 * currently, we want to just continue executing.
895 */
896 struct brw_instruction *next = &p->store[p->nr_insn];
897
898 assert(patch_insn->header.opcode == BRW_OPCODE_ADD);
899
900 patch_insn->bits3.ud = (next - patch_insn) * 16;
901 } else {
902 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_ENDIF);
903
904 if (intel->gen < 6) {
905 brw_set_dest(insn, retype(brw_vec4_grf(0,0), BRW_REGISTER_TYPE_UD));
906 brw_set_src0(insn, retype(brw_vec4_grf(0,0), BRW_REGISTER_TYPE_UD));
907 brw_set_src1(insn, brw_imm_d(0x0));
908 } else {
909 brw_set_dest(insn, retype(brw_vec4_grf(0,0), BRW_REGISTER_TYPE_W));
910 brw_set_src0(insn, brw_null_reg());
911 brw_set_src1(insn, brw_null_reg());
912 }
913
914 insn->header.compression_control = BRW_COMPRESSION_NONE;
915 insn->header.execution_size = patch_insn->header.execution_size;
916 insn->header.mask_control = BRW_MASK_ENABLE;
917 insn->header.thread_control = BRW_THREAD_SWITCH;
918
919 assert(patch_insn->bits3.if_else.jump_count == 0);
920
921 /* Patch the if or else instructions to point at this or the next
922 * instruction respectively.
923 */
924 if (patch_insn->header.opcode == BRW_OPCODE_IF) {
925 if (intel->gen < 6) {
926 /* Turn it into an IFF, which means no mask stack operations for
927 * all-false and jumping past the ENDIF.
928 */
929 patch_insn->header.opcode = BRW_OPCODE_IFF;
930 patch_insn->bits3.if_else.jump_count = br * (insn - patch_insn + 1);
931 patch_insn->bits3.if_else.pop_count = 0;
932 patch_insn->bits3.if_else.pad0 = 0;
933 } else {
934 /* As of gen6, there is no IFF and IF must point to the ENDIF. */
935 patch_insn->bits1.branch_gen6.jump_count = br * (insn - patch_insn);
936 }
937 } else {
938 assert(patch_insn->header.opcode == BRW_OPCODE_ELSE);
939 if (intel->gen < 6) {
940 /* BRW_OPCODE_ELSE pre-gen6 should point just past the
941 * matching ENDIF.
942 */
943 patch_insn->bits3.if_else.jump_count = br * (insn - patch_insn + 1);
944 patch_insn->bits3.if_else.pop_count = 1;
945 patch_insn->bits3.if_else.pad0 = 0;
946 } else {
947 /* BRW_OPCODE_ELSE on gen6 should point to the matching ENDIF. */
948 patch_insn->bits1.branch_gen6.jump_count = br * (insn - patch_insn);
949 }
950 }
951
952 /* Also pop item off the stack in the endif instruction:
953 */
954 if (intel->gen < 6) {
955 insn->bits3.if_else.jump_count = 0;
956 insn->bits3.if_else.pop_count = 1;
957 insn->bits3.if_else.pad0 = 0;
958 } else {
959 insn->bits1.branch_gen6.jump_count = 2;
960 }
961 }
962 }
963
964 struct brw_instruction *brw_BREAK(struct brw_compile *p, int pop_count)
965 {
966 struct brw_instruction *insn;
967 insn = next_insn(p, BRW_OPCODE_BREAK);
968 brw_set_dest(insn, brw_ip_reg());
969 brw_set_src0(insn, brw_ip_reg());
970 brw_set_src1(insn, brw_imm_d(0x0));
971 insn->header.compression_control = BRW_COMPRESSION_NONE;
972 insn->header.execution_size = BRW_EXECUTE_8;
973 /* insn->header.mask_control = BRW_MASK_DISABLE; */
974 insn->bits3.if_else.pad0 = 0;
975 insn->bits3.if_else.pop_count = pop_count;
976 return insn;
977 }
978
979 struct brw_instruction *brw_CONT(struct brw_compile *p, int pop_count)
980 {
981 struct brw_instruction *insn;
982 insn = next_insn(p, BRW_OPCODE_CONTINUE);
983 brw_set_dest(insn, brw_ip_reg());
984 brw_set_src0(insn, brw_ip_reg());
985 brw_set_src1(insn, brw_imm_d(0x0));
986 insn->header.compression_control = BRW_COMPRESSION_NONE;
987 insn->header.execution_size = BRW_EXECUTE_8;
988 /* insn->header.mask_control = BRW_MASK_DISABLE; */
989 insn->bits3.if_else.pad0 = 0;
990 insn->bits3.if_else.pop_count = pop_count;
991 return insn;
992 }
993
994 /* DO/WHILE loop:
995 */
996 struct brw_instruction *brw_DO(struct brw_compile *p, GLuint execute_size)
997 {
998 if (p->single_program_flow) {
999 return &p->store[p->nr_insn];
1000 } else {
1001 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_DO);
1002
1003 /* Override the defaults for this instruction:
1004 */
1005 brw_set_dest(insn, brw_null_reg());
1006 brw_set_src0(insn, brw_null_reg());
1007 brw_set_src1(insn, brw_null_reg());
1008
1009 insn->header.compression_control = BRW_COMPRESSION_NONE;
1010 insn->header.execution_size = execute_size;
1011 insn->header.predicate_control = BRW_PREDICATE_NONE;
1012 /* insn->header.mask_control = BRW_MASK_ENABLE; */
1013 /* insn->header.mask_control = BRW_MASK_DISABLE; */
1014
1015 return insn;
1016 }
1017 }
1018
1019
1020
1021 struct brw_instruction *brw_WHILE(struct brw_compile *p,
1022 struct brw_instruction *do_insn)
1023 {
1024 struct intel_context *intel = &p->brw->intel;
1025 struct brw_instruction *insn;
1026 GLuint br = 1;
1027
1028 if (intel->gen >= 5)
1029 br = 2;
1030
1031 if (p->single_program_flow)
1032 insn = next_insn(p, BRW_OPCODE_ADD);
1033 else
1034 insn = next_insn(p, BRW_OPCODE_WHILE);
1035
1036 brw_set_dest(insn, brw_ip_reg());
1037 brw_set_src0(insn, brw_ip_reg());
1038 brw_set_src1(insn, brw_imm_d(0x0));
1039
1040 insn->header.compression_control = BRW_COMPRESSION_NONE;
1041
1042 if (p->single_program_flow) {
1043 insn->header.execution_size = BRW_EXECUTE_1;
1044
1045 insn->bits3.d = (do_insn - insn) * 16;
1046 } else {
1047 insn->header.execution_size = do_insn->header.execution_size;
1048
1049 assert(do_insn->header.opcode == BRW_OPCODE_DO);
1050 insn->bits3.if_else.jump_count = br * (do_insn - insn + 1);
1051 insn->bits3.if_else.pop_count = 0;
1052 insn->bits3.if_else.pad0 = 0;
1053 }
1054
1055 /* insn->header.mask_control = BRW_MASK_ENABLE; */
1056
1057 /* insn->header.mask_control = BRW_MASK_DISABLE; */
1058 p->current->header.predicate_control = BRW_PREDICATE_NONE;
1059 return insn;
1060 }
1061
1062
1063 /* FORWARD JUMPS:
1064 */
1065 void brw_land_fwd_jump(struct brw_compile *p,
1066 struct brw_instruction *jmp_insn)
1067 {
1068 struct intel_context *intel = &p->brw->intel;
1069 struct brw_instruction *landing = &p->store[p->nr_insn];
1070 GLuint jmpi = 1;
1071
1072 if (intel->gen >= 5)
1073 jmpi = 2;
1074
1075 assert(jmp_insn->header.opcode == BRW_OPCODE_JMPI);
1076 assert(jmp_insn->bits1.da1.src1_reg_file == BRW_IMMEDIATE_VALUE);
1077
1078 jmp_insn->bits3.ud = jmpi * ((landing - jmp_insn) - 1);
1079 }
1080
1081
1082
1083 /* To integrate with the above, it makes sense that the comparison
1084 * instruction should populate the flag register. It might be simpler
1085 * just to use the flag reg for most WM tasks?
1086 */
1087 void brw_CMP(struct brw_compile *p,
1088 struct brw_reg dest,
1089 GLuint conditional,
1090 struct brw_reg src0,
1091 struct brw_reg src1)
1092 {
1093 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_CMP);
1094
1095 insn->header.destreg__conditionalmod = conditional;
1096 brw_set_dest(insn, dest);
1097 brw_set_src0(insn, src0);
1098 brw_set_src1(insn, src1);
1099
1100 /* guess_execution_size(insn, src0); */
1101
1102
1103 /* Make it so that future instructions will use the computed flag
1104 * value until brw_set_predicate_control_flag_value() is called
1105 * again.
1106 */
1107 if (dest.file == BRW_ARCHITECTURE_REGISTER_FILE &&
1108 dest.nr == 0) {
1109 p->current->header.predicate_control = BRW_PREDICATE_NORMAL;
1110 p->flag_value = 0xff;
1111 }
1112 }
1113
1114 /* Issue 'wait' instruction for n1, host could program MMIO
1115 to wake up thread. */
1116 void brw_WAIT (struct brw_compile *p)
1117 {
1118 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_WAIT);
1119 struct brw_reg src = brw_notification_1_reg();
1120
1121 brw_set_dest(insn, src);
1122 brw_set_src0(insn, src);
1123 brw_set_src1(insn, brw_null_reg());
1124 insn->header.execution_size = 0; /* must */
1125 insn->header.predicate_control = 0;
1126 insn->header.compression_control = 0;
1127 }
1128
1129
1130 /***********************************************************************
1131 * Helpers for the various SEND message types:
1132 */
1133
1134 /** Extended math function, float[8].
1135 */
1136 void brw_math( struct brw_compile *p,
1137 struct brw_reg dest,
1138 GLuint function,
1139 GLuint saturate,
1140 GLuint msg_reg_nr,
1141 struct brw_reg src,
1142 GLuint data_type,
1143 GLuint precision )
1144 {
1145 struct intel_context *intel = &p->brw->intel;
1146
1147 if (intel->gen >= 6) {
1148 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_MATH);
1149
1150 /* Math is the same ISA format as other opcodes, except that CondModifier
1151 * becomes FC[3:0] and ThreadCtrl becomes FC[5:4].
1152 */
1153 insn->header.destreg__conditionalmod = function;
1154
1155 brw_set_dest(insn, dest);
1156 brw_set_src0(insn, src);
1157 brw_set_src1(insn, brw_null_reg());
1158 } else {
1159 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_SEND);
1160 GLuint msg_length = (function == BRW_MATH_FUNCTION_POW) ? 2 : 1;
1161 GLuint response_length = (function == BRW_MATH_FUNCTION_SINCOS) ? 2 : 1;
1162 /* Example code doesn't set predicate_control for send
1163 * instructions.
1164 */
1165 insn->header.predicate_control = 0;
1166 insn->header.destreg__conditionalmod = msg_reg_nr;
1167
1168 brw_set_dest(insn, dest);
1169 brw_set_src0(insn, src);
1170 brw_set_math_message(p->brw,
1171 insn,
1172 msg_length, response_length,
1173 function,
1174 BRW_MATH_INTEGER_UNSIGNED,
1175 precision,
1176 saturate,
1177 data_type);
1178 }
1179 }
1180
1181 /** Extended math function, float[8].
1182 */
1183 void brw_math2(struct brw_compile *p,
1184 struct brw_reg dest,
1185 GLuint function,
1186 struct brw_reg src0,
1187 struct brw_reg src1)
1188 {
1189 struct intel_context *intel = &p->brw->intel;
1190 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_MATH);
1191
1192 assert(intel->gen >= 6);
1193
1194 /* Math is the same ISA format as other opcodes, except that CondModifier
1195 * becomes FC[3:0] and ThreadCtrl becomes FC[5:4].
1196 */
1197 insn->header.destreg__conditionalmod = function;
1198
1199 brw_set_dest(insn, dest);
1200 brw_set_src0(insn, src0);
1201 brw_set_src1(insn, src1);
1202 }
1203
1204 /**
1205 * Extended math function, float[16].
1206 * Use 2 send instructions.
1207 */
1208 void brw_math_16( struct brw_compile *p,
1209 struct brw_reg dest,
1210 GLuint function,
1211 GLuint saturate,
1212 GLuint msg_reg_nr,
1213 struct brw_reg src,
1214 GLuint precision )
1215 {
1216 struct intel_context *intel = &p->brw->intel;
1217 struct brw_instruction *insn;
1218 GLuint msg_length = (function == BRW_MATH_FUNCTION_POW) ? 2 : 1;
1219 GLuint response_length = (function == BRW_MATH_FUNCTION_SINCOS) ? 2 : 1;
1220
1221 if (intel->gen >= 6) {
1222 insn = next_insn(p, BRW_OPCODE_MATH);
1223
1224 /* Math is the same ISA format as other opcodes, except that CondModifier
1225 * becomes FC[3:0] and ThreadCtrl becomes FC[5:4].
1226 */
1227 insn->header.destreg__conditionalmod = function;
1228
1229 brw_set_dest(insn, dest);
1230 brw_set_src0(insn, src);
1231 brw_set_src1(insn, brw_null_reg());
1232 return;
1233 }
1234
1235 /* First instruction:
1236 */
1237 brw_push_insn_state(p);
1238 brw_set_predicate_control_flag_value(p, 0xff);
1239 brw_set_compression_control(p, BRW_COMPRESSION_NONE);
1240
1241 insn = next_insn(p, BRW_OPCODE_SEND);
1242 insn->header.destreg__conditionalmod = msg_reg_nr;
1243
1244 brw_set_dest(insn, dest);
1245 brw_set_src0(insn, src);
1246 brw_set_math_message(p->brw,
1247 insn,
1248 msg_length, response_length,
1249 function,
1250 BRW_MATH_INTEGER_UNSIGNED,
1251 precision,
1252 saturate,
1253 BRW_MATH_DATA_VECTOR);
1254
1255 /* Second instruction:
1256 */
1257 insn = next_insn(p, BRW_OPCODE_SEND);
1258 insn->header.compression_control = BRW_COMPRESSION_2NDHALF;
1259 insn->header.destreg__conditionalmod = msg_reg_nr+1;
1260
1261 brw_set_dest(insn, offset(dest,1));
1262 brw_set_src0(insn, src);
1263 brw_set_math_message(p->brw,
1264 insn,
1265 msg_length, response_length,
1266 function,
1267 BRW_MATH_INTEGER_UNSIGNED,
1268 precision,
1269 saturate,
1270 BRW_MATH_DATA_VECTOR);
1271
1272 brw_pop_insn_state(p);
1273 }
1274
1275
1276 /**
1277 * Write block of 16 dwords/floats to the data port Render Cache scratch buffer.
1278 * Scratch offset should be a multiple of 64.
1279 * Used for register spilling.
1280 */
1281 void brw_dp_WRITE_16( struct brw_compile *p,
1282 struct brw_reg src,
1283 GLuint scratch_offset )
1284 {
1285 struct intel_context *intel = &p->brw->intel;
1286 GLuint msg_reg_nr = 1;
1287 {
1288 brw_push_insn_state(p);
1289 brw_set_mask_control(p, BRW_MASK_DISABLE);
1290 brw_set_compression_control(p, BRW_COMPRESSION_NONE);
1291
1292 /* set message header global offset field (reg 0, element 2) */
1293 brw_MOV(p,
1294 retype(brw_vec1_grf(0, 2), BRW_REGISTER_TYPE_D),
1295 brw_imm_d(scratch_offset));
1296
1297 brw_pop_insn_state(p);
1298 }
1299
1300 {
1301 GLuint msg_length = 3;
1302 struct brw_reg dest;
1303 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_SEND);
1304 int send_commit_msg;
1305
1306 insn->header.predicate_control = 0; /* XXX */
1307 insn->header.compression_control = BRW_COMPRESSION_NONE;
1308 insn->header.destreg__conditionalmod = msg_reg_nr;
1309
1310 /* Until gen6, writes followed by reads from the same location
1311 * are not guaranteed to be ordered unless write_commit is set.
1312 * If set, then a no-op write is issued to the destination
1313 * register to set a dependency, and a read from the destination
1314 * can be used to ensure the ordering.
1315 *
1316 * For gen6, only writes between different threads need ordering
1317 * protection. Our use of DP writes is all about register
1318 * spilling within a thread.
1319 */
1320 if (intel->gen >= 6) {
1321 dest = retype(vec16(brw_null_reg()), BRW_REGISTER_TYPE_UW);
1322 send_commit_msg = 0;
1323 } else {
1324 dest = brw_uw16_grf(0, 0);
1325 send_commit_msg = 1;
1326 }
1327
1328 brw_set_dest(insn, dest);
1329 brw_set_src0(insn, src);
1330
1331 brw_set_dp_write_message(p->brw,
1332 insn,
1333 255, /* binding table index (255=stateless) */
1334 BRW_DATAPORT_OWORD_BLOCK_4_OWORDS, /* msg_control */
1335 BRW_DATAPORT_WRITE_MESSAGE_OWORD_BLOCK_WRITE, /* msg_type */
1336 msg_length,
1337 GL_TRUE, /* header_present */
1338 0, /* pixel scoreboard */
1339 send_commit_msg, /* response_length */
1340 0, /* eot */
1341 send_commit_msg);
1342 }
1343 }
1344
1345
1346 /**
1347 * Read block of 16 dwords/floats from the data port Render Cache scratch buffer.
1348 * Scratch offset should be a multiple of 64.
1349 * Used for register spilling.
1350 */
1351 void brw_dp_READ_16( struct brw_compile *p,
1352 struct brw_reg dest,
1353 GLuint scratch_offset )
1354 {
1355 GLuint msg_reg_nr = 1;
1356 {
1357 brw_push_insn_state(p);
1358 brw_set_compression_control(p, BRW_COMPRESSION_NONE);
1359 brw_set_mask_control(p, BRW_MASK_DISABLE);
1360
1361 /* set message header global offset field (reg 0, element 2) */
1362 brw_MOV(p,
1363 retype(brw_vec1_grf(0, 2), BRW_REGISTER_TYPE_D),
1364 brw_imm_d(scratch_offset));
1365
1366 brw_pop_insn_state(p);
1367 }
1368
1369 {
1370 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_SEND);
1371
1372 insn->header.predicate_control = 0; /* XXX */
1373 insn->header.compression_control = BRW_COMPRESSION_NONE;
1374 insn->header.destreg__conditionalmod = msg_reg_nr;
1375
1376 brw_set_dest(insn, dest); /* UW? */
1377 brw_set_src0(insn, retype(brw_vec8_grf(0, 0), BRW_REGISTER_TYPE_UW));
1378
1379 brw_set_dp_read_message(p->brw,
1380 insn,
1381 255, /* binding table index (255=stateless) */
1382 BRW_DATAPORT_OWORD_BLOCK_4_OWORDS,
1383 BRW_DATAPORT_READ_MESSAGE_OWORD_BLOCK_READ, /* msg_type */
1384 1, /* target cache (render/scratch) */
1385 1, /* msg_length */
1386 2, /* response_length */
1387 0); /* eot */
1388 }
1389 }
1390
1391
1392 /**
1393 * Read a float[4] vector from the data port Data Cache (const buffer).
1394 * Location (in buffer) should be a multiple of 16.
1395 * Used for fetching shader constants.
1396 * If relAddr is true, we'll do an indirect fetch using the address register.
1397 */
1398 void brw_dp_READ_4( struct brw_compile *p,
1399 struct brw_reg dest,
1400 GLboolean relAddr,
1401 GLuint location,
1402 GLuint bind_table_index )
1403 {
1404 /* XXX: relAddr not implemented */
1405 GLuint msg_reg_nr = 1;
1406 {
1407 struct brw_reg b;
1408 brw_push_insn_state(p);
1409 brw_set_predicate_control(p, BRW_PREDICATE_NONE);
1410 brw_set_compression_control(p, BRW_COMPRESSION_NONE);
1411 brw_set_mask_control(p, BRW_MASK_DISABLE);
1412
1413 /* Setup MRF[1] with location/offset into const buffer */
1414 b = brw_message_reg(msg_reg_nr);
1415 b = retype(b, BRW_REGISTER_TYPE_UD);
1416 /* XXX I think we're setting all the dwords of MRF[1] to 'location'.
1417 * when the docs say only dword[2] should be set. Hmmm. But it works.
1418 */
1419 brw_MOV(p, b, brw_imm_ud(location));
1420 brw_pop_insn_state(p);
1421 }
1422
1423 {
1424 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_SEND);
1425
1426 insn->header.predicate_control = BRW_PREDICATE_NONE;
1427 insn->header.compression_control = BRW_COMPRESSION_NONE;
1428 insn->header.destreg__conditionalmod = msg_reg_nr;
1429 insn->header.mask_control = BRW_MASK_DISABLE;
1430
1431 /* cast dest to a uword[8] vector */
1432 dest = retype(vec8(dest), BRW_REGISTER_TYPE_UW);
1433
1434 brw_set_dest(insn, dest);
1435 brw_set_src0(insn, brw_null_reg());
1436
1437 brw_set_dp_read_message(p->brw,
1438 insn,
1439 bind_table_index,
1440 0, /* msg_control (0 means 1 Oword) */
1441 BRW_DATAPORT_READ_MESSAGE_OWORD_BLOCK_READ, /* msg_type */
1442 0, /* source cache = data cache */
1443 1, /* msg_length */
1444 1, /* response_length (1 Oword) */
1445 0); /* eot */
1446 }
1447 }
1448
1449
1450 /**
1451 * Read float[4] constant(s) from VS constant buffer.
1452 * For relative addressing, two float[4] constants will be read into 'dest'.
1453 * Otherwise, one float[4] constant will be read into the lower half of 'dest'.
1454 */
1455 void brw_dp_READ_4_vs(struct brw_compile *p,
1456 struct brw_reg dest,
1457 GLuint location,
1458 GLuint bind_table_index)
1459 {
1460 struct brw_instruction *insn;
1461 GLuint msg_reg_nr = 1;
1462 struct brw_reg b;
1463
1464 /*
1465 printf("vs const read msg, location %u, msg_reg_nr %d\n",
1466 location, msg_reg_nr);
1467 */
1468
1469 /* Setup MRF[1] with location/offset into const buffer */
1470 brw_push_insn_state(p);
1471 brw_set_compression_control(p, BRW_COMPRESSION_NONE);
1472 brw_set_mask_control(p, BRW_MASK_DISABLE);
1473 brw_set_predicate_control(p, BRW_PREDICATE_NONE);
1474
1475 /* XXX I think we're setting all the dwords of MRF[1] to 'location'.
1476 * when the docs say only dword[2] should be set. Hmmm. But it works.
1477 */
1478 b = brw_message_reg(msg_reg_nr);
1479 b = retype(b, BRW_REGISTER_TYPE_UD);
1480 /*b = get_element_ud(b, 2);*/
1481 brw_MOV(p, b, brw_imm_ud(location));
1482
1483 brw_pop_insn_state(p);
1484
1485 insn = next_insn(p, BRW_OPCODE_SEND);
1486
1487 insn->header.predicate_control = BRW_PREDICATE_NONE;
1488 insn->header.compression_control = BRW_COMPRESSION_NONE;
1489 insn->header.destreg__conditionalmod = msg_reg_nr;
1490 insn->header.mask_control = BRW_MASK_DISABLE;
1491
1492 brw_set_dest(insn, dest);
1493 brw_set_src0(insn, brw_null_reg());
1494
1495 brw_set_dp_read_message(p->brw,
1496 insn,
1497 bind_table_index,
1498 0,
1499 BRW_DATAPORT_READ_MESSAGE_OWORD_BLOCK_READ, /* msg_type */
1500 0, /* source cache = data cache */
1501 1, /* msg_length */
1502 1, /* response_length (1 Oword) */
1503 0); /* eot */
1504 }
1505
1506 /**
1507 * Read a float[4] constant per vertex from VS constant buffer, with
1508 * relative addressing.
1509 */
1510 void brw_dp_READ_4_vs_relative(struct brw_compile *p,
1511 struct brw_reg dest,
1512 struct brw_reg addr_reg,
1513 GLuint offset,
1514 GLuint bind_table_index)
1515 {
1516 struct intel_context *intel = &p->brw->intel;
1517 int msg_type;
1518
1519 /* Setup MRF[1] with offset into const buffer */
1520 brw_push_insn_state(p);
1521 brw_set_compression_control(p, BRW_COMPRESSION_NONE);
1522 brw_set_mask_control(p, BRW_MASK_DISABLE);
1523 brw_set_predicate_control(p, BRW_PREDICATE_NONE);
1524
1525 /* M1.0 is block offset 0, M1.4 is block offset 1, all other
1526 * fields ignored.
1527 */
1528 brw_ADD(p, retype(brw_message_reg(1), BRW_REGISTER_TYPE_UD),
1529 addr_reg, brw_imm_d(offset));
1530 brw_pop_insn_state(p);
1531
1532 struct brw_instruction *insn = next_insn(p, BRW_OPCODE_SEND);
1533
1534 insn->header.predicate_control = BRW_PREDICATE_NONE;
1535 insn->header.compression_control = BRW_COMPRESSION_NONE;
1536 insn->header.destreg__conditionalmod = 0;
1537 insn->header.mask_control = BRW_MASK_DISABLE;
1538
1539 brw_set_dest(insn, dest);
1540 brw_set_src0(insn, brw_vec8_grf(0, 0));
1541
1542 if (intel->gen == 6)
1543 msg_type = GEN6_DATAPORT_READ_MESSAGE_OWORD_DUAL_BLOCK_READ;
1544 else if (intel->gen == 5 || intel->is_g4x)
1545 msg_type = G45_DATAPORT_READ_MESSAGE_OWORD_DUAL_BLOCK_READ;
1546 else
1547 msg_type = BRW_DATAPORT_READ_MESSAGE_OWORD_DUAL_BLOCK_READ;
1548
1549 brw_set_dp_read_message(p->brw,
1550 insn,
1551 bind_table_index,
1552 BRW_DATAPORT_OWORD_DUAL_BLOCK_1OWORD,
1553 msg_type,
1554 0, /* source cache = data cache */
1555 2, /* msg_length */
1556 1, /* response_length */
1557 0); /* eot */
1558 }
1559
1560
1561
1562 void brw_fb_WRITE(struct brw_compile *p,
1563 int dispatch_width,
1564 struct brw_reg dest,
1565 GLuint msg_reg_nr,
1566 struct brw_reg src0,
1567 GLuint binding_table_index,
1568 GLuint msg_length,
1569 GLuint response_length,
1570 GLboolean eot)
1571 {
1572 struct intel_context *intel = &p->brw->intel;
1573 struct brw_instruction *insn;
1574 GLuint msg_control, msg_type;
1575 GLboolean header_present = GL_TRUE;
1576
1577 insn = next_insn(p, BRW_OPCODE_SEND);
1578 insn->header.predicate_control = 0; /* XXX */
1579 insn->header.compression_control = BRW_COMPRESSION_NONE;
1580
1581 if (intel->gen >= 6) {
1582 if (msg_length == 4)
1583 header_present = GL_FALSE;
1584
1585 /* headerless version, just submit color payload */
1586 src0 = brw_message_reg(msg_reg_nr);
1587
1588 msg_type = BRW_DATAPORT_WRITE_MESSAGE_RENDER_TARGET_WRITE_GEN6;
1589 } else {
1590 insn->header.destreg__conditionalmod = msg_reg_nr;
1591
1592 msg_type = BRW_DATAPORT_WRITE_MESSAGE_RENDER_TARGET_WRITE;
1593 }
1594
1595 if (dispatch_width == 16)
1596 msg_control = BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD16_SINGLE_SOURCE;
1597 else
1598 msg_control = BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD8_SINGLE_SOURCE_SUBSPAN01;
1599
1600 brw_set_dest(insn, dest);
1601 brw_set_src0(insn, src0);
1602 brw_set_dp_write_message(p->brw,
1603 insn,
1604 binding_table_index,
1605 msg_control,
1606 msg_type,
1607 msg_length,
1608 header_present,
1609 1, /* pixel scoreboard */
1610 response_length,
1611 eot,
1612 0 /* send_commit_msg */);
1613 }
1614
1615
1616 /**
1617 * Texture sample instruction.
1618 * Note: the msg_type plus msg_length values determine exactly what kind
1619 * of sampling operation is performed. See volume 4, page 161 of docs.
1620 */
1621 void brw_SAMPLE(struct brw_compile *p,
1622 struct brw_reg dest,
1623 GLuint msg_reg_nr,
1624 struct brw_reg src0,
1625 GLuint binding_table_index,
1626 GLuint sampler,
1627 GLuint writemask,
1628 GLuint msg_type,
1629 GLuint response_length,
1630 GLuint msg_length,
1631 GLboolean eot,
1632 GLuint header_present,
1633 GLuint simd_mode)
1634 {
1635 struct intel_context *intel = &p->brw->intel;
1636 GLboolean need_stall = 0;
1637
1638 if (writemask == 0) {
1639 /*printf("%s: zero writemask??\n", __FUNCTION__); */
1640 return;
1641 }
1642
1643 /* Hardware doesn't do destination dependency checking on send
1644 * instructions properly. Add a workaround which generates the
1645 * dependency by other means. In practice it seems like this bug
1646 * only crops up for texture samples, and only where registers are
1647 * written by the send and then written again later without being
1648 * read in between. Luckily for us, we already track that
1649 * information and use it to modify the writemask for the
1650 * instruction, so that is a guide for whether a workaround is
1651 * needed.
1652 */
1653 if (writemask != WRITEMASK_XYZW) {
1654 GLuint dst_offset = 0;
1655 GLuint i, newmask = 0, len = 0;
1656
1657 for (i = 0; i < 4; i++) {
1658 if (writemask & (1<<i))
1659 break;
1660 dst_offset += 2;
1661 }
1662 for (; i < 4; i++) {
1663 if (!(writemask & (1<<i)))
1664 break;
1665 newmask |= 1<<i;
1666 len++;
1667 }
1668
1669 if (newmask != writemask) {
1670 need_stall = 1;
1671 /* printf("need stall %x %x\n", newmask , writemask); */
1672 }
1673 else {
1674 GLboolean dispatch_16 = GL_FALSE;
1675
1676 struct brw_reg m1 = brw_message_reg(msg_reg_nr);
1677
1678 guess_execution_size(p->current, dest);
1679 if (p->current->header.execution_size == BRW_EXECUTE_16)
1680 dispatch_16 = GL_TRUE;
1681
1682 newmask = ~newmask & WRITEMASK_XYZW;
1683
1684 brw_push_insn_state(p);
1685
1686 brw_set_compression_control(p, BRW_COMPRESSION_NONE);
1687 brw_set_mask_control(p, BRW_MASK_DISABLE);
1688
1689 brw_MOV(p, m1, brw_vec8_grf(0,0));
1690 brw_MOV(p, get_element_ud(m1, 2), brw_imm_ud(newmask << 12));
1691
1692 brw_pop_insn_state(p);
1693
1694 src0 = retype(brw_null_reg(), BRW_REGISTER_TYPE_UW);
1695 dest = offset(dest, dst_offset);
1696
1697 /* For 16-wide dispatch, masked channels are skipped in the
1698 * response. For 8-wide, masked channels still take up slots,
1699 * and are just not written to.
1700 */
1701 if (dispatch_16)
1702 response_length = len * 2;
1703 }
1704 }
1705
1706 {
1707 struct brw_instruction *insn;
1708
1709 /* Sandybridge doesn't have the implied move for SENDs,
1710 * and the first message register index comes from src0.
1711 */
1712 if (intel->gen >= 6) {
1713 brw_push_insn_state(p);
1714 brw_set_mask_control( p, BRW_MASK_DISABLE );
1715 /* m1 contains header? */
1716 brw_MOV(p, brw_message_reg(msg_reg_nr), src0);
1717 brw_pop_insn_state(p);
1718 src0 = brw_message_reg(msg_reg_nr);
1719 }
1720
1721 insn = next_insn(p, BRW_OPCODE_SEND);
1722 insn->header.predicate_control = 0; /* XXX */
1723 insn->header.compression_control = BRW_COMPRESSION_NONE;
1724 if (intel->gen < 6)
1725 insn->header.destreg__conditionalmod = msg_reg_nr;
1726
1727 brw_set_dest(insn, dest);
1728 brw_set_src0(insn, src0);
1729 brw_set_sampler_message(p->brw, insn,
1730 binding_table_index,
1731 sampler,
1732 msg_type,
1733 response_length,
1734 msg_length,
1735 eot,
1736 header_present,
1737 simd_mode);
1738 }
1739
1740 if (need_stall) {
1741 struct brw_reg reg = vec8(offset(dest, response_length-1));
1742
1743 /* mov (8) r9.0<1>:f r9.0<8;8,1>:f { Align1 }
1744 */
1745 brw_push_insn_state(p);
1746 brw_set_compression_control(p, BRW_COMPRESSION_NONE);
1747 brw_MOV(p, reg, reg);
1748 brw_pop_insn_state(p);
1749 }
1750
1751 }
1752
1753 /* All these variables are pretty confusing - we might be better off
1754 * using bitmasks and macros for this, in the old style. Or perhaps
1755 * just having the caller instantiate the fields in dword3 itself.
1756 */
1757 void brw_urb_WRITE(struct brw_compile *p,
1758 struct brw_reg dest,
1759 GLuint msg_reg_nr,
1760 struct brw_reg src0,
1761 GLboolean allocate,
1762 GLboolean used,
1763 GLuint msg_length,
1764 GLuint response_length,
1765 GLboolean eot,
1766 GLboolean writes_complete,
1767 GLuint offset,
1768 GLuint swizzle)
1769 {
1770 struct intel_context *intel = &p->brw->intel;
1771 struct brw_instruction *insn;
1772
1773 /* Sandybridge doesn't have the implied move for SENDs,
1774 * and the first message register index comes from src0.
1775 */
1776 if (intel->gen >= 6) {
1777 brw_push_insn_state(p);
1778 brw_set_mask_control( p, BRW_MASK_DISABLE );
1779 brw_MOV(p, brw_message_reg(msg_reg_nr), src0);
1780 brw_pop_insn_state(p);
1781 src0 = brw_message_reg(msg_reg_nr);
1782 }
1783
1784 insn = next_insn(p, BRW_OPCODE_SEND);
1785
1786 assert(msg_length < BRW_MAX_MRF);
1787
1788 brw_set_dest(insn, dest);
1789 brw_set_src0(insn, src0);
1790 brw_set_src1(insn, brw_imm_d(0));
1791
1792 if (intel->gen < 6)
1793 insn->header.destreg__conditionalmod = msg_reg_nr;
1794
1795 brw_set_urb_message(p->brw,
1796 insn,
1797 allocate,
1798 used,
1799 msg_length,
1800 response_length,
1801 eot,
1802 writes_complete,
1803 offset,
1804 swizzle);
1805 }
1806
1807 void brw_ff_sync(struct brw_compile *p,
1808 struct brw_reg dest,
1809 GLuint msg_reg_nr,
1810 struct brw_reg src0,
1811 GLboolean allocate,
1812 GLuint response_length,
1813 GLboolean eot)
1814 {
1815 struct intel_context *intel = &p->brw->intel;
1816 struct brw_instruction *insn;
1817
1818 /* Sandybridge doesn't have the implied move for SENDs,
1819 * and the first message register index comes from src0.
1820 */
1821 if (intel->gen >= 6) {
1822 brw_push_insn_state(p);
1823 brw_set_mask_control( p, BRW_MASK_DISABLE );
1824 brw_MOV(p, brw_message_reg(msg_reg_nr), src0);
1825 brw_pop_insn_state(p);
1826 src0 = brw_message_reg(msg_reg_nr);
1827 }
1828
1829 insn = next_insn(p, BRW_OPCODE_SEND);
1830 brw_set_dest(insn, dest);
1831 brw_set_src0(insn, src0);
1832 brw_set_src1(insn, brw_imm_d(0));
1833
1834 if (intel->gen < 6)
1835 insn->header.destreg__conditionalmod = msg_reg_nr;
1836
1837 brw_set_ff_sync_message(p->brw,
1838 insn,
1839 allocate,
1840 response_length,
1841 eot);
1842 }