Initial implementation of Vulkan backend

[libs/gl.git] / source / core / module.cpp

diff --git a/source/core/module.cpp b/source/core/module.cpp
index 4eefc0347494ecadb077e8b0bc8a984688b08464..0c2df8e189678fd3a0854aa81a2857e00095588b 100644 (file)
--- a/source/core/module.cpp
+++ b/source/core/module.cpp
@@ -32,8 +32,14 @@ enum SpirVConstants
        OP_SPEC_CONSTANT_FALSE = 49,
        OP_SPEC_CONSTANT = 50,
        OP_VARIABLE = 59,
+       OP_LOAD = 61,
+       OP_STORE = 62,
+       OP_ACCESS_CHAIN = 65,
        OP_DECORATE = 71,
        OP_MEMBER_DECORATE = 72,
+       OP_LABEL = 248,
+       OP_BRANCH = 249,
+       OP_BRANCH_CONDITIONAL = 250,
 
        DECO_SPEC_ID = 1,
        DECO_ARRAY_STRIDE = 6,
@@ -110,6 +116,7 @@ void SpirVModule::load_code(IO::Base &io)
        }
 
        reflect();
+       create();
 }
 
 void SpirVModule::compile(SL::Compiler &compiler)
@@ -117,6 +124,7 @@ void SpirVModule::compile(SL::Compiler &compiler)
        compiler.compile(SL::Compiler::SPIRV);
        code = compiler.get_combined_spirv();
        reflect();
+       create();
 }
 
 void SpirVModule::reflect()
@@ -210,6 +218,32 @@ void SpirVModule::reflect()
                        v = (i!=var_indices.end() ? &variables[i->second] : 0);
                }
        }
+
+       map<const InstructionBlock *, unsigned> block_indices;
+       blocks.reserve(reflection.blocks.size());
+       for(const auto &kvp: reflection.blocks)
+       {
+               block_indices[&kvp.second] = blocks.size();
+               blocks.push_back(kvp.second);
+       }
+
+       for(InstructionBlock &b: blocks)
+       {
+               auto i = spec_indices.find(b.condition);
+               b.condition = (i!=spec_indices.end() ? &spec_constants[i->second] : 0);
+
+               for(const Variable *&v: b.accessed_variables)
+               {
+                       auto j = var_indices.find(v);
+                       v = (j!=var_indices.end() ? &variables[j->second] : 0);
+               }
+
+               for(const InstructionBlock *&s: b.successors)
+               {
+                       auto j = block_indices.find(s);
+                       s = (j!=block_indices.end() ? &blocks[j->second] : 0);
+               }
+       }
 }
 
 
@@ -288,8 +322,14 @@ void SpirVModule::Reflection::reflect_code(const vector<uint32_t> &code)
                case OP_SPEC_CONSTANT_FALSE:
                case OP_SPEC_CONSTANT: reflect_constant(op); break;
                case OP_VARIABLE: reflect_variable(op); break;
+               case OP_LOAD:
+               case OP_STORE: reflect_access(op); break;
+               case OP_ACCESS_CHAIN: reflect_access_chain(op); break;
                case OP_DECORATE: reflect_decorate(op); break;
                case OP_MEMBER_DECORATE: reflect_member_decorate(op); break;
+               case OP_LABEL: reflect_label(op); break;
+               case OP_BRANCH: reflect_branch(op); break;
+               case OP_BRANCH_CONDITIONAL: reflect_branch_conditional(op); break;
                }
 
                op += word_count;
@@ -376,7 +416,7 @@ void SpirVModule::Reflection::reflect_image_type(CodeIterator op)
        unsigned dimensions = *(op+3);
        bool depth = *(op+4)==1;
        bool array = *(op+5);
-       type.type = static_cast<DataType>((depth*0x200000) | (array*0x80000) | (dimensions+1) | sample);
+       type.type = static_cast<DataType>((depth*0x200000) | (array*0x80000) | ((dimensions+1)<<16) | sample);
 }
 
 void SpirVModule::Reflection::reflect_sampled_image_type(CodeIterator op)
@@ -428,13 +468,14 @@ void SpirVModule::Reflection::reflect_pointer_type(CodeIterator op)
 
 void SpirVModule::Reflection::reflect_constant(CodeIterator op)
 {
+       unsigned opcode = get_opcode(*op);
        unsigned id = *(op+2);
        Constant &cnst = constants[id];
        cnst.name = names[id];
        cnst.type = types[*(op+1)].type;
-       if(*op==OP_CONSTANT_TRUE || *op==OP_SPEC_CONSTANT_TRUE)
+       if(opcode==OP_CONSTANT_TRUE || opcode==OP_SPEC_CONSTANT_TRUE)
                cnst.i_value = true;
-       else if(*op==OP_CONSTANT_FALSE || *op==OP_SPEC_CONSTANT_FALSE)
+       else if(opcode==OP_CONSTANT_FALSE || opcode==OP_SPEC_CONSTANT_FALSE)
                cnst.i_value = false;
        else if(cnst.type==INT || cnst.type==UNSIGNED_INT)
                cnst.i_value = *(op+3);
@@ -454,6 +495,26 @@ void SpirVModule::Reflection::reflect_variable(CodeIterator op)
        var.array_size = type.array_size;
 }
 
+void SpirVModule::Reflection::reflect_access(CodeIterator op)
+{
+       if(current_block)
+       {
+               unsigned id = (get_opcode(*op)==OP_LOAD ? *(op+3) : *(op+1));
+               auto i = access_chain_bases.find(id);
+               if(i!=access_chain_bases.end())
+                       id = i->second;
+               Variable &var = variables[id];
+               auto j = find(current_block->accessed_variables, &var);
+               if(j==current_block->accessed_variables.end())
+                       current_block->accessed_variables.push_back(&var);
+       }
+}
+
+void SpirVModule::Reflection::reflect_access_chain(CodeIterator op)
+{
+       access_chain_bases[*(op+2)] = *(op+3);
+}
+
 void SpirVModule::Reflection::reflect_decorate(CodeIterator op)
 {
        unsigned id = *(op+1);
@@ -507,5 +568,38 @@ void SpirVModule::Reflection::reflect_member_decorate(CodeIterator op)
        }
 }
 
+void SpirVModule::Reflection::reflect_label(CodeIterator op)
+{
+       current_block = &blocks[*(op+1)];
+}
+
+void SpirVModule::Reflection::reflect_branch(CodeIterator op)
+{
+       InstructionBlock &block = blocks[*(op+1)];
+       block.condition = &true_condition;
+       current_block->successors.push_back(&block);
+}
+
+void SpirVModule::Reflection::reflect_branch_conditional(CodeIterator op)
+{
+       InstructionBlock &true_block = blocks[*(op+2)];
+       InstructionBlock &false_block = blocks[*(op+3)];
+
+       auto i = constants.find(*(op+1));
+       if(i!=constants.end() && i->second.constant_id)
+       {
+               if(!true_block.condition)
+                       true_block.condition = &i->second;
+               if(!false_block.condition)
+               {
+                       false_block.condition = &i->second;
+                       false_block.negate_condition = true;
+               }
+       }
+
+       current_block->successors.push_back(&true_block);
+       current_block->successors.push_back(&false_block);
+}
+
 } // namespace GL
 } // namespace Msp