X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fprogramcompiler.cpp;h=5bb84269f30abe4fcd38198cef0b6a2ae416b2f8;hp=fd756de0e00cbbca4c5aa18587b251afc4e94ccb;hb=3c46227c280bc4cd8a4487c648f2f080d5b4f7ea;hpb=48e37a09b49cd4148db390170cfd07eef92c9d02 diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp index fd756de0..5bb84269 100644 --- a/source/programcompiler.cpp +++ b/source/programcompiler.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include "error.h" @@ -12,12 +13,12 @@ using namespace std; namespace { const char builtins_src[] = - "////// vertex\n" + "#pragma MSP stage(vertex)\n" "out gl_PerVertex {\n" " vec4 gl_Position;\n" " float gl_ClipDistance[];\n" - "};" - "////// geometry\n" + "};\n" + "#pragma MSP stage(geometry)\n" "in gl_PerVertex {\n" " vec4 gl_Position;\n" " float gl_ClipDistance[];\n" @@ -34,25 +35,45 @@ namespace GL { using namespace ProgramSyntax; +// XXX For some reason global declarations are emitted for otherwise undeclared local variables + ProgramCompiler::ProgramCompiler(): resources(0), module(0) { } -void ProgramCompiler::compile(const string &source) +ProgramCompiler::~ProgramCompiler() +{ + delete module; +} + +void ProgramCompiler::compile(const string &source, const string &src_name) { resources = 0; - module = &parser.parse(source); + delete module; + module = new Module(); + ProgramParser parser; + imported_names.insert(src_name); + append_module(parser.parse(source, src_name)); process(); } -void ProgramCompiler::compile(IO::Base &io, Resources *res) +void ProgramCompiler::compile(IO::Base &io, Resources *res, const string &src_name) { resources = res; - module = &parser.parse(io); + delete module; + module = new Module(); + ProgramParser parser; + imported_names.insert(src_name); + append_module(parser.parse(io, src_name)); process(); } +void ProgramCompiler::compile(IO::Base &io, const string &src_name) +{ + compile(io, 0, src_name); +} + void ProgramCompiler::add_shaders(Program &program) { if(!module) @@ -71,8 +92,11 @@ void ProgramCompiler::add_shaders(Program &program) else if(i->type==FRAGMENT) { program.attach_shader_owned(new FragmentShader(apply(*i))); - for(map::iterator j=i->locations.begin(); j!=i->locations.end(); ++j) - program.bind_fragment_data(j->second, j->first); + if(EXT_gpu_shader4) + { + for(map::iterator j=i->locations.begin(); j!=i->locations.end(); ++j) + program.bind_fragment_data(j->second, j->first); + } } } } @@ -80,7 +104,7 @@ void ProgramCompiler::add_shaders(Program &program) Module *ProgramCompiler::create_builtins_module() { ProgramParser parser; - Module *module = new Module(parser.parse(builtins_src)); + Module *module = new Module(parser.parse(builtins_src, "")); for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) { VariableResolver resolver; @@ -106,13 +130,47 @@ Stage *ProgramCompiler::get_builtins(StageType type) return 0; } -void ProgramCompiler::process() +void ProgramCompiler::append_module(ProgramSyntax::Module &mod) { - list imports = apply >(module->shared); - for(list::iterator i=imports.end(); i!=imports.begin(); ) - import((*--i)->module); - apply(module->shared, set(imports.begin(), imports.end())); + vector imports = apply >(mod.shared); + for(vector::iterator i=imports.begin(); i!=imports.end(); ++i) + import((*i)->module); + apply(mod.shared, set(imports.begin(), imports.end())); + + append_stage(mod.shared); + for(list::iterator i=mod.stages.begin(); i!=mod.stages.end(); ++i) + append_stage(*i); +} + +void ProgramCompiler::append_stage(Stage &stage) +{ + Stage *target = 0; + if(stage.type==SHARED) + target = &module->shared; + else + { + list::iterator i; + for(i=module->stages.begin(); (i!=module->stages.end() && i->typestages.end() || i->type>stage.type) + { + list::iterator j = module->stages.insert(i, stage.type); + if(i!=module->stages.end()) + i->previous = &*j; + i = j; + if(i!=module->stages.begin()) + i->previous = &*--j; + } + + target = &*i; + } + + for(NodeList::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i) + target->content.body.push_back(*i); + apply(*target); +} +void ProgramCompiler::process() +{ for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) generate(*i); for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ) @@ -122,57 +180,44 @@ void ProgramCompiler::process() else ++i; } + for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) + finalize(*i); } void ProgramCompiler::import(const string &name) { string fn = name+".glsl"; + if(imported_names.count(fn)) + return; + imported_names.insert(fn); + RefPtr io = (resources ? resources->open_raw(fn) : Resources::get_builtins().open(fn)); if(!io) throw runtime_error(format("module %s not found", name)); ProgramParser import_parser; - Module &imported_module = import_parser.parse(*io); - - inject_block(module->shared.content, imported_module.shared.content); - apply(module->shared); - for(list::iterator i=imported_module.stages.begin(); i!=imported_module.stages.end(); ++i) - { - list::iterator j; - for(j=module->stages.begin(); (j!=module->stages.end() && j->typetype); ++j) ; - if(j==module->stages.end() || j->type>i->type) - { - j = module->stages.insert(j, *i); - list::iterator k = j; - if(++k!=module->stages.end()) - k->previous = &*j; - if(j!=module->stages.begin()) - j->previous = &*--(k=j); - } - else - { - inject_block(j->content, i->content); - apply(*j); - } - } + append_module(import_parser.parse(*io, fn)); } void ProgramCompiler::generate(Stage &stage) { inject_block(stage.content, module->shared.content); + apply(stage); apply(stage); apply(stage); apply(stage); apply(stage); - apply(stage); + apply(stage); + apply(stage); apply(stage); - apply(stage); } bool ProgramCompiler::optimize(Stage &stage) { apply(stage); - apply(stage); + + set inlineable = apply(stage); + apply(stage, inlineable); set unused = apply(stage); set unused2 = apply(stage); @@ -182,10 +227,18 @@ bool ProgramCompiler::optimize(Stage &stage) return !unused.empty(); } +void ProgramCompiler::finalize(Stage &stage) +{ + if(get_gl_api()==OPENGL_ES2) + apply(stage); + else + apply(stage); +} + void ProgramCompiler::inject_block(Block &target, const Block &source) { - list >::iterator insert_point = target.body.begin(); - for(list >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i) + list >::iterator insert_point = target.body.begin(); + for(list >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i) target.body.insert(insert_point, (*i)->clone()); } @@ -217,6 +270,38 @@ void ProgramCompiler::Visitor::apply(Stage &s) } +ProgramCompiler::BlockModifier::BlockModifier(): + remove_node(false) +{ } + +void ProgramCompiler::BlockModifier::flatten_block(Block &block) +{ + insert_nodes.insert(insert_nodes.end(), block.body.begin(), block.body.end()); + remove_node = true; +} + +void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list >::iterator &i) +{ + block.body.insert(i, insert_nodes.begin(), insert_nodes.end()); + insert_nodes.clear(); + + if(remove_node) + block.body.erase(i++); + else + ++i; + remove_node = false; +} + +void ProgramCompiler::BlockModifier::visit(Block &block) +{ + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + { + (*i)->visit(*this); + apply_and_increment(block, i); + } +} + + ProgramCompiler::Formatter::Formatter(): indent(0), parameter_list(false), @@ -225,9 +310,17 @@ ProgramCompiler::Formatter::Formatter(): void ProgramCompiler::Formatter::apply(ProgramSyntax::Stage &s) { + GLApi api = get_gl_api(); const Version &ver = s.required_version; - if(ver.major) - formatted += format("#version %d%d\n", ver.major, ver.minor); + + if(ver) + { + formatted += format("#version %d%02d", ver.major, ver.minor); + if(api==OPENGL_ES2 && ver>=Version(3, 0)) + formatted += " es"; + formatted += '\n'; + } + Visitor::apply(s); } @@ -281,7 +374,7 @@ void ProgramCompiler::Formatter::visit(Assignment &assign) void ProgramCompiler::Formatter::visit(FunctionCall &call) { formatted += format("%s(", call.name); - for(vector >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) + for(vector >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) { if(i!=call.arguments.begin()) formatted += ", "; @@ -308,7 +401,7 @@ void ProgramCompiler::Formatter::visit(Block &block) SetForScope set(indent, indent+(indent>0 || use_braces)); string spaces(indent*2, ' '); - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ++i) + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ++i) { if(i!=block.body.begin()) formatted += '\n'; @@ -326,6 +419,11 @@ void ProgramCompiler::Formatter::visit(Import &import) formatted += format("import %s;", import.module); } +void ProgramCompiler::Formatter::visit(Precision &prec) +{ + formatted += format("precision %s %s;", prec.precision, prec.type); +} + void ProgramCompiler::Formatter::visit(Layout &layout) { formatted += "layout("; @@ -365,7 +463,19 @@ void ProgramCompiler::Formatter::visit(VariableDeclaration &var) if(!var.sampling.empty()) formatted += format("%s ", var.sampling); if(!var.interface.empty() && var.interface!=block_interface) - formatted += format("%s ", var.interface); + { + string interface = var.interface; + if(stage->required_versiontype==VERTEX && var.interface=="in") + interface = "attribute"; + else if((stage->type==VERTEX && var.interface=="out") || (stage->type==FRAGMENT && var.interface=="in")) + interface = "varying"; + } + formatted += format("%s ", interface); + } + if(!var.precision.empty()) + formatted += format("%s ", var.precision); formatted += format("%s %s", var.type, var.name); if(var.array) { @@ -394,7 +504,7 @@ void ProgramCompiler::Formatter::visit(InterfaceBlock &iface) void ProgramCompiler::Formatter::visit(FunctionDeclaration &func) { formatted += format("%s %s(", func.return_type, func.name); - for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) + for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) { if(i!=func.parameters.begin()) formatted += ", "; @@ -450,10 +560,15 @@ void ProgramCompiler::Formatter::visit(Return &ret) formatted += ';'; } +void ProgramCompiler::Formatter::visit(Jump &jump) +{ + formatted += jump.keyword; + formatted += ';'; +} + ProgramCompiler::DeclarationCombiner::DeclarationCombiner(): - toplevel(true), - remove_node(false) + toplevel(true) { } void ProgramCompiler::DeclarationCombiner::visit(Block &block) @@ -462,15 +577,7 @@ void ProgramCompiler::DeclarationCombiner::visit(Block &block) return; SetForScope set(toplevel, false); - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) - { - remove_node = false; - (*i)->visit(*this); - if(remove_node) - block.body.erase(i++); - else - ++i; - } + BlockModifier::visit(block); } void ProgramCompiler::DeclarationCombiner::visit(FunctionDeclaration &func) @@ -670,40 +777,6 @@ void ProgramCompiler::FunctionResolver::visit(FunctionDeclaration &func) } -ProgramCompiler::BlockModifier::BlockModifier(): - remove_node(false) -{ } - -void ProgramCompiler::BlockModifier::flatten_block(Block &block) -{ - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ++i) - insert_nodes.push_back((*i)->clone()); - remove_node = true; -} - -void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list >::iterator &i) -{ - for(list::iterator j=insert_nodes.begin(); j!=insert_nodes.end(); ++j) - block.body.insert(i, *j); - insert_nodes.clear(); - - if(remove_node) - block.body.erase(i++); - else - ++i; - remove_node = false; -} - -void ProgramCompiler::BlockModifier::visit(Block &block) -{ - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) - { - (*i)->visit(*this); - apply_and_increment(block, i); - } -} - - ProgramCompiler::InterfaceGenerator::InterfaceGenerator(): scope_level(0) { } @@ -730,15 +803,15 @@ void ProgramCompiler::InterfaceGenerator::apply(Stage &s) void ProgramCompiler::InterfaceGenerator::visit(Block &block) { SetForScope set(scope_level, scope_level+1); - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) { (*i)->visit(*this); if(scope_level==1) { - for(map::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j) + for(map >::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j) { - list >::iterator k = block.body.insert(i, j->second); + list >::iterator k = block.body.insert(i, j->second); (*k)->visit(*this); } iface_declarations.clear(); @@ -790,6 +863,7 @@ void ProgramCompiler::InterfaceGenerator::insert_assignment(const string &left, ExpressionStatement *stmt = new ExpressionStatement; stmt->expression = assign; + stmt->visit(*this); insert_nodes.push_back(stmt); } @@ -805,7 +879,10 @@ void ProgramCompiler::InterfaceGenerator::visit(VariableReference &var) if(i==prev_out.end()) i = prev_out.find(in_prefix+var.name); if(i!=prev_out.end()) - generate_interface(*i->second, "in", var.name); + { + generate_interface(*i->second, "in", i->second->name); + var.name = i->second->name; + } } void ProgramCompiler::InterfaceGenerator::visit(VariableDeclaration &var) @@ -818,7 +895,10 @@ void ProgramCompiler::InterfaceGenerator::visit(VariableDeclaration &var) { remove_node = true; if(var.init_expression) + { insert_assignment(var.name, var.init_expression->clone()); + return; + } } } else if(var.interface=="in") @@ -847,9 +927,9 @@ void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass) for(map::const_iterator i=stage->in_variables.begin(); i!=stage->in_variables.end(); ++i) pass_vars.push_back(i->second); - for(map::const_iterator i=iface_declarations.begin(); i!=iface_declarations.end(); ++i) + for(map >::const_iterator i=iface_declarations.begin(); i!=iface_declarations.end(); ++i) if(i->second->interface=="in") - pass_vars.push_back(i->second); + pass_vars.push_back(i->second.get()); if(stage->previous) { @@ -907,17 +987,212 @@ void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass) } -void ProgramCompiler::VariableRenamer::visit(VariableReference &var) +ProgramCompiler::DeclarationReorderer::DeclarationReorderer(): + scope_level(0), + kind(NO_DECLARATION) +{ } + +void ProgramCompiler::DeclarationReorderer::visit(FunctionCall &call) { - if(var.declaration) - var.name = var.declaration->name; + FunctionDeclaration *def = call.declaration; + if(def) + def = def->definition; + if(def && !ordered_funcs.count(def)) + needed_funcs.insert(def); } -void ProgramCompiler::VariableRenamer::visit(VariableDeclaration &var) +void ProgramCompiler::DeclarationReorderer::visit(Block &block) { - if(var.linked_declaration) - var.name = var.linked_declaration->name; - TraversingVisitor::visit(var); + SetForScope set(scope_level, scope_level+1); + if(scope_level>1) + return Visitor::visit(block); + + list >::iterator struct_insert_point = block.body.end(); + list >::iterator variable_insert_point = block.body.end(); + list >::iterator function_insert_point = block.body.end(); + unsigned unordered_func_count = 0; + bool ordered_any_funcs = false; + + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + { + kind = NO_DECLARATION; + (*i)->visit(*this); + + bool moved = false; + if(kind==STRUCT && struct_insert_point!=block.body.end()) + { + block.body.insert(struct_insert_point, *i); + moved = true; + } + else if(kind>STRUCT && struct_insert_point==block.body.end()) + struct_insert_point = i; + + if(kind==VARIABLE && variable_insert_point!=block.body.end()) + { + block.body.insert(variable_insert_point, *i); + moved = true; + } + else if(kind>VARIABLE && variable_insert_point==block.body.end()) + variable_insert_point = i; + + if(kind==FUNCTION) + { + if(function_insert_point==block.body.end()) + function_insert_point = i; + + if(needed_funcs.empty()) + { + ordered_funcs.insert(i->get()); + if(i!=function_insert_point) + { + block.body.insert(function_insert_point, *i); + moved = true; + } + else + ++function_insert_point; + ordered_any_funcs = true; + } + else + ++unordered_func_count; + } + + if(moved) + { + if(function_insert_point==i) + ++function_insert_point; + block.body.erase(i++); + } + else + ++i; + + if(i==block.body.end() && unordered_func_count) + { + if(!ordered_any_funcs) + // A subset of the remaining functions forms a recursive loop + /* TODO pick a function and move it up, adding any necessary + declarations */ + break; + + i = function_insert_point; + unordered_func_count = 0; + } + } +} + +void ProgramCompiler::DeclarationReorderer::visit(ProgramSyntax::VariableDeclaration &var) +{ + Visitor::visit(var); + kind = VARIABLE; +} + +void ProgramCompiler::DeclarationReorderer::visit(FunctionDeclaration &func) +{ + needed_funcs.clear(); + func.body.visit(*this); + needed_funcs.erase(&func); + kind = FUNCTION; +} + + +ProgramCompiler::InlineableFunctionLocator::InlineableFunctionLocator(): + in_function(0) +{ } + +void ProgramCompiler::InlineableFunctionLocator::visit(FunctionCall &call) +{ + FunctionDeclaration *def = call.declaration; + if(def && def->definition!=def) + def = def->definition; + + if(def) + { + unsigned &count = refcounts[def]; + ++count; + if(count>1 || def==in_function) + inlineable.erase(def); + } + + TraversingVisitor::visit(call); +} + +void ProgramCompiler::InlineableFunctionLocator::visit(FunctionDeclaration &func) +{ + unsigned &count = refcounts[func.definition]; + if(!count && func.parameters.empty()) + inlineable.insert(func.definition); + + SetForScope set(in_function, &func); + TraversingVisitor::visit(func); +} + + +ProgramCompiler::FunctionInliner::FunctionInliner(): + extract_result(0) +{ } + +ProgramCompiler::FunctionInliner::FunctionInliner(const set &in): + inlineable(in), + extract_result(0) +{ } + +void ProgramCompiler::FunctionInliner::visit_and_inline(RefPtr &ptr) +{ + inline_result = 0; + ptr->visit(*this); + if(inline_result) + ptr = inline_result; +} + +void ProgramCompiler::FunctionInliner::visit(Block &block) +{ + if(extract_result) + --extract_result; + + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ++i) + { + (*i)->visit(*this); + if(extract_result) + --extract_result; + } +} + +void ProgramCompiler::FunctionInliner::visit(UnaryExpression &unary) +{ + visit_and_inline(unary.expression); + inline_result = 0; +} + +void ProgramCompiler::FunctionInliner::visit(BinaryExpression &binary) +{ + visit_and_inline(binary.left); + visit_and_inline(binary.right); + inline_result = 0; +} + +void ProgramCompiler::FunctionInliner::visit(FunctionCall &call) +{ + for(vector >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) + visit_and_inline(*i); + + FunctionDeclaration *def = call.declaration; + if(def && def->definition!=def) + def = def->definition; + + if(def && inlineable.count(def)) + { + extract_result = 2; + def->visit(*this); + } + else + inline_result = 0; +} + +void ProgramCompiler::FunctionInliner::visit(Return &ret) +{ + TraversingVisitor::visit(ret); + + if(extract_result) + inline_result = ret.expression->clone(); } @@ -944,6 +1219,11 @@ void ProgramCompiler::ExpressionEvaluator::visit(Literal &literal) result_valid = true; } +void ProgramCompiler::ExpressionEvaluator::visit(ParenthesizedExpression &parexp) +{ + parexp.expression->visit(*this); +} + void ProgramCompiler::ExpressionEvaluator::visit(VariableReference &var) { if(!var.declaration) @@ -1027,7 +1307,7 @@ void ProgramCompiler::ConstantConditionEliminator::visit(Assignment &assign) void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &var) { if(var.constant || scope_level>1) - variable_values[&var] = &*var.init_expression; + variable_values[&var] = var.init_expression.get(); } void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond) @@ -1060,38 +1340,39 @@ void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter) ProgramCompiler::UnusedVariableLocator::UnusedVariableLocator(): aggregate(0), assignment(0), - assignment_target(false) + assignment_target(false), + global_scope(true) { } void ProgramCompiler::UnusedVariableLocator::apply(Stage &s) { - assignments.push_back(BlockAssignmentMap()); + variables.push_back(BlockVariableMap()); Visitor::apply(s); - assignments.pop_back(); + BlockVariableMap &global_variables = variables.back(); + for(BlockVariableMap::iterator i=global_variables.begin(); i!=global_variables.end(); ++i) + { + if(i->first->interface=="out" && (s.type==FRAGMENT || i->first->linked_declaration || !i->first->name.compare(0, 3, "gl_"))) + continue; + if(!i->second.referenced) + { + unused_nodes.insert(i->first); + clear_assignments(i->second, true); + } + } + variables.pop_back(); } void ProgramCompiler::UnusedVariableLocator::visit(VariableReference &var) { - unused_nodes.erase(var.declaration); - map::iterator i = aggregates.find(var.declaration); if(i!=aggregates.end()) unused_nodes.erase(i->second); - if(assignment_target) - return; - - for(vector::iterator j=assignments.end(); j!=assignments.begin(); ) + if(var.declaration && !assignment_target) { - --j; - BlockAssignmentMap::iterator k = j->find(var.declaration); - if(k!=j->end()) - { - for(vector::iterator l=k->second.nodes.begin(); l!=k->second.nodes.end(); ++l) - unused_nodes.erase(*l); - j->erase(k); - break; - } + VariableInfo &var_info = variables.back()[var.declaration]; + var_info.assignments.clear(); + var_info.referenced = true; } } @@ -1125,14 +1406,21 @@ void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign) void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool self_ref) { - unused_nodes.insert(&node); - BlockAssignmentMap &block_assignments = assignments.back(); - AssignmentList &var_assignments = block_assignments[&var]; + VariableInfo &var_info = variables.back()[&var]; if(!self_ref) - var_assignments.nodes.clear(); - var_assignments.nodes.push_back(&node); - var_assignments.conditional = false; - var_assignments.self_referencing = self_ref; + clear_assignments(var_info, true); + var_info.assignments.push_back(&node); + var_info.conditionally_assigned = false; +} + +void ProgramCompiler::UnusedVariableLocator::clear_assignments(VariableInfo &var_info, bool mark_unused) +{ + if(mark_unused) + { + for(vector::iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i) + unused_nodes.insert(*i); + } + var_info.assignments.clear(); } void ProgramCompiler::UnusedVariableLocator::visit(ExpressionStatement &expr) @@ -1156,7 +1444,7 @@ void ProgramCompiler::UnusedVariableLocator::visit(VariableDeclaration &var) aggregates[&var] = aggregate; else { - unused_nodes.insert(&var); + variables.back()[&var].local = true; if(var.init_expression) record_assignment(var, *var.init_expression, false); } @@ -1173,90 +1461,106 @@ void ProgramCompiler::UnusedVariableLocator::visit(InterfaceBlock &iface) void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func) { - assignments.push_back(BlockAssignmentMap()); + variables.push_back(BlockVariableMap()); - for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) - (*i)->visit(*this); - func.body.visit(*this); - - BlockAssignmentMap &block_assignments = assignments.back(); - for(map::iterator i=func.body.variables.begin(); i!=func.body.variables.end(); ++i) - block_assignments.erase(i->second); - for(BlockAssignmentMap::iterator i=block_assignments.begin(); i!=block_assignments.end(); ++i) { - if(i->first->interface=="out" && stage->type!=FRAGMENT && !i->first->linked_declaration) - continue; - - for(vector::iterator j=i->second.nodes.begin(); j!=i->second.nodes.end(); ++j) - unused_nodes.erase(*j); + SetForScope set(global_scope, false); + for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) + (*i)->visit(*this); + func.body.visit(*this); } - assignments.pop_back(); + BlockVariableMap &block_variables = variables.back(); + for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i) + i->second.conditionally_assigned = true; + for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) + block_variables[i->get()].referenced = true; + merge_down_variables(); } -void ProgramCompiler::UnusedVariableLocator::merge_down_assignments() +void ProgramCompiler::UnusedVariableLocator::merge_down_variables() { - BlockAssignmentMap &parent_assignments = assignments[assignments.size()-2]; - BlockAssignmentMap &block_assignments = assignments.back(); - for(BlockAssignmentMap::iterator i=block_assignments.begin(); i!=block_assignments.end(); ++i) + BlockVariableMap &parent_variables = variables[variables.size()-2]; + BlockVariableMap &block_variables = variables.back(); + for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i) { - BlockAssignmentMap::iterator j = parent_assignments.find(i->first); - if(j==parent_assignments.end()) - parent_assignments.insert(*i); - else if(i->second.self_referencing || i->second.conditional) + if(i->second.local) { - j->second.nodes.insert(j->second.nodes.end(), i->second.nodes.begin(), i->second.nodes.end()); - j->second.conditional |= i->second.conditional; - j->second.self_referencing |= i->second.self_referencing; + if(!i->second.referenced) + unused_nodes.insert(i->first); + clear_assignments(i->second, true); + continue; } + + BlockVariableMap::iterator j = parent_variables.find(i->first); + if(j==parent_variables.end()) + parent_variables.insert(*i); else - j->second = i->second; + { + if(i->second.referenced || !i->second.conditionally_assigned) + clear_assignments(j->second, !i->second.referenced); + j->second.conditionally_assigned = i->second.conditionally_assigned; + j->second.referenced |= i->second.referenced; + j->second.assignments.insert(j->second.assignments.end(), i->second.assignments.begin(), i->second.assignments.end()); + } } - assignments.pop_back(); + variables.pop_back(); } void ProgramCompiler::UnusedVariableLocator::visit(Conditional &cond) { cond.condition->visit(*this); - assignments.push_back(BlockAssignmentMap()); + variables.push_back(BlockVariableMap()); cond.body.visit(*this); - BlockAssignmentMap if_assignments; - swap(assignments.back(), if_assignments); + BlockVariableMap if_variables; + swap(variables.back(), if_variables); cond.else_body.visit(*this); - BlockAssignmentMap &else_assignments = assignments.back(); - for(BlockAssignmentMap::iterator i=else_assignments.begin(); i!=else_assignments.end(); ++i) + BlockVariableMap &else_variables = variables.back(); + for(BlockVariableMap::iterator i=else_variables.begin(); i!=else_variables.end(); ++i) { - BlockAssignmentMap::iterator j = if_assignments.find(i->first); - if(j!=if_assignments.end()) + BlockVariableMap::iterator j = if_variables.find(i->first); + if(j!=if_variables.end()) { - i->second.nodes.insert(i->second.nodes.end(), j->second.nodes.begin(), j->second.nodes.end()); - i->second.conditional |= j->second.conditional; - i->second.self_referencing |= j->second.self_referencing; - if_assignments.erase(j); + i->second.assignments.insert(i->second.assignments.end(), j->second.assignments.begin(), j->second.assignments.end()); + i->second.conditionally_assigned |= j->second.conditionally_assigned; + if_variables.erase(j); } else - i->second.conditional = true; + i->second.conditionally_assigned = true; } - for(BlockAssignmentMap::iterator i=if_assignments.begin(); i!=if_assignments.end(); ++i) + for(BlockVariableMap::iterator i=if_variables.begin(); i!=if_variables.end(); ++i) { - i->second.conditional = true; - else_assignments.insert(*i); + i->second.conditionally_assigned = true; + else_variables.insert(*i); } - merge_down_assignments(); + merge_down_variables(); } void ProgramCompiler::UnusedVariableLocator::visit(Iteration &iter) { - assignments.push_back(BlockAssignmentMap()); + variables.push_back(BlockVariableMap()); TraversingVisitor::visit(iter); - merge_down_assignments(); + + BlockVariableMap &block_variables = variables.back(); + for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i) + if(!i->second.local && i->second.referenced) + i->second.assignments.clear(); + + merge_down_variables(); } +ProgramCompiler::UnusedVariableLocator::VariableInfo::VariableInfo(): + local(false), + conditionally_assigned(false), + referenced(false) +{ } + + void ProgramCompiler::UnusedFunctionLocator::visit(FunctionCall &call) { TraversingVisitor::visit(call); @@ -1270,7 +1574,7 @@ void ProgramCompiler::UnusedFunctionLocator::visit(FunctionDeclaration &func) { TraversingVisitor::visit(func); - if(func.name!="main" && !used_definitions.count(&func)) + if((func.name!="main" || func.body.body.empty()) && !used_definitions.count(&func)) unused_nodes.insert(&func); } @@ -1281,10 +1585,10 @@ ProgramCompiler::NodeRemover::NodeRemover(const set &r): void ProgramCompiler::NodeRemover::visit(Block &block) { - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) { (*i)->visit(*this); - if(to_remove.count(&**i)) + if(to_remove.count(i->get())) block.body.erase(i++); else ++i; @@ -1301,20 +1605,83 @@ void ProgramCompiler::NodeRemover::visit(VariableDeclaration &var) if(var.linked_declaration) var.linked_declaration->linked_declaration = 0; } - else if(var.init_expression && to_remove.count(&*var.init_expression)) + else if(var.init_expression && to_remove.count(var.init_expression.get())) var.init_expression = 0; } +void ProgramCompiler::PrecisionRemover::visit(Precision &) +{ + remove_node = true; +} + +void ProgramCompiler::PrecisionRemover::visit(VariableDeclaration &var) +{ + var.precision.clear(); +} + + +ProgramCompiler::DefaultPrecisionGenerator::DefaultPrecisionGenerator(): + toplevel(true) +{ } + +void ProgramCompiler::DefaultPrecisionGenerator::visit(Block &block) +{ + if(toplevel) + { + SetForScope set(toplevel, false); + BlockModifier::visit(block); + } + else + Visitor::visit(block); +} + +void ProgramCompiler::DefaultPrecisionGenerator::visit(Precision &prec) +{ + have_default.insert(prec.type); +} + +void ProgramCompiler::DefaultPrecisionGenerator::visit(VariableDeclaration &var) +{ + if(var.type_declaration) + return; + + string type = var.type; + if(!type.compare(0, 3, "vec") || !type.compare(0, 3, "mat")) + type = "float"; + else if(!type.compare(0, 3, "ivec") || type=="uint") + type = "int"; + + if(!have_default.count(type)) + { + Precision *prec = new Precision; + if(!type.compare(0, 7, "sampler")) + prec->precision = "lowp"; + else if(stage->type==FRAGMENT) + prec->precision = "mediump"; + else + prec->precision = "highp"; + prec->type = type; + insert_nodes.push_back(prec); + + have_default.insert(type); + } +} + + ProgramCompiler::LegacyConverter::LegacyConverter(): - target_version(get_glsl_version()) + target_api(get_gl_api()), + target_version(get_glsl_version()), + frag_out(0) { } ProgramCompiler::LegacyConverter::LegacyConverter(const Version &v): - target_version(v) + target_api(get_gl_api()), + target_version(v), + frag_out(0) { } -bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_version) +bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_version) const { if(target_version >::iterator i = call.arguments.begin(); + vector >::iterator i = call.arguments.begin(); if(i!=call.arguments.end()) { (*i)->visit(*this); @@ -1365,9 +1755,17 @@ void ProgramCompiler::LegacyConverter::visit(FunctionCall &call) TraversingVisitor::visit(call); } +bool ProgramCompiler::LegacyConverter::supports_interface_layouts() const +{ + if(target_api==OPENGL_ES2) + return check_version(Version(3, 0)); + else + return check_version(Version(3, 30)); +} + void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var) { - if(var.layout && !check_version(Version(3, 30))) + if(var.layout && !supports_interface_layouts()) { vector::iterator i; for(i=var.layout->qualifiers.begin(); (i!=var.layout->qualifiers.end() && i->identifier!="location"); ++i) ; @@ -1381,6 +1779,8 @@ void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var) } else if(stage->type==FRAGMENT && var.interface=="out") { + if(location!=0) + static Require _req(EXT_gpu_shader4); stage->locations[var.name] = location; var.layout->qualifiers.erase(i); } @@ -1390,15 +1790,11 @@ void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var) } } - if((var.interface=="in" || var.interface=="out") && !check_version(Version(1, 30))) + if((var.interface=="in" || var.interface=="out") && !supports_unified_interface_syntax()) { - if(stage->type==VERTEX && var.interface=="in") - var.interface = "attribute"; - else if((stage->type==VERTEX && var.interface=="out") || (stage->type==FRAGMENT && var.interface=="in")) - var.interface = "varying"; - else if(stage->type==FRAGMENT && var.interface=="out") + if(stage->type==FRAGMENT && var.interface=="out") { - frag_out_name = var.name; + frag_out = &var; remove_node = true; } } @@ -1406,9 +1802,22 @@ void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var) TraversingVisitor::visit(var); } +bool ProgramCompiler::LegacyConverter::supports_interface_blocks(const string &iface) const +{ + if(target_api==OPENGL_ES2) + { + if(iface=="uniform") + return check_version(Version(3, 0)); + else + return check_version(Version(3, 20)); + } + else + return check_version(Version(1, 50)); +} + void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface) { - if(!check_version(Version(1, 50))) + if(!supports_interface_blocks(iface.interface)) flatten_block(iface.members); }