X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fcompiler.cpp;h=5b488f4d4a8f74ac1216e1f6be193b9510d95f63;hb=59347f76bc985e8c9c769d4a3eee672cba9c920b;hp=332dd331f69b6bc6e287e89306e2e21eeff52e72;hpb=4c6f1a526ed949f6c9f4c3a57c036b3cdb1aaa91;p=libs%2Fgl.git diff --git a/source/glsl/compiler.cpp b/source/glsl/compiler.cpp index 332dd331..5b488f4d 100644 --- a/source/glsl/compiler.cpp +++ b/source/glsl/compiler.cpp @@ -2,15 +2,17 @@ #include #include #include "builtin.h" -#include "compatibility.h" #include "compiler.h" #include "debug.h" #include "error.h" +#include "finalize.h" #include "generate.h" #include "glsl_error.h" +#include "modulecache.h" #include "optimize.h" #include "output.h" -#include "resources.h" +#include "resolve.h" +#include "spirv.h" #include "validate.h" #undef interface @@ -24,12 +26,14 @@ namespace SL { Compiler::Compiler(): features(Features::from_context()), module(0), + compiled(false), specialized(false) { } Compiler::Compiler(const Features &f): features(f), module(0), + compiled(false), specialized(false) { } @@ -49,17 +53,17 @@ void Compiler::clear() void Compiler::set_source(const string &source, const string &src_name) { clear(); - Parser parser; imported_names.push_back(src_name); - append_module(parser.parse(source, src_name, 1), 0); + ModuleCache mod_cache(0); + append_module(mod_cache.add_module(source, src_name), mod_cache); } void Compiler::load_source(IO::Base &io, DataFile::Collection *res, const string &src_name) { clear(); - Parser parser; imported_names.push_back(src_name); - append_module(parser.parse(io, src_name, 1), res); + ModuleCache mod_cache(res); + append_module(mod_cache.add_module(io, src_name), mod_cache); } void Compiler::load_source(IO::Base &io, const string &src_name) @@ -75,18 +79,30 @@ void Compiler::specialize(const map &sv) void Compiler::compile(Mode mode) { + if(specialized && mode!=PROGRAM) + throw invalid_operation("Compiler::compile"); + + for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) + generate(*i); + ConstantIdAssigner().apply(*module, features); + for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) - generate(*i, mode); + validate(*i); + GlobalInterfaceValidator().apply(*module); bool valid = true; for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) - if(!validate(*i)) + if(!check_errors(*i)) valid = false; if(!valid) throw invalid_shader_source(get_diagnostics()); - unsigned n = 0; - for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++n) + if(specialized) + { + for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) + ConstantSpecializer().apply(*i, spec_values); + } + for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ) { OptimizeResult result = optimize(*i); if(result==REDO_PREVIOUS) @@ -94,12 +110,19 @@ void Compiler::compile(Mode mode) else if(result!=REDO_STAGE) ++i; } + + LocationAllocator().apply(*module, features); for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) finalize(*i, mode); + + compiled = true; } string Compiler::get_combined_glsl() const { + if(!compiled) + throw invalid_operation("Compiler::get_combined_glsl"); + string glsl; unsigned source_count = module->source_map.get_count(); @@ -108,7 +131,7 @@ string Compiler::get_combined_glsl() const for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) { glsl += format("#pragma MSP stage(%s)\n", Stage::get_stage_name(i->type)); - glsl += Formatter().apply(*i, MODULE); + glsl += Formatter().apply(*i); glsl += '\n'; } @@ -126,14 +149,27 @@ vector Compiler::get_stages() const string Compiler::get_stage_glsl(Stage::Type stage_type) const { + if(!compiled) + throw invalid_operation("Compiler::get_stage_glsl"); for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) if(i->type==stage_type) - return Formatter().apply(*i, PROGRAM); + return Formatter().apply(*i); throw key_error(Stage::get_stage_name(stage_type)); } +vector Compiler::get_combined_spirv() const +{ + if(!compiled) + throw invalid_operation("Compiler::get_combined_spirv"); + SpirVGenerator gen; + gen.apply(*module); + return gen.get_code(); +} + const map &Compiler::get_vertex_attributes() const { + if(!compiled) + throw invalid_operation("Compiler::get_vertex_attributes"); for(list::const_iterator i=module->stages.begin(); i!=module->stages.end(); ++i) if(i->type==Stage::VERTEX) return i->locations; @@ -142,12 +178,28 @@ const map &Compiler::get_vertex_attributes() const const map &Compiler::get_fragment_outputs() const { + if(!compiled) + throw invalid_operation("Compiler::get_fragment_outputs"); for(list::const_iterator i=module->stages.begin(); i!=module->stages.end(); ++i) if(i->type==Stage::FRAGMENT) return i->locations; throw invalid_operation("Compiler::get_fragment_outputs"); } +const map &Compiler::get_texture_bindings() const +{ + if(!compiled) + throw invalid_operation("Compiler::get_texture_bindings"); + return module->shared.texture_bindings; +} + +const map &Compiler::get_uniform_block_bindings() const +{ + if(!compiled) + throw invalid_operation("Compiler::get_uniform_block_bindings"); + return module->shared.uniform_block_bindings; +} + const SourceMap &Compiler::get_source_map() const { return module->source_map; @@ -171,7 +223,7 @@ string Compiler::get_diagnostics() const return combined; } -void Compiler::append_module(Module &mod, DataFile::Collection *res) +void Compiler::append_module(const Module &mod, ModuleCache &mod_cache) { module->source_map.merge_from(mod.source_map); @@ -180,15 +232,14 @@ void Compiler::append_module(Module &mod, DataFile::Collection *res) if(Import *imp = dynamic_cast(i->get())) imports.push_back(imp); for(vector::iterator i=imports.begin(); i!=imports.end(); ++i) - import(res, (*i)->module); - NodeRemover().apply(mod.shared, set(imports.begin(), imports.end())); + import(mod_cache, (*i)->module); append_stage(mod.shared); - for(list::iterator i=mod.stages.begin(); i!=mod.stages.end(); ++i) + for(list::const_iterator i=mod.stages.begin(); i!=mod.stages.end(); ++i) append_stage(*i); } -void Compiler::append_stage(Stage &stage) +void Compiler::append_stage(const Stage &stage) { Stage *target = 0; if(stage.type==Stage::SHARED) @@ -212,26 +263,21 @@ void Compiler::append_stage(Stage &stage) if(stage.required_features.glsl_version>target->required_features.glsl_version) target->required_features.glsl_version = stage.required_features.glsl_version; - for(NodeList::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i) - target->content.body.push_back(*i); - DeclarationCombiner().apply(*target); + for(NodeList::const_iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i) + if(!dynamic_cast(i->get())) + target->content.body.push_back(*i); } -void Compiler::import(DataFile::Collection *resources, const string &name) +void Compiler::import(ModuleCache &mod_cache, const string &name) { - string fn = name+".glsl"; - if(find(imported_names, fn)!=imported_names.end()) + if(find(imported_names, name)!=imported_names.end()) return; - imported_names.push_back(fn); + imported_names.push_back(name); - RefPtr io = (resources ? resources->open_raw(fn) : Resources::get_builtins().open(fn)); - if(!io) - throw runtime_error(format("module %s not found", name)); - Parser import_parser; - append_module(import_parser.parse(*io, fn, module->source_map.get_count()), resources); + append_module(mod_cache.get_module(name), mod_cache); } -void Compiler::generate(Stage &stage, Mode mode) +void Compiler::generate(Stage &stage) { stage.required_features.gl_api = features.gl_api; if(module->shared.required_features.glsl_version>stage.required_features.glsl_version) @@ -250,13 +296,6 @@ void Compiler::generate(Stage &stage, Mode mode) variables through interfaces. */ InterfaceGenerator().apply(stage); resolve(stage, RESOLVE_BLOCKS|RESOLVE_TYPES|RESOLVE_VARIABLES); - - ConstantSpecializer().apply(stage, (mode==PROGRAM && specialized ? &spec_values : 0)); - if(mode==PROGRAM) - { - LegacyConverter().apply(stage, features); - resolve(stage, RESOLVE_VARIABLES|RESOLVE_FUNCTIONS); - } } template @@ -282,17 +321,22 @@ void Compiler::resolve(Stage &stage, unsigned flags) else if(resolve(stage, flags, RESOLVE_FUNCTIONS)) flags |= RESOLVE_EXPRESSIONS; else if(resolve(stage, flags, RESOLVE_EXPRESSIONS)) - flags |= RESOLVE_VARIABLES; + flags |= RESOLVE_VARIABLES|RESOLVE_FUNCTIONS; } } -bool Compiler::validate(Stage &stage) +void Compiler::validate(Stage &stage) { - TypeValidator().apply(stage); DeclarationValidator().apply(stage); + IdentifierValidator().apply(stage); ReferenceValidator().apply(stage); ExpressionValidator().apply(stage); + FlowControlValidator().apply(stage); + StageInterfaceValidator().apply(stage); +} +bool Compiler::check_errors(Stage &stage) +{ stable_sort(stage.diagnostics, &diagnostic_line_order); for(vector::const_iterator i=stage.diagnostics.begin(); i!=stage.diagnostics.end(); ++i) @@ -319,6 +363,8 @@ bool Compiler::diagnostic_line_order(const Diagnostic &diag1, const Diagnostic & Compiler::OptimizeResult Compiler::optimize(Stage &stage) { + if(ConstantFolder().apply(stage)) + resolve(stage, RESOLVE_EXPRESSIONS); ConstantConditionEliminator().apply(stage); bool any_inlined = false; @@ -335,7 +381,8 @@ Compiler::OptimizeResult Compiler::optimize(Stage &stage) /* Removing variables or functions may cause things from the previous stage to become unused. */ - bool any_removed = UnusedVariableRemover().apply(stage); + bool any_removed = UnreachableCodeRemover().apply(stage); + any_removed |= UnusedVariableRemover().apply(stage); any_removed |= UnusedFunctionRemover().apply(stage); any_removed |= UnusedTypeRemover().apply(stage); @@ -344,10 +391,18 @@ Compiler::OptimizeResult Compiler::optimize(Stage &stage) void Compiler::finalize(Stage &stage, Mode mode) { - if(get_gl_api()==OPENGL_ES2 && mode==PROGRAM) - DefaultPrecisionGenerator().apply(stage); - else if(mode==MODULE) - PrecisionRemover().apply(stage); + if(mode==PROGRAM) + { + LegacyConverter().apply(stage, features); + resolve(stage, RESOLVE_VARIABLES|RESOLVE_FUNCTIONS); + PrecisionConverter().apply(stage); + } + else if(mode==SPIRV) + StructOrganizer().apply(stage); + + // Collect bindings from all stages into the shared stage's maps + module->shared.texture_bindings.insert(stage.texture_bindings.begin(), stage.texture_bindings.end()); + module->shared.uniform_block_bindings.insert(stage.uniform_block_bindings.begin(), stage.uniform_block_bindings.end()); } void Compiler::inject_block(Block &target, const Block &source)