#include <msp/core/algorithm.h>
#include <msp/io/print.h>
-#include "deviceinfo.h"
+#include "device.h"
#include "module.h"
#include "resources.h"
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_SELECTION_MERGE = 247,
+ OP_LABEL = 248,
+ OP_BRANCH = 249,
+ OP_BRANCH_CONDITIONAL = 250,
+ OP_SWITCH = 251,
+ OP_KILL = 252,
+ OP_RETURN = 253,
+ OP_RETURN_VALUE = 254,
+ OP_UNREACHABLE = 255,
DECO_SPEC_ID = 1,
DECO_ARRAY_STRIDE = 6,
void Module::set_source(const string &src)
{
- SL::Compiler compiler(DeviceInfo::get_global().glsl_features);
+ SL::Compiler compiler(create_features());
compiler.set_source(src);
compile(compiler);
}
void Module::load_source(IO::Base &io, Resources *res, const string &name)
{
- SL::Compiler compiler(DeviceInfo::get_global().glsl_features);
+ SL::Compiler compiler(create_features());
compiler.load_source(io, res, name);
compile(compiler);
}
load_source(io, 0, name);
}
+SL::Features Module::create_features() const
+{
+ const DeviceInfo &dev_info = Device::get_current().get_info();
+ const SL::Features &device_features = dev_info.glsl_features;
+ SL::Features latest_features = SL::Features::latest(dev_info.api);
+ SL::Features features;
+ features.target_api = latest_features.target_api;
+ features.glsl_version = latest_features.glsl_version;
+ features.constant_id_range = device_features.constant_id_range;
+ features.uniform_binding_range = device_features.uniform_binding_range;
+ features.texture_binding_range = device_features.texture_binding_range;
+ return features;
+}
+
void GlslModule::compile(SL::Compiler &compiler)
{
}
-SpirVModule::SpirVModule(const SpirVModule &other):
- code(other.code),
- entry_points(other.entry_points),
- structs(other.structs),
- variables(other.variables)
-{
- remap_pointers_from(other);
-}
-
-SpirVModule &SpirVModule::operator=(const SpirVModule &other)
-{
- code = other.code;
- entry_points = other.entry_points;
- structs = other.structs;
- variables = other.variables;
- remap_pointers_from(other);
- return *this;
-}
-
-void SpirVModule::remap_pointers_from(const SpirVModule &other)
-{
- for(EntryPoint &e: entry_points)
- for(const Variable *&v: e.globals)
- v = &variables[v-&other.variables.front()];
-
- for(Variable &v: variables)
- if(v.struct_type)
- v.struct_type = &structs[v.struct_type-&other.structs.front()];
-
- for(Structure &s: structs)
- for(StructMember &m: s.members)
- if(m.struct_type)
- m.struct_type = &structs[m.struct_type-&other.structs.front()];
-}
-
void SpirVModule::load_code(IO::Base &io)
{
uint32_t buffer[1024];
}
reflect();
+ create();
}
void SpirVModule::compile(SL::Compiler &compiler)
compiler.compile(SL::Compiler::SPIRV);
code = compiler.get_combined_spirv();
reflect();
+ create();
}
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);
+ }
+ }
+}
+
+SpirVModule *SpirVModule::specialize(const map<string, int> &spec_values) const
+{
+ vector<uint8_t> flags(code[3], 1);
+
+ std::map<unsigned, int> spec_values_by_id;
+ for(const Constant &c: spec_constants)
+ {
+ auto i = spec_values.find(c.name);
+ if(i!=spec_values.end())
+ {
+ flags[c.id] = (i->second ? 5 : 3);
+ spec_values_by_id[c.constant_id] = i->second;
+ }
+ }
+
+ for(const Variable &v: variables)
+ flags[v.id] = 0;
+ for(const InstructionBlock &b: blocks)
+ flags[b.id] = 0;
+ for(const InstructionBlock *b: collect_visited_blocks(spec_values_by_id))
+ {
+ flags[b->id] = 1;
+ for(const Variable *v: b->accessed_variables)
+ flags[v->id] = 1;
+ }
+
+ std::vector<uint32_t> new_code;
+ new_code.reserve(code.size());
+
+ auto op = code.begin()+5;
+ new_code.insert(new_code.begin(), code.begin(), op);
+
+ bool skip_block = false;
+ while(op!=code.end())
+ {
+ unsigned word_count = *op>>16;
+ unsigned opcode = *op&0xFFFF;
+
+ bool copy = !skip_block;
+ if(skip_block)
+ {
+ skip_block = (opcode!=OP_BRANCH && opcode!=OP_BRANCH_CONDITIONAL && opcode!=OP_SWITCH &&
+ opcode!=OP_KILL && opcode!=OP_RETURN && opcode!=OP_RETURN_VALUE && opcode!=OP_UNREACHABLE);
+ }
+ else
+ {
+ if(opcode==OP_NAME)
+ copy = flags[*(op+1)];
+ else if(opcode==OP_ENTRY_POINT)
+ {
+ unsigned start = new_code.size();
+ new_code.push_back(opcode);
+ new_code.push_back(*(op+1));
+ new_code.push_back(*(op+2));
+
+ unsigned i=3;
+ while(i<word_count)
+ {
+ unsigned word = *(op+i++);
+ new_code.push_back(word);
+ if(!(word&(word>>8)&(word>>16)&(word>>24)&0xFF))
+ break;
+ }
+
+ for(; i<word_count; ++i)
+ {
+ unsigned id = *(op+i);
+ if(flags[id])
+ new_code.push_back(id);
+ }
+
+ new_code[start] |= (new_code.size()-start)<<16;
+
+ copy = false;
+ }
+ else if(opcode==OP_SPEC_CONSTANT_TRUE || opcode==OP_SPEC_CONSTANT_FALSE)
+ {
+ unsigned id = *(op+2);
+ if(flags[id]&2)
+ {
+ new_code.push_back(0x30000 | (flags[id]&4 ? OP_CONSTANT_TRUE : OP_CONSTANT_FALSE));
+ new_code.push_back(*(op+1));
+ new_code.push_back(id);
+
+ copy = false;
+ }
+ }
+ else if(opcode==OP_VARIABLE)
+ copy = flags[*(op+2)];
+ else if(opcode==OP_DECORATE)
+ {
+ unsigned id = *(op+1);
+ copy = flags[id];
+ if(copy && *(op+2)==DECO_SPEC_ID)
+ copy = !(flags[id]&2);
+ }
+ else if(opcode==OP_LABEL)
+ {
+ copy = flags[*(op+1)];
+ skip_block = !copy;
+ }
+ else if(opcode==OP_SELECTION_MERGE)
+ {
+ unsigned next_opcode = *(op+word_count)&0xFFFF;
+ if(next_opcode==OP_BRANCH_CONDITIONAL)
+ {
+ unsigned true_id = *(op+word_count+2);
+ unsigned false_id = *(op+word_count+3);
+ if(!flags[true_id] || !flags[false_id])
+ {
+ new_code.push_back(0x20000 | OP_BRANCH);
+ new_code.push_back(flags[true_id] ? true_id : false_id);
+ copy = false;
+
+ /* Skip the branch instruction when it's encountered on the
+ next iteration */
+ skip_block = true;
+ }
+ }
+ }
+ }
+
+ if(copy)
+ {
+ for(unsigned i=0; i<word_count; ++i)
+ new_code.push_back(*(op+i));
+ }
+
+ op += word_count;
+ }
+
+ SpirVModule *spec_mod = new SpirVModule;
+ spec_mod->code = move(new_code);
+ spec_mod->reflect();
+ spec_mod->create();
+
+ return spec_mod;
+}
+
+vector<const SpirVModule::InstructionBlock *> SpirVModule::collect_visited_blocks(const map<unsigned, int> &spec_values) const
+{
+ vector<uint8_t> visited(blocks.size(), 4);
+ for(unsigned i=0; i<blocks.size(); ++i)
+ {
+ const InstructionBlock &b = blocks[i];
+
+ bool cond = true;
+ if(b.condition)
+ {
+ cond = b.condition->i_value;
+ auto j = spec_values.find(b.condition->constant_id);
+ if(j!=spec_values.end())
+ cond = j->second;
+ if(b.negate_condition)
+ cond = !cond;
+ }
+
+ visited[i] |= cond*2;
+ for(const InstructionBlock *s: b.successors)
+ visited[s-blocks.data()] &= 3;
+ }
+
+ for(unsigned i=0; i<blocks.size(); ++i)
+ if(visited[i]&4)
+ collect_visited_blocks(i, visited);
+
+ vector<const SpirVModule::InstructionBlock *> result;
+ for(unsigned i=0; i<blocks.size(); ++i)
+ if(visited[i]&1)
+ result.push_back(&blocks[i]);
+
+ return result;
+}
+
+void SpirVModule::collect_visited_blocks(unsigned i, vector<uint8_t> &visited) const
+{
+ visited[i] |= 1;
+ for(const InstructionBlock *s: blocks[i].successors)
+ {
+ unsigned j = s-blocks.data();
+ if((visited[j]&3)==2)
+ collect_visited_blocks(j, visited);
+ }
}
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;
void SpirVModule::Reflection::reflect_entry_point(CodeIterator op)
{
CodeIterator op_end = get_op_end(op);
- EntryPoint &entry = entry_points[*(op+2)];
+ unsigned id = *(op+2);
+ EntryPoint &entry = entry_points[id];
+ entry.id = id;
entry.stage = static_cast<Stage>(*(op+1)); // Execution model in SPIR-V spec
op += 3;
entry.name = read_string(op, op_end);
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)
unsigned id = *(op+1);
Structure &strct = structs[id];
strct.name = names[id];
+ strct.id = id;
types[id].struct_type = &strct;
op += 2;
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.id = 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);
unsigned id = *(op+2);
Variable &var = variables[id];
var.name = names[id];
+ var.id = id;
const TypeInfo &type = types[*(op+1)];
var.storage = type.storage;
var.type = type.type;
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);
}
}
+void SpirVModule::Reflection::reflect_label(CodeIterator op)
+{
+ unsigned id = *(op+1);
+ current_block = &blocks[id];
+ current_block->id = id;
+}
+
+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