1 /* 2 * Copyright 2010 Intel Corporation 3 * 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: 10 * 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 13 * Software. 14 * 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. 22 */ 23 24 /** 25 * \file opt_constant_folding.cpp 26 * Replace constant-valued expressions with references to constant values. 27 */ 28 29 #include "ir.h" 30 #include "ir_visitor.h" 31 #include "ir_rvalue_visitor.h" 32 #include "ir_optimization.h" 33 #include "compiler/glsl_types.h" 34 35 namespace { 36 37 /** 38 * Visitor class for replacing expressions with ir_constant values. 39 */ 40 41 class ir_constant_folding_visitor : public ir_rvalue_visitor { 42 public: 43 ir_constant_folding_visitor() 44 { 45 this->progress = false; 46 } 47 48 virtual ~ir_constant_folding_visitor() 49 { 50 /* empty */ 51 } 52 53 virtual ir_visitor_status visit_enter(ir_discard *ir); 54 virtual ir_visitor_status visit_enter(ir_assignment *ir); 55 virtual ir_visitor_status visit_enter(ir_call *ir); 56 57 virtual void handle_rvalue(ir_rvalue **rvalue); 58 59 bool progress; 60 }; 61 62 } /* unnamed namespace */ 63 64 bool 65 ir_constant_fold(ir_rvalue **rvalue) 66 { 67 if (*rvalue == NULL || (*rvalue)->ir_type == ir_type_constant) 68 return false; 69 70 /* Note that we do rvalue visitoring on leaving. So if an 71 * expression has a non-constant operand, no need to go looking 72 * down it to find if it's constant. This cuts the time of this 73 * pass down drastically. 74 */ 75 ir_expression *expr = (*rvalue)->as_expression(); 76 if (expr) { 77 for (unsigned int i = 0; i < expr->get_num_operands(); i++) { 78 if (!expr->operands[i]->as_constant()) 79 return false; 80 } 81 } 82 83 /* Ditto for swizzles. */ 84 ir_swizzle *swiz = (*rvalue)->as_swizzle(); 85 if (swiz && !swiz->val->as_constant()) 86 return false; 87 88 /* Ditto for array dereferences */ 89 ir_dereference_array *array_ref = (*rvalue)->as_dereference_array(); 90 if (array_ref && (!array_ref->array->as_constant() || 91 !array_ref->array_index->as_constant())) 92 return false; 93 94 /* No constant folding can be performed on variable dereferences. We need 95 * to explicitly avoid them, as calling constant_expression_value() on a 96 * variable dereference will return a clone of var->constant_value. This 97 * would make us propagate the value into the tree, which isn't our job. 98 */ 99 ir_dereference_variable *var_ref = (*rvalue)->as_dereference_variable(); 100 if (var_ref) 101 return false; 102 103 ir_constant *constant = (*rvalue)->constant_expression_value(); 104 if (constant) { 105 *rvalue = constant; 106 return true; 107 } 108 return false; 109 } 110 111 void 112 ir_constant_folding_visitor::handle_rvalue(ir_rvalue **rvalue) 113 { 114 if (ir_constant_fold(rvalue)) 115 this->progress = true; 116 } 117 118 ir_visitor_status 119 ir_constant_folding_visitor::visit_enter(ir_discard *ir) 120 { 121 if (ir->condition) { 122 ir->condition->accept(this); 123 handle_rvalue(&ir->condition); 124 125 ir_constant *const_val = ir->condition->as_constant(); 126 /* If the condition is constant, either remove the condition or 127 * remove the never-executed assignment. 128 */ 129 if (const_val) { 130 if (const_val->value.b[0]) 131 ir->condition = NULL; 132 else 133 ir->remove(); 134 this->progress = true; 135 } 136 } 137 138 return visit_continue_with_parent; 139 } 140 141 ir_visitor_status 142 ir_constant_folding_visitor::visit_enter(ir_assignment *ir) 143 { 144 ir->rhs->accept(this); 145 handle_rvalue(&ir->rhs); 146 147 if (ir->condition) { 148 ir->condition->accept(this); 149 handle_rvalue(&ir->condition); 150 151 ir_constant *const_val = ir->condition->as_constant(); 152 /* If the condition is constant, either remove the condition or 153 * remove the never-executed assignment. 154 */ 155 if (const_val) { 156 if (const_val->value.b[0]) 157 ir->condition = NULL; 158 else 159 ir->remove(); 160 this->progress = true; 161 } 162 } 163 164 /* Don't descend into the LHS because we want it to stay as a 165 * variable dereference. FINISHME: We probably should to get array 166 * indices though. 167 */ 168 return visit_continue_with_parent; 169 } 170 171 ir_visitor_status 172 ir_constant_folding_visitor::visit_enter(ir_call *ir) 173 { 174 /* Attempt to constant fold parameters */ 175 foreach_two_lists(formal_node, &ir->callee->parameters, 176 actual_node, &ir->actual_parameters) { 177 ir_rvalue *param_rval = (ir_rvalue *) actual_node; 178 ir_variable *sig_param = (ir_variable *) formal_node; 179 180 if (sig_param->data.mode == ir_var_function_in 181 || sig_param->data.mode == ir_var_const_in) { 182 ir_rvalue *new_param = param_rval; 183 184 handle_rvalue(&new_param); 185 if (new_param != param_rval) { 186 param_rval->replace_with(new_param); 187 } 188 } 189 } 190 191 /* Next, see if the call can be replaced with an assignment of a constant */ 192 ir_constant *const_val = ir->constant_expression_value(); 193 194 if (const_val != NULL) { 195 ir_assignment *assignment = 196 new(ralloc_parent(ir)) ir_assignment(ir->return_deref, const_val); 197 ir->replace_with(assignment); 198 } 199 200 return visit_continue_with_parent; 201 } 202 203 bool 204 do_constant_folding(exec_list *instructions) 205 { 206 ir_constant_folding_visitor constant_folding; 207 208 visit_list_elements(&constant_folding, instructions); 209 210 return constant_folding.progress; 211 } 212