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