source/core/module.cpp

   1 #include <msp/core/algorithm.h>
   2 #include <msp/io/print.h>
   3 #include "device.h"
   4 #include "module.h"
   5 #include "resources.h"
   6
   7 using namespace std;
   8
   9 enum SpirVConstants
  10 {
  11         SPIRV_MAGIC = 0x07230203,
  12         SPIRV_MAGIC_REVERSED = 0x03022307,
  13
  14         OP_NAME = 5,
  15         OP_MEMBER_NAME = 6,
  16         OP_ENTRY_POINT = 15,
  17         OP_TYPE_VOID = 19,
  18         OP_TYPE_BOOL = 20,
  19         OP_TYPE_INT = 21,
  20         OP_TYPE_FLOAT = 22,
  21         OP_TYPE_VECTOR = 23,
  22         OP_TYPE_MATRIX = 24,
  23         OP_TYPE_IMAGE = 25,
  24         OP_TYPE_SAMPLED_IMAGE = 27,
  25         OP_TYPE_ARRAY = 28,
  26         OP_TYPE_STRUCT = 30,
  27         OP_TYPE_POINTER = 32,
  28         OP_CONSTANT_TRUE = 41,
  29         OP_CONSTANT_FALSE = 42,
  30         OP_CONSTANT = 43,
  31         OP_SPEC_CONSTANT_TRUE = 48,
  32         OP_SPEC_CONSTANT_FALSE = 49,
  33         OP_SPEC_CONSTANT = 50,
  34         OP_VARIABLE = 59,
  35         OP_DECORATE = 71,
  36         OP_MEMBER_DECORATE = 72,
  37
  38         DECO_SPEC_ID = 1,
  39         DECO_ARRAY_STRIDE = 6,
  40         DECO_MATRIX_STRIDE = 7,
  41         DECO_BUILTIN = 11,
  42         DECO_LOCATION = 30,
  43         DECO_BINDING = 33,
  44         DECO_DESCRIPTOR_SET = 34,
  45         DECO_OFFSET = 35
  46 };
  47
  48 namespace Msp {
  49 namespace GL {
  50
  51 void Module::set_source(const string &src)
  52 {
  53         SL::Compiler compiler(create_features());
  54         compiler.set_source(src);
  55         compile(compiler);
  56 }
  57
  58 void Module::load_source(IO::Base &io, Resources *res, const string &name)
  59 {
  60         SL::Compiler compiler(create_features());
  61         compiler.load_source(io, res, name);
  62         compile(compiler);
  63 }
  64
  65 void Module::load_source(IO::Base &io, const string &name)
  66 {
  67         load_source(io, 0, name);
  68 }
  69
  70 SL::Features Module::create_features() const
  71 {
  72         const DeviceInfo &dev_info = Device::get_current().get_info();
  73         const SL::Features &device_features = dev_info.glsl_features;
  74         SL::Features latest_features = SL::Features::latest(dev_info.api);
  75         SL::Features features;
  76         features.target_api = latest_features.target_api;
  77         features.glsl_version = latest_features.glsl_version;
  78         features.constant_id_range = device_features.constant_id_range;
  79         features.uniform_binding_range = device_features.uniform_binding_range;
  80         features.texture_binding_range = device_features.texture_binding_range;
  81         return features;
  82 }
  83
  84
  85 void GlslModule::compile(SL::Compiler &compiler)
  86 {
  87         compiler.compile(SL::Compiler::MODULE);
  88         prepared_source = compiler.get_combined_glsl();
  89         source_map = compiler.get_source_map();
  90
  91 #ifdef DEBUG
  92         string diagnostics = compiler.get_diagnostics();
  93         if(!diagnostics.empty())
  94                 IO::print("Module diagnostics:\n%s\n", diagnostics);
  95 #endif
  96 }
  97
  98
  99 SpirVModule::SpirVModule(const SpirVModule &other):
 100         code(other.code),
 101         entry_points(other.entry_points),
 102         structs(other.structs),
 103         variables(other.variables)
 104 {
 105         remap_pointers_from(other);
 106 }
 107
 108 SpirVModule &SpirVModule::operator=(const SpirVModule &other)
 109 {
 110         code = other.code;
 111         entry_points = other.entry_points;
 112         structs = other.structs;
 113         variables = other.variables;
 114         remap_pointers_from(other);
 115         return *this;
 116 }
 117
 118 void SpirVModule::remap_pointers_from(const SpirVModule &other)
 119 {
 120         for(EntryPoint &e: entry_points)
 121                 for(const Variable *&v: e.globals)
 122                         v = &variables[v-&other.variables.front()];
 123
 124         for(Variable &v: variables)
 125                 if(v.struct_type)
 126                         v.struct_type = &structs[v.struct_type-&other.structs.front()];
 127
 128         for(Structure &s: structs)
 129                 for(StructMember &m: s.members)
 130                         if(m.struct_type)
 131                                 m.struct_type = &structs[m.struct_type-&other.structs.front()];
 132 }
 133
 134 void SpirVModule::load_code(IO::Base &io)
 135 {
 136         uint32_t buffer[1024];
 137         while(1)
 138         {
 139                 unsigned len = io.read(reinterpret_cast<char *>(buffer), sizeof(buffer));
 140                 if(!len)
 141                         break;
 142                 len /= 4;
 143                 code.reserve(code.size()+len);
 144                 code.insert(code.end(), buffer, buffer+len);
 145         }
 146
 147         reflect();
 148 }
 149
 150 void SpirVModule::compile(SL::Compiler &compiler)
 151 {
 152         compiler.compile(SL::Compiler::SPIRV);
 153         code = compiler.get_combined_spirv();
 154         reflect();
 155 }
 156
 157 void SpirVModule::reflect()
 158 {
 159         if(code.empty())
 160                 throw invalid_module("Empty SPIR-V code");
 161
 162         if(code[0]==SPIRV_MAGIC_REVERSED)
 163         {
 164                 for(uint32_t &c: code)
 165                         c = ((c&0xFF)<<24) || ((c&0xFF00)<<8) | ((c>>8)&0xFF00) | ((c>>24)&0xFF);
 166         }
 167         else if(code[0]!=SPIRV_MAGIC)
 168                 throw invalid_module("SPIR-V magic number not found");
 169
 170         Reflection reflection;
 171         reflection.reflect_code(code);
 172
 173         map<const Constant *, unsigned> spec_indices;
 174         for(const auto &kvp: reflection.constants)
 175                 if(kvp.second.constant_id>=0)
 176                 {
 177                         spec_indices[&kvp.second] = spec_constants.size();
 178                         spec_constants.push_back(kvp.second);
 179                 }
 180
 181         map<const Structure *, unsigned> struct_indices;
 182         structs.reserve(reflection.structs.size());
 183         for(const auto &kvp: reflection.structs)
 184         {
 185                 struct_indices[&kvp.second] = structs.size();
 186                 structs.push_back(kvp.second);
 187         }
 188
 189         for(Structure &s: structs)
 190         {
 191                 for(StructMember &m: s.members)
 192                         if(m.struct_type)
 193                         {
 194                                 auto i = struct_indices.find(m.struct_type);
 195                                 m.struct_type = (i!=struct_indices.end() ? &structs[i->second] : 0);
 196                         }
 197
 198                 const StructMember *last_member = &s.members.back();
 199                 unsigned last_offset = last_member->offset;
 200                 while(last_member->struct_type)
 201                 {
 202                         const StructMember *lm = &last_member->struct_type->members.back();
 203                         if(last_member->array_size)
 204                                 last_offset += last_member->array_stride*(last_member->array_size-1);
 205                         last_offset += lm->offset;
 206                         last_member = lm;
 207                 }
 208
 209                 unsigned last_size = get_type_size(last_member->type);
 210                 if(last_member->array_size)
 211                         last_size += last_member->array_stride*(last_member->array_size-1);
 212                 s.size = last_offset+last_size;
 213                 s.size = (s.size+15)&~15;
 214         }
 215
 216         map<const Variable *, unsigned> var_indices;
 217         variables.reserve(reflection.variables.size());
 218         for(const auto &kvp: reflection.variables)
 219         {
 220                 auto i = find_if(variables, [&kvp](const Variable &v){ return v==kvp.second; });
 221                 if(i!=variables.end())
 222                         var_indices[&kvp.second] = i-variables.begin();
 223                 else
 224                 {
 225                         var_indices[&kvp.second] = variables.size();
 226                         variables.push_back(kvp.second);
 227                 }
 228         }
 229
 230         for(Variable &v: variables)
 231                 if(v.struct_type)
 232                 {
 233                         auto i = struct_indices.find(v.struct_type);
 234                         v.struct_type = (i!=struct_indices.end() ? &structs[i->second] : 0);
 235                 }
 236
 237         entry_points.reserve(reflection.entry_points.size());
 238         for(const auto &kvp: reflection.entry_points)
 239         {
 240                 entry_points.push_back(kvp.second);
 241                 EntryPoint &entry = entry_points.back();
 242                 for(const Variable *&v: entry.globals)
 243                 {
 244                         auto i = var_indices.find(v);
 245                         v = (i!=var_indices.end() ? &variables[i->second] : 0);
 246                 }
 247         }
 248 }
 249
 250
 251 bool SpirVModule::Variable::operator==(const Variable &other) const
 252 {
 253         if(storage!=UNIFORM_CONSTANT && storage!=UNIFORM)
 254                 return false;
 255         if(storage!=other.storage || type!=other.type || struct_type!=other.struct_type)
 256                 return false;
 257         if(location!=other.location || descriptor_set!=other.descriptor_set || binding!=other.binding)
 258                 return false;
 259         return true;
 260 }
 261
 262
 263 uint32_t SpirVModule::Reflection::get_opcode(uint32_t op)
 264 {
 265         return op&0xFFFF;
 266 }
 267
 268 SpirVModule::Reflection::CodeIterator SpirVModule::Reflection::get_op_end(const CodeIterator &op)
 269 {
 270         return op+(*op>>16);
 271 }
 272
 273 string SpirVModule::Reflection::read_string(CodeIterator &op, const CodeIterator &op_end)
 274 {
 275         string result;
 276         for(; op!=op_end; ++op)
 277         {
 278                 unsigned word = *op;
 279                 for(unsigned i=0; i<4; ++i)
 280                 {
 281                         char c = word&0xFF;
 282                         if(!c)
 283                         {
 284                                 ++op;
 285                                 return result;
 286                         }
 287                         result += c;
 288                         word >>= 8;
 289                 }
 290         }
 291
 292         throw invalid_module("Unterminated SPIR-V string literal");
 293 }
 294
 295 void SpirVModule::Reflection::reflect_code(const vector<uint32_t> &code)
 296 {
 297         for(CodeIterator op=code.begin()+5; op!=code.end(); )
 298         {
 299                 unsigned word_count = *op>>16;
 300                 if(word_count>static_cast<unsigned>(code.end()-op))
 301                         throw invalid_module("Truncated SPIR-V instruction");
 302
 303                 switch(get_opcode(*op))
 304                 {
 305                 case OP_NAME: reflect_name(op); break;
 306                 case OP_MEMBER_NAME: reflect_member_name(op); break;
 307                 case OP_ENTRY_POINT: reflect_entry_point(op); break;
 308                 case OP_TYPE_VOID: reflect_void_type(op); break;
 309                 case OP_TYPE_BOOL: reflect_bool_type(op); break;
 310                 case OP_TYPE_INT: reflect_int_type(op); break;
 311                 case OP_TYPE_FLOAT: reflect_float_type(op); break;
 312                 case OP_TYPE_VECTOR: reflect_vector_type(op); break;
 313                 case OP_TYPE_MATRIX: reflect_matrix_type(op); break;
 314                 case OP_TYPE_IMAGE: reflect_image_type(op); break;
 315                 case OP_TYPE_SAMPLED_IMAGE: reflect_sampled_image_type(op); break;
 316                 case OP_TYPE_ARRAY: reflect_array_type(op); break;
 317                 case OP_TYPE_STRUCT: reflect_struct_type(op); break;
 318                 case OP_TYPE_POINTER: reflect_pointer_type(op); break;
 319                 case OP_CONSTANT_TRUE:
 320                 case OP_CONSTANT_FALSE:
 321                 case OP_CONSTANT:
 322                 case OP_SPEC_CONSTANT_TRUE:
 323                 case OP_SPEC_CONSTANT_FALSE:
 324                 case OP_SPEC_CONSTANT: reflect_constant(op); break;
 325                 case OP_VARIABLE: reflect_variable(op); break;
 326                 case OP_DECORATE: reflect_decorate(op); break;
 327                 case OP_MEMBER_DECORATE: reflect_member_decorate(op); break;
 328                 }
 329
 330                 op += word_count;
 331         }
 332 }
 333
 334 void SpirVModule::Reflection::reflect_name(CodeIterator op)
 335 {
 336         CodeIterator op_end = get_op_end(op);
 337         string &name = names[*(op+1)];
 338         op += 2;
 339         name = read_string(op, op_end);
 340 }
 341
 342 void SpirVModule::Reflection::reflect_member_name(CodeIterator op)
 343 {
 344         CodeIterator op_end = get_op_end(op);
 345         Structure &strct = structs[*(op+1)];
 346         unsigned index = *(op+2);
 347         if(index>=strct.members.size())
 348                 strct.members.resize(index+1);
 349         op += 3;
 350         strct.members[index].name = read_string(op, op_end);
 351 }
 352
 353 void SpirVModule::Reflection::reflect_entry_point(CodeIterator op)
 354 {
 355         CodeIterator op_end = get_op_end(op);
 356         EntryPoint &entry = entry_points[*(op+2)];
 357         entry.stage = static_cast<Stage>(*(op+1));  // Execution model in SPIR-V spec
 358         op += 3;
 359         entry.name = read_string(op, op_end);
 360
 361         entry.globals.reserve(op_end-op);
 362         for(; op!=op_end; ++op)
 363                 entry.globals.push_back(&variables[*op]);
 364 }
 365
 366 void SpirVModule::Reflection::reflect_void_type(CodeIterator op)
 367 {
 368         types[*(op+1)].type = VOID;
 369 }
 370
 371 void SpirVModule::Reflection::reflect_bool_type(CodeIterator op)
 372 {
 373         types[*(op+1)].type = BOOL;
 374 }
 375
 376 void SpirVModule::Reflection::reflect_int_type(CodeIterator op)
 377 {
 378         TypeInfo &type = types[*(op+1)];
 379         unsigned size = *(op+2);
 380         bool sign = *(op+3);
 381         type.type = static_cast<DataType>(size/8 | sign*0x100);
 382 }
 383
 384 void SpirVModule::Reflection::reflect_float_type(CodeIterator op)
 385 {
 386         TypeInfo &type = types[*(op+1)];
 387         unsigned size = *(op+2);
 388         type.type = static_cast<DataType>(size/8 | 0x300);
 389 }
 390
 391 void SpirVModule::Reflection::reflect_vector_type(CodeIterator op)
 392 {
 393         TypeInfo &type = types[*(op+1)];
 394         DataType component = types[*(op+2)].type;
 395         unsigned count = *(op+3);
 396         type.type = static_cast<DataType>(((count-1)<<12) | (component&0xF00) | ((component&0xFF)*count));
 397 }
 398
 399 void SpirVModule::Reflection::reflect_matrix_type(CodeIterator op)
 400 {
 401         TypeInfo &type = types[*(op+1)];
 402         DataType column = types[*(op+2)].type;
 403         unsigned count = *(op+3);
 404         type.type = static_cast<DataType>(((count-1)<<14) | (column&0x3F00) | ((column&0xFF)*count));
 405 }
 406
 407 void SpirVModule::Reflection::reflect_image_type(CodeIterator op)
 408 {
 409         TypeInfo &type = types[*(op+1)];
 410         DataType sample = types[*(op+2)].type;
 411         unsigned dimensions = *(op+3);
 412         bool depth = *(op+4)==1;
 413         bool array = *(op+5);
 414         type.type = static_cast<DataType>((depth*0x200000) | (array*0x80000) | (dimensions+1) | sample);
 415 }
 416
 417 void SpirVModule::Reflection::reflect_sampled_image_type(CodeIterator op)
 418 {
 419         TypeInfo &type = types[*(op+1)];
 420         DataType image = types[*(op+2)].type;
 421         type.type = static_cast<DataType>(image | 0x100000);
 422 }
 423
 424 void SpirVModule::Reflection::reflect_array_type(CodeIterator op)
 425 {
 426         TypeInfo &type = types[*(op+1)];
 427         const TypeInfo &elem = types[*(op+2)];
 428         type.type = elem.type;
 429         type.struct_type = elem.struct_type;
 430
 431         const Constant &size = constants[*(op+3)];
 432         if(size.type==INT || size.type==UNSIGNED_INT)
 433                 type.array_size = size.i_value;
 434 }
 435
 436 void SpirVModule::Reflection::reflect_struct_type(CodeIterator op)
 437 {
 438         CodeIterator op_end = get_op_end(op);
 439         unsigned id = *(op+1);
 440         Structure &strct = structs[id];
 441         strct.name = names[id];
 442         types[id].struct_type = &strct;
 443         op += 2;
 444
 445         strct.members.resize(op_end-op);
 446         auto mem = strct.members.begin();
 447         for(; op!=op_end; ++op, ++mem)
 448         {
 449                 TypeInfo &type = types[*op];
 450                 mem->type = type.type;
 451                 mem->struct_type = type.struct_type;
 452                 mem->array_size = type.array_size;
 453                 mem->array_stride = type.array_stride;
 454         }
 455 }
 456
 457 void SpirVModule::Reflection::reflect_pointer_type(CodeIterator op)
 458 {
 459         TypeInfo &type = types[*(op+1)];
 460         type = types[*(op+3)];
 461         type.storage = static_cast<StorageClass>(*(op+2));
 462 }
 463
 464 void SpirVModule::Reflection::reflect_constant(CodeIterator op)
 465 {
 466         unsigned id = *(op+2);
 467         Constant &cnst = constants[id];
 468         cnst.name = names[id];
 469         cnst.type = types[*(op+1)].type;
 470         if(*op==OP_CONSTANT_TRUE || *op==OP_SPEC_CONSTANT_TRUE)
 471                 cnst.i_value = true;
 472         else if(*op==OP_CONSTANT_FALSE || *op==OP_SPEC_CONSTANT_FALSE)
 473                 cnst.i_value = false;
 474         else if(cnst.type==INT || cnst.type==UNSIGNED_INT)
 475                 cnst.i_value = *(op+3);
 476         else if(cnst.type==FLOAT)
 477                 cnst.f_value = *reinterpret_cast<const float *>(&*(op+3));
 478 }
 479
 480 void SpirVModule::Reflection::reflect_variable(CodeIterator op)
 481 {
 482         unsigned id = *(op+2);
 483         Variable &var = variables[id];
 484         var.name = names[id];
 485         const TypeInfo &type = types[*(op+1)];
 486         var.storage = type.storage;
 487         var.type = type.type;
 488         var.struct_type = type.struct_type;
 489         var.array_size = type.array_size;
 490 }
 491
 492 void SpirVModule::Reflection::reflect_decorate(CodeIterator op)
 493 {
 494         unsigned id = *(op+1);
 495         unsigned decoration = *(op+2);
 496         op += 3;
 497
 498         switch(decoration)
 499         {
 500         case DECO_SPEC_ID:
 501                 constants[id].constant_id = *op;
 502                 break;
 503         case DECO_ARRAY_STRIDE:
 504                 types[id].array_stride = *op;
 505                 break;
 506         case DECO_BUILTIN:
 507                 variables[id].builtin = static_cast<BuiltinSemantic>(*op);
 508                 break;
 509         case DECO_LOCATION:
 510                 variables[id].location = *op;
 511                 break;
 512         case DECO_BINDING:
 513                 variables[id].binding = *op;
 514                 break;
 515         case DECO_DESCRIPTOR_SET:
 516                 variables[id].descriptor_set = *op;
 517                 break;
 518         }
 519 }
 520
 521 void SpirVModule::Reflection::reflect_member_decorate(CodeIterator op)
 522 {
 523         Structure &strct = structs[*(op+1)];
 524         unsigned index = *(op+2);
 525         if(index>=strct.members.size())
 526                 strct.members.resize(index+1);
 527         unsigned decoration = *(op+3);
 528         op += 4;
 529
 530         StructMember &member = strct.members[index];
 531         switch(decoration)
 532         {
 533         case DECO_MATRIX_STRIDE:
 534                 member.matrix_stride = *op;
 535                 break;
 536         case DECO_BUILTIN:
 537                 member.builtin = static_cast<BuiltinSemantic>(*op);
 538                 break;
 539         case DECO_OFFSET:
 540                 member.offset = *op;
 541                 break;
 542         }
 543 }
 544
 545 } // namespace GL
 546 } // namespace Msp