From d8df21a1e08b5b3380261f4b90acfbdc538ef93c Mon Sep 17 00:00:00 2001 From: Ethan Nicholas Date: Thu, 17 Nov 2016 16:13:37 -0500 Subject: switched skslc from std::string to SkString BUG=skia: GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=4977 Change-Id: I15e24963b09b719a2c07da67745114f5ac66cee8 Reviewed-on: https://skia-review.googlesource.com/4977 Reviewed-by: Brian Salomon Commit-Queue: Ethan Nicholas --- src/sksl/SkSLSPIRVCodeGenerator.cpp | 923 ++++++++++++++++++------------------ 1 file changed, 463 insertions(+), 460 deletions(-) (limited to 'src/sksl/SkSLSPIRVCodeGenerator.cpp') diff --git a/src/sksl/SkSLSPIRVCodeGenerator.cpp b/src/sksl/SkSLSPIRVCodeGenerator.cpp index a491968674..b5cd54abae 100644 --- a/src/sksl/SkSLSPIRVCodeGenerator.cpp +++ b/src/sksl/SkSLSPIRVCodeGenerator.cpp @@ -34,107 +34,112 @@ void SPIRVCodeGenerator::setupIntrinsics() { #define SPECIAL(x) std::make_tuple(kSpecial_IntrinsicKind, k ## x ## _SpecialIntrinsic, \ k ## x ## _SpecialIntrinsic, k ## x ## _SpecialIntrinsic, \ k ## x ## _SpecialIntrinsic) - fIntrinsicMap["round"] = ALL_GLSL(Round); - fIntrinsicMap["roundEven"] = ALL_GLSL(RoundEven); - fIntrinsicMap["trunc"] = ALL_GLSL(Trunc); - fIntrinsicMap["abs"] = BY_TYPE_GLSL(FAbs, SAbs, SAbs); - fIntrinsicMap["sign"] = BY_TYPE_GLSL(FSign, SSign, SSign); - fIntrinsicMap["floor"] = ALL_GLSL(Floor); - fIntrinsicMap["ceil"] = ALL_GLSL(Ceil); - fIntrinsicMap["fract"] = ALL_GLSL(Fract); - fIntrinsicMap["radians"] = ALL_GLSL(Radians); - fIntrinsicMap["degrees"] = ALL_GLSL(Degrees); - fIntrinsicMap["sin"] = ALL_GLSL(Sin); - fIntrinsicMap["cos"] = ALL_GLSL(Cos); - fIntrinsicMap["tan"] = ALL_GLSL(Tan); - fIntrinsicMap["asin"] = ALL_GLSL(Asin); - fIntrinsicMap["acos"] = ALL_GLSL(Acos); - fIntrinsicMap["atan"] = SPECIAL(Atan); - fIntrinsicMap["sinh"] = ALL_GLSL(Sinh); - fIntrinsicMap["cosh"] = ALL_GLSL(Cosh); - fIntrinsicMap["tanh"] = ALL_GLSL(Tanh); - fIntrinsicMap["asinh"] = ALL_GLSL(Asinh); - fIntrinsicMap["acosh"] = ALL_GLSL(Acosh); - fIntrinsicMap["atanh"] = ALL_GLSL(Atanh); - fIntrinsicMap["pow"] = ALL_GLSL(Pow); - fIntrinsicMap["exp"] = ALL_GLSL(Exp); - fIntrinsicMap["log"] = ALL_GLSL(Log); - fIntrinsicMap["exp2"] = ALL_GLSL(Exp2); - fIntrinsicMap["log2"] = ALL_GLSL(Log2); - fIntrinsicMap["sqrt"] = ALL_GLSL(Sqrt); - fIntrinsicMap["inversesqrt"] = ALL_GLSL(InverseSqrt); - fIntrinsicMap["determinant"] = ALL_GLSL(Determinant); - fIntrinsicMap["matrixInverse"] = ALL_GLSL(MatrixInverse); - fIntrinsicMap["mod"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFMod, SpvOpSMod, - SpvOpUMod, SpvOpUndef); - fIntrinsicMap["min"] = BY_TYPE_GLSL(FMin, SMin, UMin); - fIntrinsicMap["max"] = BY_TYPE_GLSL(FMax, SMax, UMax); - fIntrinsicMap["clamp"] = BY_TYPE_GLSL(FClamp, SClamp, UClamp); - fIntrinsicMap["dot"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpDot, SpvOpUndef, - SpvOpUndef, SpvOpUndef); - fIntrinsicMap["mix"] = ALL_GLSL(FMix); - fIntrinsicMap["step"] = ALL_GLSL(Step); - fIntrinsicMap["smoothstep"] = ALL_GLSL(SmoothStep); - fIntrinsicMap["fma"] = ALL_GLSL(Fma); - fIntrinsicMap["frexp"] = ALL_GLSL(Frexp); - fIntrinsicMap["ldexp"] = ALL_GLSL(Ldexp); - -#define PACK(type) fIntrinsicMap["pack" #type] = ALL_GLSL(Pack ## type); \ - fIntrinsicMap["unpack" #type] = ALL_GLSL(Unpack ## type) + fIntrinsicMap[SkString("round")] = ALL_GLSL(Round); + fIntrinsicMap[SkString("roundEven")] = ALL_GLSL(RoundEven); + fIntrinsicMap[SkString("trunc")] = ALL_GLSL(Trunc); + fIntrinsicMap[SkString("abs")] = BY_TYPE_GLSL(FAbs, SAbs, SAbs); + fIntrinsicMap[SkString("sign")] = BY_TYPE_GLSL(FSign, SSign, SSign); + fIntrinsicMap[SkString("floor")] = ALL_GLSL(Floor); + fIntrinsicMap[SkString("ceil")] = ALL_GLSL(Ceil); + fIntrinsicMap[SkString("fract")] = ALL_GLSL(Fract); + fIntrinsicMap[SkString("radians")] = ALL_GLSL(Radians); + fIntrinsicMap[SkString("degrees")] = ALL_GLSL(Degrees); + fIntrinsicMap[SkString("sin")] = ALL_GLSL(Sin); + fIntrinsicMap[SkString("cos")] = ALL_GLSL(Cos); + fIntrinsicMap[SkString("tan")] = ALL_GLSL(Tan); + fIntrinsicMap[SkString("asin")] = ALL_GLSL(Asin); + fIntrinsicMap[SkString("acos")] = ALL_GLSL(Acos); + fIntrinsicMap[SkString("atan")] = SPECIAL(Atan); + fIntrinsicMap[SkString("sinh")] = ALL_GLSL(Sinh); + fIntrinsicMap[SkString("cosh")] = ALL_GLSL(Cosh); + fIntrinsicMap[SkString("tanh")] = ALL_GLSL(Tanh); + fIntrinsicMap[SkString("asinh")] = ALL_GLSL(Asinh); + fIntrinsicMap[SkString("acosh")] = ALL_GLSL(Acosh); + fIntrinsicMap[SkString("atanh")] = ALL_GLSL(Atanh); + fIntrinsicMap[SkString("pow")] = ALL_GLSL(Pow); + fIntrinsicMap[SkString("exp")] = ALL_GLSL(Exp); + fIntrinsicMap[SkString("log")] = ALL_GLSL(Log); + fIntrinsicMap[SkString("exp2")] = ALL_GLSL(Exp2); + fIntrinsicMap[SkString("log2")] = ALL_GLSL(Log2); + fIntrinsicMap[SkString("sqrt")] = ALL_GLSL(Sqrt); + fIntrinsicMap[SkString("inversesqrt")] = ALL_GLSL(InverseSqrt); + fIntrinsicMap[SkString("determinant")] = ALL_GLSL(Determinant); + fIntrinsicMap[SkString("matrixInverse")] = ALL_GLSL(MatrixInverse); + fIntrinsicMap[SkString("mod")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFMod, + SpvOpSMod, SpvOpUMod, SpvOpUndef); + fIntrinsicMap[SkString("min")] = BY_TYPE_GLSL(FMin, SMin, UMin); + fIntrinsicMap[SkString("max")] = BY_TYPE_GLSL(FMax, SMax, UMax); + fIntrinsicMap[SkString("clamp")] = BY_TYPE_GLSL(FClamp, SClamp, UClamp); + fIntrinsicMap[SkString("dot")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpDot, + SpvOpUndef, SpvOpUndef, SpvOpUndef); + fIntrinsicMap[SkString("mix")] = ALL_GLSL(FMix); + fIntrinsicMap[SkString("step")] = ALL_GLSL(Step); + fIntrinsicMap[SkString("smoothstep")] = ALL_GLSL(SmoothStep); + fIntrinsicMap[SkString("fma")] = ALL_GLSL(Fma); + fIntrinsicMap[SkString("frexp")] = ALL_GLSL(Frexp); + fIntrinsicMap[SkString("ldexp")] = ALL_GLSL(Ldexp); + +#define PACK(type) fIntrinsicMap[SkString("pack" #type)] = ALL_GLSL(Pack ## type); \ + fIntrinsicMap[SkString("unpack" #type)] = ALL_GLSL(Unpack ## type) PACK(Snorm4x8); PACK(Unorm4x8); PACK(Snorm2x16); PACK(Unorm2x16); PACK(Half2x16); PACK(Double2x32); - fIntrinsicMap["length"] = ALL_GLSL(Length); - fIntrinsicMap["distance"] = ALL_GLSL(Distance); - fIntrinsicMap["cross"] = ALL_GLSL(Cross); - fIntrinsicMap["normalize"] = ALL_GLSL(Normalize); - fIntrinsicMap["faceForward"] = ALL_GLSL(FaceForward); - fIntrinsicMap["reflect"] = ALL_GLSL(Reflect); - fIntrinsicMap["refract"] = ALL_GLSL(Refract); - fIntrinsicMap["findLSB"] = ALL_GLSL(FindILsb); - fIntrinsicMap["findMSB"] = BY_TYPE_GLSL(FindSMsb, FindSMsb, FindUMsb); - fIntrinsicMap["dFdx"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpDPdx, SpvOpUndef, - SpvOpUndef, SpvOpUndef); - fIntrinsicMap["dFdy"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpDPdy, SpvOpUndef, - SpvOpUndef, SpvOpUndef); - fIntrinsicMap["dFdy"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpDPdy, SpvOpUndef, - SpvOpUndef, SpvOpUndef); - fIntrinsicMap["texture"] = SPECIAL(Texture); - fIntrinsicMap["texture2D"] = SPECIAL(Texture2D); - fIntrinsicMap["textureProj"] = SPECIAL(TextureProj); - - fIntrinsicMap["any"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpUndef, - SpvOpUndef, SpvOpUndef, SpvOpAny); - fIntrinsicMap["all"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpUndef, - SpvOpUndef, SpvOpUndef, SpvOpAll); - fIntrinsicMap["equal"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFOrdEqual, - SpvOpIEqual, SpvOpIEqual, - SpvOpLogicalEqual); - fIntrinsicMap["notEqual"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpFOrdNotEqual, - SpvOpINotEqual, SpvOpINotEqual, - SpvOpLogicalNotEqual); - fIntrinsicMap["lessThan"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpSLessThan, - SpvOpULessThan, SpvOpFOrdLessThan, - SpvOpUndef); - fIntrinsicMap["lessThanEqual"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpSLessThanEqual, - SpvOpULessThanEqual, SpvOpFOrdLessThanEqual, - SpvOpUndef); - fIntrinsicMap["greaterThan"] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpSGreaterThan, - SpvOpUGreaterThan, SpvOpFOrdGreaterThan, - SpvOpUndef); - fIntrinsicMap["greaterThanEqual"] = std::make_tuple(kSPIRV_IntrinsicKind, - SpvOpSGreaterThanEqual, - SpvOpUGreaterThanEqual, - SpvOpFOrdGreaterThanEqual, - SpvOpUndef); + fIntrinsicMap[SkString("length")] = ALL_GLSL(Length); + fIntrinsicMap[SkString("distance")] = ALL_GLSL(Distance); + fIntrinsicMap[SkString("cross")] = ALL_GLSL(Cross); + fIntrinsicMap[SkString("normalize")] = ALL_GLSL(Normalize); + fIntrinsicMap[SkString("faceForward")] = ALL_GLSL(FaceForward); + fIntrinsicMap[SkString("reflect")] = ALL_GLSL(Reflect); + fIntrinsicMap[SkString("refract")] = ALL_GLSL(Refract); + fIntrinsicMap[SkString("findLSB")] = ALL_GLSL(FindILsb); + fIntrinsicMap[SkString("findMSB")] = BY_TYPE_GLSL(FindSMsb, FindSMsb, FindUMsb); + fIntrinsicMap[SkString("dFdx")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpDPdx, + SpvOpUndef, SpvOpUndef, SpvOpUndef); + fIntrinsicMap[SkString("dFdy")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpDPdy, + SpvOpUndef, SpvOpUndef, SpvOpUndef); + fIntrinsicMap[SkString("dFdy")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpDPdy, + SpvOpUndef, SpvOpUndef, SpvOpUndef); + fIntrinsicMap[SkString("texture")] = SPECIAL(Texture); + fIntrinsicMap[SkString("texture2D")] = SPECIAL(Texture2D); + fIntrinsicMap[SkString("textureProj")] = SPECIAL(TextureProj); + + fIntrinsicMap[SkString("any")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpUndef, + SpvOpUndef, SpvOpUndef, SpvOpAny); + fIntrinsicMap[SkString("all")] = std::make_tuple(kSPIRV_IntrinsicKind, SpvOpUndef, + SpvOpUndef, SpvOpUndef, SpvOpAll); + fIntrinsicMap[SkString("equal")] = std::make_tuple(kSPIRV_IntrinsicKind, + SpvOpFOrdEqual, SpvOpIEqual, + SpvOpIEqual, SpvOpLogicalEqual); + fIntrinsicMap[SkString("notEqual")] = std::make_tuple(kSPIRV_IntrinsicKind, + SpvOpFOrdNotEqual, SpvOpINotEqual, + SpvOpINotEqual, + SpvOpLogicalNotEqual); + fIntrinsicMap[SkString("lessThan")] = std::make_tuple(kSPIRV_IntrinsicKind, + SpvOpSLessThan, SpvOpULessThan, + SpvOpFOrdLessThan, SpvOpUndef); + fIntrinsicMap[SkString("lessThanEqual")] = std::make_tuple(kSPIRV_IntrinsicKind, + SpvOpSLessThanEqual, + SpvOpULessThanEqual, + SpvOpFOrdLessThanEqual, + SpvOpUndef); + fIntrinsicMap[SkString("greaterThan")] = std::make_tuple(kSPIRV_IntrinsicKind, + SpvOpSGreaterThan, + SpvOpUGreaterThan, + SpvOpFOrdGreaterThan, + SpvOpUndef); + fIntrinsicMap[SkString("greaterThanEqual")] = std::make_tuple(kSPIRV_IntrinsicKind, + SpvOpSGreaterThanEqual, + SpvOpUGreaterThanEqual, + SpvOpFOrdGreaterThanEqual, + SpvOpUndef); // interpolateAt* not yet supported... } -void SPIRVCodeGenerator::writeWord(int32_t word, std::ostream& out) { +void SPIRVCodeGenerator::writeWord(int32_t word, SkWStream& out) { #if SPIRV_DEBUG out << "(" << word << ") "; #else @@ -175,603 +180,603 @@ static bool is_out(const Variable& var) { } #if SPIRV_DEBUG -static std::string opcode_text(SpvOp_ opCode) { +static SkString opcode_text(SpvOp_ opCode) { switch (opCode) { case SpvOpNop: - return "Nop"; + return SkString("Nop"); case SpvOpUndef: - return "Undef"; + return SkString("Undef"); case SpvOpSourceContinued: - return "SourceContinued"; + return SkString("SourceContinued"); case SpvOpSource: - return "Source"; + return SkString("Source"); case SpvOpSourceExtension: - return "SourceExtension"; + return SkString("SourceExtension"); case SpvOpName: - return "Name"; + return SkString("Name"); case SpvOpMemberName: - return "MemberName"; + return SkString("MemberName"); case SpvOpString: - return "String"; + return SkString("String"); case SpvOpLine: - return "Line"; + return SkString("Line"); case SpvOpExtension: - return "Extension"; + return SkString("Extension"); case SpvOpExtInstImport: - return "ExtInstImport"; + return SkString("ExtInstImport"); case SpvOpExtInst: - return "ExtInst"; + return SkString("ExtInst"); case SpvOpMemoryModel: - return "MemoryModel"; + return SkString("MemoryModel"); case SpvOpEntryPoint: - return "EntryPoint"; + return SkString("EntryPoint"); case SpvOpExecutionMode: - return "ExecutionMode"; + return SkString("ExecutionMode"); case SpvOpCapability: - return "Capability"; + return SkString("Capability"); case SpvOpTypeVoid: - return "TypeVoid"; + return SkString("TypeVoid"); case SpvOpTypeBool: - return "TypeBool"; + return SkString("TypeBool"); case SpvOpTypeInt: - return "TypeInt"; + return SkString("TypeInt"); case SpvOpTypeFloat: - return "TypeFloat"; + return SkString("TypeFloat"); case SpvOpTypeVector: - return "TypeVector"; + return SkString("TypeVector"); case SpvOpTypeMatrix: - return "TypeMatrix"; + return SkString("TypeMatrix"); case SpvOpTypeImage: - return "TypeImage"; + return SkString("TypeImage"); case SpvOpTypeSampler: - return "TypeSampler"; + return SkString("TypeSampler"); case SpvOpTypeSampledImage: - return "TypeSampledImage"; + return SkString("TypeSampledImage"); case SpvOpTypeArray: - return "TypeArray"; + return SkString("TypeArray"); case SpvOpTypeRuntimeArray: - return "TypeRuntimeArray"; + return SkString("TypeRuntimeArray"); case SpvOpTypeStruct: - return "TypeStruct"; + return SkString("TypeStruct"); case SpvOpTypeOpaque: - return "TypeOpaque"; + return SkString("TypeOpaque"); case SpvOpTypePointer: - return "TypePointer"; + return SkString("TypePointer"); case SpvOpTypeFunction: - return "TypeFunction"; + return SkString("TypeFunction"); case SpvOpTypeEvent: - return "TypeEvent"; + return SkString("TypeEvent"); case SpvOpTypeDeviceEvent: - return "TypeDeviceEvent"; + return SkString("TypeDeviceEvent"); case SpvOpTypeReserveId: - return "TypeReserveId"; + return SkString("TypeReserveId"); case SpvOpTypeQueue: - return "TypeQueue"; + return SkString("TypeQueue"); case SpvOpTypePipe: - return "TypePipe"; + return SkString("TypePipe"); case SpvOpTypeForwardPointer: - return "TypeForwardPointer"; + return SkString("TypeForwardPointer"); case SpvOpConstantTrue: - return "ConstantTrue"; + return SkString("ConstantTrue"); case SpvOpConstantFalse: - return "ConstantFalse"; + return SkString("ConstantFalse"); case SpvOpConstant: - return "Constant"; + return SkString("Constant"); case SpvOpConstantComposite: - return "ConstantComposite"; + return SkString("ConstantComposite"); case SpvOpConstantSampler: - return "ConstantSampler"; + return SkString("ConstantSampler"); case SpvOpConstantNull: - return "ConstantNull"; + return SkString("ConstantNull"); case SpvOpSpecConstantTrue: - return "SpecConstantTrue"; + return SkString("SpecConstantTrue"); case SpvOpSpecConstantFalse: - return "SpecConstantFalse"; + return SkString("SpecConstantFalse"); case SpvOpSpecConstant: - return "SpecConstant"; + return SkString("SpecConstant"); case SpvOpSpecConstantComposite: - return "SpecConstantComposite"; + return SkString("SpecConstantComposite"); case SpvOpSpecConstantOp: - return "SpecConstantOp"; + return SkString("SpecConstantOp"); case SpvOpFunction: - return "Function"; + return SkString("Function"); case SpvOpFunctionParameter: - return "FunctionParameter"; + return SkString("FunctionParameter"); case SpvOpFunctionEnd: - return "FunctionEnd"; + return SkString("FunctionEnd"); case SpvOpFunctionCall: - return "FunctionCall"; + return SkString("FunctionCall"); case SpvOpVariable: - return "Variable"; + return SkString("Variable"); case SpvOpImageTexelPointer: - return "ImageTexelPointer"; + return SkString("ImageTexelPointer"); case SpvOpLoad: - return "Load"; + return SkString("Load"); case SpvOpStore: - return "Store"; + return SkString("Store"); case SpvOpCopyMemory: - return "CopyMemory"; + return SkString("CopyMemory"); case SpvOpCopyMemorySized: - return "CopyMemorySized"; + return SkString("CopyMemorySized"); case SpvOpAccessChain: - return "AccessChain"; + return SkString("AccessChain"); case SpvOpInBoundsAccessChain: - return "InBoundsAccessChain"; + return SkString("InBoundsAccessChain"); case SpvOpPtrAccessChain: - return "PtrAccessChain"; + return SkString("PtrAccessChain"); case SpvOpArrayLength: - return "ArrayLength"; + return SkString("ArrayLength"); case SpvOpGenericPtrMemSemantics: - return "GenericPtrMemSemantics"; + return SkString("GenericPtrMemSemantics"); case SpvOpInBoundsPtrAccessChain: - return "InBoundsPtrAccessChain"; + return SkString("InBoundsPtrAccessChain"); case SpvOpDecorate: - return "Decorate"; + return SkString("Decorate"); case SpvOpMemberDecorate: - return "MemberDecorate"; + return SkString("MemberDecorate"); case SpvOpDecorationGroup: - return "DecorationGroup"; + return SkString("DecorationGroup"); case SpvOpGroupDecorate: - return "GroupDecorate"; + return SkString("GroupDecorate"); case SpvOpGroupMemberDecorate: - return "GroupMemberDecorate"; + return SkString("GroupMemberDecorate"); case SpvOpVectorExtractDynamic: - return "VectorExtractDynamic"; + return SkString("VectorExtractDynamic"); case SpvOpVectorInsertDynamic: - return "VectorInsertDynamic"; + return SkString("VectorInsertDynamic"); case SpvOpVectorShuffle: - return "VectorShuffle"; + return SkString("VectorShuffle"); case SpvOpCompositeConstruct: - return "CompositeConstruct"; + return SkString("CompositeConstruct"); case SpvOpCompositeExtract: - return "CompositeExtract"; + return SkString("CompositeExtract"); case SpvOpCompositeInsert: - return "CompositeInsert"; + return SkString("CompositeInsert"); case SpvOpCopyObject: - return "CopyObject"; + return SkString("CopyObject"); case SpvOpTranspose: - return "Transpose"; + return SkString("Transpose"); case SpvOpSampledImage: - return "SampledImage"; + return SkString("SampledImage"); case SpvOpImageSampleImplicitLod: - return "ImageSampleImplicitLod"; + return SkString("ImageSampleImplicitLod"); case SpvOpImageSampleExplicitLod: - return "ImageSampleExplicitLod"; + return SkString("ImageSampleExplicitLod"); case SpvOpImageSampleDrefImplicitLod: - return "ImageSampleDrefImplicitLod"; + return SkString("ImageSampleDrefImplicitLod"); case SpvOpImageSampleDrefExplicitLod: - return "ImageSampleDrefExplicitLod"; + return SkString("ImageSampleDrefExplicitLod"); case SpvOpImageSampleProjImplicitLod: - return "ImageSampleProjImplicitLod"; + return SkString("ImageSampleProjImplicitLod"); case SpvOpImageSampleProjExplicitLod: - return "ImageSampleProjExplicitLod"; + return SkString("ImageSampleProjExplicitLod"); case SpvOpImageSampleProjDrefImplicitLod: - return "ImageSampleProjDrefImplicitLod"; + return SkString("ImageSampleProjDrefImplicitLod"); case SpvOpImageSampleProjDrefExplicitLod: - return "ImageSampleProjDrefExplicitLod"; + return SkString("ImageSampleProjDrefExplicitLod"); case SpvOpImageFetch: - return "ImageFetch"; + return SkString("ImageFetch"); case SpvOpImageGather: - return "ImageGather"; + return SkString("ImageGather"); case SpvOpImageDrefGather: - return "ImageDrefGather"; + return SkString("ImageDrefGather"); case SpvOpImageRead: - return "ImageRead"; + return SkString("ImageRead"); case SpvOpImageWrite: - return "ImageWrite"; + return SkString("ImageWrite"); case SpvOpImage: - return "Image"; + return SkString("Image"); case SpvOpImageQueryFormat: - return "ImageQueryFormat"; + return SkString("ImageQueryFormat"); case SpvOpImageQueryOrder: - return "ImageQueryOrder"; + return SkString("ImageQueryOrder"); case SpvOpImageQuerySizeLod: - return "ImageQuerySizeLod"; + return SkString("ImageQuerySizeLod"); case SpvOpImageQuerySize: - return "ImageQuerySize"; + return SkString("ImageQuerySize"); case SpvOpImageQueryLod: - return "ImageQueryLod"; + return SkString("ImageQueryLod"); case SpvOpImageQueryLevels: - return "ImageQueryLevels"; + return SkString("ImageQueryLevels"); case SpvOpImageQuerySamples: - return "ImageQuerySamples"; + return SkString("ImageQuerySamples"); case SpvOpConvertFToU: - return "ConvertFToU"; + return SkString("ConvertFToU"); case SpvOpConvertFToS: - return "ConvertFToS"; + return SkString("ConvertFToS"); case SpvOpConvertSToF: - return "ConvertSToF"; + return SkString("ConvertSToF"); case SpvOpConvertUToF: - return "ConvertUToF"; + return SkString("ConvertUToF"); case SpvOpUConvert: - return "UConvert"; + return SkString("UConvert"); case SpvOpSConvert: - return "SConvert"; + return SkString("SConvert"); case SpvOpFConvert: - return "FConvert"; + return SkString("FConvert"); case SpvOpQuantizeToF16: - return "QuantizeToF16"; + return SkString("QuantizeToF16"); case SpvOpConvertPtrToU: - return "ConvertPtrToU"; + return SkString("ConvertPtrToU"); case SpvOpSatConvertSToU: - return "SatConvertSToU"; + return SkString("SatConvertSToU"); case SpvOpSatConvertUToS: - return "SatConvertUToS"; + return SkString("SatConvertUToS"); case SpvOpConvertUToPtr: - return "ConvertUToPtr"; + return SkString("ConvertUToPtr"); case SpvOpPtrCastToGeneric: - return "PtrCastToGeneric"; + return SkString("PtrCastToGeneric"); case SpvOpGenericCastToPtr: - return "GenericCastToPtr"; + return SkString("GenericCastToPtr"); case SpvOpGenericCastToPtrExplicit: - return "GenericCastToPtrExplicit"; + return SkString("GenericCastToPtrExplicit"); case SpvOpBitcast: - return "Bitcast"; + return SkString("Bitcast"); case SpvOpSNegate: - return "SNegate"; + return SkString("SNegate"); case SpvOpFNegate: - return "FNegate"; + return SkString("FNegate"); case SpvOpIAdd: - return "IAdd"; + return SkString("IAdd"); case SpvOpFAdd: - return "FAdd"; + return SkString("FAdd"); case SpvOpISub: - return "ISub"; + return SkString("ISub"); case SpvOpFSub: - return "FSub"; + return SkString("FSub"); case SpvOpIMul: - return "IMul"; + return SkString("IMul"); case SpvOpFMul: - return "FMul"; + return SkString("FMul"); case SpvOpUDiv: - return "UDiv"; + return SkString("UDiv"); case SpvOpSDiv: - return "SDiv"; + return SkString("SDiv"); case SpvOpFDiv: - return "FDiv"; + return SkString("FDiv"); case SpvOpUMod: - return "UMod"; + return SkString("UMod"); case SpvOpSRem: - return "SRem"; + return SkString("SRem"); case SpvOpSMod: - return "SMod"; + return SkString("SMod"); case SpvOpFRem: - return "FRem"; + return SkString("FRem"); case SpvOpFMod: - return "FMod"; + return SkString("FMod"); case SpvOpVectorTimesScalar: - return "VectorTimesScalar"; + return SkString("VectorTimesScalar"); case SpvOpMatrixTimesScalar: - return "MatrixTimesScalar"; + return SkString("MatrixTimesScalar"); case SpvOpVectorTimesMatrix: - return "VectorTimesMatrix"; + return SkString("VectorTimesMatrix"); case SpvOpMatrixTimesVector: - return "MatrixTimesVector"; + return SkString("MatrixTimesVector"); case SpvOpMatrixTimesMatrix: - return "MatrixTimesMatrix"; + return SkString("MatrixTimesMatrix"); case SpvOpOuterProduct: - return "OuterProduct"; + return SkString("OuterProduct"); case SpvOpDot: - return "Dot"; + return SkString("Dot"); case SpvOpIAddCarry: - return "IAddCarry"; + return SkString("IAddCarry"); case SpvOpISubBorrow: - return "ISubBorrow"; + return SkString("ISubBorrow"); case SpvOpUMulExtended: - return "UMulExtended"; + return SkString("UMulExtended"); case SpvOpSMulExtended: - return "SMulExtended"; + return SkString("SMulExtended"); case SpvOpAny: - return "Any"; + return SkString("Any"); case SpvOpAll: - return "All"; + return SkString("All"); case SpvOpIsNan: - return "IsNan"; + return SkString("IsNan"); case SpvOpIsInf: - return "IsInf"; + return SkString("IsInf"); case SpvOpIsFinite: - return "IsFinite"; + return SkString("IsFinite"); case SpvOpIsNormal: - return "IsNormal"; + return SkString("IsNormal"); case SpvOpSignBitSet: - return "SignBitSet"; + return SkString("SignBitSet"); case SpvOpLessOrGreater: - return "LessOrGreater"; + return SkString("LessOrGreater"); case SpvOpOrdered: - return "Ordered"; + return SkString("Ordered"); case SpvOpUnordered: - return "Unordered"; + return SkString("Unordered"); case SpvOpLogicalEqual: - return "LogicalEqual"; + return SkString("LogicalEqual"); case SpvOpLogicalNotEqual: - return "LogicalNotEqual"; + return SkString("LogicalNotEqual"); case SpvOpLogicalOr: - return "LogicalOr"; + return SkString("LogicalOr"); case SpvOpLogicalAnd: - return "LogicalAnd"; + return SkString("LogicalAnd"); case SpvOpLogicalNot: - return "LogicalNot"; + return SkString("LogicalNot"); case SpvOpSelect: - return "Select"; + return SkString("Select"); case SpvOpIEqual: - return "IEqual"; + return SkString("IEqual"); case SpvOpINotEqual: - return "INotEqual"; + return SkString("INotEqual"); case SpvOpUGreaterThan: - return "UGreaterThan"; + return SkString("UGreaterThan"); case SpvOpSGreaterThan: - return "SGreaterThan"; + return SkString("SGreaterThan"); case SpvOpUGreaterThanEqual: - return "UGreaterThanEqual"; + return SkString("UGreaterThanEqual"); case SpvOpSGreaterThanEqual: - return "SGreaterThanEqual"; + return SkString("SGreaterThanEqual"); case SpvOpULessThan: - return "ULessThan"; + return SkString("ULessThan"); case SpvOpSLessThan: - return "SLessThan"; + return SkString("SLessThan"); case SpvOpULessThanEqual: - return "ULessThanEqual"; + return SkString("ULessThanEqual"); case SpvOpSLessThanEqual: - return "SLessThanEqual"; + return SkString("SLessThanEqual"); case SpvOpFOrdEqual: - return "FOrdEqual"; + return SkString("FOrdEqual"); case SpvOpFUnordEqual: - return "FUnordEqual"; + return SkString("FUnordEqual"); case SpvOpFOrdNotEqual: - return "FOrdNotEqual"; + return SkString("FOrdNotEqual"); case SpvOpFUnordNotEqual: - return "FUnordNotEqual"; + return SkString("FUnordNotEqual"); case SpvOpFOrdLessThan: - return "FOrdLessThan"; + return SkString("FOrdLessThan"); case SpvOpFUnordLessThan: - return "FUnordLessThan"; + return SkString("FUnordLessThan"); case SpvOpFOrdGreaterThan: - return "FOrdGreaterThan"; + return SkString("FOrdGreaterThan"); case SpvOpFUnordGreaterThan: - return "FUnordGreaterThan"; + return SkString("FUnordGreaterThan"); case SpvOpFOrdLessThanEqual: - return "FOrdLessThanEqual"; + return SkString("FOrdLessThanEqual"); case SpvOpFUnordLessThanEqual: - return "FUnordLessThanEqual"; + return SkString("FUnordLessThanEqual"); case SpvOpFOrdGreaterThanEqual: - return "FOrdGreaterThanEqual"; + return SkString("FOrdGreaterThanEqual"); case SpvOpFUnordGreaterThanEqual: - return "FUnordGreaterThanEqual"; + return SkString("FUnordGreaterThanEqual"); case SpvOpShiftRightLogical: - return "ShiftRightLogical"; + return SkString("ShiftRightLogical"); case SpvOpShiftRightArithmetic: - return "ShiftRightArithmetic"; + return SkString("ShiftRightArithmetic"); case SpvOpShiftLeftLogical: - return "ShiftLeftLogical"; + return SkString("ShiftLeftLogical"); case SpvOpBitwiseOr: - return "BitwiseOr"; + return SkString("BitwiseOr"); case SpvOpBitwiseXor: - return "BitwiseXor"; + return SkString("BitwiseXor"); case SpvOpBitwiseAnd: - return "BitwiseAnd"; + return SkString("BitwiseAnd"); case SpvOpNot: - return "Not"; + return SkString("Not"); case SpvOpBitFieldInsert: - return "BitFieldInsert"; + return SkString("BitFieldInsert"); case SpvOpBitFieldSExtract: - return "BitFieldSExtract"; + return SkString("BitFieldSExtract"); case SpvOpBitFieldUExtract: - return "BitFieldUExtract"; + return SkString("BitFieldUExtract"); case SpvOpBitReverse: - return "BitReverse"; + return SkString("BitReverse"); case SpvOpBitCount: - return "BitCount"; + return SkString("BitCount"); case SpvOpDPdx: - return "DPdx"; + return SkString("DPdx"); case SpvOpDPdy: - return "DPdy"; + return SkString("DPdy"); case SpvOpFwidth: - return "Fwidth"; + return SkString("Fwidth"); case SpvOpDPdxFine: - return "DPdxFine"; + return SkString("DPdxFine"); case SpvOpDPdyFine: - return "DPdyFine"; + return SkString("DPdyFine"); case SpvOpFwidthFine: - return "FwidthFine"; + return SkString("FwidthFine"); case SpvOpDPdxCoarse: - return "DPdxCoarse"; + return SkString("DPdxCoarse"); case SpvOpDPdyCoarse: - return "DPdyCoarse"; + return SkString("DPdyCoarse"); case SpvOpFwidthCoarse: - return "FwidthCoarse"; + return SkString("FwidthCoarse"); case SpvOpEmitVertex: - return "EmitVertex"; + return SkString("EmitVertex"); case SpvOpEndPrimitive: - return "EndPrimitive"; + return SkString("EndPrimitive"); case SpvOpEmitStreamVertex: - return "EmitStreamVertex"; + return SkString("EmitStreamVertex"); case SpvOpEndStreamPrimitive: - return "EndStreamPrimitive"; + return SkString("EndStreamPrimitive"); case SpvOpControlBarrier: - return "ControlBarrier"; + return SkString("ControlBarrier"); case SpvOpMemoryBarrier: - return "MemoryBarrier"; + return SkString("MemoryBarrier"); case SpvOpAtomicLoad: - return "AtomicLoad"; + return SkString("AtomicLoad"); case SpvOpAtomicStore: - return "AtomicStore"; + return SkString("AtomicStore"); case SpvOpAtomicExchange: - return "AtomicExchange"; + return SkString("AtomicExchange"); case SpvOpAtomicCompareExchange: - return "AtomicCompareExchange"; + return SkString("AtomicCompareExchange"); case SpvOpAtomicCompareExchangeWeak: - return "AtomicCompareExchangeWeak"; + return SkString("AtomicCompareExchangeWeak"); case SpvOpAtomicIIncrement: - return "AtomicIIncrement"; + return SkString("AtomicIIncrement"); case SpvOpAtomicIDecrement: - return "AtomicIDecrement"; + return SkString("AtomicIDecrement"); case SpvOpAtomicIAdd: - return "AtomicIAdd"; + return SkString("AtomicIAdd"); case SpvOpAtomicISub: - return "AtomicISub"; + return SkString("AtomicISub"); case SpvOpAtomicSMin: - return "AtomicSMin"; + return SkString("AtomicSMin"); case SpvOpAtomicUMin: - return "AtomicUMin"; + return SkString("AtomicUMin"); case SpvOpAtomicSMax: - return "AtomicSMax"; + return SkString("AtomicSMax"); case SpvOpAtomicUMax: - return "AtomicUMax"; + return SkString("AtomicUMax"); case SpvOpAtomicAnd: - return "AtomicAnd"; + return SkString("AtomicAnd"); case SpvOpAtomicOr: - return "AtomicOr"; + return SkString("AtomicOr"); case SpvOpAtomicXor: - return "AtomicXor"; + return SkString("AtomicXor"); case SpvOpPhi: - return "Phi"; + return SkString("Phi"); case SpvOpLoopMerge: - return "LoopMerge"; + return SkString("LoopMerge"); case SpvOpSelectionMerge: - return "SelectionMerge"; + return SkString("SelectionMerge"); case SpvOpLabel: - return "Label"; + return SkString("Label"); case SpvOpBranch: - return "Branch"; + return SkString("Branch"); case SpvOpBranchConditional: - return "BranchConditional"; + return SkString("BranchConditional"); case SpvOpSwitch: - return "Switch"; + return SkString("Switch"); case SpvOpKill: - return "Kill"; + return SkString("Kill"); case SpvOpReturn: - return "Return"; + return SkString("Return"); case SpvOpReturnValue: - return "ReturnValue"; + return SkString("ReturnValue"); case SpvOpUnreachable: - return "Unreachable"; + return SkString("Unreachable"); case SpvOpLifetimeStart: - return "LifetimeStart"; + return SkString("LifetimeStart"); case SpvOpLifetimeStop: - return "LifetimeStop"; + return SkString("LifetimeStop"); case SpvOpGroupAsyncCopy: - return "GroupAsyncCopy"; + return SkString("GroupAsyncCopy"); case SpvOpGroupWaitEvents: - return "GroupWaitEvents"; + return SkString("GroupWaitEvents"); case SpvOpGroupAll: - return "GroupAll"; + return SkString("GroupAll"); case SpvOpGroupAny: - return "GroupAny"; + return SkString("GroupAny"); case SpvOpGroupBroadcast: - return "GroupBroadcast"; + return SkString("GroupBroadcast"); case SpvOpGroupIAdd: - return "GroupIAdd"; + return SkString("GroupIAdd"); case SpvOpGroupFAdd: - return "GroupFAdd"; + return SkString("GroupFAdd"); case SpvOpGroupFMin: - return "GroupFMin"; + return SkString("GroupFMin"); case SpvOpGroupUMin: - return "GroupUMin"; + return SkString("GroupUMin"); case SpvOpGroupSMin: - return "GroupSMin"; + return SkString("GroupSMin"); case SpvOpGroupFMax: - return "GroupFMax"; + return SkString("GroupFMax"); case SpvOpGroupUMax: - return "GroupUMax"; + return SkString("GroupUMax"); case SpvOpGroupSMax: - return "GroupSMax"; + return SkString("GroupSMax"); case SpvOpReadPipe: - return "ReadPipe"; + return SkString("ReadPipe"); case SpvOpWritePipe: - return "WritePipe"; + return SkString("WritePipe"); case SpvOpReservedReadPipe: - return "ReservedReadPipe"; + return SkString("ReservedReadPipe"); case SpvOpReservedWritePipe: - return "ReservedWritePipe"; + return SkString("ReservedWritePipe"); case SpvOpReserveReadPipePackets: - return "ReserveReadPipePackets"; + return SkString("ReserveReadPipePackets"); case SpvOpReserveWritePipePackets: - return "ReserveWritePipePackets"; + return SkString("ReserveWritePipePackets"); case SpvOpCommitReadPipe: - return "CommitReadPipe"; + return SkString("CommitReadPipe"); case SpvOpCommitWritePipe: - return "CommitWritePipe"; + return SkString("CommitWritePipe"); case SpvOpIsValidReserveId: - return "IsValidReserveId"; + return SkString("IsValidReserveId"); case SpvOpGetNumPipePackets: - return "GetNumPipePackets"; + return SkString("GetNumPipePackets"); case SpvOpGetMaxPipePackets: - return "GetMaxPipePackets"; + return SkString("GetMaxPipePackets"); case SpvOpGroupReserveReadPipePackets: - return "GroupReserveReadPipePackets"; + return SkString("GroupReserveReadPipePackets"); case SpvOpGroupReserveWritePipePackets: - return "GroupReserveWritePipePackets"; + return SkString("GroupReserveWritePipePackets"); case SpvOpGroupCommitReadPipe: - return "GroupCommitReadPipe"; + return SkString("GroupCommitReadPipe"); case SpvOpGroupCommitWritePipe: - return "GroupCommitWritePipe"; + return SkString("GroupCommitWritePipe"); case SpvOpEnqueueMarker: - return "EnqueueMarker"; + return SkString("EnqueueMarker"); case SpvOpEnqueueKernel: - return "EnqueueKernel"; + return SkString("EnqueueKernel"); case SpvOpGetKernelNDrangeSubGroupCount: - return "GetKernelNDrangeSubGroupCount"; + return SkString("GetKernelNDrangeSubGroupCount"); case SpvOpGetKernelNDrangeMaxSubGroupSize: - return "GetKernelNDrangeMaxSubGroupSize"; + return SkString("GetKernelNDrangeMaxSubGroupSize"); case SpvOpGetKernelWorkGroupSize: - return "GetKernelWorkGroupSize"; + return SkString("GetKernelWorkGroupSize"); case SpvOpGetKernelPreferredWorkGroupSizeMultiple: - return "GetKernelPreferredWorkGroupSizeMultiple"; + return SkString("GetKernelPreferredWorkGroupSizeMultiple"); case SpvOpRetainEvent: - return "RetainEvent"; + return SkString("RetainEvent"); case SpvOpReleaseEvent: - return "ReleaseEvent"; + return SkString("ReleaseEvent"); case SpvOpCreateUserEvent: - return "CreateUserEvent"; + return SkString("CreateUserEvent"); case SpvOpIsValidEvent: - return "IsValidEvent"; + return SkString("IsValidEvent"); case SpvOpSetUserEventStatus: - return "SetUserEventStatus"; + return SkString("SetUserEventStatus"); case SpvOpCaptureEventProfilingInfo: - return "CaptureEventProfilingInfo"; + return SkString("CaptureEventProfilingInfo"); case SpvOpGetDefaultQueue: - return "GetDefaultQueue"; + return SkString("GetDefaultQueue"); case SpvOpBuildNDRange: - return "BuildNDRange"; + return SkString("BuildNDRange"); case SpvOpImageSparseSampleImplicitLod: - return "ImageSparseSampleImplicitLod"; + return SkString("ImageSparseSampleImplicitLod"); case SpvOpImageSparseSampleExplicitLod: - return "ImageSparseSampleExplicitLod"; + return SkString("ImageSparseSampleExplicitLod"); case SpvOpImageSparseSampleDrefImplicitLod: - return "ImageSparseSampleDrefImplicitLod"; + return SkString("ImageSparseSampleDrefImplicitLod"); case SpvOpImageSparseSampleDrefExplicitLod: - return "ImageSparseSampleDrefExplicitLod"; + return SkString("ImageSparseSampleDrefExplicitLod"); case SpvOpImageSparseSampleProjImplicitLod: - return "ImageSparseSampleProjImplicitLod"; + return SkString("ImageSparseSampleProjImplicitLod"); case SpvOpImageSparseSampleProjExplicitLod: - return "ImageSparseSampleProjExplicitLod"; + return SkString("ImageSparseSampleProjExplicitLod"); case SpvOpImageSparseSampleProjDrefImplicitLod: - return "ImageSparseSampleProjDrefImplicitLod"; + return SkString("ImageSparseSampleProjDrefImplicitLod"); case SpvOpImageSparseSampleProjDrefExplicitLod: - return "ImageSparseSampleProjDrefExplicitLod"; + return SkString("ImageSparseSampleProjDrefExplicitLod"); case SpvOpImageSparseFetch: - return "ImageSparseFetch"; + return SkString("ImageSparseFetch"); case SpvOpImageSparseGather: - return "ImageSparseGather"; + return SkString("ImageSparseGather"); case SpvOpImageSparseDrefGather: - return "ImageSparseDrefGather"; + return SkString("ImageSparseDrefGather"); case SpvOpImageSparseTexelsResident: - return "ImageSparseTexelsResident"; + return SkString("ImageSparseTexelsResident"); case SpvOpNoLine: - return "NoLine"; + return SkString("NoLine"); case SpvOpAtomicFlagTestAndSet: - return "AtomicFlagTestAndSet"; + return SkString("AtomicFlagTestAndSet"); case SpvOpAtomicFlagClear: - return "AtomicFlagClear"; + return SkString("AtomicFlagClear"); case SpvOpImageSparseRead: - return "ImageSparseRead"; + return SkString("ImageSparseRead"); default: ABORT("unsupported SPIR-V op"); } } #endif -void SPIRVCodeGenerator::writeOpCode(SpvOp_ opCode, int length, std::ostream& out) { +void SPIRVCodeGenerator::writeOpCode(SpvOp_ opCode, int length, SkWStream& out) { ASSERT(opCode != SpvOpUndef); switch (opCode) { case SpvOpReturn: // fall through @@ -825,39 +830,39 @@ void SPIRVCodeGenerator::writeOpCode(SpvOp_ opCode, int length, std::ostream& ou #endif } -void SPIRVCodeGenerator::writeLabel(SpvId label, std::ostream& out) { +void SPIRVCodeGenerator::writeLabel(SpvId label, SkWStream& out) { fCurrentBlock = label; this->writeInstruction(SpvOpLabel, label, out); } -void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, std::ostream& out) { +void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, SkWStream& out) { this->writeOpCode(opCode, 1, out); } -void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, std::ostream& out) { +void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, SkWStream& out) { this->writeOpCode(opCode, 2, out); this->writeWord(word1, out); } -void SPIRVCodeGenerator::writeString(const char* string, std::ostream& out) { +void SPIRVCodeGenerator::writeString(const char* string, SkWStream& out) { size_t length = strlen(string); - out << string; + out.writeText(string); switch (length % 4) { case 1: - out << (char) 0; + out.write8(0); // fall through case 2: - out << (char) 0; + out.write8(0); // fall through case 3: - out << (char) 0; + out.write8(0); break; default: this->writeWord(0, out); } } -void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, const char* string, std::ostream& out) { +void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, const char* string, SkWStream& out) { int32_t length = (int32_t) strlen(string); this->writeOpCode(opCode, 1 + (length + 4) / 4, out); this->writeString(string, out); @@ -865,7 +870,7 @@ void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, const char* string, std void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, const char* string, - std::ostream& out) { + SkWStream& out) { int32_t length = (int32_t) strlen(string); this->writeOpCode(opCode, 2 + (length + 4) / 4, out); this->writeWord(word1, out); @@ -873,7 +878,7 @@ void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, const ch } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, - const char* string, std::ostream& out) { + const char* string, SkWStream& out) { int32_t length = (int32_t) strlen(string); this->writeOpCode(opCode, 3 + (length + 4) / 4, out); this->writeWord(word1, out); @@ -882,14 +887,14 @@ void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, - std::ostream& out) { + SkWStream& out) { this->writeOpCode(opCode, 3, out); this->writeWord(word1, out); this->writeWord(word2, out); } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, - int32_t word3, std::ostream& out) { + int32_t word3, SkWStream& out) { this->writeOpCode(opCode, 4, out); this->writeWord(word1, out); this->writeWord(word2, out); @@ -897,7 +902,7 @@ void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t } void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, - int32_t word3, int32_t word4, std::ostream& out) { + int32_t word3, int32_t word4, SkWStream& out) { this->writeOpCode(opCode, 5, out); this->writeWord(word1, out); this->writeWord(word2, out); @@ -907,7 +912,7 @@ void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, int32_t word4, int32_t word5, - std::ostream& out) { + SkWStream& out) { this->writeOpCode(opCode, 6, out); this->writeWord(word1, out); this->writeWord(word2, out); @@ -918,7 +923,7 @@ void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t word2, int32_t word3, int32_t word4, int32_t word5, - int32_t word6, std::ostream& out) { + int32_t word6, SkWStream& out) { this->writeOpCode(opCode, 7, out); this->writeWord(word1, out); this->writeWord(word2, out); @@ -930,7 +935,7 @@ void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t void SPIRVCodeGenerator::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) { + int32_t word6, int32_t word7, SkWStream& out) { this->writeOpCode(opCode, 8, out); this->writeWord(word1, out); this->writeWord(word2, out); @@ -944,7 +949,7 @@ void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t void SPIRVCodeGenerator::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) { + SkWStream& out) { this->writeOpCode(opCode, 9, out); this->writeWord(word1, out); this->writeWord(word2, out); @@ -956,7 +961,7 @@ void SPIRVCodeGenerator::writeInstruction(SpvOp_ opCode, int32_t word1, int32_t this->writeWord(word8, out); } -void SPIRVCodeGenerator::writeCapabilities(std::ostream& out) { +void SPIRVCodeGenerator::writeCapabilities(SkWStream& out) { for (uint64_t i = 0, bit = 1; i <= kLast_Capability; i++, bit <<= 1) { if (fCapabilities & bit) { this->writeInstruction(SpvOpCapability, (SpvId) i, out); @@ -1007,7 +1012,6 @@ void SPIRVCodeGenerator::writeStruct(const Type& type, SpvId resultId) { if ((kind == Type::kArray_Kind || kind == Type::kStruct_Kind) && offset % alignment != 0) { offset += alignment - offset % alignment; } - ASSERT(offset % alignment == 0); } } @@ -1082,8 +1086,8 @@ SpvId SPIRVCodeGenerator::getType(const Type& type) { } SpvId SPIRVCodeGenerator::getFunctionType(const FunctionDeclaration& function) { - std::string key = function.fReturnType.description() + "("; - std::string separator = ""; + SkString key = function.fReturnType.description() + "("; + SkString separator; for (size_t i = 0; i < function.fParameters.size(); i++) { key += separator; separator = ", "; @@ -1140,7 +1144,7 @@ SpvId SPIRVCodeGenerator::getFunctionType(const FunctionDeclaration& function) { SpvId SPIRVCodeGenerator::getPointerType(const Type& type, SpvStorageClass_ storageClass) { - std::string key = type.description() + "*" + to_string(storageClass); + SkString key = type.description() + "*" + to_string(storageClass); auto entry = fTypeMap.find(key); if (entry == fTypeMap.end()) { SpvId result = this->nextId(); @@ -1152,7 +1156,7 @@ SpvId SPIRVCodeGenerator::getPointerType(const Type& type, return entry->second; } -SpvId SPIRVCodeGenerator::writeExpression(const Expression& expr, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeExpression(const Expression& expr, SkWStream& out) { switch (expr.fKind) { case Expression::kBinary_Kind: return this->writeBinaryExpression((BinaryExpression&) expr, out); @@ -1186,7 +1190,7 @@ SpvId SPIRVCodeGenerator::writeExpression(const Expression& expr, std::ostream& return -1; } -SpvId SPIRVCodeGenerator::writeIntrinsicCall(const FunctionCall& c, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeIntrinsicCall(const FunctionCall& c, SkWStream& out) { auto intrinsic = fIntrinsicMap.find(c.fFunction.fName); ASSERT(intrinsic != fIntrinsicMap.end()); const Type& type = c.fArguments[0]->fType; @@ -1242,7 +1246,7 @@ SpvId SPIRVCodeGenerator::writeIntrinsicCall(const FunctionCall& c, std::ostream } SpvId SPIRVCodeGenerator::writeSpecialIntrinsic(const FunctionCall& c, SpecialIntrinsic kind, - std::ostream& out) { + SkWStream& out) { SpvId result = this->nextId(); switch (kind) { case kAtan_SpecialIntrinsic: { @@ -1306,7 +1310,7 @@ SpvId SPIRVCodeGenerator::writeSpecialIntrinsic(const FunctionCall& c, SpecialIn return result; } -SpvId SPIRVCodeGenerator::writeFunctionCall(const FunctionCall& c, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeFunctionCall(const FunctionCall& c, SkWStream& out) { const auto& entry = fFunctionMap.find(&c.fFunction); if (entry == fFunctionMap.end()) { return this->writeIntrinsicCall(c, out); @@ -1395,7 +1399,7 @@ SpvId SPIRVCodeGenerator::writeConstantVector(const Constructor& c) { return result; } -SpvId SPIRVCodeGenerator::writeFloatConstructor(const Constructor& c, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeFloatConstructor(const Constructor& c, SkWStream& out) { ASSERT(c.fType == *fContext.fFloat_Type); ASSERT(c.fArguments.size() == 1); ASSERT(c.fArguments[0]->fType.isNumber()); @@ -1413,7 +1417,7 @@ SpvId SPIRVCodeGenerator::writeFloatConstructor(const Constructor& c, std::ostre return result; } -SpvId SPIRVCodeGenerator::writeIntConstructor(const Constructor& c, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeIntConstructor(const Constructor& c, SkWStream& out) { ASSERT(c.fType == *fContext.fInt_Type); ASSERT(c.fArguments.size() == 1); ASSERT(c.fArguments[0]->fType.isNumber()); @@ -1431,7 +1435,7 @@ SpvId SPIRVCodeGenerator::writeIntConstructor(const Constructor& c, std::ostream return result; } -SpvId SPIRVCodeGenerator::writeMatrixConstructor(const Constructor& c, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeMatrixConstructor(const Constructor& c, SkWStream& out) { ASSERT(c.fType.kind() == Type::kMatrix_Kind); // go ahead and write the arguments so we don't try to write new instructions in the middle of // an instruction @@ -1503,7 +1507,7 @@ SpvId SPIRVCodeGenerator::writeMatrixConstructor(const Constructor& c, std::ostr return result; } -SpvId SPIRVCodeGenerator::writeVectorConstructor(const Constructor& c, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeVectorConstructor(const Constructor& c, SkWStream& out) { ASSERT(c.fType.kind() == Type::kVector_Kind); if (c.isConstant()) { return this->writeConstantVector(c); @@ -1533,7 +1537,7 @@ SpvId SPIRVCodeGenerator::writeVectorConstructor(const Constructor& c, std::ostr return result; } -SpvId SPIRVCodeGenerator::writeConstructor(const Constructor& c, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeConstructor(const Constructor& c, SkWStream& out) { if (c.fType == *fContext.fFloat_Type) { return this->writeFloatConstructor(c, out); } else if (c.fType == *fContext.fInt_Type) { @@ -1574,7 +1578,7 @@ SpvStorageClass_ get_storage_class(const Expression& expr) { } } -std::vector SPIRVCodeGenerator::getAccessChain(const Expression& expr, std::ostream& out) { +std::vector SPIRVCodeGenerator::getAccessChain(const Expression& expr, SkWStream& out) { std::vector chain; switch (expr.fKind) { case Expression::kIndex_Kind: { @@ -1607,13 +1611,13 @@ public: return fPointer; } - virtual SpvId load(std::ostream& out) override { + virtual SpvId load(SkWStream& out) override { SpvId result = fGen.nextId(); fGen.writeInstruction(SpvOpLoad, fType, result, fPointer, out); return result; } - virtual void store(SpvId value, std::ostream& out) override { + virtual void store(SpvId value, SkWStream& out) override { fGen.writeInstruction(SpvOpStore, fPointer, value, out); } @@ -1637,7 +1641,7 @@ public: return 0; } - virtual SpvId load(std::ostream& out) override { + virtual SpvId load(SkWStream& out) override { SpvId base = fGen.nextId(); fGen.writeInstruction(SpvOpLoad, fGen.getType(fBaseType), base, fVecPointer, out); SpvId result = fGen.nextId(); @@ -1652,7 +1656,7 @@ public: return result; } - virtual void store(SpvId value, std::ostream& out) override { + virtual void store(SpvId value, SkWStream& out) override { // use OpVectorShuffle to mix and match the vector components. We effectively create // a virtual vector out of the concatenation of the left and right vectors, and then // select components from this virtual vector to make the result vector. For @@ -1699,7 +1703,7 @@ private: }; std::unique_ptr SPIRVCodeGenerator::getLValue(const Expression& expr, - std::ostream& out) { + SkWStream& out) { switch (expr.fKind) { case Expression::kVariableReference_Kind: { const Variable& var = ((VariableReference&) expr).fVariable; @@ -1772,7 +1776,7 @@ std::unique_ptr SPIRVCodeGenerator::getLValue(const } } -SpvId SPIRVCodeGenerator::writeVariableReference(const VariableReference& ref, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeVariableReference(const VariableReference& ref, SkWStream& out) { auto entry = fVariableMap.find(&ref.fVariable); ASSERT(entry != fVariableMap.end()); SpvId var = entry->second; @@ -1781,15 +1785,15 @@ SpvId SPIRVCodeGenerator::writeVariableReference(const VariableReference& ref, s return result; } -SpvId SPIRVCodeGenerator::writeIndexExpression(const IndexExpression& expr, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeIndexExpression(const IndexExpression& expr, SkWStream& out) { return getLValue(expr, out)->load(out); } -SpvId SPIRVCodeGenerator::writeFieldAccess(const FieldAccess& f, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeFieldAccess(const FieldAccess& f, SkWStream& out) { return getLValue(f, out)->load(out); } -SpvId SPIRVCodeGenerator::writeSwizzle(const Swizzle& swizzle, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeSwizzle(const Swizzle& swizzle, SkWStream& out) { SpvId base = this->writeExpression(*swizzle.fBase, out); SpvId result = this->nextId(); size_t count = swizzle.fComponents.size(); @@ -1812,7 +1816,7 @@ SpvId SPIRVCodeGenerator::writeSwizzle(const Swizzle& swizzle, std::ostream& out SpvId SPIRVCodeGenerator::writeBinaryOperation(const Type& resultType, const Type& operandType, SpvId lhs, SpvId rhs, SpvOp_ ifFloat, SpvOp_ ifInt, - SpvOp_ ifUInt, SpvOp_ ifBool, std::ostream& out) { + SpvOp_ ifUInt, SpvOp_ ifBool, SkWStream& out) { SpvId result = this->nextId(); if (is_float(fContext, operandType)) { this->writeInstruction(ifFloat, this->getType(resultType), result, lhs, rhs, out); @@ -1850,7 +1854,7 @@ bool is_assignment(Token::Kind op) { } } -SpvId SPIRVCodeGenerator::writeBinaryExpression(const BinaryExpression& b, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeBinaryExpression(const BinaryExpression& b, SkWStream& out) { // handle cases where we don't necessarily evaluate both LHS and RHS switch (b.fOperator) { case Token::EQ: { @@ -2042,7 +2046,7 @@ SpvId SPIRVCodeGenerator::writeBinaryExpression(const BinaryExpression& b, std:: } } -SpvId SPIRVCodeGenerator::writeLogicalAnd(const BinaryExpression& a, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeLogicalAnd(const BinaryExpression& a, SkWStream& out) { ASSERT(a.fOperator == Token::LOGICALAND); BoolLiteral falseLiteral(fContext, Position(), false); SpvId falseConstant = this->writeBoolLiteral(falseLiteral); @@ -2063,7 +2067,7 @@ SpvId SPIRVCodeGenerator::writeLogicalAnd(const BinaryExpression& a, std::ostrea return result; } -SpvId SPIRVCodeGenerator::writeLogicalOr(const BinaryExpression& o, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeLogicalOr(const BinaryExpression& o, SkWStream& out) { ASSERT(o.fOperator == Token::LOGICALOR); BoolLiteral trueLiteral(fContext, Position(), true); SpvId trueConstant = this->writeBoolLiteral(trueLiteral); @@ -2084,7 +2088,7 @@ SpvId SPIRVCodeGenerator::writeLogicalOr(const BinaryExpression& o, std::ostream return result; } -SpvId SPIRVCodeGenerator::writeTernaryExpression(const TernaryExpression& t, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeTernaryExpression(const TernaryExpression& t, SkWStream& out) { SpvId test = this->writeExpression(*t.fTest, out); if (t.fIfTrue->isConstant() && t.fIfFalse->isConstant()) { // both true and false are constants, can just use OpSelect @@ -2128,7 +2132,7 @@ std::unique_ptr create_literal_1(const Context& context, const Type& } } -SpvId SPIRVCodeGenerator::writePrefixExpression(const PrefixExpression& p, std::ostream& out) { +SpvId SPIRVCodeGenerator::writePrefixExpression(const PrefixExpression& p, SkWStream& out) { if (p.fOperator == Token::MINUS) { SpvId result = this->nextId(); SpvId typeId = this->getType(p.fType); @@ -2181,7 +2185,7 @@ SpvId SPIRVCodeGenerator::writePrefixExpression(const PrefixExpression& p, std:: } } -SpvId SPIRVCodeGenerator::writePostfixExpression(const PostfixExpression& p, std::ostream& out) { +SpvId SPIRVCodeGenerator::writePostfixExpression(const PostfixExpression& p, SkWStream& out) { std::unique_ptr lv = this->getLValue(*p.fOperand, out); SpvId result = lv->load(out); SpvId one = this->writeExpression(*create_literal_1(fContext, p.fType), out); @@ -2278,7 +2282,7 @@ SpvId SPIRVCodeGenerator::writeFloatLiteral(const FloatLiteral& f) { } } -SpvId SPIRVCodeGenerator::writeFunctionStart(const FunctionDeclaration& f, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeFunctionStart(const FunctionDeclaration& f, SkWStream& out) { SpvId result = fFunctionMap[&f]; this->writeInstruction(SpvOpFunction, this->getType(f.fReturnType), result, SpvFunctionControlMaskNone, this->getFunctionType(f), out); @@ -2293,17 +2297,16 @@ SpvId SPIRVCodeGenerator::writeFunctionStart(const FunctionDeclaration& f, std:: return result; } -SpvId SPIRVCodeGenerator::writeFunction(const FunctionDefinition& f, std::ostream& out) { +SpvId SPIRVCodeGenerator::writeFunction(const FunctionDefinition& f, SkWStream& out) { SpvId result = this->writeFunctionStart(f.fDeclaration, out); this->writeLabel(this->nextId(), out); if (f.fDeclaration.fName == "main") { - out << fGlobalInitializersBuffer.str(); + write_data(*fGlobalInitializersBuffer.detachAsData(), out); } - std::stringstream bodyBuffer; + SkDynamicMemoryWStream bodyBuffer; this->writeBlock(*f.fBody, bodyBuffer); - out << fVariableBuffer.str(); - fVariableBuffer.str(""); - out << bodyBuffer.str(); + write_data(*fVariableBuffer.detachAsData(), out); + write_data(*bodyBuffer.detachAsData(), out); if (fCurrentBlock) { this->writeInstruction(SpvOpReturn, out); } @@ -2372,7 +2375,7 @@ SpvId SPIRVCodeGenerator::writeInterfaceBlock(const InterfaceBlock& intf) { #define BUILTIN_IGNORE 9999 void SPIRVCodeGenerator::writeGlobalVars(Program::Kind kind, const VarDeclarations& decl, - std::ostream& out) { + SkWStream& out) { for (size_t i = 0; i < decl.fVars.size(); i++) { const VarDeclaration& varDecl = decl.fVars[i]; const Variable* var = varDecl.fVar; @@ -2427,7 +2430,7 @@ void SPIRVCodeGenerator::writeGlobalVars(Program::Kind kind, const VarDeclaratio } } -void SPIRVCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, std::ostream& out) { +void SPIRVCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, SkWStream& out) { for (const auto& varDecl : decl.fVars) { const Variable* var = varDecl.fVar; SpvId id = this->nextId(); @@ -2442,7 +2445,7 @@ void SPIRVCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, std:: } } -void SPIRVCodeGenerator::writeStatement(const Statement& s, std::ostream& out) { +void SPIRVCodeGenerator::writeStatement(const Statement& s, SkWStream& out) { switch (s.fKind) { case Statement::kBlock_Kind: this->writeBlock((Block&) s, out); @@ -2476,13 +2479,13 @@ void SPIRVCodeGenerator::writeStatement(const Statement& s, std::ostream& out) { } } -void SPIRVCodeGenerator::writeBlock(const Block& b, std::ostream& out) { +void SPIRVCodeGenerator::writeBlock(const Block& b, SkWStream& out) { for (size_t i = 0; i < b.fStatements.size(); i++) { this->writeStatement(*b.fStatements[i], out); } } -void SPIRVCodeGenerator::writeIfStatement(const IfStatement& stmt, std::ostream& out) { +void SPIRVCodeGenerator::writeIfStatement(const IfStatement& stmt, SkWStream& out) { SpvId test = this->writeExpression(*stmt.fTest, out); SpvId ifTrue = this->nextId(); SpvId ifFalse = this->nextId(); @@ -2513,7 +2516,7 @@ void SPIRVCodeGenerator::writeIfStatement(const IfStatement& stmt, std::ostream& } } -void SPIRVCodeGenerator::writeForStatement(const ForStatement& f, std::ostream& out) { +void SPIRVCodeGenerator::writeForStatement(const ForStatement& f, SkWStream& out) { if (f.fInitializer) { this->writeStatement(*f.fInitializer, out); } @@ -2548,7 +2551,7 @@ void SPIRVCodeGenerator::writeForStatement(const ForStatement& f, std::ostream& fContinueTarget.pop(); } -void SPIRVCodeGenerator::writeReturnStatement(const ReturnStatement& r, std::ostream& out) { +void SPIRVCodeGenerator::writeReturnStatement(const ReturnStatement& r, SkWStream& out) { if (r.fExpression) { this->writeInstruction(SpvOpReturnValue, this->writeExpression(*r.fExpression, out), out); @@ -2557,9 +2560,9 @@ void SPIRVCodeGenerator::writeReturnStatement(const ReturnStatement& r, std::ost } } -void SPIRVCodeGenerator::writeInstructions(const Program& program, std::ostream& out) { +void SPIRVCodeGenerator::writeInstructions(const Program& program, SkWStream& out) { fGLSLExtendedInstructions = this->nextId(); - std::stringstream body; + SkDynamicMemoryWStream body; std::vector interfaceVars; // assign IDs to functions for (size_t i = 0; i < program.fElements.size(); i++) { @@ -2636,22 +2639,22 @@ void SPIRVCodeGenerator::writeInstructions(const Program& program, std::ostream& } } - out << fNameBuffer.str(); - out << fDecorationBuffer.str(); - out << fConstantBuffer.str(); - out << fExternalFunctionsBuffer.str(); - out << body.str(); + write_data(*fNameBuffer.detachAsData(), out); + write_data(*fDecorationBuffer.detachAsData(), out); + write_data(*fConstantBuffer.detachAsData(), out); + write_data(*fExternalFunctionsBuffer.detachAsData(), out); + write_data(*body.detachAsData(), out); } -void SPIRVCodeGenerator::generateCode(const Program& program, std::ostream& out) { +void SPIRVCodeGenerator::generateCode(const Program& program, SkWStream& out) { this->writeWord(SpvMagicNumber, out); this->writeWord(SpvVersion, out); this->writeWord(SKSL_MAGIC, out); - std::stringstream buffer; + SkDynamicMemoryWStream buffer; this->writeInstructions(program, buffer); this->writeWord(fIdCount, out); this->writeWord(0, out); // reserved, always zero - out << buffer.str(); + write_data(*buffer.detachAsData(), out); } } -- cgit v1.2.3