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         visit(stage.content);
  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         scope_level(0),
 128         record_only(false)
 129 { }
 130
 131 void ConstantConditionEliminator::visit(Block &block)
 132 {
 133         SetForScope<unsigned> set(scope_level, scope_level+1);
 134         BlockModifier::visit(block);
 135
 136         for(map<string, VariableDeclaration *>::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i)
 137                 variable_values.erase(i->second);
 138 }
 139
 140 void ConstantConditionEliminator::visit(UnaryExpression &unary)
 141 {
 142         if(VariableReference *var = dynamic_cast<VariableReference *>(unary.expression.get()))
 143                 if(unary.oper=="++" || unary.oper=="--")
 144                         variable_values.erase(var->declaration);
 145 }
 146
 147 void ConstantConditionEliminator::visit(Assignment &assign)
 148 {
 149         variable_values.erase(assign.target_declaration);
 150 }
 151
 152 void ConstantConditionEliminator::visit(VariableDeclaration &var)
 153 {
 154         if(var.constant || scope_level>1)
 155                 variable_values[&var] = var.init_expression.get();
 156 }
 157
 158 void ConstantConditionEliminator::visit(Conditional &cond)
 159 {
 160         if(!record_only)
 161         {
 162                 ExpressionEvaluator eval(variable_values);
 163                 cond.condition->visit(eval);
 164                 if(eval.is_result_valid())
 165                 {
 166                         flatten_block(eval.get_result() ? cond.body : cond.else_body);
 167                         return;
 168                 }
 169         }
 170
 171         TraversingVisitor::visit(cond);
 172 }
 173
 174 void ConstantConditionEliminator::visit(Iteration &iter)
 175 {
 176         if(!record_only)
 177         {
 178                 if(iter.condition)
 179                 {
 180                         /* If the loop condition is always false on the first iteration, the
 181                         entire loop can be removed */
 182                         if(iter.init_statement)
 183                                 iter.init_statement->visit(*this);
 184                         ExpressionEvaluator eval(variable_values);
 185                         iter.condition->visit(eval);
 186                         if(eval.is_result_valid() && !eval.get_result())
 187                         {
 188                                 remove_node = true;
 189                                 return;
 190                         }
 191                 }
 192
 193                 /* Record all assignments that occur inside the loop body so those
 194                 variables won't be considered as constant */
 195                 SetFlag set_record(record_only);
 196                 TraversingVisitor::visit(iter);
 197         }
 198
 199         TraversingVisitor::visit(iter);
 200
 201         if(VariableDeclaration *init_decl = dynamic_cast<VariableDeclaration *>(iter.init_statement.get()))
 202                 variable_values.erase(init_decl);
 203 }
 204
 205
 206 UnusedVariableRemover::VariableInfo::VariableInfo():
 207         local(false),
 208         conditionally_assigned(false),
 209         referenced(false)
 210 { }
 211
 212
 213 UnusedVariableRemover::UnusedVariableRemover():
 214         aggregate(0),
 215         assignment(0),
 216         assignment_target(false),
 217         assign_to_subscript(false),
 218         global_scope(true)
 219 { }
 220
 221 bool UnusedVariableRemover::apply(Stage &stage)
 222 {
 223         variables.push_back(BlockVariableMap());
 224         visit(stage.content);
 225         BlockVariableMap &global_variables = variables.back();
 226         for(BlockVariableMap::iterator i=global_variables.begin(); i!=global_variables.end(); ++i)
 227         {
 228                 if(i->first->interface=="out" && (stage.type==Stage::FRAGMENT || i->first->linked_declaration || !i->first->name.compare(0, 3, "gl_")))
 229                         continue;
 230                 if(!i->second.referenced)
 231                 {
 232                         unused_nodes.insert(i->first);
 233                         clear_assignments(i->second, true);
 234                 }
 235         }
 236         variables.pop_back();
 237
 238         NodeRemover().apply(stage, unused_nodes);
 239
 240         return !unused_nodes.empty();
 241 }
 242
 243 void UnusedVariableRemover::visit(VariableReference &var)
 244 {
 245         map<VariableDeclaration *, Node *>::iterator i = aggregates.find(var.declaration);
 246         if(i!=aggregates.end())
 247                 unused_nodes.erase(i->second);
 248
 249         if(var.declaration && !assignment_target)
 250         {
 251                 VariableInfo &var_info = variables.back()[var.declaration];
 252                 var_info.assignments.clear();
 253                 var_info.referenced = true;
 254         }
 255 }
 256
 257 void UnusedVariableRemover::visit(MemberAccess &memacc)
 258 {
 259         TraversingVisitor::visit(memacc);
 260         unused_nodes.erase(memacc.declaration);
 261 }
 262
 263 void UnusedVariableRemover::visit(BinaryExpression &binary)
 264 {
 265         if(binary.oper=="[")
 266         {
 267                 if(assignment_target)
 268                         assign_to_subscript = true;
 269                 binary.left->visit(*this);
 270                 SetForScope<bool> set(assignment_target, false);
 271                 binary.right->visit(*this);
 272         }
 273         else
 274                 TraversingVisitor::visit(binary);
 275 }
 276
 277 void UnusedVariableRemover::visit(Assignment &assign)
 278 {
 279         {
 280                 assign_to_subscript = false;
 281                 SetForScope<bool> set(assignment_target, !assign.self_referencing);
 282                 assign.left->visit(*this);
 283         }
 284         assign.right->visit(*this);
 285         assignment = &assign;
 286 }
 287
 288 void UnusedVariableRemover::record_assignment(VariableDeclaration &var, Node &node, bool chained)
 289 {
 290         VariableInfo &var_info = variables.back()[&var];
 291         if(!chained)
 292                 clear_assignments(var_info, true);
 293         var_info.assignments.push_back(&node);
 294         var_info.conditionally_assigned = false;
 295 }
 296
 297 void UnusedVariableRemover::clear_assignments(VariableInfo &var_info, bool mark_unused)
 298 {
 299         if(mark_unused)
 300         {
 301                 for(vector<Node *>::iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i)
 302                         unused_nodes.insert(*i);
 303         }
 304         var_info.assignments.clear();
 305 }
 306
 307 void UnusedVariableRemover::visit(ExpressionStatement &expr)
 308 {
 309         assignment = 0;
 310         TraversingVisitor::visit(expr);
 311         if(assignment && assignment->target_declaration)
 312                 record_assignment(*assignment->target_declaration, expr, (assignment->self_referencing || assign_to_subscript));
 313 }
 314
 315 void UnusedVariableRemover::visit(StructDeclaration &strct)
 316 {
 317         SetForScope<Node *> set(aggregate, &strct);
 318         unused_nodes.insert(&strct);
 319         TraversingVisitor::visit(strct);
 320 }
 321
 322 void UnusedVariableRemover::visit(VariableDeclaration &var)
 323 {
 324         if(aggregate)
 325                 aggregates[&var] = aggregate;
 326         else
 327         {
 328                 variables.back()[&var].local = true;
 329                 if(var.init_expression)
 330                         record_assignment(var, *var.init_expression, false);
 331         }
 332         unused_nodes.erase(var.type_declaration);
 333         TraversingVisitor::visit(var);
 334 }
 335
 336 void UnusedVariableRemover::visit(InterfaceBlock &iface)
 337 {
 338         SetForScope<Node *> set(aggregate, &iface);
 339         unused_nodes.insert(&iface);
 340         TraversingVisitor::visit(iface);
 341 }
 342
 343 void UnusedVariableRemover::visit(FunctionDeclaration &func)
 344 {
 345         variables.push_back(BlockVariableMap());
 346
 347         {
 348                 SetForScope<bool> set(global_scope, false);
 349                 for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 350                         (*i)->visit(*this);
 351                 func.body.visit(*this);
 352         }
 353
 354         BlockVariableMap &block_variables = variables.back();
 355         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
 356                 i->second.conditionally_assigned = true;
 357         for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 358                 block_variables[i->get()].referenced = true;
 359         merge_down_variables();
 360 }
 361
 362 void UnusedVariableRemover::merge_down_variables()
 363 {
 364         BlockVariableMap &parent_variables = variables[variables.size()-2];
 365         BlockVariableMap &block_variables = variables.back();
 366         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
 367         {
 368                 if(i->second.local)
 369                 {
 370                         if(!i->second.referenced)
 371                                 unused_nodes.insert(i->first);
 372                         clear_assignments(i->second, i->first->interface!="out");
 373                         continue;
 374                 }
 375
 376                 BlockVariableMap::iterator j = parent_variables.find(i->first);
 377                 if(j==parent_variables.end())
 378                         parent_variables.insert(*i);
 379                 else
 380                 {
 381                         if(i->second.referenced || !i->second.conditionally_assigned)
 382                                 clear_assignments(j->second, !i->second.referenced);
 383                         j->second.conditionally_assigned = i->second.conditionally_assigned;
 384                         j->second.referenced |= i->second.referenced;
 385                         j->second.assignments.insert(j->second.assignments.end(), i->second.assignments.begin(), i->second.assignments.end());
 386                 }
 387         }
 388         variables.pop_back();
 389 }
 390
 391 void UnusedVariableRemover::visit(Conditional &cond)
 392 {
 393         cond.condition->visit(*this);
 394         variables.push_back(BlockVariableMap());
 395         cond.body.visit(*this);
 396
 397         BlockVariableMap if_variables;
 398         swap(variables.back(), if_variables);
 399         cond.else_body.visit(*this);
 400
 401         BlockVariableMap &else_variables = variables.back();
 402         for(BlockVariableMap::iterator i=else_variables.begin(); i!=else_variables.end(); ++i)
 403         {
 404                 BlockVariableMap::iterator j = if_variables.find(i->first);
 405                 if(j!=if_variables.end())
 406                 {
 407                         i->second.assignments.insert(i->second.assignments.end(), j->second.assignments.begin(), j->second.assignments.end());
 408                         i->second.conditionally_assigned |= j->second.conditionally_assigned;
 409                         if_variables.erase(j);
 410                 }
 411                 else
 412                         i->second.conditionally_assigned = true;
 413         }
 414
 415         for(BlockVariableMap::iterator i=if_variables.begin(); i!=if_variables.end(); ++i)
 416         {
 417                 i->second.conditionally_assigned = true;
 418                 else_variables.insert(*i);
 419         }
 420
 421         merge_down_variables();
 422 }
 423
 424 void UnusedVariableRemover::visit(Iteration &iter)
 425 {
 426         variables.push_back(BlockVariableMap());
 427         TraversingVisitor::visit(iter);
 428
 429         BlockVariableMap &block_variables = variables.back();
 430         for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
 431                 if(!i->second.local && i->second.referenced)
 432                         i->second.assignments.clear();
 433
 434         merge_down_variables();
 435 }
 436
 437
 438 bool UnusedFunctionRemover::apply(Stage &stage)
 439 {
 440         visit(stage.content);
 441         NodeRemover().apply(stage, unused_nodes);
 442         return !unused_nodes.empty();
 443 }
 444
 445 void UnusedFunctionRemover::visit(FunctionCall &call)
 446 {
 447         TraversingVisitor::visit(call);
 448
 449         unused_nodes.erase(call.declaration);
 450         if(call.declaration && call.declaration->definition!=call.declaration)
 451                 used_definitions.insert(call.declaration->definition);
 452 }
 453
 454 void UnusedFunctionRemover::visit(FunctionDeclaration &func)
 455 {
 456         TraversingVisitor::visit(func);
 457
 458         if((func.name!="main" || func.body.body.empty()) && !used_definitions.count(&func))
 459                 unused_nodes.insert(&func);
 460 }
 461
 462 } // namespace SL
 463 } // namespace GL
 464 } // namespace Msp