source/glsl/optimize.cpp

   1 #include <msp/core/raii.h>
   2 #include "optimize.h"
   3
   4 using namespace std;
   5
   6 namespace Msp {
   7 namespace GL {
   8 namespace SL {
   9
  10 InlineableFunctionLocator::InlineableFunctionLocator():
  11         in_function(0)
  12 { }
  13
  14 void InlineableFunctionLocator::visit(FunctionCall &call)
  15 {
  16         FunctionDeclaration *def = call.declaration;
  17         if(def && def->definition!=def)
  18                 def = def->definition;
  19
  20         if(def)
  21         {
  22                 unsigned &count = refcounts[def];
  23                 ++count;
  24                 if(count>1 || def==in_function)
  25                         inlineable.erase(def);
  26         }
  27
  28         TraversingVisitor::visit(call);
  29 }
  30
  31 void InlineableFunctionLocator::visit(FunctionDeclaration &func)
  32 {
  33         unsigned &count = refcounts[func.definition];
  34         if(!count && func.parameters.empty())
  35                 inlineable.insert(func.definition);
  36
  37         SetForScope<FunctionDeclaration *> set(in_function, &func);
  38         TraversingVisitor::visit(func);
  39 }
  40
  41
  42 FunctionInliner::FunctionInliner():
  43         extract_result(0)
  44 { }
  45
  46 void FunctionInliner::apply(Stage &stage)
  47 {
  48         inlineable = InlineableFunctionLocator().apply(stage);
  49         stage.content.visit(*this);
  50 }
  51
  52 void FunctionInliner::visit_and_inline(RefPtr<Expression> &ptr)
  53 {
  54         inline_result = 0;
  55         ptr->visit(*this);
  56         if(inline_result)
  57                 ptr = inline_result;
  58 }
  59
  60 void FunctionInliner::visit(Block &block)
  61 {
  62         if(extract_result)
  63                 --extract_result;
  64
  65         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
  66         {
  67                 (*i)->visit(*this);
  68                 if(extract_result)
  69                         --extract_result;
  70         }
  71 }
  72
  73 void FunctionInliner::visit(UnaryExpression &unary)
  74 {
  75         visit_and_inline(unary.expression);
  76         inline_result = 0;
  77 }
  78
  79 void FunctionInliner::visit(BinaryExpression &binary)
  80 {
  81         visit_and_inline(binary.left);
  82         visit_and_inline(binary.right);
  83         inline_result = 0;
  84 }
  85
  86 void FunctionInliner::visit(MemberAccess &memacc)
  87 {
  88         visit_and_inline(memacc.left);
  89         inline_result = 0;
  90 }
  91
  92 void FunctionInliner::visit(FunctionCall &call)
  93 {
  94         for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
  95                 visit_and_inline(*i);
  96
  97         FunctionDeclaration *def = call.declaration;
  98         if(def && def->definition!=def)
  99                 def = def->definition;
 100
 101         if(def && inlineable.count(def))
 102         {
 103                 extract_result = 2;
 104                 def->visit(*this);
 105         }
 106         else
 107                 inline_result = 0;
 108 }
 109
 110 void FunctionInliner::visit(VariableDeclaration &var)
 111 {
 112         if(var.init_expression)
 113                 visit_and_inline(var.init_expression);
 114         inline_result = 0;
 115 }
 116
 117 void FunctionInliner::visit(Return &ret)
 118 {
 119         TraversingVisitor::visit(ret);
 120
 121         if(extract_result)
 122                 inline_result = ret.expression->clone();
 123 }
 124
 125
 126 ConstantConditionEliminator::ConstantConditionEliminator():
 127         record_only(false)
 128 { }
 129
 130 void ConstantConditionEliminator::apply(Stage &stage)
 131 {
 132         stage.content.visit(*this);
 133         NodeRemover().apply(stage, nodes_to_remove);
 134 }
 135
 136 void ConstantConditionEliminator::visit(Block &block)
 137 {
 138         SetForScope<Block *> set_block(current_block, &block);
 139         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 140         {
 141                 insert_point = i;
 142                 (*i)->visit(*this);
 143         }
 144
 145         for(map<string, VariableDeclaration *>::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i)
 146                 variable_values.erase(i->second);
 147 }
 148
 149 void ConstantConditionEliminator::visit(UnaryExpression &unary)
 150 {
 151         if(VariableReference *var = dynamic_cast<VariableReference *>(unary.expression.get()))
 152                 if(unary.oper=="++" || unary.oper=="--")
 153                         variable_values.erase(var->declaration);
 154 }
 155
 156 void ConstantConditionEliminator::visit(Assignment &assign)
 157 {
 158         variable_values.erase(assign.target_declaration);
 159 }
 160
 161 void ConstantConditionEliminator::visit(VariableDeclaration &var)
 162 {
 163         if((var.constant || current_block->parent) && var.init_expression)
 164                 variable_values[&var] = var.init_expression.get();
 165 }
 166
 167 void ConstantConditionEliminator::visit(Conditional &cond)
 168 {
 169         if(!record_only)
 170         {
 171                 ExpressionEvaluator eval(variable_values);
 172                 cond.condition->visit(eval);
 173                 if(eval.is_result_valid())
 174                 {
 175                         Block &block = (eval.get_result() ? cond.body : cond.else_body);
 176                         current_block->body.splice(insert_point, block.body);
 177                         nodes_to_remove.insert(&cond);
 178                         return;
 179                 }
 180         }
 181
 182         TraversingVisitor::visit(cond);
 183 }
 184
 185 void ConstantConditionEliminator::visit(Iteration &iter)
 186 {
 187         if(!record_only)
 188         {
 189                 if(iter.condition)
 190                 {
 191                         /* If the loop condition is always false on the first iteration, the
 192                         entire loop can be removed */
 193                         if(iter.init_statement)
 194                                 iter.init_statement->visit(*this);
 195                         ExpressionEvaluator eval(variable_values);
 196                         iter.condition->visit(eval);
 197                         if(eval.is_result_valid() && !eval.get_result())
 198                         {
 199                                 nodes_to_remove.insert(&iter);
 200                                 return;
 201                         }
 202                 }
 203
 204                 /* Record all assignments that occur inside the loop body so those
 205                 variables won't be considered as constant */
 206                 SetFlag set_record(record_only);
 207                 TraversingVisitor::visit(iter);
 208         }
 209
 210         TraversingVisitor::visit(iter);
 211
 212         if(VariableDeclaration *init_decl = dynamic_cast<VariableDeclaration *>(iter.init_statement.get()))
 213                 variable_values.erase(init_decl);
 214 }
 215
 216
 217 UnusedVariableRemover::VariableInfo::VariableInfo():
 218         local(false),
 219         conditionally_assigned(false),
 220         referenced(false)
 221 { }
 222
 223
 224 UnusedVariableRemover::UnusedVariableRemover():
 225         aggregate(0),
 226         assignment(0),
 227         assignment_target(false),
 228         assign_to_subscript(false)
 229 { }
 230
 231 bool UnusedVariableRemover::apply(Stage &stage)
 232 {
 233         variables.push_back(BlockVariableMap());
 234         stage.content.visit(*this);
 235         BlockVariableMap &global_variables = variables.back();
 236         for(BlockVariableMap::iterator i=global_variables.begin(); i!=global_variables.end(); ++i)
 237         {
 238                 if(i->first->interface=="out" && (stage.type==Stage::FRAGMENT || i->first->linked_declaration || !i->first->name.compare(0, 3, "gl_")))
 239                         continue;
 240                 if(!i->second.referenced)
 241                 {
 242                         unused_nodes.insert(i->first);
 243                         clear_assignments(i->second, true);
 244                 }
 245         }
 246         variables.pop_back();
 247
 248         NodeRemover().apply(stage, unused_nodes);
 249
 250         return !unused_nodes.empty();
 251 }
 252
 253 void UnusedVariableRemover::visit(VariableReference &var)
 254 {
 255         map<VariableDeclaration *, Node *>::iterator i = aggregates.find(var.declaration);
 256         if(i!=aggregates.end())
 257                 unused_nodes.erase(i->second);
 258
 259         if(var.declaration && !assignment_target)
 260         {
 261                 VariableInfo &var_info = variables.back()[var.declaration];
 262                 var_info.assignments.clear();
 263                 var_info.referenced = true;
 264         }
 265 }
 266
 267 void UnusedVariableRemover::visit(InterfaceBlockReference &iface)
 268 {
 269         unused_nodes.erase(iface.declaration);
 270 }
 271
 272 void UnusedVariableRemover::visit(MemberAccess &memacc)
 273 {
 274         TraversingVisitor::visit(memacc);
 275         unused_nodes.erase(memacc.declaration);
 276 }
 277
 278 void UnusedVariableRemover::visit(BinaryExpression &binary)
 279 {
 280         if(binary.oper=="[")
 281         {
 282                 if(assignment_target)
 283                         assign_to_subscript = true;
 284                 binary.left->visit(*this);
 285                 SetForScope<bool> set(assignment_target, false);
 286                 binary.right->visit(*this);
 287         }
 288         else
 289                 TraversingVisitor::visit(binary);
 290 }
 291
 292 void UnusedVariableRemover::visit(Assignment &assign)
 293 {
 294         {
 295                 assign_to_subscript = false;
 296                 SetForScope<bool> set(assignment_target, !assign.self_referencing);
 297                 assign.left->visit(*this);
 298         }
 299         assign.right->visit(*this);
 300         assignment = &assign;
 301 }
 302
 303 void UnusedVariableRemover::record_assignment(VariableDeclaration &var, Node &node, bool chained)
 304 {
 305         VariableInfo &var_info = variables.back()[&var];
 306         if(!chained)
 307                 clear_assignments(var_info, true);
 308         var_info.assignments.push_back(&node);
 309         var_info.conditionally_assigned = false;
 310 }
 311
 312 void UnusedVariableRemover::clear_assignments(VariableInfo &var_info, bool mark_unused)
 313 {
 314         if(mark_unused)
 315         {
 316                 for(vector<Node *>::iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i)
 317                         unused_nodes.insert(*i);
 318         }
 319         var_info.assignments.clear();
 320 }
 321
 322 void UnusedVariableRemover::visit(ExpressionStatement &expr)
 323 {
 324         assignment = 0;
 325         TraversingVisitor::visit(expr);
 326         if(assignment && assignment->target_declaration)
 327                 record_assignment(*assignment->target_declaration, expr, (assignment->self_referencing || assign_to_subscript));
 328 }
 329
 330 void UnusedVariableRemover::visit(StructDeclaration &strct)
 331 {
 332         SetForScope<Node *> set(aggregate, &strct);
 333         unused_nodes.insert(&strct);
 334         TraversingVisitor::visit(strct);
 335 }
 336
 337 void UnusedVariableRemover::visit(VariableDeclaration &var)
 338 {
 339         if(aggregate)
 340                 aggregates[&var] = aggregate;
 341         else
 342         {
 343                 variables.back()[&var].local = true;
 344                 if(var.init_expression)
 345                         record_assignment(var, *var.init_expression, false);
 346         }
 347         unused_nodes.erase(var.type_declaration);
 348         TraversingVisitor::visit(var);
 349 }
 350
 351 void UnusedVariableRemover::visit(InterfaceBlock &iface)
 352 {
 353         SetForScope<Node *> set(aggregate, &iface);
 354         unused_nodes.insert(&iface);
 355         TraversingVisitor::visit(iface);
 356 }
 357
 358 void UnusedVariableRemover::visit(FunctionDeclaration &func)
 359 {
 360         variables.push_back(BlockVariableMap());
 361
 362         for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 363                 (*i)->visit(*this);
 364         func.body.visit(*this);
 365
 366         BlockVariableMap &block_variables = variables.back();
 367         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
 368                 i->second.conditionally_assigned = true;
 369         for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 370                 block_variables[i->get()].referenced = true;
 371         merge_down_variables();
 372 }
 373
 374 void UnusedVariableRemover::merge_down_variables()
 375 {
 376         BlockVariableMap &parent_variables = variables[variables.size()-2];
 377         BlockVariableMap &block_variables = variables.back();
 378         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
 379         {
 380                 if(i->second.local)
 381                 {
 382                         if(!i->second.referenced)
 383                                 unused_nodes.insert(i->first);
 384                         clear_assignments(i->second, i->first->interface!="out");
 385                         continue;
 386                 }
 387
 388                 BlockVariableMap::iterator j = parent_variables.find(i->first);
 389                 if(j==parent_variables.end())
 390                         parent_variables.insert(*i);
 391                 else
 392                 {
 393                         if(i->second.referenced || !i->second.conditionally_assigned)
 394                                 clear_assignments(j->second, !i->second.referenced);
 395                         j->second.conditionally_assigned = i->second.conditionally_assigned;
 396                         j->second.referenced |= i->second.referenced;
 397                         j->second.assignments.insert(j->second.assignments.end(), i->second.assignments.begin(), i->second.assignments.end());
 398                 }
 399         }
 400         variables.pop_back();
 401 }
 402
 403 void UnusedVariableRemover::visit(Conditional &cond)
 404 {
 405         cond.condition->visit(*this);
 406         variables.push_back(BlockVariableMap());
 407         cond.body.visit(*this);
 408
 409         BlockVariableMap if_variables;
 410         swap(variables.back(), if_variables);
 411         cond.else_body.visit(*this);
 412
 413         BlockVariableMap &else_variables = variables.back();
 414         for(BlockVariableMap::iterator i=else_variables.begin(); i!=else_variables.end(); ++i)
 415         {
 416                 BlockVariableMap::iterator j = if_variables.find(i->first);
 417                 if(j!=if_variables.end())
 418                 {
 419                         i->second.assignments.insert(i->second.assignments.end(), j->second.assignments.begin(), j->second.assignments.end());
 420                         i->second.conditionally_assigned |= j->second.conditionally_assigned;
 421                         if_variables.erase(j);
 422                 }
 423                 else
 424                         i->second.conditionally_assigned = true;
 425         }
 426
 427         for(BlockVariableMap::iterator i=if_variables.begin(); i!=if_variables.end(); ++i)
 428         {
 429                 i->second.conditionally_assigned = true;
 430                 else_variables.insert(*i);
 431         }
 432
 433         merge_down_variables();
 434 }
 435
 436 void UnusedVariableRemover::visit(Iteration &iter)
 437 {
 438         variables.push_back(BlockVariableMap());
 439         TraversingVisitor::visit(iter);
 440
 441         BlockVariableMap &block_variables = variables.back();
 442         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
 443                 if(!i->second.local && i->second.referenced)
 444                         i->second.assignments.clear();
 445
 446         merge_down_variables();
 447 }
 448
 449
 450 bool UnusedFunctionRemover::apply(Stage &stage)
 451 {
 452         stage.content.visit(*this);
 453         NodeRemover().apply(stage, unused_nodes);
 454         return !unused_nodes.empty();
 455 }
 456
 457 void UnusedFunctionRemover::visit(FunctionCall &call)
 458 {
 459         TraversingVisitor::visit(call);
 460
 461         unused_nodes.erase(call.declaration);
 462         if(call.declaration && call.declaration->definition!=call.declaration)
 463                 used_definitions.insert(call.declaration->definition);
 464 }
 465
 466 void UnusedFunctionRemover::visit(FunctionDeclaration &func)
 467 {
 468         TraversingVisitor::visit(func);
 469
 470         if((func.name!="main" || func.body.body.empty()) && !used_definitions.count(&func))
 471                 unused_nodes.insert(&func);
 472 }
 473
 474 } // namespace SL
 475 } // namespace GL
 476 } // namespace Msp