added support for push_constant layout

src/sksl/SkSLSPIRVCodeGenerator.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #ifndef SKSL_SPIRVCODEGENERATOR
 #define SKSL_SPIRVCODEGENERATOR
 
 #include <sstream>
 #include <stack>
 #include <tuple>
 #include <unordered_map>
 
 #include "SkSLCodeGenerator.h"
+#include "SkSLMemoryLayout.h"
 #include "ir/SkSLBinaryExpression.h"
 #include "ir/SkSLBoolLiteral.h"
 #include "ir/SkSLConstructor.h"
 #include "ir/SkSLFloatLiteral.h"
 #include "ir/SkSLIfStatement.h"
 #include "ir/SkSLIndexExpression.h"
 #include "ir/SkSLInterfaceBlock.h"
 #include "ir/SkSLIntLiteral.h"
 #include "ir/SkSLFieldAccess.h"
 #include "ir/SkSLForStatement.h"
@@ skipping 29 matching lines @@
         // by a pointer (e.g. vector swizzles), returns 0.
         virtual SpvId getPointer() = 0;
 
         virtual SpvId load(std::ostream& out) = 0;
 
         virtual void store(SpvId value, std::ostream& out) = 0;
     };
 
     SPIRVCodeGenerator(const Context* context)
     : fContext(*context)
+    , fDefaultLayout(MemoryLayout::k140_Standard)
     , fCapabilities(1 << SpvCapabilityShader)
     , fIdCount(1)
     , fBoolTrue(0)
     , fBoolFalse(0)
     , fCurrentBlock(0) {
         this->setupIntrinsics();
     }
 
     void generateCode(const Program& program, std::ostream& out) override;
 
@@ skipping 10 matching lines @@
         kTexture2D_SpecialIntrinsic,
         kTextureProj_SpecialIntrinsic
     };
 
     void setupIntrinsics();
 
     SpvId nextId();
 
     SpvId getType(const Type& type);
 
+    SpvId getType(const Type& type, const MemoryLayout& layout);
+
     SpvId getFunctionType(const FunctionDeclaration& function);
 
     SpvId getPointerType(const Type& type, SpvStorageClass_ storageClass);
 
+    SpvId getPointerType(const Type& type, const MemoryLayout& layout, 
+                         SpvStorageClass_ storageClass);
+
     std::vector<SpvId> getAccessChain(const Expression& expr, std::ostream& out);
 
     void writeLayout(const Layout& layout, SpvId target);
 
     void writeLayout(const Layout& layout, SpvId target, int member);
 
-    void writeStruct(const Type& type, SpvId resultId);
+    void writeStruct(const Type& type, const MemoryLayout& layout, SpvId resultId);
 
     void writeProgramElement(const ProgramElement& pe, std::ostream& out);
 
     SpvId writeInterfaceBlock(const InterfaceBlock& intf);
 
     SpvId writeFunctionStart(const FunctionDeclaration& f, std::ostream& out);
     
     SpvId writeFunctionDeclaration(const FunctionDeclaration& f, std::ostream& out);
 
     SpvId writeFunction(const FunctionDefinition& f, std::ostream& out);
@@ skipping 105 matching lines @@
                           int32_t word5, int32_t word6, std::ostream& out);
 
     void writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, int32_t word4,
                           int32_t word5, int32_t word6, int32_t word7, std::ostream& out);
 
     void writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, int32_t word4,
                           int32_t word5, int32_t word6, int32_t word7, int32_t word8, 
                           std::ostream& out);
 
     const Context& fContext;
+    const MemoryLayout fDefaultLayout;
 
     uint64_t fCapabilities;
     SpvId fIdCount;
     SpvId fGLSLExtendedInstructions;
     typedef std::tuple<IntrinsicKind, int32_t, int32_t, int32_t, int32_t> Intrinsic;
     std::unordered_map<std::string, Intrinsic> fIntrinsicMap;
     std::unordered_map<const FunctionDeclaration*, SpvId> fFunctionMap;
     std::unordered_map<const Variable*, SpvId> fVariableMap;
     std::unordered_map<const Variable*, int32_t> fInterfaceBlockMap;
     std::unordered_map<std::string, SpvId> fTypeMap;
@@ skipping 16 matching lines @@
     std::stack<SpvId> fBreakTarget;
     std::stack<SpvId> fContinueTarget;
 
     friend class PointerLValue;
     friend class SwizzleLValue;
 };
 
 }
 
 #endif