X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Fvalidate.h;h=c9a7b736035519e3d3767062e198cb22e5f8ba6b;hp=63af3610a3b9a81e7bc3c73921eb6c16c3808964;hb=HEAD;hpb=20a86c5905e1f7527d3c9edc3f56f6b7679c268a diff --git a/source/glsl/validate.h b/source/glsl/validate.h index 63af3610..3166c39b 100644 --- a/source/glsl/validate.h +++ b/source/glsl/validate.h @@ -10,13 +10,15 @@ namespace Msp { namespace GL { namespace SL { +/** Base class for validators. Contains some utilities for adding diagnostic +messages. */ class Validator: protected TraversingVisitor { protected: - Stage *stage; - Node *last_provoker; + Stage *stage = 0; + Node *last_provoker = 0; - Validator(); + Validator() = default; void diagnose(Node &, Node &, Diagnostic::Severity, const std::string &); void diagnose(Node &n, Diagnostic::Severity s, const std::string &m) { diagnose(n, n, s, m); } @@ -24,6 +26,7 @@ protected: void add_info(Node &, const std::string &); }; +/** Verifies that declarations are valid in isolation. */ class DeclarationValidator: private Validator { private: @@ -36,15 +39,18 @@ private: FUNCTION }; - ScopeType scope; - InterfaceLayout *iface_layout; - InterfaceBlock *iface_block; - VariableDeclaration *variable; + Features features; + ScopeType scope = GLOBAL; + InterfaceLayout *iface_layout = 0; + VariableDeclaration *iface_block = 0; + VariableDeclaration *variable = 0; + bool have_input_primitive = false; + bool have_output_primitive = false; + bool have_output_vertex_count = false; + bool have_workgroup_size = false; public: - DeclarationValidator(); - - void apply(Stage &s) { stage = &s; s.content.visit(*this); } + void apply(Stage &, const Features &); private: static const char *describe_variable(ScopeType); @@ -55,23 +61,22 @@ private: virtual void visit(ImageTypeDeclaration &); virtual void visit(StructDeclaration &); virtual void visit(VariableDeclaration &); - virtual void visit(InterfaceBlock &); virtual void visit(FunctionDeclaration &); }; +/** Verifies that identifiers are unique or, in the case of functions, are +overloaded only in valid ways. */ class IdentifierValidator: private Validator { private: typedef std::map BlockDeclarationMap; std::map declarations; - std::map interface_blocks; + std::map interface_blocks; std::map overloaded_functions; - bool anonymous_block; + bool anonymous_block = false; public: - IdentifierValidator(); - void apply(Stage &s) { stage = &s; s.content.visit(*this); } private: @@ -85,10 +90,10 @@ private: virtual void visit(ImageTypeDeclaration &t) { visit(static_cast(t)); } virtual void visit(StructDeclaration &); virtual void visit(VariableDeclaration &); - virtual void visit(InterfaceBlock &); virtual void visit(FunctionDeclaration &); }; +/** Verifies that there are no unresolved references. */ class ReferenceValidator: private Validator { public: @@ -99,34 +104,67 @@ private: virtual void visit(ImageTypeDeclaration &); virtual void visit(VariableReference &); virtual void visit(MemberAccess &); - virtual void visit(InterfaceBlockReference &); virtual void visit(FunctionCall &); virtual void visit(VariableDeclaration &); - virtual void visit(InterfaceBlock &); virtual void visit(FunctionDeclaration &); }; +/** Verifies that expressions are valid. In most cases an invalid expression +is indicated by a null result type. */ class ExpressionValidator: private Validator { private: - FunctionDeclaration *current_function; + enum ConstantKind + { + NOT_CONSTANT, + FIXED_CONSTANT, + SPEC_CONSTANT + }; -public: - ExpressionValidator(); + FunctionDeclaration *current_function = 0; + bool in_struct = false; + ConstantKind constant_expression = NOT_CONSTANT; +public: void apply(Stage &s) { stage = &s; s.content.visit(*this); } private: + virtual void visit(VariableReference &); virtual void visit(Swizzle &); virtual void visit(UnaryExpression &); virtual void visit(BinaryExpression &); virtual void visit(Assignment &); virtual void visit(TernaryExpression &); + virtual void visit(StructDeclaration &); virtual void visit(VariableDeclaration &); virtual void visit(FunctionDeclaration &); + virtual void visit(Conditional &); + virtual void visit(Iteration &); virtual void visit(Return &); }; +/** Verifies flow control constructs. Functions returning non-void must have +return statements. Warnings are given about dead code. */ +class FlowControlValidator: private Validator +{ +private: + bool reachable = true; + +public: + void apply(Stage &s) { stage = &s; s.content.visit(*this); } + +private: + virtual void visit(Block &); + virtual void visit(FunctionDeclaration &); + virtual void visit(Conditional &); + virtual void visit(Iteration &); + virtual void visit(Return &) { reachable = false; } + virtual void visit(Jump &) { reachable = false; } +}; + +/** Verifies that stage input and output interfaces are valid. Linked +variables must have matching types and locations and there must not be any +overlap in locations. */ class StageInterfaceValidator: private Validator { private: @@ -136,36 +174,38 @@ public: void apply(Stage &s) { stage = &s; s.content.visit(*this); } private: - int get_location(const Layout &); - virtual void visit(VariableDeclaration &); virtual void visit(FunctionDeclaration &) { } }; +/** Verifies that uniform interfaces are valid across the entire module. +Variables declared with the same binding must have the same name and type. */ class GlobalInterfaceValidator: private Validator { private: - struct Binding + struct Uniform { - Node *node; - TypeDeclaration *type; + Node *node = 0; + TypeDeclaration *type = 0; std::string name; - - Binding(VariableDeclaration &v): node(&v), type(v.type_declaration), name(v.name) { } - Binding(InterfaceBlock &i): node(&i), type(i.struct_declaration), name(i.block_name) { } + int location = -1; + unsigned loc_count = 1; + int desc_set = 0; + int bind_point = -1; }; - std::map > used_bindings; + std::list uniforms; + std::map used_names; + std::map used_locations; + std::map > used_bindings; public: void apply(Module &); private: - void get_binding(const Layout &, unsigned &, int &); - void check_binding(const Layout &, const Binding &); + void check_uniform(const Uniform &); virtual void visit(VariableDeclaration &); - virtual void visit(InterfaceBlock &); virtual void visit(FunctionDeclaration &) { } };