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