+#include <msp/core/algorithm.h>
#include <msp/core/raii.h>
+#include <msp/gl/extensions/arb_explicit_attrib_location.h>
+#include <msp/gl/extensions/arb_gpu_shader5.h>
+#include <msp/gl/extensions/arb_uniform_buffer_object.h>
#include <msp/gl/extensions/ext_gpu_shader4.h>
#include <msp/strings/format.h>
#include <msp/strings/utils.h>
#include "resources.h"
#include "shader.h"
+#undef interface
+
using namespace std;
namespace {
using namespace ProgramSyntax;
-// XXX For some reason global declarations are emitted for otherwise undeclared local variables
-
ProgramCompiler::ProgramCompiler():
resources(0),
module(0)
target = &*i;
}
- for(NodeList<Node>::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i)
+ for(NodeList<Statement>::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i)
target->content.body.push_back(*i);
apply<DeclarationCombiner>(*target);
}
void ProgramCompiler::inject_block(Block &target, const Block &source)
{
- list<RefPtr<Node> >::iterator insert_point = target.body.begin();
- for(list<RefPtr<Node> >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i)
+ list<RefPtr<Statement> >::iterator insert_point = target.body.begin();
+ for(list<RefPtr<Statement> >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i)
target.body.insert(insert_point, (*i)->clone());
}
remove_node = true;
}
-void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<RefPtr<Node> >::iterator &i)
+void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<RefPtr<Statement> >::iterator &i)
{
block.body.insert(i, insert_nodes.begin(), insert_nodes.end());
insert_nodes.clear();
void ProgramCompiler::BlockModifier::visit(Block &block)
{
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); )
{
(*i)->visit(*this);
apply_and_increment(block, i);
formatted += '\n';
}
+ for(vector<const Extension *>::const_iterator i=s.required_extensions.begin(); i!=s.required_extensions.end(); ++i)
+ formatted += format("#extension %s: require\n", (*i)->get_name());
+ if(!s.required_extensions.empty())
+ formatted += '\n';
+
Visitor::apply(s);
}
SetForScope<unsigned> set(indent, indent+(indent>0 || use_braces));
string spaces(indent*2, ' ');
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
{
if(i!=block.body.begin())
formatted += '\n';
void ProgramCompiler::Formatter::visit(Iteration &iter)
{
- formatted += "for(";
- iter.init_statement->visit(*this);
- formatted += ' ';
- iter.condition->visit(*this);
- formatted += "; ";
- iter.loop_expression->visit(*this);
- formatted += ")\n";
- iter.body.visit(*this);
+ if(!iter.init_statement && iter.condition && !iter.loop_expression)
+ {
+ formatted += "while(";
+ iter.condition->visit(*this);
+ formatted += ')';
+ }
+ else
+ {
+ formatted += "for(";
+ if(iter.init_statement)
+ iter.init_statement->visit(*this);
+ else
+ formatted += ';';
+ if(iter.condition)
+ {
+ formatted += ' ';
+ iter.condition->visit(*this);
+ }
+ formatted += ';';
+ if(iter.loop_expression)
+ {
+ formatted += ' ';
+ iter.loop_expression->visit(*this);
+ }
+ formatted += ')';
+ }
+
+ if(iter.body.body.empty())
+ formatted += " { }";
+ else
+ {
+ formatted += '\n';
+ iter.body.visit(*this);
+ }
}
void ProgramCompiler::Formatter::visit(Return &ret)
{
- formatted += "return ";
- ret.expression->visit(*this);
+ formatted += "return";
+ if(ret.expression)
+ {
+ formatted += ' ';
+ ret.expression->visit(*this);
+ }
formatted += ';';
}
ptr->type = var.type;
if(var.init_expression)
ptr->init_expression = var.init_expression;
+ if(var.layout)
+ {
+ if(ptr->layout)
+ {
+ for(vector<Layout::Qualifier>::iterator i=var.layout->qualifiers.begin(); i!=var.layout->qualifiers.end(); ++i)
+ {
+ bool found = false;
+ for(vector<Layout::Qualifier>::iterator j=ptr->layout->qualifiers.begin(); (!found && j!=ptr->layout->qualifiers.end()); ++j)
+ if(j->identifier==i->identifier)
+ {
+ j->value = i->value;
+ found = true;
+ }
+
+ if(!found)
+ ptr->layout->qualifiers.push_back(*i);
+ }
+ }
+ else
+ ptr->layout = var.layout;
+ }
remove_node = true;
}
else
void ProgramCompiler::InterfaceGenerator::visit(Block &block)
{
SetForScope<unsigned> set(scope_level, scope_level+1);
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); )
{
(*i)->visit(*this);
{
for(map<string, RefPtr<VariableDeclaration> >::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j)
{
- list<RefPtr<Node> >::iterator k = block.body.insert(i, j->second);
+ list<RefPtr<Statement> >::iterator k = block.body.insert(i, j->second);
(*k)->visit(*this);
}
iface_declarations.clear();
if(scope_level>1)
return Visitor::visit(block);
- list<RefPtr<Node> >::iterator struct_insert_point = block.body.end();
- list<RefPtr<Node> >::iterator variable_insert_point = block.body.end();
- list<RefPtr<Node> >::iterator function_insert_point = block.body.end();
+ list<RefPtr<Statement> >::iterator struct_insert_point = block.body.end();
+ list<RefPtr<Statement> >::iterator variable_insert_point = block.body.end();
+ list<RefPtr<Statement> >::iterator function_insert_point = block.body.end();
unsigned unordered_func_count = 0;
bool ordered_any_funcs = false;
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); )
{
kind = NO_DECLARATION;
(*i)->visit(*this);
if(extract_result)
--extract_result;
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
{
(*i)->visit(*this);
if(extract_result)
inline_result = 0;
}
+void ProgramCompiler::FunctionInliner::visit(MemberAccess &memacc)
+{
+ visit_and_inline(memacc.left);
+ inline_result = 0;
+}
+
void ProgramCompiler::FunctionInliner::visit(FunctionCall &call)
{
for(vector<RefPtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
inline_result = 0;
}
+void ProgramCompiler::FunctionInliner::visit(VariableDeclaration &var)
+{
+ if(var.init_expression)
+ visit_and_inline(var.init_expression);
+ inline_result = 0;
+}
+
void ProgramCompiler::FunctionInliner::visit(Return &ret)
{
TraversingVisitor::visit(ret);
ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
- scope_level(0)
+ scope_level(0),
+ record_only(false)
{ }
void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
variable_values.erase(i->second);
}
+void ProgramCompiler::ConstantConditionEliminator::visit(UnaryExpression &unary)
+{
+ if(VariableReference *var = dynamic_cast<VariableReference *>(unary.expression.get()))
+ if(unary.oper=="++" || unary.oper=="--")
+ variable_values.erase(var->declaration);
+}
+
void ProgramCompiler::ConstantConditionEliminator::visit(Assignment &assign)
{
variable_values.erase(assign.target_declaration);
void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
{
- ExpressionEvaluator eval(variable_values);
- cond.condition->visit(eval);
- if(eval.result_valid)
- flatten_block(eval.result ? cond.body : cond.else_body);
- else
- TraversingVisitor::visit(cond);
+ if(!record_only)
+ {
+ ExpressionEvaluator eval(variable_values);
+ cond.condition->visit(eval);
+ if(eval.result_valid)
+ {
+ flatten_block(eval.result ? cond.body : cond.else_body);
+ return;
+ }
+ }
+
+ TraversingVisitor::visit(cond);
}
void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
{
- if(iter.condition)
+ if(!record_only)
{
- ExpressionEvaluator eval;
- iter.condition->visit(eval);
- if(eval.result_valid && !eval.result)
+ if(iter.condition)
{
- remove_node = true;
- return;
+ /* If the loop condition is always false on the first iteration, the
+ entire loop can be removed */
+ if(iter.init_statement)
+ iter.init_statement->visit(*this);
+ ExpressionEvaluator eval(variable_values);
+ iter.condition->visit(eval);
+ if(eval.result_valid && !eval.result)
+ {
+ remove_node = true;
+ return;
+ }
}
+
+ /* Record all assignments that occur inside the loop body so those
+ variables won't be considered as constant */
+ SetFlag set_record(record_only);
+ TraversingVisitor::visit(iter);
}
TraversingVisitor::visit(iter);
+
+ if(VariableDeclaration *init_decl = dynamic_cast<VariableDeclaration *>(iter.init_statement.get()))
+ variable_values.erase(init_decl);
}
aggregate(0),
assignment(0),
assignment_target(false),
+ assign_to_subscript(false),
global_scope(true)
{ }
{
if(binary.oper=="[")
{
+ if(assignment_target)
+ assign_to_subscript = true;
binary.left->visit(*this);
SetForScope<bool> set(assignment_target, false);
binary.right->visit(*this);
void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign)
{
{
+ assign_to_subscript = false;
SetForScope<bool> set(assignment_target, !assign.self_referencing);
assign.left->visit(*this);
}
assignment = &assign;
}
-void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool self_ref)
+void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool chained)
{
VariableInfo &var_info = variables.back()[&var];
- if(!self_ref)
+ if(!chained)
clear_assignments(var_info, true);
var_info.assignments.push_back(&node);
var_info.conditionally_assigned = false;
assignment = 0;
TraversingVisitor::visit(expr);
if(assignment && assignment->target_declaration)
- record_assignment(*assignment->target_declaration, expr, assignment->self_referencing);
+ record_assignment(*assignment->target_declaration, expr, (assignment->self_referencing || assign_to_subscript));
}
void ProgramCompiler::UnusedVariableLocator::visit(StructDeclaration &strct)
void ProgramCompiler::NodeRemover::visit(Block &block)
{
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); )
{
(*i)->visit(*this);
if(to_remove.count(i->get()))
var.init_expression = 0;
}
+void ProgramCompiler::NodeRemover::visit(Iteration &iter)
+{
+ if(to_remove.count(iter.init_statement.get()))
+ iter.init_statement = 0;
+ TraversingVisitor::visit(iter);
+}
+
void ProgramCompiler::PrecisionRemover::visit(Precision &)
{
return true;
}
+bool ProgramCompiler::LegacyConverter::check_extension(const Extension &extension) const
+{
+ if(!extension)
+ return false;
+
+ vector<const Extension *>::iterator i = find(stage->required_extensions, &extension);
+ if(i==stage->required_extensions.end())
+ stage->required_extensions.push_back(&extension);
+
+ return true;
+}
+
bool ProgramCompiler::LegacyConverter::supports_unified_interface_syntax() const
{
if(target_api==OPENGL_ES2)
{
if(target_api==OPENGL_ES2)
return check_version(Version(3, 0));
+ else if(check_version(Version(3, 30)))
+ return true;
else
- return check_version(Version(3, 30));
+ return check_extension(ARB_explicit_attrib_location);
}
bool ProgramCompiler::LegacyConverter::supports_centroid_sampling() const
{
if(target_api==OPENGL_ES2)
return check_version(Version(3, 0));
+ else if(check_version(Version(1, 20)))
+ return true;
else
- return check_version(Version(1, 20));
+ return check_extension(EXT_gpu_shader4);
}
bool ProgramCompiler::LegacyConverter::supports_sample_sampling() const
{
if(target_api==OPENGL_ES2)
return check_version(Version(3, 20));
+ else if(check_version(Version(4, 0)))
+ return true;
else
- return check_version(Version(4, 0));
+ return check_extension(ARB_gpu_shader5);
}
void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
else
return check_version(Version(3, 20));
}
+ else if(check_version(Version(1, 50)))
+ return true;
+ else if(iface=="uniform")
+ return check_extension(ARB_uniform_buffer_object);
else
- return check_version(Version(1, 50));
+ return false;
}
void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface)