SkSL performance improvements

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
 
@@ skipping 43 matching lines @@
         
         // returns a pointer to the lvalue, if possible. If the lvalue cannot be directly referenced
         // 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()
-    : fCapabilities(1 << SpvCapabilityShader)
+    SPIRVCodeGenerator(const Context* context)
+    : fContext(*context)
+    , fCapabilities(1 << SpvCapabilityShader)
     , fIdCount(1)
     , fBoolTrue(0)
     , fBoolFalse(0)
     , fCurrentBlock(0) {
         this->setupIntrinsics();
     }
 
     void generateCode(Program& program, std::ostream& out) override;
 
 private:
     enum IntrinsicKind {
         kGLSL_STD_450_IntrinsicKind,
         kSPIRV_IntrinsicKind,
         kSpecial_IntrinsicKind
     };
 
     enum SpecialIntrinsic {
         kAtan_SpecialIntrinsic,
         kTexture_SpecialIntrinsic,
         kTexture2D_SpecialIntrinsic,
         kTextureProj_SpecialIntrinsic
     };
 
     void setupIntrinsics();
 
     SpvId nextId();
 
     SpvId getType(const Type& type);
 
-    SpvId getFunctionType(std::shared_ptr<FunctionDeclaration> function);
+    SpvId getFunctionType(const FunctionDeclaration& function);
 
-    SpvId getPointerType(std::shared_ptr<Type> type, SpvStorageClass_ storageClass);
+    SpvId getPointerType(const Type& type, SpvStorageClass_ storageClass);
 
     std::vector<SpvId> getAccessChain(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 writeProgramElement(ProgramElement& pe, std::ostream& out);
 
     SpvId writeInterfaceBlock(InterfaceBlock& intf);
 
-    SpvId writeFunctionStart(std::shared_ptr<FunctionDeclaration> f, std::ostream& out);
+    SpvId writeFunctionStart(const FunctionDeclaration& f, std::ostream& out);
     
-    SpvId writeFunctionDeclaration(std::shared_ptr<FunctionDeclaration> f, std::ostream& out);
+    SpvId writeFunctionDeclaration(const FunctionDeclaration& f, std::ostream& out);
 
-    SpvId writeFunction(FunctionDefinition& f, std::ostream& out);
+    SpvId writeFunction(const FunctionDefinition& f, std::ostream& out);
 
     void writeGlobalVars(VarDeclaration& v, std::ostream& out);
 
     void writeVarDeclaration(VarDeclaration& decl, std::ostream& out);
 
     SpvId writeVariableReference(VariableReference& ref, std::ostream& out);
 
     std::unique_ptr<LValue> getLValue(Expression& value, std::ostream& out);
 
     SpvId writeExpression(Expression& expr, std::ostream& out);
@@ skipping 94 matching lines @@
     void writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, int32_t word4,
                           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;
+
     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<std::shared_ptr<FunctionDeclaration>, SpvId> fFunctionMap;
-    std::unordered_map<std::shared_ptr<Variable>, SpvId> fVariableMap;
-    std::unordered_map<std::shared_ptr<Variable>, int32_t> fInterfaceBlockMap;
+    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;
     std::stringstream fCapabilitiesBuffer;
     std::stringstream fGlobalInitializersBuffer;
     std::stringstream fConstantBuffer;
     std::stringstream fExternalFunctionsBuffer;
     std::stringstream fVariableBuffer;
     std::stringstream fNameBuffer;
     std::stringstream fDecorationBuffer;
 
     SpvId fBoolTrue;
     SpvId fBoolFalse;
     std::unordered_map<int64_t, SpvId> fIntConstants;
     std::unordered_map<uint64_t, SpvId> fUIntConstants;
     std::unordered_map<float, SpvId> fFloatConstants;
     std::unordered_map<double, SpvId> fDoubleConstants;
     // label of the current block, or 0 if we are not in a block
     SpvId fCurrentBlock;
     std::stack<SpvId> fBreakTarget;
     std::stack<SpvId> fContinueTarget;
 
     friend class PointerLValue;
     friend class SwizzleLValue;
 };
 
 }
 
 #endif