source/glsl/validate.h

   1 #ifndef MSP_GL_SL_VALIDATE_H_
   2 #define MSP_GL_SL_VALIDATE_H_
   3
   4 #include <string>
   5 #include <vector>
   6 #include "glsl_error.h"
   7 #include "visitor.h"
   8
   9 namespace Msp {
  10 namespace GL {
  11 namespace SL {
  12
  13 /** Base class for validators.  Contains some utilities for adding diagnostic
  14 messages. */
  15 class Validator: protected TraversingVisitor
  16 {
  17 protected:
  18         Stage *stage = 0;
  19         Node *last_provoker = 0;
  20
  21         Validator() = default;
  22
  23         void diagnose(Node &, Node &, Diagnostic::Severity, const std::string &);
  24         void diagnose(Node &n, Diagnostic::Severity s, const std::string &m) { diagnose(n, n, s, m); }
  25         void error(Node &n, const std::string &m) { diagnose(n, Diagnostic::ERR, m); }
  26         void add_info(Node &, const std::string &);
  27 };
  28
  29 /** Verifies that declarations are valid in isolation. */
  30 class DeclarationValidator: private Validator
  31 {
  32 private:
  33         enum ScopeType
  34         {
  35                 GLOBAL,
  36                 STRUCT,
  37                 INTERFACE_BLOCK,
  38                 FUNCTION_PARAM,
  39                 FUNCTION
  40         };
  41
  42         ScopeType scope = GLOBAL;
  43         InterfaceLayout *iface_layout = 0;
  44         InterfaceBlock *iface_block = 0;
  45         VariableDeclaration *variable = 0;
  46
  47 public:
  48         void apply(Stage &s) { stage = &s; s.content.visit(*this); }
  49
  50 private:
  51         static const char *describe_variable(ScopeType);
  52
  53         virtual void visit(Layout &);
  54         virtual void visit(InterfaceLayout &);
  55         virtual void visit(BasicTypeDeclaration &);
  56         virtual void visit(ImageTypeDeclaration &);
  57         virtual void visit(StructDeclaration &);
  58         virtual void visit(VariableDeclaration &);
  59         virtual void visit(InterfaceBlock &);
  60         virtual void visit(FunctionDeclaration &);
  61 };
  62
  63 /** Verifies that identifiers are unique or, in the case of functions, are
  64 overloaded only in valid ways. */
  65 class IdentifierValidator: private Validator
  66 {
  67 private:
  68         typedef std::map<std::string, Statement *> BlockDeclarationMap;
  69
  70         std::map<Block *, BlockDeclarationMap> declarations;
  71         std::map<std::string, InterfaceBlock *> interface_blocks;
  72         std::map<std::string, FunctionDeclaration *> overloaded_functions;
  73         bool anonymous_block = false;
  74
  75 public:
  76         void apply(Stage &s) { stage = &s; s.content.visit(*this); }
  77
  78 private:
  79         void multiple_definition(const std::string &, Statement &, Statement &);
  80         Statement *find_definition(const std::string &);
  81         void check_definition(const std::string &, Statement &);
  82         void record_definition(const std::string &, Statement &);
  83
  84         virtual void visit(TypeDeclaration &);
  85         virtual void visit(BasicTypeDeclaration &t) { visit(static_cast<TypeDeclaration &>(t)); }
  86         virtual void visit(ImageTypeDeclaration &t) { visit(static_cast<TypeDeclaration &>(t)); }
  87         virtual void visit(StructDeclaration &);
  88         virtual void visit(VariableDeclaration &);
  89         virtual void visit(InterfaceBlock &);
  90         virtual void visit(FunctionDeclaration &);
  91 };
  92
  93 /** Verifies that there are no unresolved references. */
  94 class ReferenceValidator: private Validator
  95 {
  96 public:
  97         void apply(Stage &s) { stage = &s; s.content.visit(*this); }
  98
  99 private:
 100         virtual void visit(BasicTypeDeclaration &);
 101         virtual void visit(ImageTypeDeclaration &);
 102         virtual void visit(VariableReference &);
 103         virtual void visit(MemberAccess &);
 104         virtual void visit(InterfaceBlockReference &);
 105         virtual void visit(FunctionCall &);
 106         virtual void visit(VariableDeclaration &);
 107         virtual void visit(InterfaceBlock &);
 108         virtual void visit(FunctionDeclaration &);
 109 };
 110
 111 /** Verifies that expressions are valid.  In most cases an invalid expression
 112 is indicated by a null result type. */
 113 class ExpressionValidator: private Validator
 114 {
 115 private:
 116         FunctionDeclaration *current_function = 0;
 117         bool constant_expression = false;
 118
 119 public:
 120         void apply(Stage &s) { stage = &s; s.content.visit(*this); }
 121
 122 private:
 123         virtual void visit(VariableReference &);
 124         virtual void visit(InterfaceBlockReference &);
 125         virtual void visit(Swizzle &);
 126         virtual void visit(UnaryExpression &);
 127         virtual void visit(BinaryExpression &);
 128         virtual void visit(Assignment &);
 129         virtual void visit(TernaryExpression &);
 130         virtual void visit(VariableDeclaration &);
 131         virtual void visit(FunctionDeclaration &);
 132         virtual void visit(Conditional &);
 133         virtual void visit(Iteration &);
 134         virtual void visit(Return &);
 135 };
 136
 137 /** Verifies flow control constructs.  Functions returning non-void must have
 138 return statements.  Warnings are given about dead code. */
 139 class FlowControlValidator: private Validator
 140 {
 141 private:
 142         bool reachable = true;
 143
 144 public:
 145         void apply(Stage &s) { stage = &s; s.content.visit(*this); }
 146
 147 private:
 148         virtual void visit(Block &);
 149         virtual void visit(FunctionDeclaration &);
 150         virtual void visit(Conditional &);
 151         virtual void visit(Iteration &);
 152         virtual void visit(Return &) { reachable = false; }
 153         virtual void visit(Jump &) { reachable = false; }
 154 };
 155
 156 /** Verifies that stage input and output interfaces are valid.  Linked
 157 variables must have matching types and locations and there must not be any
 158 overlap in locations. */
 159 class StageInterfaceValidator: private Validator
 160 {
 161 private:
 162         std::map<std::string, std::map<unsigned, VariableDeclaration *> > used_locations;
 163
 164 public:
 165         void apply(Stage &s) { stage = &s; s.content.visit(*this); }
 166
 167 private:
 168         int get_location(const Layout &);
 169
 170         virtual void visit(VariableDeclaration &);
 171         virtual void visit(FunctionDeclaration &) { }
 172 };
 173
 174 /** Verifies that uniform interfaces are valid across the entire module.
 175 Variables declared with the same binding must have the same name and type. */
 176 class GlobalInterfaceValidator: private Validator
 177 {
 178 private:
 179         struct Uniform
 180         {
 181                 Node *node = 0;
 182                 TypeDeclaration *type = 0;
 183                 std::string name;
 184                 int location = -1;
 185                 unsigned loc_count = 1;
 186                 int desc_set = 0;
 187                 int bind_point = -1;
 188         };
 189
 190         std::list<Uniform> uniforms;
 191         std::map<std::string, const Uniform *> used_names;
 192         std::map<unsigned, const Uniform *> used_locations;
 193         std::map<unsigned, std::map<unsigned, const Uniform *> > used_bindings;
 194
 195 public:
 196         void apply(Module &);
 197
 198 private:
 199         void check_uniform(const Uniform &);
 200
 201         virtual void visit(VariableDeclaration &);
 202         virtual void visit(InterfaceBlock &);
 203         virtual void visit(FunctionDeclaration &) { }
 204 };
 205
 206 } // namespace SL
 207 } // namespace GL
 208 } // namespace Msp
 209
 210 #endif