OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6bb9acfb4eb3f6a2c61e03cbd5a6c6c464d2ae0c
third_party_mesa3d/src/glsl/ir_optimization.h

116 lines
5.0 KiB
C
Raw Normal View History

ir_dead_code_local: Remove redundant assignments within basic blocks. This cleans up a bunch of junk code in some of the GLSL parser tests, and could potentially help real-world too (particularly after copy propagation has happened).
2010-05-05 10:37:25 -07:00
/*
* Copyright © 2010 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
/**
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
* \file ir_optimization.h
ir_dead_code_local: Remove redundant assignments within basic blocks. This cleans up a bunch of junk code in some of the GLSL parser tests, and could potentially help real-world too (particularly after copy propagation has happened).
2010-05-05 10:37:25 -07:00
*
* Prototypes for optimization passes to be called by the compiler and drivers.
*/
glsl: Combine many instruction lowering passes into one. This should save on the overhead of tree-walking and provide a convenient place to add more instruction lowering in the future. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-11-18 17:54:07 -08:00
/* Operations for lower_instructions() */
glsl: Use a separate div_to_mul_rcp lowering flag for integers. Using multiply and reciprocal for integer division involves potentially lossy floating point conversions. This is okay for older GPUs that represent integers as floating point, but undesirable for GPUs with native integer division instructions. TGSI, for example, has UDIV/IDIV instructions for integer division, so it makes sense to handle this directly. Likewise for i965. Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> Signed-off-by: Bryan Cain <bryancain3@gmail.com> Signed-off-by: Kenneth Graunke <kenneth@whitecape.org>
2011-08-27 18:32:58 -05:00
#define SUB_TO_ADD_NEG 0x01
#define DIV_TO_MUL_RCP 0x02
#define EXP_TO_EXP2 0x04
#define POW_TO_EXP2 0x08
#define LOG_TO_LOG2 0x10
#define MOD_TO_FRACT 0x20
#define INT_DIV_TO_MUL_RCP 0x40
glsl: Convert mix() to use a new ir_triop_lrp opcode. Many GPUs have an instruction to do linear interpolation which is more efficient than simply performing the algebra necessary (two multiplies, an add, and a subtract). Pattern matching or peepholing this is more desirable, but can be tricky. By using an opcode, we can at least make shaders which use the mix() built-in get the more efficient behavior. Currently, all consumers lower ir_triop_lrp. Subsequent patches will actually generate different code. v2 [mattst88]: - Add LRP_TO_ARITH flag to ir_to_mesa.cpp. Will be removed in a subsequent patch and ir_triop_lrp translated directly. v3 [mattst88]: - Move changes from the next patch to opt_algebraic.cpp to accept 3-src operations. Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net> Signed-off-by: Kenneth Graunke <kenneth@whitecape.org>
2012-12-01 23:49:26 -08:00
#define LRP_TO_ARITH 0x80
glsl: Add a pass to lower bitfield-insert into bfm+bfi. i965/Gen7+ and Radeon/Evergreen+ have bfm/bfi instructions to implement bitfieldInsert() from ARB_gpu_shader5. v2: Add ir_binop_bfm and ir_triop_bfi to st_glsl_to_tgsi.cpp. Remove spurious temporary assignment and dereference. Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
2013-04-09 22:43:05 -07:00
#define BITFIELD_INSERT_TO_BFM_BFI 0x100
glsl: Combine many instruction lowering passes into one. This should save on the overhead of tree-walking and provide a convenient place to add more instruction lowering in the future. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-11-18 17:54:07 -08:00
glsl: Add lowering pass for GLSL ES 3.00 pack/unpack operations (v4) Lower them to arithmetic and bit manipulation expressions. v2: Rewrite using ir_builder [for idr]. v3: Comment typos. [for mattst88] v4: Fix arithmetic error in comments. Factor out a shift instruction. Don't heap allocate factory.instructions. [for paul] Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> (v2) Reviewed-by: Matt Tuner <mattst88@gmail.com> (v3) Reviewed-by: Paul Berry <stereotype441@gmail.com> (v4) Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 15:15:32 -08:00
/**
* \see class lower_packing_builtins_visitor
*/
enum lower_packing_builtins_op {
LOWER_PACK_UNPACK_NONE = 0x0000,
LOWER_PACK_SNORM_2x16 = 0x0001,
LOWER_UNPACK_SNORM_2x16 = 0x0002,
LOWER_PACK_UNORM_2x16 = 0x0004,
LOWER_UNPACK_UNORM_2x16 = 0x0008,
LOWER_PACK_HALF_2x16 = 0x0010,
LOWER_UNPACK_HALF_2x16 = 0x0020,
LOWER_PACK_HALF_2x16_TO_SPLIT = 0x0040,
LOWER_UNPACK_HALF_2x16_TO_SPLIT = 0x0080,
glsl: Add support for lowering 4x8 pack/unpack operations Lower them to arithmetic and bit manipulation expressions. Reviewed-by: Chad Versace <chad.versace@linux.intel.com> Reviewed-by: Paul Berry <stereotype441@gmail.com>
2013-01-21 15:31:00 -08:00
LOWER_PACK_SNORM_4x8 = 0x0100,
LOWER_UNPACK_SNORM_4x8 = 0x0200,
LOWER_PACK_UNORM_4x8 = 0x0400,
LOWER_UNPACK_UNORM_4x8 = 0x0800,
glsl: Add lowering pass for GLSL ES 3.00 pack/unpack operations (v4) Lower them to arithmetic and bit manipulation expressions. v2: Rewrite using ir_builder [for idr]. v3: Comment typos. [for mattst88] v4: Fix arithmetic error in comments. Factor out a shift instruction. Don't heap allocate factory.instructions. [for paul] Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> (v2) Reviewed-by: Matt Tuner <mattst88@gmail.com> (v3) Reviewed-by: Paul Berry <stereotype441@gmail.com> (v4) Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 15:15:32 -08:00
};
glsl: Add uniform_locations_assigned parameter to do_dead_code opt pass Setting this flag prevents declarations of uniforms from being removed from the IR. Since the IR is directly used by several API functions that query uniforms in shaders, uniform declarations cannot be removed after the locations have been set. However, it should still be safe to reorder the declarations (this is not tested). Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=41980 Tested-by: Brian Paul <brianp@vmware.com> Reviewed-by: Bryan Cain <bryancain3@gmail.com> Cc: Vinson Lee <vlee@vmware.com> Cc: José Fonseca <jfonseca@vmware.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
2011-10-21 11:17:39 -07:00
bool do_common_optimization(exec_list *ir, bool linked,
bool uniform_locations_assigned,
unsigned max_unroll_iterations);
glsl2: Move the common optimization passes to a helper function. These are passes that we expect all codegen to be happy with. The other lowering passes for Mesa IR are moved to the Mesa IR generator.
2010-08-10 13:06:49 -07:00
glsl2: Add optimization pass for algebraic simplifications. This cleans up the assembly output of almost all the non-logic tests glsl-algebraic-*. glsl-algebraic-pow-two needs love (basically, flattening to a temporary and squaring it).
2010-07-26 22:50:29 -07:00
bool do_algebraic(exec_list *instructions);
Move optimization pass prototypes to a single header.
2010-05-05 11:45:30 -07:00
bool do_constant_folding(exec_list *instructions);
ir_constant_variable: New pass to mark constant-assigned variables constant. This removes a bunch of gratuitous moving around of constant values from constructors. Makes a shader ir I was looking at for structure handling almost readable.
2010-05-12 12:10:41 -07:00
bool do_constant_variable(exec_list *instructions);
bool do_constant_variable_unlinked(exec_list *instructions);
Move optimization pass prototypes to a single header.
2010-05-05 11:45:30 -07:00
bool do_copy_propagation(exec_list *instructions);
glsl: Add a new opt_copy_propagation variant that does it channel-wise. This patch cleans up many of the extra copies in GLSL IR introduced by i965's scalarizing passes. It doesn't result in a statistically significant performance difference on nexuiz high settings (n=3) or my demo (n=10), due to brw_fs.cpp's register coalescing covering most of those extra moves anyway. However, it does make the debug of wine's GLSL shaders much more tractable, and reduces instruction count of glsl-fs-convolution-2 from 376 to 288.
2011-01-25 10:28:13 +10:00
bool do_copy_propagation_elements(exec_list *instructions);
glsl2: Add constant propagation. Whereas constant folding evaluates constant expressions at rvalue nodes, constant propagation tracks constant components of vectors across execution to replace (possibly swizzled) variable dereferences with constant values, triggering possible constant folding or reduced variable liveness.
2010-08-09 17:03:46 -07:00
bool do_constant_propagation(exec_list *instructions);
glsl: Add uniform_locations_assigned parameter to do_dead_code opt pass Setting this flag prevents declarations of uniforms from being removed from the IR. Since the IR is directly used by several API functions that query uniforms in shaders, uniform declarations cannot be removed after the locations have been set. However, it should still be safe to reorder the declarations (this is not tested). Signed-off-by: Ian Romanick <ian.d.romanick@intel.com> Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=41980 Tested-by: Brian Paul <brianp@vmware.com> Reviewed-by: Bryan Cain <bryancain3@gmail.com> Cc: Vinson Lee <vlee@vmware.com> Cc: José Fonseca <jfonseca@vmware.com> Reviewed-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
2011-10-21 11:17:39 -07:00
bool do_dead_code(exec_list *instructions, bool uniform_locations_assigned);
ir_dead_code_local: Remove redundant assignments within basic blocks. This cleans up a bunch of junk code in some of the GLSL parser tests, and could potentially help real-world too (particularly after copy propagation has happened).
2010-05-05 10:37:25 -07:00
bool do_dead_code_local(exec_list *instructions);
glsl2: Make the dead code handler make its own talloc context. This way, we don't need to pass in a parse state, and the context doesn't grow with the number of passes through optimization.
2010-07-27 11:28:26 -07:00
bool do_dead_code_unlinked(exec_list *instructions);
glsl2: Add a pass for removing unused functions. For a shader involving many small functions, this avoids running optimization across all of them after they've been inlined post-linking. Reduces the runtime of linking and running a fragment shader from Yo Frankie from 1.6 seconds to 0.9 seconds (-44.9%, +/- 3.3%).
2010-08-05 10:09:12 -07:00
bool do_dead_functions(exec_list *instructions);
Move optimization pass prototypes to a single header.
2010-05-05 11:45:30 -07:00
bool do_function_inlining(exec_list *instructions);
glsl: add continue/break/return unification/elimination pass (v2) Changes in v2: - Base class renamed to ir_control_flow_visitor - Tried to comply with coding style This is a new pass that supersedes ir_if_return and "lowers" jumps to if/else structures. Currently it causes no regressions on softpipe and nv40, but I'm not sure whether the piglit glsl tests are thorough enough, so consider this experimental. It can be asked to: 1. Pull jumps out of ifs where possible 2. Remove all "continue"s, replacing them with an "execute flag" 3. Replace all "break" with a single conditional one at the end of the loop 4. Replace all "return"s with a single return at the end of the function, for the main function and/or other functions This gives several great benefits: 1. All functions can be inlined after this pass 2. nv40 and other pre-DX10 chips without "continue" can be supported 3. nv30 and other pre-DX10 chips with no control flow at all are better supported Note that for full effect we should also teach the unroller to unroll loops with a fixed maximum number of iterations but with the canonical conditional "break" that this pass will insert if asked to. Continues are lowered by adding a per-loop "execute flag", initialized to TRUE, that when cleared inhibits all execution until the end of the loop. Breaks are lowered to continues, plus setting a "break flag" that is checked at the end of the loop, and trigger the unique "break". Returns are lowered to breaks/continues, plus adding a "return flag" that causes loops to break again out of their enclosing loops until all the loops are exited: then the "execute flag" logic will ignore everything until the end of the function. Note that "continue" and "return" can also be implemented by adding a dummy loop and using break. However, this is bad for hardware with limited nesting depth, and prevents further optimization, and thus is not currently performed.
2010-09-07 00:24:08 +02:00
bool do_lower_jumps(exec_list *instructions, bool pull_out_jumps = true, bool lower_sub_return = true, bool lower_main_return = false, bool lower_continue = false, bool lower_break = false);
glsl: Add a lowering pass for texture projection.
2010-09-30 20:07:27 -07:00
bool do_lower_texture_projection(exec_list *instructions);
Move optimization pass prototypes to a single header.
2010-05-05 11:45:30 -07:00
bool do_if_simplification(exec_list *instructions);
glsl: Add an optimization pass to flatten simple nested if blocks. GLBenchmark 2.7's shaders contain conditional blocks like: if (x) { if (y) { ... } } where the outer conditional's then clause contains exactly one statement (the nested if) and there are no else clauses. This can easily be optimized into: if (x && y) { ... } This saves a few instructions in GLBenchmark 2.7: total instructions in shared programs: 11833 -> 11649 (-1.55%) instructions in affected programs: 8234 -> 8050 (-2.23%) It also helps CS:GO slightly (-0.05%/-0.22%). More importantly, however, it simplifies the control flow graph, which could enable other optimizations. Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Reviewed-by: Matt Turner <mattst88@gmail.com> Reviewed-by: Eric Anholt <eric@anholt.net>
2013-04-03 23:56:57 -07:00
bool opt_flatten_nested_if_blocks(exec_list *instructions);
glsl: Add an optimization pass to simplify discards. NOTE: This is a candidate for the 7.9 branch.
2010-11-24 22:02:26 -08:00
bool do_discard_simplification(exec_list *instructions);
glsl: Support if-flattening beyond a given maximum nesting depth. This adds a new optional max_depth parameter (defaulting to 0) to lower_if_to_cond_assign, and makes the pass only flatten if-statements nested deeper than that. By default, all if-statements will be flattened, just like before. This patch also renames do_if_to_cond_assign to lower_if_to_cond_assign, to match the new naming conventions.
2010-12-27 00:22:38 -08:00
bool lower_if_to_cond_assign(exec_list *instructions, unsigned max_depth = 0);
glsl2: Add a new pass at the IR level to break down matrix ops to vector ops. This will be used by the Mesa IR and likely most HW backends, as it allows other optimizations to occur that might not otherwise. Fixes glsl-vs-mat-sub-1, glsl-vs-mat-div-1.
2010-07-12 11:04:07 -07:00
bool do_mat_op_to_vec(exec_list *instructions);
glsl2: Add a pass to strip out noop swizzles. With the glsl2-965 branch, the optimization of glsl-algebraic-rcp-rcp regressed due to noop swizzles hiding information from ir_algebraic. This cleans up those noop swizzles for us.
2010-08-13 07:16:38 -07:00
bool do_noop_swizzle(exec_list *instructions);
ir_structure_splitting: New pass to chop structures into their components. This doesn't do anything if your structure goes through an uninlined function call or if whole-structure assignment occurs. As such, the impact is limited, at least until we do some global copy propagation to reduce whole-structure assignment.
2010-08-05 11:01:09 -07:00
bool do_structure_splitting(exec_list *instructions);
ir_swizzle_swizzle: Reduce swizzle chains to a single swizzle.
2010-05-11 12:34:21 -07:00
bool do_swizzle_swizzle(exec_list *instructions);
glsl2: Add new tree grafting optimization pass.
2010-07-30 17:04:49 -07:00
bool do_tree_grafting(exec_list *instructions);
glsl2: Add pass for supporting variable vector indexing in rvalues. The Mesa IR needs this to support vector indexing correctly, and hardware backends such as 915 would want this behavior as well. Fixes glsl-vs-vec4-indexing-2.
2010-07-06 17:53:32 -07:00
bool do_vec_index_to_cond_assign(exec_list *instructions);
ir_vec_index_to_swizzle: Pass to convert indexing of vectors to swizzles. This should remove the burden of handling constant vector indexing well from backend codegen, and could help with swizzle optimizations.
2010-05-11 11:31:09 -07:00
bool do_vec_index_to_swizzle(exec_list *instructions);
glsl: Add a lowering pass to move discards out of if-statements. This should allow lower_if_to_cond_assign to work in the presence of discards, fixing bug #31690 and likely #31983. NOTE: This is a candidate for the 7.9 branch.
2010-11-25 01:09:26 -08:00
bool lower_discard(exec_list *instructions);
glsl: Fix lower_discard_flow prototype mismatch. Should fix MSVC link failure.
2012-05-15 12:27:15 +01:00
void lower_discard_flow(exec_list *instructions);
glsl: Combine many instruction lowering passes into one. This should save on the overhead of tree-walking and provide a convenient place to add more instruction lowering in the future. Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
2010-11-18 17:54:07 -08:00
bool lower_instructions(exec_list *instructions, unsigned what_to_lower);
glsl2: Add lowering pass to remove noise opcodes
2010-09-09 15:20:09 -07:00
bool lower_noise(exec_list *instructions);
glsl2: Add flags to enable variable index lowering
2010-09-16 14:40:26 +02:00
bool lower_variable_index_to_cond_assign(exec_list *instructions,
bool lower_input, bool lower_output, bool lower_temp, bool lower_uniform);
glsl: Add ir_quadop_vector expression The vector operator collects 2, 3, or 4 scalar components into a vector. Doing this has several advantages. First, it will make ud-chain tracking for components of vectors much easier. Second, a later optimization pass could collect scalars into vectors to allow generation of SWZ instructions (or similar as operands to other instructions on R200 and i915). It also enables an easy way to generate IR for SWZ instructions in the ARB_vertex_program assembler.
2010-11-16 12:01:42 -08:00
bool lower_quadop_vector(exec_list *instructions, bool dont_lower_swz);
glsl/lower_clip_distance: Update symbol table. This patch modifies the clip distance lowering pass so that the new symbol it generates (glClipDistanceMESA) is added to the shader's symbol table. This will allow a later patch to modify the linker so that it finds transform feedback varyings using the symbol table rather than having to iterate through all the declarations in the shader. Reviewed-by: Eric Anholt <eric@anholt.net> Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
2012-12-04 11:11:02 -08:00
bool lower_clip_distance(gl_shader *shader);
glsl: Add a lowering pass to remove reads of shader output variables. This is similar to Gallium's existing glsl_to_tgsi::remove_output_read lowering pass, but done entirely inside the GLSL compiler. Signed-off-by: Vincent Lejeune <vljn@ovi.com> Signed-off-by: Kenneth Graunke <kenneth@whitecape.org> Signed-off-by: Dave Airlie <airlied@redhat.com>
2012-01-03 02:08:32 -08:00
void lower_output_reads(exec_list *instructions);
glsl: Add lowering pass for GLSL ES 3.00 pack/unpack operations (v4) Lower them to arithmetic and bit manipulation expressions. v2: Rewrite using ir_builder [for idr]. v3: Comment typos. [for mattst88] v4: Fix arithmetic error in comments. Factor out a shift instruction. Don't heap allocate factory.instructions. [for paul] Reviewed-by: Ian Romanick <ian.d.romanick@intel.com> (v2) Reviewed-by: Matt Tuner <mattst88@gmail.com> (v3) Reviewed-by: Paul Berry <stereotype441@gmail.com> (v4) Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2012-11-19 15:15:32 -08:00
bool lower_packing_builtins(exec_list *instructions, int op_mask);
glsl: Add a lowering pass to turn complicated UBO references to vector loads. v2: Reduce the impenetrable code in emit_ubo_loads() by 23 lines by keeping the ir_variable as the variable part of the offset from handle_rvalue(), and track the constant offsets from that with a plain old integer value, avoiding a bunch of temporary variables in the array and struct handling. Also, fix file description doxygen. v3: Fix a row vs col typo, and fix spelling in a comment. Reviewed-by: Eric Anholt <eric@anholt.net>
2012-07-11 08:26:31 -07:00
void lower_ubo_reference(struct gl_shader *shader, exec_list *instructions);
glsl: Add a lowering pass for packing varyings. This lowering pass generates GLSL code that manually packs varyings into vec4 slots, for the benefit of back-ends that don't support packed varyings natively. No functional change--the lowering pass is not yet used. Reviewed-by: Eric Anholt <eric@anholt.net> v2: Don't use ir_hierarchical_visitor--just loop over instructions directly. Also, make the names of the packed varyings include the names of the original varyings that were packed into them.
2012-12-09 15:25:38 -08:00
void lower_packed_varyings(void *mem_ctx, unsigned location_base,
unsigned locations_used, ir_variable_mode mode,
gl_shader *shader);
glsl2: Add pass to remove redundant jumps
2010-09-13 14:25:26 -07:00
bool optimize_redundant_jumps(exec_list *instructions);
glsl: Add an array splitting pass. I've had this code laying around almost done for a long time. The idea is like opt_structure_splitting, that we've got a bunch of transforms at the GLSL IR level that only understand scalars and vectors, which just skip complicated dereferences. While driver backends may manage some optimization after they split matrices up themselves, it would be better to bring all of our optimization to bear on the problem. While I wasn't expecting changes quite yet, a few programs end up winning: a gstreamer convolution shader, and the Humus dynamic branching demo: Total instructions: 269430 -> 269342 3/2148 programs affected (0.1%) 1498 -> 1410 instructions in affected programs (5.9% reduction)
2010-10-02 22:57:17 -07:00
bool optimize_split_arrays(exec_list *instructions, bool linked);
glsl: Factor out code that generates block of index comparisons Reviewed-by: Eric Anholt <eric@anholt.net>
2011-07-18 18:48:39 -07:00
ir_rvalue *
compare_index_block(exec_list *instructions, ir_variable *index,
unsigned base, unsigned components, void *mem_ctx);
Reference in New Issue Copy Permalink