added support for push_constant layout

src/sksl/SkSLSPIRVCodeGenerator.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #include "SkSLSPIRVCodeGenerator.h"
 
 #include "string.h"
@@ skipping 950 matching lines @@
         if (fCapabilities & bit) {
             this->writeInstruction(SpvOpCapability, (SpvId) i, out);
         }
     }
 }
 
 SpvId SPIRVCodeGenerator::nextId() {
     return fIdCount++;
 }
 
-void SPIRVCodeGenerator::writeStruct(const Type& type, SpvId resultId) {
+void SPIRVCodeGenerator::writeStruct(const Type& type, const MemoryLayout& layout, SpvId resultId) {
     this->writeInstruction(SpvOpName, resultId, type.name().c_str(), fNameBuffer);
     // go ahead and write all of the field types, so we don't inadvertently write them while we're
     // in the middle of writing the struct instruction
     std::vector<SpvId> types;
     for (const auto& f : type.fields()) {
-        types.push_back(this->getType(*f.fType));
+        types.push_back(this->getType(*f.fType, layout));
     }
     this->writeOpCode(SpvOpTypeStruct, 2 + (int32_t) types.size(), fConstantBuffer);
     this->writeWord(resultId, fConstantBuffer);
     for (SpvId id : types) {
         this->writeWord(id, fConstantBuffer);
     }
     size_t offset = 0;
     for (int32_t i = 0; i < (int32_t) type.fields().size(); i++) {
-        size_t size = type.fields()[i].fType->size();
-        size_t alignment = type.fields()[i].fType->alignment();
+        size_t size = layout.size(*type.fields()[i].fType);
+        size_t alignment = layout.alignment(*type.fields()[i].fType);
         size_t mod = offset % alignment;
         if (mod != 0) {
             offset += alignment - mod;
         }
         this->writeInstruction(SpvOpMemberName, resultId, i, type.fields()[i].fName.c_str(),
                                fNameBuffer);
         this->writeLayout(type.fields()[i].fModifiers.fLayout, resultId, i);
         if (type.fields()[i].fModifiers.fLayout.fBuiltin < 0) {
             this->writeInstruction(SpvOpMemberDecorate, resultId, (SpvId) i, SpvDecorationOffset, 
                                    (SpvId) offset, fDecorationBuffer);
         }
         if (type.fields()[i].fType->kind() == Type::kMatrix_Kind) {
             this->writeInstruction(SpvOpMemberDecorate, resultId, i, SpvDecorationColMajor, 
                                    fDecorationBuffer);
             this->writeInstruction(SpvOpMemberDecorate, resultId, i, SpvDecorationMatrixStride, 
-                                   (SpvId) type.fields()[i].fType->stride(), fDecorationBuffer);
+                                   (SpvId) layout.stride(*type.fields()[i].fType), 
+                                   fDecorationBuffer);
         }
         offset += size;
         Type::Kind kind = type.fields()[i].fType->kind();
         if ((kind == Type::kArray_Kind || kind == Type::kStruct_Kind) && offset % alignment != 0) {
             offset += alignment - offset % alignment;
         }
         ASSERT(offset % alignment == 0);
     }
 }
 
 SpvId SPIRVCodeGenerator::getType(const Type& type) {
-    auto entry = fTypeMap.find(type.name());
+    return this->getType(type, fDefaultLayout);
+}
+
+SpvId SPIRVCodeGenerator::getType(const Type& type, const MemoryLayout& layout) {
+    std::string key = type.name() + to_string((int) layout.fStd);
+    auto entry = fTypeMap.find(key);
     if (entry == fTypeMap.end()) {
         SpvId result = this->nextId();
         switch (type.kind()) {
             case Type::kScalar_Kind:
                 if (type == *fContext.fBool_Type) {
                     this->writeInstruction(SpvOpTypeBool, result, fConstantBuffer);
                 } else if (type == *fContext.fInt_Type) {
                     this->writeInstruction(SpvOpTypeInt, result, 32, 1, fConstantBuffer);
                 } else if (type == *fContext.fUInt_Type) {
                     this->writeInstruction(SpvOpTypeInt, result, 32, 0, fConstantBuffer);
                 } else if (type == *fContext.fFloat_Type) {
                     this->writeInstruction(SpvOpTypeFloat, result, 32, fConstantBuffer);
                 } else if (type == *fContext.fDouble_Type) {
                     this->writeInstruction(SpvOpTypeFloat, result, 64, fConstantBuffer);
                 } else {
                     ASSERT(false);
                 }
                 break;
             case Type::kVector_Kind:
                 this->writeInstruction(SpvOpTypeVector, result, 
-                                       this->getType(type.componentType()),
+                                       this->getType(type.componentType(), layout),
                                        type.columns(), fConstantBuffer);
                 break;
             case Type::kMatrix_Kind:
                 this->writeInstruction(SpvOpTypeMatrix, result, 
-                                       this->getType(index_type(fContext, type)), 
+                                       this->getType(index_type(fContext, type), layout), 
                                        type.columns(), fConstantBuffer);
                 break;
             case Type::kStruct_Kind:
-                this->writeStruct(type, result);
+                this->writeStruct(type, layout, result);
                 break;
             case Type::kArray_Kind: {
                 if (type.columns() > 0) {
                     IntLiteral count(fContext, Position(), type.columns());
                     this->writeInstruction(SpvOpTypeArray, result, 
-                                           this->getType(type.componentType()), 
+                                           this->getType(type.componentType(), layout), 
                                            this->writeIntLiteral(count), fConstantBuffer);
                     this->writeInstruction(SpvOpDecorate, result, SpvDecorationArrayStride, 
-                                           (int32_t) type.stride(), fDecorationBuffer);
+                                           (int32_t) layout.stride(type), 
+                                           fDecorationBuffer);
                 } else {
                     ABORT("runtime-sized arrays are not yet supported");
                     this->writeInstruction(SpvOpTypeRuntimeArray, result, 
-                                           this->getType(type.componentType()), fConstantBuffer);
+                                           this->getType(type.componentType(), layout), 
+                                           fConstantBuffer);
                 }
                 break;
             }
             case Type::kSampler_Kind: {
                 SpvId image = this->nextId();
-                this->writeInstruction(SpvOpTypeImage, image, this->getType(*fContext.fFloat_Type), 
+                this->writeInstruction(SpvOpTypeImage, image, 
+                                       this->getType(*fContext.fFloat_Type, layout), 
                                        type.dimensions(), type.isDepth(), type.isArrayed(),
                                        type.isMultisampled(), type.isSampled(), 
                                        SpvImageFormatUnknown, fConstantBuffer);
                 this->writeInstruction(SpvOpTypeSampledImage, result, image, fConstantBuffer);
                 break;
             }
             default:
                 if (type == *fContext.fVoid_Type) {
                     this->writeInstruction(SpvOpTypeVoid, result, fConstantBuffer);
                 } else {
                     ABORT("invalid type: %s", type.description().c_str());
                 }
         }
-        fTypeMap[type.name()] = result;
+        fTypeMap[key] = result;
         return result;
     }
     return entry->second;
 }
 
 SpvId SPIRVCodeGenerator::getFunctionType(const FunctionDeclaration& function) {
     std::string key = function.fReturnType.description() + "(";
     std::string separator = "";
     for (size_t i = 0; i < function.fParameters.size(); i++) {
         key += separator;
@@ skipping 42 matching lines @@
         this->writeWord(returnType, fConstantBuffer);
         for (SpvId id : parameterTypes) {
             this->writeWord(id, fConstantBuffer);
         }
         fTypeMap[key] = result;
         return result;
     }
     return entry->second;
 }
 
-SpvId SPIRVCodeGenerator::getPointerType(const Type& type, 
+SpvId SPIRVCodeGenerator::getPointerType(const Type& type, SpvStorageClass_ storageClass) {
+    return this->getPointerType(type, fDefaultLayout, storageClass);
+}
+
+SpvId SPIRVCodeGenerator::getPointerType(const Type& type, const MemoryLayout& layout,
                                          SpvStorageClass_ storageClass) {
-    std::string key = type.description() + "*" + to_string(storageClass);
+    std::string key = type.description() + "*" + to_string(layout.fStd) + to_string(storageClass);
     auto entry = fTypeMap.find(key);
     if (entry == fTypeMap.end()) {
         SpvId result = this->nextId();
         this->writeInstruction(SpvOpTypePointer, result, storageClass, 
                                this->getType(type), fConstantBuffer);
         fTypeMap[key] = result;
         return result;
     }
     return entry->second;
 }
@@ skipping 390 matching lines @@
             return this->writeVectorConstructor(c, out);
         case Type::kMatrix_Kind:
             return this->writeMatrixConstructor(c, out);
         default:
             ABORT("unsupported constructor: %s", c.description().c_str());
     }
 }
 
 SpvStorageClass_ get_storage_class(const Modifiers& modifiers) {
     if (modifiers.fFlags & Modifiers::kIn_Flag) {
+        ASSERT(!modifiers.fLayout.fPushConstant);
         return SpvStorageClassInput;
     } else if (modifiers.fFlags & Modifiers::kOut_Flag) {
+        ASSERT(!modifiers.fLayout.fPushConstant);
         return SpvStorageClassOutput;
     } else if (modifiers.fFlags & Modifiers::kUniform_Flag) {
+        if (modifiers.fLayout.fPushConstant) {
+            return SpvStorageClassPushConstant;
+        }
         return SpvStorageClassUniform;
     } else {
         return SpvStorageClassFunction;
     }
 }
 
 SpvStorageClass_ get_storage_class(const Expression& expr) {
     switch (expr.fKind) {
         case Expression::kVariableReference_Kind:
             return get_storage_class(((VariableReference&) expr).fVariable.fModifiers);
@@ skipping 783 matching lines @@
         this->writeInstruction(SpvOpMemberDecorate, target, member, SpvDecorationDescriptorSet, 
                                layout.fSet, fDecorationBuffer);
     }
     if (layout.fBuiltin >= 0) {
         this->writeInstruction(SpvOpMemberDecorate, target, member, SpvDecorationBuiltIn, 
                                layout.fBuiltin, fDecorationBuffer);
     }
 }
 
 SpvId SPIRVCodeGenerator::writeInterfaceBlock(const InterfaceBlock& intf) {
-    SpvId type = this->getType(intf.fVariable.fType);
+    MemoryLayout layout = intf.fVariable.fModifiers.fLayout.fPushConstant ?
+                          MemoryLayout(MemoryLayout::k430_Standard) :
+                          fDefaultLayout;
+    SpvId type = this->getType(intf.fVariable.fType, layout);
     SpvId result = this->nextId();
     this->writeInstruction(SpvOpDecorate, type, SpvDecorationBlock, fDecorationBuffer);
     SpvStorageClass_ storageClass = get_storage_class(intf.fVariable.fModifiers);
     SpvId ptrType = this->nextId();
     this->writeInstruction(SpvOpTypePointer, ptrType, storageClass, type, fConstantBuffer);
     this->writeInstruction(SpvOpVariable, ptrType, result, storageClass, fConstantBuffer);
     this->writeLayout(intf.fVariable.fModifiers.fLayout, result);
     fVariableMap[&intf.fVariable] = result;
     return result;
 }
@@ skipping 35 matching lines @@
         }
         SpvId id = this->nextId();
         fVariableMap[var] = id;
         SpvId type = this->getPointerType(var->fType, storageClass);
         this->writeInstruction(SpvOpVariable, type, id, storageClass, fConstantBuffer);
         this->writeInstruction(SpvOpName, id, var->fName.c_str(), fNameBuffer);
         if (var->fType.kind() == Type::kMatrix_Kind) {
             this->writeInstruction(SpvOpMemberDecorate, id, (SpvId) i, SpvDecorationColMajor, 
                                    fDecorationBuffer);
             this->writeInstruction(SpvOpMemberDecorate, id, (SpvId) i, SpvDecorationMatrixStride, 
-                                   (SpvId) var->fType.stride(), fDecorationBuffer);
+                                   (SpvId) fDefaultLayout.stride(var->fType), 

[egdaniel, 2016/11/14 18:48:35]

extra whitespace

+                                   fDecorationBuffer);
         }
         if (varDecl.fValue) {
             ASSERT(!fCurrentBlock);
             fCurrentBlock = -1;
             SpvId value = this->writeExpression(*varDecl.fValue, fGlobalInitializersBuffer);
             this->writeInstruction(SpvOpStore, id, value, fGlobalInitializersBuffer);
             fCurrentBlock = 0;
         }
         this->writeLayout(var->fModifiers.fLayout, id);
     }
@@ skipping 220 matching lines @@
     this->writeWord(SpvVersion, out);
     this->writeWord(SKSL_MAGIC, out);
     std::stringstream buffer;
     this->writeInstructions(program, buffer);
     this->writeWord(fIdCount, out);
     this->writeWord(0, out); // reserved, always zero
     out << buffer.str();
 }
 
 }