source/programcompiler.h

   1 #ifndef MSP_GL_PROGRAMCOMPILER_H_
   2 #define MSP_GL_PROGRAMCOMPILER_H_
   3
   4 #include <set>
   5 #include "programparser.h"
   6 #include "programsyntax.h"
   7
   8 namespace Msp {
   9 namespace GL {
  10
  11 class Program;
  12 class Resources;
  13
  14 class ProgramCompiler
  15 {
  16 private:
  17         struct Visitor: ProgramSyntax::TraversingVisitor
  18         {
  19                 typedef void ResultType;
  20
  21                 ProgramSyntax::Stage *stage;
  22
  23                 Visitor();
  24
  25                 virtual void apply(ProgramSyntax::Stage &);
  26                 void get_result() const { }
  27         };
  28
  29         struct BlockModifier: Visitor
  30         {
  31                 bool remove_node;
  32                 std::vector<RefPtr<ProgramSyntax::Node> > insert_nodes;
  33
  34                 BlockModifier();
  35
  36                 void flatten_block(ProgramSyntax::Block &);
  37                 void apply_and_increment(ProgramSyntax::Block &, std::list<RefPtr<ProgramSyntax::Node> >::iterator &);
  38                 using Visitor::visit;
  39                 virtual void visit(ProgramSyntax::Block &);
  40         };
  41
  42         struct Formatter: Visitor
  43         {
  44                 typedef std::string ResultType;
  45
  46                 std::string formatted;
  47                 unsigned indent;
  48                 bool parameter_list;
  49                 unsigned else_if;
  50                 std::string block_interface;
  51
  52                 Formatter();
  53
  54                 virtual void apply(ProgramSyntax::Stage &);
  55                 const std::string &get_result() const { return formatted; }
  56                 using Visitor::visit;
  57                 virtual void visit(ProgramSyntax::Block &);
  58                 virtual void visit(ProgramSyntax::Literal &);
  59                 virtual void visit(ProgramSyntax::ParenthesizedExpression &);
  60                 virtual void visit(ProgramSyntax::VariableReference &);
  61                 virtual void visit(ProgramSyntax::MemberAccess &);
  62                 virtual void visit(ProgramSyntax::UnaryExpression &);
  63                 virtual void visit(ProgramSyntax::BinaryExpression &);
  64                 virtual void visit(ProgramSyntax::Assignment &);
  65                 virtual void visit(ProgramSyntax::FunctionCall &);
  66                 virtual void visit(ProgramSyntax::ExpressionStatement &);
  67                 virtual void visit(ProgramSyntax::Import &);
  68                 virtual void visit(ProgramSyntax::Precision &);
  69                 virtual void visit(ProgramSyntax::Layout &);
  70                 virtual void visit(ProgramSyntax::InterfaceLayout &);
  71                 virtual void visit(ProgramSyntax::StructDeclaration &);
  72                 virtual void visit(ProgramSyntax::VariableDeclaration &);
  73                 virtual void visit(ProgramSyntax::InterfaceBlock &);
  74                 virtual void visit(ProgramSyntax::FunctionDeclaration &);
  75                 virtual void visit(ProgramSyntax::Conditional &);
  76                 virtual void visit(ProgramSyntax::Iteration &);
  77                 virtual void visit(ProgramSyntax::Return &);
  78                 virtual void visit(ProgramSyntax::Jump &);
  79         };
  80
  81         template<typename T>
  82         struct NodeGatherer: Visitor
  83         {
  84                 typedef std::vector<T *> ResultType;
  85
  86                 std::vector<T *> nodes;
  87
  88                 const ResultType &get_result() const { return nodes; }
  89                 using Visitor::visit;
  90                 virtual void visit(T &n) { nodes.push_back(&n); }
  91         };
  92
  93         struct DeclarationCombiner: BlockModifier
  94         {
  95                 bool toplevel;
  96                 std::map<std::string, std::vector<ProgramSyntax::FunctionDeclaration *> > functions;
  97                 std::map<std::string, ProgramSyntax::VariableDeclaration *> variables;
  98
  99                 DeclarationCombiner();
 100
 101                 using Visitor::visit;
 102                 virtual void visit(ProgramSyntax::Block &);
 103                 virtual void visit(ProgramSyntax::FunctionDeclaration &);
 104                 virtual void visit(ProgramSyntax::VariableDeclaration &);
 105         };
 106
 107         struct VariableResolver: Visitor
 108         {
 109                 std::vector<ProgramSyntax::Block *> blocks;
 110                 ProgramSyntax::StructDeclaration *type;
 111                 bool anonymous;
 112                 std::string block_interface;
 113                 bool record_target;
 114                 ProgramSyntax::VariableDeclaration *assignment_target;
 115                 bool self_referencing;
 116
 117                 VariableResolver();
 118
 119                 virtual void apply(ProgramSyntax::Stage &);
 120                 using Visitor::visit;
 121                 virtual void visit(ProgramSyntax::Block &);
 122                 virtual void visit(ProgramSyntax::VariableReference &);
 123                 virtual void visit(ProgramSyntax::MemberAccess &);
 124                 virtual void visit(ProgramSyntax::BinaryExpression &);
 125                 virtual void visit(ProgramSyntax::Assignment &);
 126                 virtual void visit(ProgramSyntax::StructDeclaration &);
 127                 virtual void visit(ProgramSyntax::VariableDeclaration &);
 128                 virtual void visit(ProgramSyntax::InterfaceBlock &);
 129         };
 130
 131         struct FunctionResolver: Visitor
 132         {
 133                 std::map<std::string, std::vector<ProgramSyntax::FunctionDeclaration *> > functions;
 134
 135                 using Visitor::visit;
 136                 virtual void visit(ProgramSyntax::FunctionCall &);
 137                 virtual void visit(ProgramSyntax::FunctionDeclaration &);
 138         };
 139
 140         struct InterfaceGenerator: BlockModifier
 141         {
 142                 std::string in_prefix;
 143                 std::string out_prefix;
 144                 unsigned scope_level;
 145                 std::map<std::string, RefPtr<ProgramSyntax::VariableDeclaration> > iface_declarations;
 146
 147                 InterfaceGenerator();
 148
 149                 static std::string get_out_prefix(ProgramSyntax::StageType);
 150                 virtual void apply(ProgramSyntax::Stage &);
 151                 using Visitor::visit;
 152                 virtual void visit(ProgramSyntax::Block &);
 153                 std::string change_prefix(const std::string &, const std::string &) const;
 154                 bool generate_interface(ProgramSyntax::VariableDeclaration &, const std::string &, const std::string &);
 155                 void insert_assignment(const std::string &, ProgramSyntax::Expression *);
 156                 virtual void visit(ProgramSyntax::VariableReference &);
 157                 virtual void visit(ProgramSyntax::VariableDeclaration &);
 158                 virtual void visit(ProgramSyntax::Passthrough &);
 159         };
 160
 161         struct DeclarationReorderer: Visitor
 162         {
 163                 enum DeclarationKind
 164                 {
 165                         NO_DECLARATION,
 166                         LAYOUT,
 167                         STRUCT,
 168                         VARIABLE,
 169                         FUNCTION
 170                 };
 171
 172                 unsigned scope_level;
 173                 DeclarationKind kind;
 174                 std::set<ProgramSyntax::Node *> ordered_funcs;
 175                 std::set<ProgramSyntax::Node *> needed_funcs;
 176
 177                 DeclarationReorderer();
 178
 179                 using Visitor::visit;
 180                 virtual void visit(ProgramSyntax::Block &);
 181                 virtual void visit(ProgramSyntax::FunctionCall &);
 182                 virtual void visit(ProgramSyntax::InterfaceLayout &) { kind = LAYOUT; }
 183                 virtual void visit(ProgramSyntax::StructDeclaration &) { kind = STRUCT; }
 184                 virtual void visit(ProgramSyntax::VariableDeclaration &);
 185                 virtual void visit(ProgramSyntax::InterfaceBlock &) { kind = VARIABLE; }
 186                 virtual void visit(ProgramSyntax::FunctionDeclaration &);
 187         };
 188
 189         struct InlineableFunctionLocator: Visitor
 190         {
 191                 typedef std::set<ProgramSyntax::FunctionDeclaration *> ResultType;
 192
 193                 std::map<ProgramSyntax::FunctionDeclaration *, unsigned> refcounts;
 194                 std::set<ProgramSyntax::FunctionDeclaration *> inlineable;
 195                 ProgramSyntax::FunctionDeclaration *in_function;
 196
 197                 InlineableFunctionLocator();
 198
 199                 const ResultType &get_result() const { return inlineable; }
 200                 using Visitor::visit;
 201                 virtual void visit(ProgramSyntax::FunctionCall &);
 202                 virtual void visit(ProgramSyntax::FunctionDeclaration &);
 203         };
 204
 205         struct FunctionInliner: Visitor
 206         {
 207                 std::set<ProgramSyntax::FunctionDeclaration *> inlineable;
 208                 unsigned extract_result;
 209                 RefPtr<ProgramSyntax::Expression> inline_result;
 210
 211                 FunctionInliner();
 212                 FunctionInliner(const std::set<ProgramSyntax::FunctionDeclaration *> &);
 213
 214                 void visit_and_inline(RefPtr<ProgramSyntax::Expression> &);
 215                 using Visitor::visit;
 216                 virtual void visit(ProgramSyntax::Block &);
 217                 virtual void visit(ProgramSyntax::UnaryExpression &);
 218                 virtual void visit(ProgramSyntax::BinaryExpression &);
 219                 virtual void visit(ProgramSyntax::FunctionCall &);
 220                 virtual void visit(ProgramSyntax::Return &);
 221         };
 222
 223         struct ExpressionEvaluator: ProgramSyntax::NodeVisitor
 224         {
 225                 typedef std::map<ProgramSyntax::VariableDeclaration *, ProgramSyntax::Expression *> ValueMap;
 226
 227                 const ValueMap *variable_values;
 228                 bool const_only;
 229                 float result;
 230                 bool result_valid;
 231
 232                 ExpressionEvaluator();
 233                 ExpressionEvaluator(const ValueMap *, bool);
 234
 235                 using ProgramSyntax::NodeVisitor::visit;
 236                 virtual void visit(ProgramSyntax::Literal &);
 237                 virtual void visit(ProgramSyntax::ParenthesizedExpression &);
 238                 virtual void visit(ProgramSyntax::VariableReference &);
 239                 virtual void visit(ProgramSyntax::UnaryExpression &);
 240                 virtual void visit(ProgramSyntax::BinaryExpression &);
 241         };
 242
 243         struct ConstantConditionEliminator: BlockModifier
 244         {
 245                 unsigned scope_level;
 246                 bool in_loop;
 247                 ExpressionEvaluator::ValueMap variable_values;
 248
 249                 ConstantConditionEliminator();
 250
 251                 using Visitor::visit;
 252                 virtual void visit(ProgramSyntax::Block &);
 253                 virtual void visit(ProgramSyntax::Assignment &);
 254                 virtual void visit(ProgramSyntax::VariableDeclaration &);
 255                 virtual void visit(ProgramSyntax::Conditional &);
 256                 virtual void visit(ProgramSyntax::Iteration &);
 257         };
 258
 259         struct UnusedVariableLocator: Visitor
 260         {
 261                 struct VariableInfo
 262                 {
 263                         bool local;
 264                         std::vector<ProgramSyntax::Node *> assignments;
 265                         bool conditionally_assigned;
 266                         bool referenced;
 267
 268                         VariableInfo();
 269                 };
 270
 271                 typedef std::set<ProgramSyntax::Node *> ResultType;
 272                 typedef std::map<ProgramSyntax::VariableDeclaration *, VariableInfo> BlockVariableMap;
 273
 274                 std::set<ProgramSyntax::Node *> unused_nodes;
 275                 std::map<ProgramSyntax::VariableDeclaration *, ProgramSyntax::Node *> aggregates;
 276                 ProgramSyntax::Node *aggregate;
 277                 std::vector<BlockVariableMap> variables;
 278                 ProgramSyntax::Assignment *assignment;
 279                 bool assignment_target;
 280                 bool global_scope;
 281
 282                 UnusedVariableLocator();
 283
 284                 virtual void apply(ProgramSyntax::Stage &);
 285                 const ResultType &get_result() const { return unused_nodes; }
 286                 using Visitor::visit;
 287                 virtual void visit(ProgramSyntax::VariableReference &);
 288                 virtual void visit(ProgramSyntax::MemberAccess &);
 289                 virtual void visit(ProgramSyntax::BinaryExpression &);
 290                 virtual void visit(ProgramSyntax::Assignment &);
 291                 void record_assignment(ProgramSyntax::VariableDeclaration &, ProgramSyntax::Node &, bool);
 292                 void clear_assignments(VariableInfo &, bool);
 293                 virtual void visit(ProgramSyntax::ExpressionStatement &);
 294                 virtual void visit(ProgramSyntax::StructDeclaration &);
 295                 virtual void visit(ProgramSyntax::VariableDeclaration &);
 296                 virtual void visit(ProgramSyntax::InterfaceBlock &);
 297                 virtual void visit(ProgramSyntax::FunctionDeclaration &);
 298                 void merge_down_variables();
 299                 virtual void visit(ProgramSyntax::Conditional &);
 300                 virtual void visit(ProgramSyntax::Iteration &);
 301         };
 302
 303         struct UnusedFunctionLocator: Visitor
 304         {
 305                 typedef std::set<ProgramSyntax::Node *> ResultType;
 306
 307                 std::set<ProgramSyntax::Node *> unused_nodes;
 308                 std::set<ProgramSyntax::FunctionDeclaration *> used_definitions;
 309
 310                 const ResultType &get_result() const { return unused_nodes; }
 311                 using Visitor::visit;
 312                 virtual void visit(ProgramSyntax::FunctionCall &);
 313                 virtual void visit(ProgramSyntax::FunctionDeclaration &);
 314         };
 315
 316         struct NodeRemover: Visitor
 317         {
 318                 std::set<ProgramSyntax::Node *> to_remove;
 319
 320                 NodeRemover() { }
 321                 NodeRemover(const std::set<ProgramSyntax::Node *> &);
 322
 323                 using Visitor::visit;
 324                 virtual void visit(ProgramSyntax::Block &);
 325                 virtual void visit(ProgramSyntax::VariableDeclaration &);
 326         };
 327
 328         struct PrecisionRemover: BlockModifier
 329         {
 330                 using Visitor::visit;
 331                 virtual void visit(ProgramSyntax::Precision &);
 332                 virtual void visit(ProgramSyntax::VariableDeclaration &);
 333         };
 334
 335         struct DefaultPrecisionGenerator: BlockModifier
 336         {
 337                 bool toplevel;
 338                 std::set<std::string> have_default;
 339
 340                 DefaultPrecisionGenerator();
 341
 342                 using Visitor::visit;
 343                 virtual void visit(ProgramSyntax::Block &);
 344                 virtual void visit(ProgramSyntax::Precision &);
 345                 virtual void visit(ProgramSyntax::VariableDeclaration &);
 346         };
 347
 348         struct LegacyConverter: BlockModifier
 349         {
 350                 GLApi target_api;
 351                 Version target_version;
 352                 std::string type;
 353                 ProgramSyntax::VariableDeclaration *frag_out;
 354
 355                 LegacyConverter();
 356                 LegacyConverter(const Version &);
 357
 358                 bool check_version(const Version &) const;
 359                 using Visitor::visit;
 360                 bool supports_unified_interface_syntax() const;
 361                 virtual void visit(ProgramSyntax::VariableReference &);
 362                 virtual void visit(ProgramSyntax::Assignment &);
 363                 bool supports_unified_sampling_functions() const;
 364                 virtual void visit(ProgramSyntax::FunctionCall &);
 365                 bool supports_interface_layouts() const;
 366                 bool supports_centroid_sampling() const;
 367                 bool supports_sample_sampling() const;
 368                 virtual void visit(ProgramSyntax::VariableDeclaration &);
 369                 bool supports_interface_blocks(const std::string &) const;
 370                 virtual void visit(ProgramSyntax::InterfaceBlock &);
 371         };
 372
 373         Resources *resources;
 374         ProgramSyntax::Module *module;
 375         std::set<std::string> imported_names;
 376
 377 public:
 378         ProgramCompiler();
 379         ~ProgramCompiler();
 380
 381         void compile(const std::string &, const std::string & = "<string>");
 382         void compile(IO::Base &, Resources * = 0, const std::string & = "<file>");
 383         void compile(IO::Base &, const std::string &);
 384         void add_shaders(Program &);
 385
 386 private:
 387         static ProgramSyntax::Module *create_builtins_module();
 388         static ProgramSyntax::Module &get_builtins_module();
 389         static ProgramSyntax::Stage *get_builtins(ProgramSyntax::StageType);
 390         void append_module(ProgramSyntax::Module &);
 391         void append_stage(ProgramSyntax::Stage &);
 392         void process();
 393         void import(const std::string &);
 394         void generate(ProgramSyntax::Stage &);
 395         bool optimize(ProgramSyntax::Stage &);
 396         void finalize(ProgramSyntax::Stage &);
 397         static void inject_block(ProgramSyntax::Block &, const ProgramSyntax::Block &);
 398         template<typename T>
 399         static typename T::ResultType apply(ProgramSyntax::Stage &);
 400         template<typename T, typename A>
 401         static typename T::ResultType apply(ProgramSyntax::Stage &, const A &);
 402 };
 403
 404 } // namespace GL
 405 } // namespace Msp
 406
 407 #endif