1 /* Copyright © 2011 Intel Corporation
3 * Permission is hereby granted, free of charge, to any person obtaining a
4 * copy of this software and associated documentation files (the "Software"),
5 * to deal in the Software without restriction, including without limitation
6 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
7 * and/or sell copies of the Software, and to permit persons to whom the
8 * Software is furnished to do so, subject to the following conditions:
10 * The above copyright notice and this permission notice (including the next
11 * paragraph) shall be included in all copies or substantial portions of the
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
24 #include "glsl/ir_print_visitor.h"
35 vec4_visitor::setup_attributes(int payload_reg
)
38 int attribute_map
[VERT_ATTRIB_MAX
];
41 for (int i
= 0; i
< VERT_ATTRIB_MAX
; i
++) {
42 if (prog_data
->inputs_read
& BITFIELD64_BIT(i
)) {
43 attribute_map
[i
] = payload_reg
+ nr_attributes
;
46 /* Do GL_FIXED rescaling for GLES2.0. Our GL_FIXED
47 * attributes come in as floating point conversions of the
50 if (c
->key
.gl_fixed_input_size
[i
] != 0) {
51 struct brw_reg reg
= brw_vec8_grf(attribute_map
[i
], 0);
54 brw_writemask(reg
, (1 << c
->key
.gl_fixed_input_size
[i
]) - 1),
55 reg
, brw_imm_f(1.0 / 65536.0));
60 foreach_list(node
, &this->instructions
) {
61 vec4_instruction
*inst
= (vec4_instruction
*)node
;
63 for (int i
= 0; i
< 3; i
++) {
64 if (inst
->src
[i
].file
!= ATTR
)
67 int grf
= attribute_map
[inst
->src
[i
].reg
+ inst
->src
[i
].reg_offset
];
69 struct brw_reg reg
= brw_vec8_grf(grf
, 0);
70 reg
.dw1
.bits
.swizzle
= inst
->src
[i
].swizzle
;
73 if (inst
->src
[i
].negate
)
76 inst
->src
[i
].file
= HW_REG
;
77 inst
->src
[i
].fixed_hw_reg
= reg
;
81 /* The BSpec says we always have to read at least one thing from
82 * the VF, and it appears that the hardware wedges otherwise.
84 if (nr_attributes
== 0)
87 prog_data
->urb_read_length
= (nr_attributes
+ 1) / 2;
89 return payload_reg
+ nr_attributes
;
93 vec4_visitor::setup_uniforms(int reg
)
95 /* User clip planes from curbe:
97 if (c
->key
.nr_userclip
) {
98 if (intel
->gen
>= 6) {
99 for (int i
= 0; i
< c
->key
.nr_userclip
; i
++) {
100 c
->userplane
[i
] = stride(brw_vec4_grf(reg
+ i
/ 2,
101 (i
% 2) * 4), 0, 4, 1);
103 reg
+= ALIGN(c
->key
.nr_userclip
, 2) / 2;
105 for (int i
= 0; i
< c
->key
.nr_userclip
; i
++) {
106 c
->userplane
[i
] = stride(brw_vec4_grf(reg
+ (6 + i
) / 2,
107 (i
% 2) * 4), 0, 4, 1);
109 reg
+= (ALIGN(6 + c
->key
.nr_userclip
, 4) / 4) * 2;
113 /* The pre-gen6 VS requires that some push constants get loaded no
114 * matter what, or the GPU would hang.
116 if (intel
->gen
< 6 && this->uniforms
== 0) {
117 this->uniform_vector_size
[this->uniforms
] = 1;
119 for (unsigned int i
= 0; i
< 4; i
++) {
120 unsigned int slot
= this->uniforms
* 4 + i
;
122 c
->prog_data
.param
[slot
] = NULL
;
128 reg
+= ALIGN(uniforms
, 2) / 2;
131 c
->prog_data
.nr_params
= this->uniforms
* 4;
133 c
->prog_data
.curb_read_length
= reg
- 1;
134 c
->prog_data
.uses_new_param_layout
= true;
140 vec4_visitor::setup_payload(void)
144 /* The payload always contains important data in g0, which contains
145 * the URB handles that are passed on to the URB write at the end
146 * of the thread. So, we always start push constants at g1.
150 reg
= setup_uniforms(reg
);
152 reg
= setup_attributes(reg
);
154 this->first_non_payload_grf
= reg
;
158 vec4_instruction::get_dst(void)
160 struct brw_reg brw_reg
;
164 brw_reg
= brw_vec8_grf(dst
.reg
+ dst
.reg_offset
, 0);
165 brw_reg
= retype(brw_reg
, dst
.type
);
166 brw_reg
.dw1
.bits
.writemask
= dst
.writemask
;
170 brw_reg
= dst
.fixed_hw_reg
;
174 brw_reg
= brw_null_reg();
178 assert(!"not reached");
179 brw_reg
= brw_null_reg();
186 vec4_instruction::get_src(int i
)
188 struct brw_reg brw_reg
;
190 switch (src
[i
].file
) {
192 brw_reg
= brw_vec8_grf(src
[i
].reg
+ src
[i
].reg_offset
, 0);
193 brw_reg
= retype(brw_reg
, src
[i
].type
);
194 brw_reg
.dw1
.bits
.swizzle
= src
[i
].swizzle
;
196 brw_reg
= brw_abs(brw_reg
);
198 brw_reg
= negate(brw_reg
);
202 switch (src
[i
].type
) {
203 case BRW_REGISTER_TYPE_F
:
204 brw_reg
= brw_imm_f(src
[i
].imm
.f
);
206 case BRW_REGISTER_TYPE_D
:
207 brw_reg
= brw_imm_d(src
[i
].imm
.i
);
209 case BRW_REGISTER_TYPE_UD
:
210 brw_reg
= brw_imm_ud(src
[i
].imm
.u
);
213 assert(!"not reached");
214 brw_reg
= brw_null_reg();
220 brw_reg
= stride(brw_vec4_grf(1 + (src
[i
].reg
+ src
[i
].reg_offset
) / 2,
221 ((src
[i
].reg
+ src
[i
].reg_offset
) % 2) * 4),
223 brw_reg
= retype(brw_reg
, src
[i
].type
);
224 brw_reg
.dw1
.bits
.swizzle
= src
[i
].swizzle
;
226 brw_reg
= brw_abs(brw_reg
);
228 brw_reg
= negate(brw_reg
);
230 /* This should have been moved to pull constants. */
231 assert(!src
[i
].reladdr
);
235 brw_reg
= src
[i
].fixed_hw_reg
;
239 /* Probably unused. */
240 brw_reg
= brw_null_reg();
244 assert(!"not reached");
245 brw_reg
= brw_null_reg();
253 vec4_visitor::generate_math1_gen4(vec4_instruction
*inst
,
259 brw_math_function(inst
->opcode
),
260 BRW_MATH_SATURATE_NONE
,
263 BRW_MATH_DATA_SCALAR
,
264 BRW_MATH_PRECISION_FULL
);
268 check_gen6_math_src_arg(struct brw_reg src
)
270 /* Source swizzles are ignored. */
273 assert(src
.dw1
.bits
.swizzle
= BRW_SWIZZLE_XYZW
);
277 vec4_visitor::generate_math1_gen6(vec4_instruction
*inst
,
281 /* Can't do writemask because math can't be align16. */
282 assert(dst
.dw1
.bits
.writemask
== WRITEMASK_XYZW
);
283 check_gen6_math_src_arg(src
);
285 brw_set_access_mode(p
, BRW_ALIGN_1
);
288 brw_math_function(inst
->opcode
),
289 BRW_MATH_SATURATE_NONE
,
292 BRW_MATH_DATA_SCALAR
,
293 BRW_MATH_PRECISION_FULL
);
294 brw_set_access_mode(p
, BRW_ALIGN_16
);
298 vec4_visitor::generate_math2_gen6(vec4_instruction
*inst
,
303 /* Can't do writemask because math can't be align16. */
304 assert(dst
.dw1
.bits
.writemask
== WRITEMASK_XYZW
);
305 /* Source swizzles are ignored. */
306 check_gen6_math_src_arg(src0
);
307 check_gen6_math_src_arg(src1
);
309 brw_set_access_mode(p
, BRW_ALIGN_1
);
312 brw_math_function(inst
->opcode
),
314 brw_set_access_mode(p
, BRW_ALIGN_16
);
318 vec4_visitor::generate_math2_gen4(vec4_instruction
*inst
,
323 /* Can't do writemask because math can't be align16. */
324 assert(dst
.dw1
.bits
.writemask
== WRITEMASK_XYZW
);
326 brw_MOV(p
, brw_message_reg(inst
->base_mrf
+ 1), src1
);
328 brw_set_access_mode(p
, BRW_ALIGN_1
);
331 brw_math_function(inst
->opcode
),
332 BRW_MATH_SATURATE_NONE
,
335 BRW_MATH_DATA_VECTOR
,
336 BRW_MATH_PRECISION_FULL
);
337 brw_set_access_mode(p
, BRW_ALIGN_16
);
341 vec4_visitor::generate_urb_write(vec4_instruction
*inst
)
344 brw_null_reg(), /* dest */
345 inst
->base_mrf
, /* starting mrf reg nr */
346 brw_vec8_grf(0, 0), /* src */
347 false, /* allocate */
350 0, /* response len */
352 inst
->eot
, /* writes complete */
353 inst
->offset
, /* urb destination offset */
354 BRW_URB_SWIZZLE_INTERLEAVE
);
358 vec4_visitor::generate_oword_dual_block_offsets(struct brw_reg m1
,
359 struct brw_reg index
)
361 int second_vertex_offset
;
364 second_vertex_offset
= 1;
366 second_vertex_offset
= 16;
368 m1
= retype(m1
, BRW_REGISTER_TYPE_D
);
370 /* Set up M1 (message payload). Only the block offsets in M1.0 and
371 * M1.4 are used, and the rest are ignored.
373 struct brw_reg m1_0
= suboffset(vec1(m1
), 0);
374 struct brw_reg m1_4
= suboffset(vec1(m1
), 4);
375 struct brw_reg index_0
= suboffset(vec1(index
), 0);
376 struct brw_reg index_4
= suboffset(vec1(index
), 4);
378 brw_push_insn_state(p
);
379 brw_set_mask_control(p
, BRW_MASK_DISABLE
);
380 brw_set_access_mode(p
, BRW_ALIGN_1
);
382 brw_MOV(p
, m1_0
, index_0
);
384 brw_set_predicate_inverse(p
, true);
385 if (index
.file
== BRW_IMMEDIATE_VALUE
) {
387 brw_MOV(p
, m1_4
, index_4
);
389 brw_ADD(p
, m1_4
, index_4
, brw_imm_d(second_vertex_offset
));
392 brw_pop_insn_state(p
);
396 vec4_visitor::generate_scratch_read(vec4_instruction
*inst
,
398 struct brw_reg index
)
400 if (intel
->gen
>= 6) {
401 brw_push_insn_state(p
);
402 brw_set_mask_control(p
, BRW_MASK_DISABLE
);
404 retype(brw_message_reg(inst
->base_mrf
), BRW_REGISTER_TYPE_D
),
405 retype(brw_vec8_grf(0, 0), BRW_REGISTER_TYPE_D
));
406 brw_pop_insn_state(p
);
409 generate_oword_dual_block_offsets(brw_message_reg(inst
->base_mrf
+ 1),
415 msg_type
= GEN6_DATAPORT_READ_MESSAGE_OWORD_DUAL_BLOCK_READ
;
416 else if (intel
->gen
== 5 || intel
->is_g4x
)
417 msg_type
= G45_DATAPORT_READ_MESSAGE_OWORD_DUAL_BLOCK_READ
;
419 msg_type
= BRW_DATAPORT_READ_MESSAGE_OWORD_DUAL_BLOCK_READ
;
421 /* Each of the 8 channel enables is considered for whether each
424 struct brw_instruction
*send
= brw_next_insn(p
, BRW_OPCODE_SEND
);
425 brw_set_dest(p
, send
, dst
);
426 brw_set_src0(p
, send
, brw_message_reg(inst
->base_mrf
));
427 brw_set_dp_read_message(p
, send
,
428 255, /* binding table index: stateless access */
429 BRW_DATAPORT_OWORD_DUAL_BLOCK_1OWORD
,
431 BRW_DATAPORT_READ_TARGET_RENDER_CACHE
,
437 vec4_visitor::generate_scratch_write(vec4_instruction
*inst
,
440 struct brw_reg index
)
442 /* If the instruction is predicated, we'll predicate the send, not
445 brw_set_predicate_control(p
, false);
447 if (intel
->gen
>= 6) {
448 brw_push_insn_state(p
);
449 brw_set_mask_control(p
, BRW_MASK_DISABLE
);
451 retype(brw_message_reg(inst
->base_mrf
), BRW_REGISTER_TYPE_D
),
452 retype(brw_vec8_grf(0, 0), BRW_REGISTER_TYPE_D
));
453 brw_pop_insn_state(p
);
456 generate_oword_dual_block_offsets(brw_message_reg(inst
->base_mrf
+ 1),
460 retype(brw_message_reg(inst
->base_mrf
+ 2), BRW_REGISTER_TYPE_D
),
461 retype(src
, BRW_REGISTER_TYPE_D
));
466 msg_type
= GEN6_DATAPORT_WRITE_MESSAGE_OWORD_DUAL_BLOCK_WRITE
;
468 msg_type
= BRW_DATAPORT_WRITE_MESSAGE_OWORD_DUAL_BLOCK_WRITE
;
470 brw_set_predicate_control(p
, inst
->predicate
);
472 /* Each of the 8 channel enables is considered for whether each
475 struct brw_instruction
*send
= brw_next_insn(p
, BRW_OPCODE_SEND
);
476 brw_set_dest(p
, send
, dst
);
477 brw_set_src0(p
, send
, brw_message_reg(inst
->base_mrf
));
478 brw_set_dp_write_message(p
, send
,
479 255, /* binding table index: stateless access */
480 BRW_DATAPORT_OWORD_DUAL_BLOCK_1OWORD
,
483 true, /* header present */
484 false, /* pixel scoreboard */
491 vec4_visitor::generate_pull_constant_load(vec4_instruction
*inst
,
493 struct brw_reg index
)
495 struct brw_reg header
= brw_vec8_grf(0, 0);
497 gen6_resolve_implied_move(p
, &header
, inst
->base_mrf
);
499 brw_MOV(p
, retype(brw_message_reg(inst
->base_mrf
+ 1), BRW_REGISTER_TYPE_D
),
505 msg_type
= GEN6_DATAPORT_READ_MESSAGE_OWORD_DUAL_BLOCK_READ
;
506 else if (intel
->gen
== 5 || intel
->is_g4x
)
507 msg_type
= G45_DATAPORT_READ_MESSAGE_OWORD_DUAL_BLOCK_READ
;
509 msg_type
= BRW_DATAPORT_READ_MESSAGE_OWORD_DUAL_BLOCK_READ
;
511 /* Each of the 8 channel enables is considered for whether each
514 struct brw_instruction
*send
= brw_next_insn(p
, BRW_OPCODE_SEND
);
515 brw_set_dest(p
, send
, dst
);
516 brw_set_src0(p
, send
, header
);
517 brw_set_dp_read_message(p
, send
,
518 SURF_INDEX_VERT_CONST_BUFFER
,
519 BRW_DATAPORT_OWORD_DUAL_BLOCK_1OWORD
,
521 BRW_DATAPORT_READ_TARGET_DATA_CACHE
,
527 vec4_visitor::generate_vs_instruction(vec4_instruction
*instruction
,
531 vec4_instruction
*inst
= (vec4_instruction
*)instruction
;
533 switch (inst
->opcode
) {
534 case SHADER_OPCODE_RCP
:
535 case SHADER_OPCODE_RSQ
:
536 case SHADER_OPCODE_SQRT
:
537 case SHADER_OPCODE_EXP2
:
538 case SHADER_OPCODE_LOG2
:
539 case SHADER_OPCODE_SIN
:
540 case SHADER_OPCODE_COS
:
541 if (intel
->gen
>= 6) {
542 generate_math1_gen6(inst
, dst
, src
[0]);
544 generate_math1_gen4(inst
, dst
, src
[0]);
548 case SHADER_OPCODE_POW
:
549 if (intel
->gen
>= 6) {
550 generate_math2_gen6(inst
, dst
, src
[0], src
[1]);
552 generate_math2_gen4(inst
, dst
, src
[0], src
[1]);
556 case VS_OPCODE_URB_WRITE
:
557 generate_urb_write(inst
);
560 case VS_OPCODE_SCRATCH_READ
:
561 generate_scratch_read(inst
, dst
, src
[0]);
564 case VS_OPCODE_SCRATCH_WRITE
:
565 generate_scratch_write(inst
, dst
, src
[0], src
[1]);
568 case VS_OPCODE_PULL_CONSTANT_LOAD
:
569 generate_pull_constant_load(inst
, dst
, src
[0]);
573 if (inst
->opcode
< (int)ARRAY_SIZE(brw_opcodes
)) {
574 fail("unsupported opcode in `%s' in VS\n",
575 brw_opcodes
[inst
->opcode
].name
);
577 fail("Unsupported opcode %d in VS", inst
->opcode
);
585 /* Generate VS IR for main(). (the visitor only descends into
586 * functions called "main").
588 visit_instructions(shader
->ir
);
592 /* Before any optimization, push array accesses out to scratch
593 * space where we need them to be. This pass may allocate new
594 * virtual GRFs, so we want to do it early. It also makes sure
595 * that we have reladdr computations available for CSE, since we'll
596 * often do repeated subexpressions for those.
598 move_grf_array_access_to_scratch();
599 move_uniform_array_access_to_pull_constants();
604 progress
= dead_code_eliminate() || progress
;
607 pack_uniform_registers();
618 brw_set_access_mode(p
, BRW_ALIGN_16
);
626 vec4_visitor::generate_code()
628 int last_native_inst
= p
->nr_insn
;
629 const char *last_annotation_string
= NULL
;
630 ir_instruction
*last_annotation_ir
= NULL
;
632 int loop_stack_array_size
= 16;
633 int loop_stack_depth
= 0;
634 brw_instruction
**loop_stack
=
635 rzalloc_array(this->mem_ctx
, brw_instruction
*, loop_stack_array_size
);
636 int *if_depth_in_loop
=
637 rzalloc_array(this->mem_ctx
, int, loop_stack_array_size
);
640 if (unlikely(INTEL_DEBUG
& DEBUG_VS
)) {
641 printf("Native code for vertex shader %d:\n", prog
->Name
);
644 foreach_list(node
, &this->instructions
) {
645 vec4_instruction
*inst
= (vec4_instruction
*)node
;
646 struct brw_reg src
[3], dst
;
648 if (unlikely(INTEL_DEBUG
& DEBUG_VS
)) {
649 if (last_annotation_ir
!= inst
->ir
) {
650 last_annotation_ir
= inst
->ir
;
651 if (last_annotation_ir
) {
653 last_annotation_ir
->print();
657 if (last_annotation_string
!= inst
->annotation
) {
658 last_annotation_string
= inst
->annotation
;
659 if (last_annotation_string
)
660 printf(" %s\n", last_annotation_string
);
664 for (unsigned int i
= 0; i
< 3; i
++) {
665 src
[i
] = inst
->get_src(i
);
667 dst
= inst
->get_dst();
669 brw_set_conditionalmod(p
, inst
->conditional_mod
);
670 brw_set_predicate_control(p
, inst
->predicate
);
671 brw_set_predicate_inverse(p
, inst
->predicate_inverse
);
672 brw_set_saturate(p
, inst
->saturate
);
674 switch (inst
->opcode
) {
676 brw_MOV(p
, dst
, src
[0]);
679 brw_ADD(p
, dst
, src
[0], src
[1]);
682 brw_MUL(p
, dst
, src
[0], src
[1]);
684 case BRW_OPCODE_MACH
:
685 brw_set_acc_write_control(p
, 1);
686 brw_MACH(p
, dst
, src
[0], src
[1]);
687 brw_set_acc_write_control(p
, 0);
691 brw_FRC(p
, dst
, src
[0]);
693 case BRW_OPCODE_RNDD
:
694 brw_RNDD(p
, dst
, src
[0]);
696 case BRW_OPCODE_RNDE
:
697 brw_RNDE(p
, dst
, src
[0]);
699 case BRW_OPCODE_RNDZ
:
700 brw_RNDZ(p
, dst
, src
[0]);
704 brw_AND(p
, dst
, src
[0], src
[1]);
707 brw_OR(p
, dst
, src
[0], src
[1]);
710 brw_XOR(p
, dst
, src
[0], src
[1]);
713 brw_NOT(p
, dst
, src
[0]);
716 brw_ASR(p
, dst
, src
[0], src
[1]);
719 brw_SHR(p
, dst
, src
[0], src
[1]);
722 brw_SHL(p
, dst
, src
[0], src
[1]);
726 brw_CMP(p
, dst
, inst
->conditional_mod
, src
[0], src
[1]);
729 brw_SEL(p
, dst
, src
[0], src
[1]);
733 brw_DP4(p
, dst
, src
[0], src
[1]);
737 brw_DP3(p
, dst
, src
[0], src
[1]);
741 brw_DP2(p
, dst
, src
[0], src
[1]);
745 if (inst
->src
[0].file
!= BAD_FILE
) {
746 /* The instruction has an embedded compare (only allowed on gen6) */
747 assert(intel
->gen
== 6);
748 gen6_IF(p
, inst
->conditional_mod
, src
[0], src
[1]);
750 struct brw_instruction
*brw_inst
= brw_IF(p
, BRW_EXECUTE_8
);
751 brw_inst
->header
.predicate_control
= inst
->predicate
;
753 if_depth_in_loop
[loop_stack_depth
]++;
756 case BRW_OPCODE_ELSE
:
759 case BRW_OPCODE_ENDIF
:
761 if_depth_in_loop
[loop_stack_depth
]--;
765 loop_stack
[loop_stack_depth
++] = brw_DO(p
, BRW_EXECUTE_8
);
766 if (loop_stack_array_size
<= loop_stack_depth
) {
767 loop_stack_array_size
*= 2;
768 loop_stack
= reralloc(this->mem_ctx
, loop_stack
, brw_instruction
*,
769 loop_stack_array_size
);
770 if_depth_in_loop
= reralloc(this->mem_ctx
, if_depth_in_loop
, int,
771 loop_stack_array_size
);
773 if_depth_in_loop
[loop_stack_depth
] = 0;
776 case BRW_OPCODE_BREAK
:
777 brw_BREAK(p
, if_depth_in_loop
[loop_stack_depth
]);
778 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
780 case BRW_OPCODE_CONTINUE
:
781 /* FINISHME: We need to write the loop instruction support still. */
783 gen6_CONT(p
, loop_stack
[loop_stack_depth
- 1]);
785 brw_CONT(p
, if_depth_in_loop
[loop_stack_depth
]);
786 brw_set_predicate_control(p
, BRW_PREDICATE_NONE
);
789 case BRW_OPCODE_WHILE
: {
790 struct brw_instruction
*inst0
, *inst1
;
796 assert(loop_stack_depth
> 0);
798 inst0
= inst1
= brw_WHILE(p
, loop_stack
[loop_stack_depth
]);
799 if (intel
->gen
< 6) {
800 /* patch all the BREAK/CONT instructions from last BGNLOOP */
801 while (inst0
> loop_stack
[loop_stack_depth
]) {
803 if (inst0
->header
.opcode
== BRW_OPCODE_BREAK
&&
804 inst0
->bits3
.if_else
.jump_count
== 0) {
805 inst0
->bits3
.if_else
.jump_count
= br
* (inst1
- inst0
+ 1);
807 else if (inst0
->header
.opcode
== BRW_OPCODE_CONTINUE
&&
808 inst0
->bits3
.if_else
.jump_count
== 0) {
809 inst0
->bits3
.if_else
.jump_count
= br
* (inst1
- inst0
);
817 generate_vs_instruction(inst
, dst
, src
);
821 if (unlikely(INTEL_DEBUG
& DEBUG_VS
)) {
822 for (unsigned int i
= last_native_inst
; i
< p
->nr_insn
; i
++) {
824 printf("0x%08x 0x%08x 0x%08x 0x%08x ",
825 ((uint32_t *)&p
->store
[i
])[3],
826 ((uint32_t *)&p
->store
[i
])[2],
827 ((uint32_t *)&p
->store
[i
])[1],
828 ((uint32_t *)&p
->store
[i
])[0]);
830 brw_disasm(stdout
, &p
->store
[i
], intel
->gen
);
834 last_native_inst
= p
->nr_insn
;
837 if (unlikely(INTEL_DEBUG
& DEBUG_VS
)) {
841 ralloc_free(loop_stack
);
842 ralloc_free(if_depth_in_loop
);
846 /* OK, while the INTEL_DEBUG=vs above is very nice for debugging VS
847 * emit issues, it doesn't get the jump distances into the output,
848 * which is often something we want to debug. So this is here in
849 * case you're doing that.
852 if (unlikely(INTEL_DEBUG
& DEBUG_VS
)) {
853 for (unsigned int i
= 0; i
< p
->nr_insn
; i
++) {
854 printf("0x%08x 0x%08x 0x%08x 0x%08x ",
855 ((uint32_t *)&p
->store
[i
])[3],
856 ((uint32_t *)&p
->store
[i
])[2],
857 ((uint32_t *)&p
->store
[i
])[1],
858 ((uint32_t *)&p
->store
[i
])[0]);
859 brw_disasm(stdout
, &p
->store
[i
], intel
->gen
);
868 brw_vs_emit(struct gl_shader_program
*prog
, struct brw_vs_compile
*c
)
873 struct brw_shader
*shader
=
874 (brw_shader
*) prog
->_LinkedShaders
[MESA_SHADER_VERTEX
];
878 if (unlikely(INTEL_DEBUG
& DEBUG_VS
)) {
879 printf("GLSL IR for native vertex shader %d:\n", prog
->Name
);
880 _mesa_print_ir(shader
->ir
, NULL
);
884 vec4_visitor
v(c
, prog
, shader
);
886 prog
->LinkStatus
= GL_FALSE
;
887 ralloc_strcat(&prog
->InfoLog
, v
.fail_msg
);
896 } /* namespace brw */