2 * Copyright © 2011 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
25 * \file lower_varyings_to_packed.cpp
27 * This lowering pass generates GLSL code that manually packs varyings into
28 * vec4 slots, for the benefit of back-ends that don't support packed varyings
31 * For example, the following shader:
33 * out mat3x2 foo; // location=4, location_frac=0
34 * out vec3 bar[2]; // location=5, location_frac=2
45 * out vec4 packed4; // location=4, location_frac=0
46 * out vec4 packed5; // location=5, location_frac=0
47 * out vec4 packed6; // location=6, location_frac=0
52 * packed4.xy = foo[0];
53 * packed4.zw = foo[1];
54 * packed5.xy = foo[2];
55 * packed5.zw = bar[0].xy;
56 * packed6.x = bar[0].z;
57 * packed6.yzw = bar[1];
60 * This lowering pass properly handles "double parking" of a varying vector
61 * across two varying slots. For example, in the code above, two of the
62 * components of bar[0] are stored in packed5, and the remaining component is
65 * Note that in theory, the extra instructions may cause some loss of
66 * performance. However, hopefully in most cases the performance loss will
67 * either be absorbed by a later optimization pass, or it will be offset by
68 * memory bandwidth savings (because fewer varyings are used).
70 * This lowering pass also packs flat floats, ints, and uints together, by
71 * using ivec4 as the base type of flat "varyings", and using appropriate
72 * casts to convert floats and uints into ints.
74 * This lowering pass also handles varyings whose type is a struct or an array
75 * of struct. Structs are packed in order and with no gaps, so there may be a
76 * performance penalty due to structure elements being double-parked.
78 * Lowering of geometry shader inputs is slightly more complex, since geometry
79 * inputs are always arrays, so we need to lower arrays to arrays. For
80 * example, the following input:
86 * } arr[3]; // location=4, location_frac=0
88 * Would get lowered like this if it occurred in a fragment shader:
95 * in vec4 packed4; // location=4, location_frac=0
96 * in vec4 packed5; // location=5, location_frac=0
97 * in vec4 packed6; // location=6, location_frac=0
98 * in vec4 packed7; // location=7, location_frac=0
99 * in vec4 packed8; // location=8, location_frac=0
100 * in vec4 packed9; // location=9, location_frac=0
104 * arr[0].f = packed4.x;
105 * arr[0].v = packed4.yzw;
106 * arr[0].a[0] = packed5.xy;
107 * arr[0].a[1] = packed5.zw;
108 * arr[1].f = packed6.x;
109 * arr[1].v = packed6.yzw;
110 * arr[1].a[0] = packed7.xy;
111 * arr[1].a[1] = packed7.zw;
112 * arr[2].f = packed8.x;
113 * arr[2].v = packed8.yzw;
114 * arr[2].a[0] = packed9.xy;
115 * arr[2].a[1] = packed9.zw;
119 * But it would get lowered like this if it occurred in a geometry shader:
126 * in vec4 packed4[3]; // location=4, location_frac=0
127 * in vec4 packed5[3]; // location=5, location_frac=0
131 * arr[0].f = packed4[0].x;
132 * arr[0].v = packed4[0].yzw;
133 * arr[0].a[0] = packed5[0].xy;
134 * arr[0].a[1] = packed5[0].zw;
135 * arr[1].f = packed4[1].x;
136 * arr[1].v = packed4[1].yzw;
137 * arr[1].a[0] = packed5[1].xy;
138 * arr[1].a[1] = packed5[1].zw;
139 * arr[2].f = packed4[2].x;
140 * arr[2].v = packed4[2].yzw;
141 * arr[2].a[0] = packed5[2].xy;
142 * arr[2].a[1] = packed5[2].zw;
147 #include "glsl_symbol_table.h"
149 #include "ir_builder.h"
150 #include "ir_optimization.h"
151 #include "program/prog_instruction.h"
152 #include "main/mtypes.h"
154 using namespace ir_builder
;
159 * Visitor that performs varying packing. For each varying declared in the
160 * shader, this visitor determines whether it needs to be packed. If so, it
161 * demotes it to an ordinary global, creates new packed varyings, and
162 * generates assignments to convert between the original varying and the
165 class lower_packed_varyings_visitor
168 lower_packed_varyings_visitor(void *mem_ctx
,
169 unsigned locations_used
,
170 const uint8_t *components
,
171 ir_variable_mode mode
,
172 unsigned gs_input_vertices
,
173 exec_list
*out_instructions
,
174 exec_list
*out_variables
,
175 bool disable_varying_packing
,
176 bool disable_xfb_packing
,
179 void run(struct gl_linked_shader
*shader
);
182 void bitwise_assign_pack(ir_rvalue
*lhs
, ir_rvalue
*rhs
);
183 void bitwise_assign_unpack(ir_rvalue
*lhs
, ir_rvalue
*rhs
);
184 unsigned lower_rvalue(ir_rvalue
*rvalue
, unsigned fine_location
,
185 ir_variable
*unpacked_var
, const char *name
,
186 bool gs_input_toplevel
, unsigned vertex_index
);
187 unsigned lower_arraylike(ir_rvalue
*rvalue
, unsigned array_size
,
188 unsigned fine_location
,
189 ir_variable
*unpacked_var
, const char *name
,
190 bool gs_input_toplevel
, unsigned vertex_index
);
191 ir_dereference
*get_packed_varying_deref(unsigned location
,
192 ir_variable
*unpacked_var
,
194 unsigned vertex_index
);
195 bool needs_lowering(ir_variable
*var
);
198 * Memory context used to allocate new instructions for the shader.
200 void * const mem_ctx
;
203 * Number of generic varying slots which are used by this shader. This is
204 * used to allocate temporary intermediate data structures. If any varying
205 * used by this shader has a location greater than or equal to
206 * VARYING_SLOT_VAR0 + locations_used, an assertion will fire.
208 const unsigned locations_used
;
210 const uint8_t* components
;
213 * Array of pointers to the packed varyings that have been created for each
214 * generic varying slot. NULL entries in this array indicate varying slots
215 * for which a packed varying has not been created yet.
217 ir_variable
**packed_varyings
;
220 * Type of varying which is being lowered in this pass (either
221 * ir_var_shader_in or ir_var_shader_out).
223 const ir_variable_mode mode
;
226 * If we are currently lowering geometry shader inputs, the number of input
227 * vertices the geometry shader accepts. Otherwise zero.
229 const unsigned gs_input_vertices
;
232 * Exec list into which the visitor should insert the packing instructions.
233 * Caller provides this list; it should insert the instructions into the
234 * appropriate place in the shader once the visitor has finished running.
236 exec_list
*out_instructions
;
239 * Exec list into which the visitor should insert any new variables.
241 exec_list
*out_variables
;
243 bool disable_varying_packing
;
244 bool disable_xfb_packing
;
248 } /* anonymous namespace */
250 lower_packed_varyings_visitor::lower_packed_varyings_visitor(
251 void *mem_ctx
, unsigned locations_used
, const uint8_t *components
,
252 ir_variable_mode mode
,
253 unsigned gs_input_vertices
, exec_list
*out_instructions
,
254 exec_list
*out_variables
, bool disable_varying_packing
,
255 bool disable_xfb_packing
, bool xfb_enabled
)
257 locations_used(locations_used
),
258 components(components
),
259 packed_varyings((ir_variable
**)
260 rzalloc_array_size(mem_ctx
, sizeof(*packed_varyings
),
263 gs_input_vertices(gs_input_vertices
),
264 out_instructions(out_instructions
),
265 out_variables(out_variables
),
266 disable_varying_packing(disable_varying_packing
),
267 disable_xfb_packing(disable_xfb_packing
),
268 xfb_enabled(xfb_enabled
)
273 lower_packed_varyings_visitor::run(struct gl_linked_shader
*shader
)
275 foreach_in_list(ir_instruction
, node
, shader
->ir
) {
276 ir_variable
*var
= node
->as_variable();
280 if (var
->data
.mode
!= this->mode
||
281 var
->data
.location
< VARYING_SLOT_VAR0
||
282 !this->needs_lowering(var
))
285 /* This lowering pass is only capable of packing floats and ints
286 * together when their interpolation mode is "flat". Treat integers as
287 * being flat when the interpolation mode is none.
289 assert(var
->data
.interpolation
== INTERP_MODE_FLAT
||
290 var
->data
.interpolation
== INTERP_MODE_NONE
||
291 !var
->type
->contains_integer());
293 /* Clone the variable for program resource list before
294 * it gets modified and lost.
296 if (!shader
->packed_varyings
)
297 shader
->packed_varyings
= new (shader
) exec_list
;
299 shader
->packed_varyings
->push_tail(var
->clone(shader
, NULL
));
301 /* Change the old varying into an ordinary global. */
302 assert(var
->data
.mode
!= ir_var_temporary
);
303 var
->data
.mode
= ir_var_auto
;
305 /* Create a reference to the old varying. */
306 ir_dereference_variable
*deref
307 = new(this->mem_ctx
) ir_dereference_variable(var
);
309 /* Recursively pack or unpack it. */
310 this->lower_rvalue(deref
, var
->data
.location
* 4 + var
->data
.location_frac
, var
,
311 var
->name
, this->gs_input_vertices
!= 0, 0);
315 #define SWIZZLE_ZWZW MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W)
318 * Make an ir_assignment from \c rhs to \c lhs, performing appropriate
319 * bitcasts if necessary to match up types.
321 * This function is called when packing varyings.
324 lower_packed_varyings_visitor::bitwise_assign_pack(ir_rvalue
*lhs
,
327 if (lhs
->type
->base_type
!= rhs
->type
->base_type
) {
328 /* Since we only mix types in flat varyings, and we always store flat
329 * varyings as type ivec4, we need only produce conversions from (uint
332 assert(lhs
->type
->base_type
== GLSL_TYPE_INT
);
333 switch (rhs
->type
->base_type
) {
335 rhs
= new(this->mem_ctx
)
336 ir_expression(ir_unop_u2i
, lhs
->type
, rhs
);
338 case GLSL_TYPE_FLOAT
:
339 rhs
= new(this->mem_ctx
)
340 ir_expression(ir_unop_bitcast_f2i
, lhs
->type
, rhs
);
342 case GLSL_TYPE_DOUBLE
:
343 assert(rhs
->type
->vector_elements
<= 2);
344 if (rhs
->type
->vector_elements
== 2) {
345 ir_variable
*t
= new(mem_ctx
) ir_variable(lhs
->type
, "pack", ir_var_temporary
);
347 assert(lhs
->type
->vector_elements
== 4);
348 this->out_variables
->push_tail(t
);
349 this->out_instructions
->push_tail(
350 assign(t
, u2i(expr(ir_unop_unpack_double_2x32
, swizzle_x(rhs
->clone(mem_ctx
, NULL
)))), 0x3));
351 this->out_instructions
->push_tail(
352 assign(t
, u2i(expr(ir_unop_unpack_double_2x32
, swizzle_y(rhs
))), 0xc));
355 rhs
= u2i(expr(ir_unop_unpack_double_2x32
, rhs
));
358 case GLSL_TYPE_INT64
:
359 assert(rhs
->type
->vector_elements
<= 2);
360 if (rhs
->type
->vector_elements
== 2) {
361 ir_variable
*t
= new(mem_ctx
) ir_variable(lhs
->type
, "pack", ir_var_temporary
);
363 assert(lhs
->type
->vector_elements
== 4);
364 this->out_variables
->push_tail(t
);
365 this->out_instructions
->push_tail(
366 assign(t
, expr(ir_unop_unpack_int_2x32
, swizzle_x(rhs
->clone(mem_ctx
, NULL
))), 0x3));
367 this->out_instructions
->push_tail(
368 assign(t
, expr(ir_unop_unpack_int_2x32
, swizzle_y(rhs
)), 0xc));
371 rhs
= expr(ir_unop_unpack_int_2x32
, rhs
);
374 case GLSL_TYPE_UINT64
:
375 assert(rhs
->type
->vector_elements
<= 2);
376 if (rhs
->type
->vector_elements
== 2) {
377 ir_variable
*t
= new(mem_ctx
) ir_variable(lhs
->type
, "pack", ir_var_temporary
);
379 assert(lhs
->type
->vector_elements
== 4);
380 this->out_variables
->push_tail(t
);
381 this->out_instructions
->push_tail(
382 assign(t
, u2i(expr(ir_unop_unpack_uint_2x32
, swizzle_x(rhs
->clone(mem_ctx
, NULL
)))), 0x3));
383 this->out_instructions
->push_tail(
384 assign(t
, u2i(expr(ir_unop_unpack_uint_2x32
, swizzle_y(rhs
))), 0xc));
387 rhs
= u2i(expr(ir_unop_unpack_uint_2x32
, rhs
));
390 case GLSL_TYPE_SAMPLER
:
391 rhs
= u2i(expr(ir_unop_unpack_sampler_2x32
, rhs
));
393 case GLSL_TYPE_IMAGE
:
394 rhs
= u2i(expr(ir_unop_unpack_image_2x32
, rhs
));
397 assert(!"Unexpected type conversion while lowering varyings");
401 this->out_instructions
->push_tail(new (this->mem_ctx
) ir_assignment(lhs
, rhs
));
406 * Make an ir_assignment from \c rhs to \c lhs, performing appropriate
407 * bitcasts if necessary to match up types.
409 * This function is called when unpacking varyings.
412 lower_packed_varyings_visitor::bitwise_assign_unpack(ir_rvalue
*lhs
,
415 if (lhs
->type
->base_type
!= rhs
->type
->base_type
) {
416 /* Since we only mix types in flat varyings, and we always store flat
417 * varyings as type ivec4, we need only produce conversions from int to
420 assert(rhs
->type
->base_type
== GLSL_TYPE_INT
);
421 switch (lhs
->type
->base_type
) {
423 rhs
= new(this->mem_ctx
)
424 ir_expression(ir_unop_i2u
, lhs
->type
, rhs
);
426 case GLSL_TYPE_FLOAT
:
427 rhs
= new(this->mem_ctx
)
428 ir_expression(ir_unop_bitcast_i2f
, lhs
->type
, rhs
);
430 case GLSL_TYPE_DOUBLE
:
431 assert(lhs
->type
->vector_elements
<= 2);
432 if (lhs
->type
->vector_elements
== 2) {
433 ir_variable
*t
= new(mem_ctx
) ir_variable(lhs
->type
, "unpack", ir_var_temporary
);
434 assert(rhs
->type
->vector_elements
== 4);
435 this->out_variables
->push_tail(t
);
436 this->out_instructions
->push_tail(
437 assign(t
, expr(ir_unop_pack_double_2x32
, i2u(swizzle_xy(rhs
->clone(mem_ctx
, NULL
)))), 0x1));
438 this->out_instructions
->push_tail(
439 assign(t
, expr(ir_unop_pack_double_2x32
, i2u(swizzle(rhs
->clone(mem_ctx
, NULL
), SWIZZLE_ZWZW
, 2))), 0x2));
442 rhs
= expr(ir_unop_pack_double_2x32
, i2u(rhs
));
445 case GLSL_TYPE_INT64
:
446 assert(lhs
->type
->vector_elements
<= 2);
447 if (lhs
->type
->vector_elements
== 2) {
448 ir_variable
*t
= new(mem_ctx
) ir_variable(lhs
->type
, "unpack", ir_var_temporary
);
449 assert(rhs
->type
->vector_elements
== 4);
450 this->out_variables
->push_tail(t
);
451 this->out_instructions
->push_tail(
452 assign(t
, expr(ir_unop_pack_int_2x32
, swizzle_xy(rhs
->clone(mem_ctx
, NULL
))), 0x1));
453 this->out_instructions
->push_tail(
454 assign(t
, expr(ir_unop_pack_int_2x32
, swizzle(rhs
->clone(mem_ctx
, NULL
), SWIZZLE_ZWZW
, 2)), 0x2));
457 rhs
= expr(ir_unop_pack_int_2x32
, rhs
);
460 case GLSL_TYPE_UINT64
:
461 assert(lhs
->type
->vector_elements
<= 2);
462 if (lhs
->type
->vector_elements
== 2) {
463 ir_variable
*t
= new(mem_ctx
) ir_variable(lhs
->type
, "unpack", ir_var_temporary
);
464 assert(rhs
->type
->vector_elements
== 4);
465 this->out_variables
->push_tail(t
);
466 this->out_instructions
->push_tail(
467 assign(t
, expr(ir_unop_pack_uint_2x32
, i2u(swizzle_xy(rhs
->clone(mem_ctx
, NULL
)))), 0x1));
468 this->out_instructions
->push_tail(
469 assign(t
, expr(ir_unop_pack_uint_2x32
, i2u(swizzle(rhs
->clone(mem_ctx
, NULL
), SWIZZLE_ZWZW
, 2))), 0x2));
472 rhs
= expr(ir_unop_pack_uint_2x32
, i2u(rhs
));
475 case GLSL_TYPE_SAMPLER
:
477 ir_expression(ir_unop_pack_sampler_2x32
, lhs
->type
, i2u(rhs
));
479 case GLSL_TYPE_IMAGE
:
481 ir_expression(ir_unop_pack_image_2x32
, lhs
->type
, i2u(rhs
));
484 assert(!"Unexpected type conversion while lowering varyings");
488 this->out_instructions
->push_tail(new(this->mem_ctx
) ir_assignment(lhs
, rhs
));
493 * Recursively pack or unpack the given varying (or portion of a varying) by
494 * traversing all of its constituent vectors.
496 * \param fine_location is the location where the first constituent vector
497 * should be packed--the word "fine" indicates that this location is expressed
498 * in multiples of a float, rather than multiples of a vec4 as is used
501 * \param gs_input_toplevel should be set to true if we are lowering geometry
502 * shader inputs, and we are currently lowering the whole input variable
503 * (i.e. we are lowering the array whose index selects the vertex).
505 * \param vertex_index: if we are lowering geometry shader inputs, and the
506 * level of the array that we are currently lowering is *not* the top level,
507 * then this indicates which vertex we are currently lowering. Otherwise it
510 * \return the location where the next constituent vector (after this one)
514 lower_packed_varyings_visitor::lower_rvalue(ir_rvalue
*rvalue
,
515 unsigned fine_location
,
516 ir_variable
*unpacked_var
,
518 bool gs_input_toplevel
,
519 unsigned vertex_index
)
521 unsigned dmul
= rvalue
->type
->is_64bit() ? 2 : 1;
522 /* When gs_input_toplevel is set, we should be looking at a geometry shader
525 assert(!gs_input_toplevel
|| rvalue
->type
->is_array());
527 if (rvalue
->type
->is_struct()) {
528 for (unsigned i
= 0; i
< rvalue
->type
->length
; i
++) {
530 rvalue
= rvalue
->clone(this->mem_ctx
, NULL
);
531 const char *field_name
= rvalue
->type
->fields
.structure
[i
].name
;
532 ir_dereference_record
*dereference_record
= new(this->mem_ctx
)
533 ir_dereference_record(rvalue
, field_name
);
535 = ralloc_asprintf(this->mem_ctx
, "%s.%s", name
, field_name
);
536 fine_location
= this->lower_rvalue(dereference_record
, fine_location
,
537 unpacked_var
, deref_name
, false,
540 return fine_location
;
541 } else if (rvalue
->type
->is_array()) {
542 /* Arrays are packed/unpacked by considering each array element in
545 return this->lower_arraylike(rvalue
, rvalue
->type
->array_size(),
546 fine_location
, unpacked_var
, name
,
547 gs_input_toplevel
, vertex_index
);
548 } else if (rvalue
->type
->is_matrix()) {
549 /* Matrices are packed/unpacked by considering each column vector in
552 return this->lower_arraylike(rvalue
, rvalue
->type
->matrix_columns
,
553 fine_location
, unpacked_var
, name
,
554 false, vertex_index
);
555 } else if (rvalue
->type
->vector_elements
* dmul
+
556 fine_location
% 4 > 4) {
557 /* This vector is going to be "double parked" across two varying slots,
558 * so handle it as two separate assignments. For doubles, a dvec3/dvec4
559 * can end up being spread over 3 slots. However the second splitting
560 * will happen later, here we just always want to split into 2.
562 unsigned left_components
, right_components
;
563 unsigned left_swizzle_values
[4] = { 0, 0, 0, 0 };
564 unsigned right_swizzle_values
[4] = { 0, 0, 0, 0 };
565 char left_swizzle_name
[4] = { 0, 0, 0, 0 };
566 char right_swizzle_name
[4] = { 0, 0, 0, 0 };
568 left_components
= 4 - fine_location
% 4;
569 if (rvalue
->type
->is_64bit()) {
570 /* We might actually end up with 0 left components! */
571 left_components
/= 2;
573 right_components
= rvalue
->type
->vector_elements
- left_components
;
575 for (unsigned i
= 0; i
< left_components
; i
++) {
576 left_swizzle_values
[i
] = i
;
577 left_swizzle_name
[i
] = "xyzw"[i
];
579 for (unsigned i
= 0; i
< right_components
; i
++) {
580 right_swizzle_values
[i
] = i
+ left_components
;
581 right_swizzle_name
[i
] = "xyzw"[i
+ left_components
];
583 ir_swizzle
*left_swizzle
= new(this->mem_ctx
)
584 ir_swizzle(rvalue
, left_swizzle_values
, left_components
);
585 ir_swizzle
*right_swizzle
= new(this->mem_ctx
)
586 ir_swizzle(rvalue
->clone(this->mem_ctx
, NULL
), right_swizzle_values
,
589 = ralloc_asprintf(this->mem_ctx
, "%s.%s", name
, left_swizzle_name
);
591 = ralloc_asprintf(this->mem_ctx
, "%s.%s", name
, right_swizzle_name
);
593 fine_location
= this->lower_rvalue(left_swizzle
, fine_location
,
594 unpacked_var
, left_name
, false,
597 /* Top up the fine location to the next slot */
599 return this->lower_rvalue(right_swizzle
, fine_location
, unpacked_var
,
600 right_name
, false, vertex_index
);
602 /* No special handling is necessary; pack the rvalue into the
605 unsigned swizzle_values
[4] = { 0, 0, 0, 0 };
606 unsigned components
= rvalue
->type
->vector_elements
* dmul
;
607 unsigned location
= fine_location
/ 4;
608 unsigned location_frac
= fine_location
% 4;
609 for (unsigned i
= 0; i
< components
; ++i
)
610 swizzle_values
[i
] = i
+ location_frac
;
611 ir_dereference
*packed_deref
=
612 this->get_packed_varying_deref(location
, unpacked_var
, name
,
614 if (unpacked_var
->data
.stream
!= 0) {
615 assert(unpacked_var
->data
.stream
< 4);
616 ir_variable
*packed_var
= packed_deref
->variable_referenced();
617 for (unsigned i
= 0; i
< components
; ++i
) {
618 packed_var
->data
.stream
|=
619 unpacked_var
->data
.stream
<< (2 * (location_frac
+ i
));
622 ir_swizzle
*swizzle
= new(this->mem_ctx
)
623 ir_swizzle(packed_deref
, swizzle_values
, components
);
624 if (this->mode
== ir_var_shader_out
) {
625 this->bitwise_assign_pack(swizzle
, rvalue
);
627 this->bitwise_assign_unpack(rvalue
, swizzle
);
629 return fine_location
+ components
;
634 * Recursively pack or unpack a varying for which we need to iterate over its
635 * constituent elements, accessing each one using an ir_dereference_array.
636 * This takes care of both arrays and matrices, since ir_dereference_array
637 * treats a matrix like an array of its column vectors.
639 * \param gs_input_toplevel should be set to true if we are lowering geometry
640 * shader inputs, and we are currently lowering the whole input variable
641 * (i.e. we are lowering the array whose index selects the vertex).
643 * \param vertex_index: if we are lowering geometry shader inputs, and the
644 * level of the array that we are currently lowering is *not* the top level,
645 * then this indicates which vertex we are currently lowering. Otherwise it
649 lower_packed_varyings_visitor::lower_arraylike(ir_rvalue
*rvalue
,
651 unsigned fine_location
,
652 ir_variable
*unpacked_var
,
654 bool gs_input_toplevel
,
655 unsigned vertex_index
)
657 for (unsigned i
= 0; i
< array_size
; i
++) {
659 rvalue
= rvalue
->clone(this->mem_ctx
, NULL
);
660 ir_constant
*constant
= new(this->mem_ctx
) ir_constant(i
);
661 ir_dereference_array
*dereference_array
= new(this->mem_ctx
)
662 ir_dereference_array(rvalue
, constant
);
663 if (gs_input_toplevel
) {
664 /* Geometry shader inputs are a special case. Instead of storing
665 * each element of the array at a different location, all elements
666 * are at the same location, but with a different vertex index.
668 (void) this->lower_rvalue(dereference_array
, fine_location
,
669 unpacked_var
, name
, false, i
);
671 char *subscripted_name
672 = ralloc_asprintf(this->mem_ctx
, "%s[%d]", name
, i
);
674 this->lower_rvalue(dereference_array
, fine_location
,
675 unpacked_var
, subscripted_name
,
676 false, vertex_index
);
679 return fine_location
;
683 * Retrieve the packed varying corresponding to the given varying location.
684 * If no packed varying has been created for the given varying location yet,
685 * create it and add it to the shader before returning it.
687 * The newly created varying inherits its interpolation parameters from \c
688 * unpacked_var. Its base type is ivec4 if we are lowering a flat varying,
691 * \param vertex_index: if we are lowering geometry shader inputs, then this
692 * indicates which vertex we are currently lowering. Otherwise it is ignored.
695 lower_packed_varyings_visitor::get_packed_varying_deref(
696 unsigned location
, ir_variable
*unpacked_var
, const char *name
,
697 unsigned vertex_index
)
699 unsigned slot
= location
- VARYING_SLOT_VAR0
;
700 assert(slot
< locations_used
);
701 if (this->packed_varyings
[slot
] == NULL
) {
702 char *packed_name
= ralloc_asprintf(this->mem_ctx
, "packed:%s", name
);
703 const glsl_type
*packed_type
;
704 assert(components
[slot
] != 0);
705 if (unpacked_var
->is_interpolation_flat())
706 packed_type
= glsl_type::get_instance(GLSL_TYPE_INT
, components
[slot
], 1);
708 packed_type
= glsl_type::get_instance(GLSL_TYPE_FLOAT
, components
[slot
], 1);
709 if (this->gs_input_vertices
!= 0) {
711 glsl_type::get_array_instance(packed_type
,
712 this->gs_input_vertices
);
714 ir_variable
*packed_var
= new(this->mem_ctx
)
715 ir_variable(packed_type
, packed_name
, this->mode
);
716 if (this->gs_input_vertices
!= 0) {
717 /* Prevent update_array_sizes() from messing with the size of the
720 packed_var
->data
.max_array_access
= this->gs_input_vertices
- 1;
722 packed_var
->data
.centroid
= unpacked_var
->data
.centroid
;
723 packed_var
->data
.sample
= unpacked_var
->data
.sample
;
724 packed_var
->data
.patch
= unpacked_var
->data
.patch
;
725 packed_var
->data
.interpolation
=
726 packed_type
->without_array() == glsl_type::ivec4_type
727 ? unsigned(INTERP_MODE_FLAT
) : unpacked_var
->data
.interpolation
;
728 packed_var
->data
.location
= location
;
729 packed_var
->data
.precision
= unpacked_var
->data
.precision
;
730 packed_var
->data
.always_active_io
= unpacked_var
->data
.always_active_io
;
731 packed_var
->data
.stream
= 1u << 31;
732 unpacked_var
->insert_before(packed_var
);
733 this->packed_varyings
[slot
] = packed_var
;
735 ir_variable
*var
= this->packed_varyings
[slot
];
737 /* The slot needs to be marked as always active if any variable that got
740 var
->data
.always_active_io
|= unpacked_var
->data
.always_active_io
;
742 /* For geometry shader inputs, only update the packed variable name the
743 * first time we visit each component.
745 if (this->gs_input_vertices
== 0 || vertex_index
== 0) {
746 if (var
->is_name_ralloced())
747 ralloc_asprintf_append((char **) &var
->name
, ",%s", name
);
749 var
->name
= ralloc_asprintf(var
, "%s,%s", var
->name
, name
);
753 ir_dereference
*deref
= new(this->mem_ctx
)
754 ir_dereference_variable(this->packed_varyings
[slot
]);
755 if (this->gs_input_vertices
!= 0) {
756 /* When lowering GS inputs, the packed variable is an array, so we need
757 * to dereference it using vertex_index.
759 ir_constant
*constant
= new(this->mem_ctx
) ir_constant(vertex_index
);
760 deref
= new(this->mem_ctx
) ir_dereference_array(deref
, constant
);
766 lower_packed_varyings_visitor::needs_lowering(ir_variable
*var
)
768 /* Things composed of vec4's, varyings with explicitly assigned
769 * locations or varyings marked as must_be_shader_input (which might be used
770 * by interpolateAt* functions) shouldn't be lowered. Everything else can be.
772 if (var
->data
.explicit_location
|| var
->data
.must_be_shader_input
)
775 const glsl_type
*type
= var
->type
;
777 /* Some drivers (e.g. panfrost) don't support packing of transform
780 if (disable_xfb_packing
&& var
->data
.is_xfb
&&
781 !(type
->is_array() || type
->is_struct() || type
->is_matrix()) &&
785 /* Override disable_varying_packing if the var is only used by transform
786 * feedback. Also override it if transform feedback is enabled and the
787 * variable is an array, struct or matrix as the elements of these types
788 * will always have the same interpolation and therefore are safe to pack.
790 if (disable_varying_packing
&& !var
->data
.is_xfb_only
&&
791 !((type
->is_array() || type
->is_struct() || type
->is_matrix()) &&
795 type
= type
->without_array();
796 if (type
->vector_elements
== 4 && !type
->is_64bit())
803 * Visitor that splices varying packing code before every use of EmitVertex()
804 * in a geometry shader.
806 class lower_packed_varyings_gs_splicer
: public ir_hierarchical_visitor
809 explicit lower_packed_varyings_gs_splicer(void *mem_ctx
,
810 const exec_list
*instructions
);
812 virtual ir_visitor_status
visit_leave(ir_emit_vertex
*ev
);
816 * Memory context used to allocate new instructions for the shader.
818 void * const mem_ctx
;
821 * Instructions that should be spliced into place before each EmitVertex()
824 const exec_list
*instructions
;
828 lower_packed_varyings_gs_splicer::lower_packed_varyings_gs_splicer(
829 void *mem_ctx
, const exec_list
*instructions
)
830 : mem_ctx(mem_ctx
), instructions(instructions
)
836 lower_packed_varyings_gs_splicer::visit_leave(ir_emit_vertex
*ev
)
838 foreach_in_list(ir_instruction
, ir
, this->instructions
) {
839 ev
->insert_before(ir
->clone(this->mem_ctx
, NULL
));
841 return visit_continue
;
845 * Visitor that splices varying packing code before every return.
847 class lower_packed_varyings_return_splicer
: public ir_hierarchical_visitor
850 explicit lower_packed_varyings_return_splicer(void *mem_ctx
,
851 const exec_list
*instructions
);
853 virtual ir_visitor_status
visit_leave(ir_return
*ret
);
857 * Memory context used to allocate new instructions for the shader.
859 void * const mem_ctx
;
862 * Instructions that should be spliced into place before each return.
864 const exec_list
*instructions
;
868 lower_packed_varyings_return_splicer::lower_packed_varyings_return_splicer(
869 void *mem_ctx
, const exec_list
*instructions
)
870 : mem_ctx(mem_ctx
), instructions(instructions
)
876 lower_packed_varyings_return_splicer::visit_leave(ir_return
*ret
)
878 foreach_in_list(ir_instruction
, ir
, this->instructions
) {
879 ret
->insert_before(ir
->clone(this->mem_ctx
, NULL
));
881 return visit_continue
;
885 lower_packed_varyings(void *mem_ctx
, unsigned locations_used
,
886 const uint8_t *components
,
887 ir_variable_mode mode
, unsigned gs_input_vertices
,
888 gl_linked_shader
*shader
, bool disable_varying_packing
,
889 bool disable_xfb_packing
, bool xfb_enabled
)
891 exec_list
*instructions
= shader
->ir
;
892 ir_function
*main_func
= shader
->symbols
->get_function("main");
893 exec_list void_parameters
;
894 ir_function_signature
*main_func_sig
895 = main_func
->matching_signature(NULL
, &void_parameters
, false);
896 exec_list new_instructions
, new_variables
;
897 lower_packed_varyings_visitor
visitor(mem_ctx
,
904 disable_varying_packing
,
908 if (mode
== ir_var_shader_out
) {
909 if (shader
->Stage
== MESA_SHADER_GEOMETRY
) {
910 /* For geometry shaders, outputs need to be lowered before each call
913 lower_packed_varyings_gs_splicer
splicer(mem_ctx
, &new_instructions
);
915 /* Add all the variables in first. */
916 main_func_sig
->body
.get_head_raw()->insert_before(&new_variables
);
918 /* Now update all the EmitVertex instances */
919 splicer
.run(instructions
);
921 /* For other shader types, outputs need to be lowered before each
922 * return statement and at the end of main()
925 lower_packed_varyings_return_splicer
splicer(mem_ctx
, &new_instructions
);
927 main_func_sig
->body
.get_head_raw()->insert_before(&new_variables
);
929 splicer
.run(instructions
);
931 /* Lower outputs at the end of main() if the last instruction is not
934 if (((ir_instruction
*)instructions
->get_tail())->ir_type
!= ir_type_return
) {
935 main_func_sig
->body
.append_list(&new_instructions
);
939 /* Shader inputs need to be lowered at the beginning of main() */
940 main_func_sig
->body
.get_head_raw()->insert_before(&new_instructions
);
941 main_func_sig
->body
.get_head_raw()->insert_before(&new_variables
);