ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2016 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
Mike Klein | 6ad9909 | 2016-10-26 10:35:22 -0400 | [diff] [blame] | 7 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "src/sksl/SkSLCompiler.h" |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 9 | |
John Stiles | fbd050b | 2020-08-03 13:21:46 -0400 | [diff] [blame] | 10 | #include <memory> |
John Stiles | b8e010c | 2020-08-11 18:05:39 -0400 | [diff] [blame] | 11 | #include <unordered_set> |
John Stiles | fbd050b | 2020-08-03 13:21:46 -0400 | [diff] [blame] | 12 | |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 13 | #include "src/sksl/SkSLAnalysis.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 14 | #include "src/sksl/SkSLByteCodeGenerator.h" |
| 15 | #include "src/sksl/SkSLCFGGenerator.h" |
| 16 | #include "src/sksl/SkSLCPPCodeGenerator.h" |
| 17 | #include "src/sksl/SkSLGLSLCodeGenerator.h" |
| 18 | #include "src/sksl/SkSLHCodeGenerator.h" |
| 19 | #include "src/sksl/SkSLIRGenerator.h" |
| 20 | #include "src/sksl/SkSLMetalCodeGenerator.h" |
| 21 | #include "src/sksl/SkSLPipelineStageCodeGenerator.h" |
Ethan Nicholas | c18bb51 | 2020-07-28 14:46:53 -0400 | [diff] [blame] | 22 | #include "src/sksl/SkSLRehydrator.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 23 | #include "src/sksl/SkSLSPIRVCodeGenerator.h" |
Brian Osman | c024391 | 2020-02-19 15:35:26 -0500 | [diff] [blame] | 24 | #include "src/sksl/SkSLSPIRVtoHLSL.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 25 | #include "src/sksl/ir/SkSLEnum.h" |
| 26 | #include "src/sksl/ir/SkSLExpression.h" |
| 27 | #include "src/sksl/ir/SkSLExpressionStatement.h" |
| 28 | #include "src/sksl/ir/SkSLFunctionCall.h" |
| 29 | #include "src/sksl/ir/SkSLIntLiteral.h" |
| 30 | #include "src/sksl/ir/SkSLModifiersDeclaration.h" |
| 31 | #include "src/sksl/ir/SkSLNop.h" |
| 32 | #include "src/sksl/ir/SkSLSymbolTable.h" |
| 33 | #include "src/sksl/ir/SkSLTernaryExpression.h" |
| 34 | #include "src/sksl/ir/SkSLUnresolvedFunction.h" |
| 35 | #include "src/sksl/ir/SkSLVarDeclarations.h" |
John Stiles | e615000 | 2020-10-05 12:03:53 -0400 | [diff] [blame] | 36 | #include "src/utils/SkBitSet.h" |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 37 | |
Ethan Nicholas | b33fa3f | 2020-08-06 13:00:19 -0400 | [diff] [blame] | 38 | #include <fstream> |
| 39 | |
Ethan Nicholas | a11035b | 2019-11-26 16:27:47 -0500 | [diff] [blame] | 40 | #if !defined(SKSL_STANDALONE) & SK_SUPPORT_GPU |
| 41 | #include "include/gpu/GrContextOptions.h" |
| 42 | #include "src/gpu/GrShaderCaps.h" |
| 43 | #endif |
| 44 | |
Ethan Nicholas | a6ae1f7 | 2017-03-16 09:56:54 -0400 | [diff] [blame] | 45 | #ifdef SK_ENABLE_SPIRV_VALIDATION |
| 46 | #include "spirv-tools/libspirv.hpp" |
| 47 | #endif |
| 48 | |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 49 | #if defined(SKSL_STANDALONE) |
Ethan Nicholas | c18bb51 | 2020-07-28 14:46:53 -0400 | [diff] [blame] | 50 | |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 51 | // In standalone mode, we load the textual sksl source files. GN generates or copies these files |
| 52 | // to the skslc executable directory. The "data" in this mode is just the filename. |
| 53 | #define MODULE_DATA(name) MakeModulePath("sksl_" #name ".sksl") |
| 54 | |
| 55 | #else |
| 56 | |
| 57 | // At runtime, we load the dehydrated sksl data files. The data is a (pointer, size) pair. |
Ethan Nicholas | c18bb51 | 2020-07-28 14:46:53 -0400 | [diff] [blame] | 58 | #include "src/sksl/generated/sksl_fp.dehydrated.sksl" |
| 59 | #include "src/sksl/generated/sksl_frag.dehydrated.sksl" |
| 60 | #include "src/sksl/generated/sksl_geom.dehydrated.sksl" |
| 61 | #include "src/sksl/generated/sksl_gpu.dehydrated.sksl" |
| 62 | #include "src/sksl/generated/sksl_interp.dehydrated.sksl" |
| 63 | #include "src/sksl/generated/sksl_pipeline.dehydrated.sksl" |
| 64 | #include "src/sksl/generated/sksl_vert.dehydrated.sksl" |
| 65 | |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 66 | #define MODULE_DATA(name) MakeModuleData(SKSL_INCLUDE_sksl_##name,\ |
| 67 | SKSL_INCLUDE_sksl_##name##_LENGTH) |
Ethan Nicholas | c18bb51 | 2020-07-28 14:46:53 -0400 | [diff] [blame] | 68 | |
| 69 | #endif |
Ethan Nicholas | 0d99766 | 2019-04-08 09:46:01 -0400 | [diff] [blame] | 70 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 71 | namespace SkSL { |
| 72 | |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 73 | class AutoSource { |
| 74 | public: |
| 75 | AutoSource(Compiler* compiler, const String* source) |
| 76 | : fCompiler(compiler), fOldSource(fCompiler->fSource) { |
| 77 | fCompiler->fSource = source; |
| 78 | } |
| 79 | |
| 80 | ~AutoSource() { fCompiler->fSource = fOldSource; } |
| 81 | |
| 82 | Compiler* fCompiler; |
| 83 | const String* fOldSource; |
| 84 | }; |
| 85 | |
Ethan Nicholas | 6e1cbc0 | 2017-07-14 10:12:15 -0400 | [diff] [blame] | 86 | Compiler::Compiler(Flags flags) |
Brian Osman | 00a8b5b | 2020-10-02 09:06:04 -0400 | [diff] [blame] | 87 | : fFlags(flags) |
John Stiles | 810c8cf | 2020-08-26 19:46:27 -0400 | [diff] [blame] | 88 | , fContext(std::make_shared<Context>()) |
Ethan Nicholas | 6e1cbc0 | 2017-07-14 10:12:15 -0400 | [diff] [blame] | 89 | , fErrorCount(0) { |
Brian Osman | eac4983 | 2020-09-18 11:49:22 -0400 | [diff] [blame] | 90 | fRootSymbolTable = std::make_shared<SymbolTable>(this); |
John Stiles | 4c412bc | 2020-10-13 11:19:41 -0400 | [diff] [blame] | 91 | fIRGenerator = std::make_unique<IRGenerator>(fContext.get(), &fInliner, *this); |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 92 | #define ADD_TYPE(t) fRootSymbolTable->addWithoutOwnership(fContext->f##t##_Type.get()) |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 93 | ADD_TYPE(Void); |
| 94 | ADD_TYPE(Float); |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 95 | ADD_TYPE(Float2); |
| 96 | ADD_TYPE(Float3); |
| 97 | ADD_TYPE(Float4); |
Ethan Nicholas | dcba08e | 2017-08-02 10:52:54 -0400 | [diff] [blame] | 98 | ADD_TYPE(Half); |
| 99 | ADD_TYPE(Half2); |
| 100 | ADD_TYPE(Half3); |
| 101 | ADD_TYPE(Half4); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 102 | ADD_TYPE(Int); |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 103 | ADD_TYPE(Int2); |
| 104 | ADD_TYPE(Int3); |
| 105 | ADD_TYPE(Int4); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 106 | ADD_TYPE(UInt); |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 107 | ADD_TYPE(UInt2); |
| 108 | ADD_TYPE(UInt3); |
| 109 | ADD_TYPE(UInt4); |
Ethan Nicholas | dcba08e | 2017-08-02 10:52:54 -0400 | [diff] [blame] | 110 | ADD_TYPE(Short); |
| 111 | ADD_TYPE(Short2); |
| 112 | ADD_TYPE(Short3); |
| 113 | ADD_TYPE(Short4); |
| 114 | ADD_TYPE(UShort); |
| 115 | ADD_TYPE(UShort2); |
| 116 | ADD_TYPE(UShort3); |
| 117 | ADD_TYPE(UShort4); |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 118 | ADD_TYPE(Byte); |
| 119 | ADD_TYPE(Byte2); |
| 120 | ADD_TYPE(Byte3); |
| 121 | ADD_TYPE(Byte4); |
| 122 | ADD_TYPE(UByte); |
| 123 | ADD_TYPE(UByte2); |
| 124 | ADD_TYPE(UByte3); |
| 125 | ADD_TYPE(UByte4); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 126 | ADD_TYPE(Bool); |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 127 | ADD_TYPE(Bool2); |
| 128 | ADD_TYPE(Bool3); |
| 129 | ADD_TYPE(Bool4); |
| 130 | ADD_TYPE(Float2x2); |
| 131 | ADD_TYPE(Float2x3); |
| 132 | ADD_TYPE(Float2x4); |
| 133 | ADD_TYPE(Float3x2); |
| 134 | ADD_TYPE(Float3x3); |
| 135 | ADD_TYPE(Float3x4); |
| 136 | ADD_TYPE(Float4x2); |
| 137 | ADD_TYPE(Float4x3); |
| 138 | ADD_TYPE(Float4x4); |
Ethan Nicholas | dcba08e | 2017-08-02 10:52:54 -0400 | [diff] [blame] | 139 | ADD_TYPE(Half2x2); |
| 140 | ADD_TYPE(Half2x3); |
| 141 | ADD_TYPE(Half2x4); |
| 142 | ADD_TYPE(Half3x2); |
| 143 | ADD_TYPE(Half3x3); |
| 144 | ADD_TYPE(Half3x4); |
| 145 | ADD_TYPE(Half4x2); |
| 146 | ADD_TYPE(Half4x3); |
| 147 | ADD_TYPE(Half4x4); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 148 | ADD_TYPE(GenType); |
Ethan Nicholas | dcba08e | 2017-08-02 10:52:54 -0400 | [diff] [blame] | 149 | ADD_TYPE(GenHType); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 150 | ADD_TYPE(GenIType); |
| 151 | ADD_TYPE(GenUType); |
| 152 | ADD_TYPE(GenBType); |
| 153 | ADD_TYPE(Mat); |
| 154 | ADD_TYPE(Vec); |
| 155 | ADD_TYPE(GVec); |
| 156 | ADD_TYPE(GVec2); |
| 157 | ADD_TYPE(GVec3); |
| 158 | ADD_TYPE(GVec4); |
Ethan Nicholas | dcba08e | 2017-08-02 10:52:54 -0400 | [diff] [blame] | 159 | ADD_TYPE(HVec); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 160 | ADD_TYPE(IVec); |
| 161 | ADD_TYPE(UVec); |
Ethan Nicholas | dcba08e | 2017-08-02 10:52:54 -0400 | [diff] [blame] | 162 | ADD_TYPE(SVec); |
| 163 | ADD_TYPE(USVec); |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 164 | ADD_TYPE(ByteVec); |
| 165 | ADD_TYPE(UByteVec); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 166 | ADD_TYPE(BVec); |
| 167 | |
| 168 | ADD_TYPE(Sampler1D); |
| 169 | ADD_TYPE(Sampler2D); |
| 170 | ADD_TYPE(Sampler3D); |
ethannicholas | 5961bc9 | 2016-10-12 06:39:56 -0700 | [diff] [blame] | 171 | ADD_TYPE(SamplerExternalOES); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 172 | ADD_TYPE(SamplerCube); |
| 173 | ADD_TYPE(Sampler2DRect); |
| 174 | ADD_TYPE(Sampler1DArray); |
| 175 | ADD_TYPE(Sampler2DArray); |
| 176 | ADD_TYPE(SamplerCubeArray); |
| 177 | ADD_TYPE(SamplerBuffer); |
| 178 | ADD_TYPE(Sampler2DMS); |
| 179 | ADD_TYPE(Sampler2DMSArray); |
| 180 | |
Brian Salomon | bf7b620 | 2016-11-11 16:08:03 -0500 | [diff] [blame] | 181 | ADD_TYPE(ISampler2D); |
| 182 | |
Brian Salomon | 2a51de8 | 2016-11-16 12:06:01 -0500 | [diff] [blame] | 183 | ADD_TYPE(Image2D); |
| 184 | ADD_TYPE(IImage2D); |
| 185 | |
Greg Daniel | 64773e6 | 2016-11-22 09:44:03 -0500 | [diff] [blame] | 186 | ADD_TYPE(SubpassInput); |
| 187 | ADD_TYPE(SubpassInputMS); |
| 188 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 189 | ADD_TYPE(GSampler1D); |
| 190 | ADD_TYPE(GSampler2D); |
| 191 | ADD_TYPE(GSampler3D); |
| 192 | ADD_TYPE(GSamplerCube); |
| 193 | ADD_TYPE(GSampler2DRect); |
| 194 | ADD_TYPE(GSampler1DArray); |
| 195 | ADD_TYPE(GSampler2DArray); |
| 196 | ADD_TYPE(GSamplerCubeArray); |
| 197 | ADD_TYPE(GSamplerBuffer); |
| 198 | ADD_TYPE(GSampler2DMS); |
| 199 | ADD_TYPE(GSampler2DMSArray); |
| 200 | |
| 201 | ADD_TYPE(Sampler1DShadow); |
| 202 | ADD_TYPE(Sampler2DShadow); |
| 203 | ADD_TYPE(SamplerCubeShadow); |
| 204 | ADD_TYPE(Sampler2DRectShadow); |
| 205 | ADD_TYPE(Sampler1DArrayShadow); |
| 206 | ADD_TYPE(Sampler2DArrayShadow); |
| 207 | ADD_TYPE(SamplerCubeArrayShadow); |
| 208 | ADD_TYPE(GSampler2DArrayShadow); |
| 209 | ADD_TYPE(GSamplerCubeArrayShadow); |
Ethan Nicholas | c9472af | 2017-10-10 16:30:21 -0400 | [diff] [blame] | 210 | ADD_TYPE(FragmentProcessor); |
Stephen White | ff5d7a2 | 2019-07-26 17:42:06 -0400 | [diff] [blame] | 211 | ADD_TYPE(Sampler); |
| 212 | ADD_TYPE(Texture2D); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 213 | |
Brian Osman | 3887a01 | 2020-09-30 13:22:27 -0400 | [diff] [blame] | 214 | // sk_Caps is "builtin", but all references to it are resolved to Settings, so we don't need to |
| 215 | // treat it as builtin (ie, no need to clone it into the Program). |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 216 | StringFragment skCapsName("sk_Caps"); |
John Stiles | b8cc665 | 2020-10-08 09:12:07 -0400 | [diff] [blame] | 217 | fRootSymbolTable->add(std::make_unique<Variable>(/*offset=*/-1, |
Ethan Nicholas | 041fd0a | 2020-10-07 16:42:04 -0400 | [diff] [blame] | 218 | fIRGenerator->fModifiers->handle(Modifiers()), |
Ethan Nicholas | 453f67f | 2020-10-09 10:43:45 -0400 | [diff] [blame] | 219 | skCapsName, |
| 220 | fContext->fSkCaps_Type.get(), |
| 221 | /*builtin=*/false, |
| 222 | Variable::Storage::kGlobal)); |
Ethan Nicholas | 3605ace | 2016-11-21 15:59:48 -0500 | [diff] [blame] | 223 | |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 224 | fRootModule = {fRootSymbolTable, /*fIntrinsics=*/nullptr}; |
John Stiles | bc0c29e | 2020-09-28 13:13:40 -0400 | [diff] [blame] | 225 | |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 226 | fGPUModule = this->parseModule(Program::kFragment_Kind, MODULE_DATA(gpu), fRootModule); |
| 227 | fVertexModule = this->parseModule(Program::kVertex_Kind, MODULE_DATA(vert), fGPUModule); |
| 228 | fFragmentModule = this->parseModule(Program::kFragment_Kind, MODULE_DATA(frag), fGPUModule); |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 229 | } |
| 230 | |
John Stiles | 656427a | 2020-08-27 15:26:26 -0400 | [diff] [blame] | 231 | Compiler::~Compiler() {} |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 232 | |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 233 | const ParsedModule& Compiler::loadGeometryModule() { |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 234 | if (!fGeometryModule.fSymbols) { |
| 235 | fGeometryModule = this->parseModule(Program::kGeometry_Kind, MODULE_DATA(geom), fGPUModule); |
Ethan Nicholas | c18bb51 | 2020-07-28 14:46:53 -0400 | [diff] [blame] | 236 | } |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 237 | return fGeometryModule; |
Ethan Nicholas | c18bb51 | 2020-07-28 14:46:53 -0400 | [diff] [blame] | 238 | } |
| 239 | |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 240 | const ParsedModule& Compiler::loadFPModule() { |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 241 | if (!fFPModule.fSymbols) { |
| 242 | fFPModule = |
| 243 | this->parseModule(Program::kFragmentProcessor_Kind, MODULE_DATA(fp), fGPUModule); |
Brian Osman | 8e2ef02 | 2020-09-30 13:26:43 -0400 | [diff] [blame] | 244 | } |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 245 | return fFPModule; |
Brian Osman | 8e2ef02 | 2020-09-30 13:26:43 -0400 | [diff] [blame] | 246 | } |
| 247 | |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 248 | const ParsedModule& Compiler::loadPipelineModule() { |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 249 | if (!fPipelineModule.fSymbols) { |
| 250 | fPipelineModule = |
| 251 | this->parseModule(Program::kPipelineStage_Kind, MODULE_DATA(pipeline), fGPUModule); |
Brian Osman | f1319c3 | 2020-10-13 09:34:23 -0400 | [diff] [blame] | 252 | |
| 253 | // Add some aliases to the pipeline module so that it's friendlier, and more like GLSL |
| 254 | fPipelineModule.fSymbols->addAlias("shader", fContext->fFragmentProcessor_Type.get()); |
| 255 | |
| 256 | fPipelineModule.fSymbols->addAlias("vec2", fContext->fFloat2_Type.get()); |
| 257 | fPipelineModule.fSymbols->addAlias("vec3", fContext->fFloat3_Type.get()); |
| 258 | fPipelineModule.fSymbols->addAlias("vec4", fContext->fFloat4_Type.get()); |
| 259 | |
| 260 | fPipelineModule.fSymbols->addAlias("bvec2", fContext->fBool2_Type.get()); |
| 261 | fPipelineModule.fSymbols->addAlias("bvec3", fContext->fBool3_Type.get()); |
| 262 | fPipelineModule.fSymbols->addAlias("bvec4", fContext->fBool4_Type.get()); |
| 263 | |
| 264 | fPipelineModule.fSymbols->addAlias("mat2", fContext->fFloat2x2_Type.get()); |
| 265 | fPipelineModule.fSymbols->addAlias("mat3", fContext->fFloat3x3_Type.get()); |
| 266 | fPipelineModule.fSymbols->addAlias("mat4", fContext->fFloat4x4_Type.get()); |
| 267 | |
| 268 | fPipelineModule.fSymbols->addAlias("mat2x2", fContext->fFloat2x2_Type.get()); |
| 269 | fPipelineModule.fSymbols->addAlias("mat2x3", fContext->fFloat2x3_Type.get()); |
| 270 | fPipelineModule.fSymbols->addAlias("mat2x4", fContext->fFloat2x4_Type.get()); |
| 271 | |
| 272 | fPipelineModule.fSymbols->addAlias("mat3x2", fContext->fFloat3x2_Type.get()); |
| 273 | fPipelineModule.fSymbols->addAlias("mat3x3", fContext->fFloat3x3_Type.get()); |
| 274 | fPipelineModule.fSymbols->addAlias("mat3x4", fContext->fFloat3x4_Type.get()); |
| 275 | |
| 276 | fPipelineModule.fSymbols->addAlias("mat4x2", fContext->fFloat4x2_Type.get()); |
| 277 | fPipelineModule.fSymbols->addAlias("mat4x3", fContext->fFloat4x3_Type.get()); |
| 278 | fPipelineModule.fSymbols->addAlias("mat4x4", fContext->fFloat4x4_Type.get()); |
Ethan Nicholas | c18bb51 | 2020-07-28 14:46:53 -0400 | [diff] [blame] | 279 | } |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 280 | return fPipelineModule; |
Ethan Nicholas | c18bb51 | 2020-07-28 14:46:53 -0400 | [diff] [blame] | 281 | } |
| 282 | |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 283 | const ParsedModule& Compiler::loadInterpreterModule() { |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 284 | if (!fInterpreterModule.fSymbols) { |
| 285 | fInterpreterModule = |
| 286 | this->parseModule(Program::kGeneric_Kind, MODULE_DATA(interp), fRootModule); |
Ethan Nicholas | c18bb51 | 2020-07-28 14:46:53 -0400 | [diff] [blame] | 287 | } |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 288 | return fInterpreterModule; |
| 289 | } |
| 290 | |
| 291 | const ParsedModule& Compiler::moduleForProgramKind(Program::Kind kind) { |
| 292 | switch (kind) { |
| 293 | case Program::kVertex_Kind: return fVertexModule; break; |
| 294 | case Program::kFragment_Kind: return fFragmentModule; break; |
| 295 | case Program::kGeometry_Kind: return this->loadGeometryModule(); break; |
| 296 | case Program::kFragmentProcessor_Kind: return this->loadFPModule(); break; |
| 297 | case Program::kPipelineStage_Kind: return this->loadPipelineModule(); break; |
| 298 | case Program::kGeneric_Kind: return this->loadInterpreterModule(); break; |
| 299 | } |
| 300 | SkUNREACHABLE; |
Ethan Nicholas | c18bb51 | 2020-07-28 14:46:53 -0400 | [diff] [blame] | 301 | } |
| 302 | |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 303 | LoadedModule Compiler::loadModule(Program::Kind kind, |
| 304 | ModuleData data, |
| 305 | std::shared_ptr<SymbolTable> base) { |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 306 | if (!base) { |
| 307 | base = fRootSymbolTable; |
| 308 | } |
| 309 | |
| 310 | #if defined(SKSL_STANDALONE) |
| 311 | SkASSERT(data.fPath); |
| 312 | std::ifstream in(data.fPath); |
Brian Osman | e498b3c | 2020-09-23 14:42:11 -0400 | [diff] [blame] | 313 | std::unique_ptr<String> text = std::make_unique<String>(std::istreambuf_iterator<char>(in), |
| 314 | std::istreambuf_iterator<char>()); |
Ethan Nicholas | b33fa3f | 2020-08-06 13:00:19 -0400 | [diff] [blame] | 315 | if (in.rdstate()) { |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 316 | printf("error reading %s\n", data.fPath); |
Ethan Nicholas | b33fa3f | 2020-08-06 13:00:19 -0400 | [diff] [blame] | 317 | abort(); |
| 318 | } |
Brian Osman | e498b3c | 2020-09-23 14:42:11 -0400 | [diff] [blame] | 319 | const String* source = fRootSymbolTable->takeOwnershipOfString(std::move(text)); |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 320 | AutoSource as(this, source); |
Ethan Nicholas | 8da1e65 | 2019-05-24 11:01:59 -0400 | [diff] [blame] | 321 | Program::Settings settings; |
John Stiles | 881a10c | 2020-09-19 10:13:24 -0400 | [diff] [blame] | 322 | SkASSERT(fIRGenerator->fCanInline); |
| 323 | fIRGenerator->fCanInline = false; |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 324 | ParsedModule baseModule = {base, /*fIntrinsics=*/nullptr}; |
| 325 | IRGenerator::IRBundle ir = fIRGenerator->convertProgram( |
| 326 | kind, &settings, baseModule, /*isBuiltinCode=*/true, source->c_str(), source->length(), |
| 327 | /*externalValues=*/nullptr); |
| 328 | LoadedModule module = { std::move(ir.fSymbolTable), std::move(ir.fElements) }; |
John Stiles | 881a10c | 2020-09-19 10:13:24 -0400 | [diff] [blame] | 329 | fIRGenerator->fCanInline = true; |
Ethan Nicholas | 8da1e65 | 2019-05-24 11:01:59 -0400 | [diff] [blame] | 330 | if (this->fErrorCount) { |
| 331 | printf("Unexpected errors: %s\n", this->fErrorText.c_str()); |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 332 | SkDEBUGFAILF("%s %s\n", data.fPath, this->fErrorText.c_str()); |
Ethan Nicholas | 8da1e65 | 2019-05-24 11:01:59 -0400 | [diff] [blame] | 333 | } |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 334 | fModifiers.push_back(std::move(ir.fModifiers)); |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 335 | #else |
| 336 | SkASSERT(data.fData && (data.fSize != 0)); |
| 337 | Rehydrator rehydrator(fContext.get(), fIRGenerator->fModifiers.get(), base, this, |
| 338 | data.fData, data.fSize); |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 339 | LoadedModule module = { rehydrator.symbolTable(), rehydrator.elements() }; |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 340 | fModifiers.push_back(fIRGenerator->releaseModifiers()); |
| 341 | #endif |
| 342 | |
| 343 | return module; |
| 344 | } |
| 345 | |
| 346 | ParsedModule Compiler::parseModule(Program::Kind kind, ModuleData data, const ParsedModule& base) { |
| 347 | auto [symbols, elements] = this->loadModule(kind, data, base.fSymbols); |
| 348 | |
| 349 | // For modules that just declare (but don't define) intrinsic functions, there will be no new |
| 350 | // program elements. In that case, we can share our parent's intrinsic map: |
| 351 | if (elements.empty()) { |
| 352 | return {symbols, base.fIntrinsics}; |
| 353 | } |
| 354 | |
| 355 | auto intrinsics = std::make_shared<IRIntrinsicMap>(base.fIntrinsics.get()); |
| 356 | |
| 357 | // Now, transfer all of the program elements to an intrinsic map. This maps certain types of |
| 358 | // global objects to the declaring ProgramElement. |
| 359 | for (std::unique_ptr<ProgramElement>& element : elements) { |
| 360 | switch (element->kind()) { |
| 361 | case ProgramElement::Kind::kFunction: { |
| 362 | const FunctionDefinition& f = element->as<FunctionDefinition>(); |
Ethan Nicholas | 0a5d096 | 2020-10-14 13:33:18 -0400 | [diff] [blame] | 363 | SkASSERT(f.declaration().isBuiltin()); |
| 364 | intrinsics->insertOrDie(f.declaration().description(), std::move(element)); |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 365 | break; |
| 366 | } |
| 367 | case ProgramElement::Kind::kEnum: { |
| 368 | const Enum& e = element->as<Enum>(); |
| 369 | SkASSERT(e.isBuiltin()); |
| 370 | intrinsics->insertOrDie(e.typeName(), std::move(element)); |
| 371 | break; |
| 372 | } |
| 373 | case ProgramElement::Kind::kGlobalVar: { |
Ethan Nicholas | c51f33e | 2020-10-13 13:49:44 -0400 | [diff] [blame] | 374 | const GlobalVarDeclaration& global = element->as<GlobalVarDeclaration>(); |
| 375 | const Variable& var = global.declaration()->as<VarDeclaration>().var(); |
| 376 | SkASSERT(var.isBuiltin()); |
| 377 | intrinsics->insertOrDie(var.name(), std::move(element)); |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 378 | break; |
| 379 | } |
| 380 | case ProgramElement::Kind::kInterfaceBlock: { |
Ethan Nicholas | eaf4788 | 2020-10-15 10:10:08 -0400 | [diff] [blame^] | 381 | const Variable& var = element->as<InterfaceBlock>().variable(); |
| 382 | SkASSERT(var.isBuiltin()); |
| 383 | intrinsics->insertOrDie(var.name(), std::move(element)); |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 384 | break; |
| 385 | } |
| 386 | default: |
| 387 | printf("Unsupported element: %s\n", element->description().c_str()); |
| 388 | SkASSERT(false); |
| 389 | break; |
| 390 | } |
| 391 | } |
| 392 | |
| 393 | return {symbols, std::move(intrinsics)}; |
Ethan Nicholas | 8da1e65 | 2019-05-24 11:01:59 -0400 | [diff] [blame] | 394 | } |
| 395 | |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 396 | // add the definition created by assigning to the lvalue to the definition set |
Ethan Nicholas | 86a4340 | 2017-01-19 13:32:00 -0500 | [diff] [blame] | 397 | void Compiler::addDefinition(const Expression* lvalue, std::unique_ptr<Expression>* expr, |
| 398 | DefinitionMap* definitions) { |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 399 | switch (lvalue->kind()) { |
| 400 | case Expression::Kind::kVariableReference: { |
Ethan Nicholas | 7868692 | 2020-10-08 06:46:27 -0400 | [diff] [blame] | 401 | const Variable& var = *lvalue->as<VariableReference>().variable(); |
Ethan Nicholas | 453f67f | 2020-10-09 10:43:45 -0400 | [diff] [blame] | 402 | if (var.storage() == Variable::Storage::kLocal) { |
John Stiles | 796cdb7 | 2020-10-08 12:06:53 -0400 | [diff] [blame] | 403 | definitions->set(&var, expr); |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 404 | } |
| 405 | break; |
| 406 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 407 | case Expression::Kind::kSwizzle: |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 408 | // We consider the variable written to as long as at least some of its components have |
| 409 | // been written to. This will lead to some false negatives (we won't catch it if you |
| 410 | // write to foo.x and then read foo.y), but being stricter could lead to false positives |
Mike Klein | 6ad9909 | 2016-10-26 10:35:22 -0400 | [diff] [blame] | 411 | // (we write to foo.x, and then pass foo to a function which happens to only read foo.x, |
| 412 | // but since we pass foo as a whole it is flagged as an error) unless we perform a much |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 413 | // more complicated whole-program analysis. This is probably good enough. |
Ethan Nicholas | 6b4d581 | 2020-10-12 16:11:51 -0400 | [diff] [blame] | 414 | this->addDefinition(lvalue->as<Swizzle>().base().get(), |
Ethan Nicholas | 26a9aad | 2018-03-27 14:10:52 -0400 | [diff] [blame] | 415 | (std::unique_ptr<Expression>*) &fContext->fDefined_Expression, |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 416 | definitions); |
| 417 | break; |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 418 | case Expression::Kind::kIndex: |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 419 | // see comments in Swizzle |
Ethan Nicholas | 2a4952d | 2020-10-08 15:35:56 -0400 | [diff] [blame] | 420 | this->addDefinition(lvalue->as<IndexExpression>().base().get(), |
Ethan Nicholas | 26a9aad | 2018-03-27 14:10:52 -0400 | [diff] [blame] | 421 | (std::unique_ptr<Expression>*) &fContext->fDefined_Expression, |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 422 | definitions); |
| 423 | break; |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 424 | case Expression::Kind::kFieldAccess: |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 425 | // see comments in Swizzle |
Ethan Nicholas | 7a95b20 | 2020-10-09 11:55:40 -0400 | [diff] [blame] | 426 | this->addDefinition(lvalue->as<FieldAccess>().base().get(), |
Ethan Nicholas | 26a9aad | 2018-03-27 14:10:52 -0400 | [diff] [blame] | 427 | (std::unique_ptr<Expression>*) &fContext->fDefined_Expression, |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 428 | definitions); |
| 429 | break; |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 430 | case Expression::Kind::kTernary: |
Ethan Nicholas | a583b81 | 2018-01-18 13:32:11 -0500 | [diff] [blame] | 431 | // To simplify analysis, we just pretend that we write to both sides of the ternary. |
| 432 | // This allows for false positives (meaning we fail to detect that a variable might not |
| 433 | // have been assigned), but is preferable to false negatives. |
Ethan Nicholas | dd21816 | 2020-10-08 05:48:01 -0400 | [diff] [blame] | 434 | this->addDefinition(lvalue->as<TernaryExpression>().ifTrue().get(), |
Ethan Nicholas | 26a9aad | 2018-03-27 14:10:52 -0400 | [diff] [blame] | 435 | (std::unique_ptr<Expression>*) &fContext->fDefined_Expression, |
Ethan Nicholas | a583b81 | 2018-01-18 13:32:11 -0500 | [diff] [blame] | 436 | definitions); |
Ethan Nicholas | dd21816 | 2020-10-08 05:48:01 -0400 | [diff] [blame] | 437 | this->addDefinition(lvalue->as<TernaryExpression>().ifFalse().get(), |
Ethan Nicholas | 26a9aad | 2018-03-27 14:10:52 -0400 | [diff] [blame] | 438 | (std::unique_ptr<Expression>*) &fContext->fDefined_Expression, |
Ethan Nicholas | a583b81 | 2018-01-18 13:32:11 -0500 | [diff] [blame] | 439 | definitions); |
| 440 | break; |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 441 | case Expression::Kind::kExternalValue: |
Ethan Nicholas | 91164d1 | 2019-05-15 15:29:54 -0400 | [diff] [blame] | 442 | break; |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 443 | default: |
| 444 | // not an lvalue, can't happen |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 445 | SkASSERT(false); |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 446 | } |
| 447 | } |
| 448 | |
| 449 | // add local variables defined by this node to the set |
John Stiles | 796cdb7 | 2020-10-08 12:06:53 -0400 | [diff] [blame] | 450 | void Compiler::addDefinitions(const BasicBlock::Node& node, DefinitionMap* definitions) { |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 451 | if (node.isExpression()) { |
| 452 | Expression* expr = node.expression()->get(); |
| 453 | switch (expr->kind()) { |
| 454 | case Expression::Kind::kBinary: { |
| 455 | BinaryExpression* b = &expr->as<BinaryExpression>(); |
| 456 | if (b->getOperator() == Token::Kind::TK_EQ) { |
| 457 | this->addDefinition(&b->left(), &b->rightPointer(), definitions); |
| 458 | } else if (Compiler::IsAssignment(b->getOperator())) { |
| 459 | this->addDefinition( |
| 460 | &b->left(), |
| 461 | (std::unique_ptr<Expression>*) &fContext->fDefined_Expression, |
| 462 | definitions); |
Ethan Nicholas | 86a4340 | 2017-01-19 13:32:00 -0500 | [diff] [blame] | 463 | |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 464 | } |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 465 | break; |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 466 | } |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 467 | case Expression::Kind::kFunctionCall: { |
| 468 | const FunctionCall& c = expr->as<FunctionCall>(); |
Brian Osman | 5bf3e20 | 2020-10-13 10:34:18 -0400 | [diff] [blame] | 469 | const std::vector<const Variable*>& parameters = c.function().parameters(); |
Ethan Nicholas | ed84b73 | 2020-10-08 11:45:44 -0400 | [diff] [blame] | 470 | for (size_t i = 0; i < parameters.size(); ++i) { |
| 471 | if (parameters[i]->modifiers().fFlags & Modifiers::kOut_Flag) { |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 472 | this->addDefinition( |
Ethan Nicholas | 0dec992 | 2020-10-05 15:51:52 -0400 | [diff] [blame] | 473 | c.arguments()[i].get(), |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 474 | (std::unique_ptr<Expression>*) &fContext->fDefined_Expression, |
| 475 | definitions); |
| 476 | } |
| 477 | } |
| 478 | break; |
| 479 | } |
| 480 | case Expression::Kind::kPrefix: { |
| 481 | const PrefixExpression* p = &expr->as<PrefixExpression>(); |
Ethan Nicholas | 444ccc6 | 2020-10-09 10:16:22 -0400 | [diff] [blame] | 482 | if (p->getOperator() == Token::Kind::TK_MINUSMINUS || |
| 483 | p->getOperator() == Token::Kind::TK_PLUSPLUS) { |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 484 | this->addDefinition( |
Ethan Nicholas | 444ccc6 | 2020-10-09 10:16:22 -0400 | [diff] [blame] | 485 | p->operand().get(), |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 486 | (std::unique_ptr<Expression>*) &fContext->fDefined_Expression, |
| 487 | definitions); |
| 488 | } |
| 489 | break; |
| 490 | } |
| 491 | case Expression::Kind::kPostfix: { |
| 492 | const PostfixExpression* p = &expr->as<PostfixExpression>(); |
Ethan Nicholas | 444ccc6 | 2020-10-09 10:16:22 -0400 | [diff] [blame] | 493 | if (p->getOperator() == Token::Kind::TK_MINUSMINUS || |
| 494 | p->getOperator() == Token::Kind::TK_PLUSPLUS) { |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 495 | this->addDefinition( |
Ethan Nicholas | 444ccc6 | 2020-10-09 10:16:22 -0400 | [diff] [blame] | 496 | p->operand().get(), |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 497 | (std::unique_ptr<Expression>*) &fContext->fDefined_Expression, |
| 498 | definitions); |
| 499 | } |
| 500 | break; |
| 501 | } |
| 502 | case Expression::Kind::kVariableReference: { |
| 503 | const VariableReference* v = &expr->as<VariableReference>(); |
Ethan Nicholas | 453f67f | 2020-10-09 10:43:45 -0400 | [diff] [blame] | 504 | if (v->refKind() != VariableReference::RefKind::kRead) { |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 505 | this->addDefinition( |
| 506 | v, |
| 507 | (std::unique_ptr<Expression>*) &fContext->fDefined_Expression, |
| 508 | definitions); |
| 509 | } |
| 510 | break; |
| 511 | } |
| 512 | default: |
| 513 | break; |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 514 | } |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 515 | } else if (node.isStatement()) { |
| 516 | Statement* stmt = node.statement()->get(); |
| 517 | if (stmt->is<VarDeclaration>()) { |
| 518 | VarDeclaration& vd = stmt->as<VarDeclaration>(); |
Ethan Nicholas | c51f33e | 2020-10-13 13:49:44 -0400 | [diff] [blame] | 519 | if (vd.value()) { |
| 520 | definitions->set(&vd.var(), &vd.value()); |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 521 | } |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 522 | } |
| 523 | } |
| 524 | } |
| 525 | |
John Stiles | e615000 | 2020-10-05 12:03:53 -0400 | [diff] [blame] | 526 | void Compiler::scanCFG(CFG* cfg, BlockId blockId, SkBitSet* processedSet) { |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 527 | BasicBlock& block = cfg->fBlocks[blockId]; |
| 528 | |
| 529 | // compute definitions after this block |
Ethan Nicholas | 86a4340 | 2017-01-19 13:32:00 -0500 | [diff] [blame] | 530 | DefinitionMap after = block.fBefore; |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 531 | for (const BasicBlock::Node& n : block.fNodes) { |
| 532 | this->addDefinitions(n, &after); |
| 533 | } |
| 534 | |
| 535 | // propagate definitions to exits |
| 536 | for (BlockId exitId : block.fExits) { |
Ethan Nicholas | 26a9aad | 2018-03-27 14:10:52 -0400 | [diff] [blame] | 537 | if (exitId == blockId) { |
| 538 | continue; |
| 539 | } |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 540 | BasicBlock& exit = cfg->fBlocks[exitId]; |
John Stiles | 796cdb7 | 2020-10-08 12:06:53 -0400 | [diff] [blame] | 541 | after.foreach([&](const Variable* var, std::unique_ptr<Expression>** e1Ptr) { |
| 542 | std::unique_ptr<Expression>* e1 = *e1Ptr; |
| 543 | std::unique_ptr<Expression>** exitDef = exit.fBefore.find(var); |
| 544 | if (!exitDef) { |
John Stiles | e615000 | 2020-10-05 12:03:53 -0400 | [diff] [blame] | 545 | // exit has no definition for it, just copy it and reprocess exit block |
| 546 | processedSet->reset(exitId); |
John Stiles | 796cdb7 | 2020-10-08 12:06:53 -0400 | [diff] [blame] | 547 | exit.fBefore[var] = e1; |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 548 | } else { |
Ethan Nicholas | 86a4340 | 2017-01-19 13:32:00 -0500 | [diff] [blame] | 549 | // exit has a (possibly different) value already defined |
John Stiles | 796cdb7 | 2020-10-08 12:06:53 -0400 | [diff] [blame] | 550 | std::unique_ptr<Expression>* e2 = *exitDef; |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 551 | if (e1 != e2) { |
John Stiles | e615000 | 2020-10-05 12:03:53 -0400 | [diff] [blame] | 552 | // definition has changed, merge and reprocess the exit block |
| 553 | processedSet->reset(exitId); |
Ethan Nicholas | af19769 | 2017-02-27 13:26:45 -0500 | [diff] [blame] | 554 | if (e1 && e2) { |
John Stiles | 796cdb7 | 2020-10-08 12:06:53 -0400 | [diff] [blame] | 555 | *exitDef = (std::unique_ptr<Expression>*)&fContext->fDefined_Expression; |
Ethan Nicholas | af19769 | 2017-02-27 13:26:45 -0500 | [diff] [blame] | 556 | } else { |
John Stiles | 796cdb7 | 2020-10-08 12:06:53 -0400 | [diff] [blame] | 557 | *exitDef = nullptr; |
Ethan Nicholas | af19769 | 2017-02-27 13:26:45 -0500 | [diff] [blame] | 558 | } |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 559 | } |
| 560 | } |
John Stiles | 796cdb7 | 2020-10-08 12:06:53 -0400 | [diff] [blame] | 561 | }); |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 562 | } |
| 563 | } |
| 564 | |
| 565 | // returns a map which maps all local variables in the function to null, indicating that their value |
| 566 | // is initially unknown |
Ethan Nicholas | 86a4340 | 2017-01-19 13:32:00 -0500 | [diff] [blame] | 567 | static DefinitionMap compute_start_state(const CFG& cfg) { |
| 568 | DefinitionMap result; |
Mike Klein | 6ad9909 | 2016-10-26 10:35:22 -0400 | [diff] [blame] | 569 | for (const auto& block : cfg.fBlocks) { |
| 570 | for (const auto& node : block.fNodes) { |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 571 | if (node.isStatement()) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 572 | const Statement* s = node.statement()->get(); |
Brian Osman | c021360 | 2020-10-06 14:43:32 -0400 | [diff] [blame] | 573 | if (s->is<VarDeclaration>()) { |
Ethan Nicholas | c51f33e | 2020-10-13 13:49:44 -0400 | [diff] [blame] | 574 | result[&s->as<VarDeclaration>().var()] = nullptr; |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 575 | } |
| 576 | } |
| 577 | } |
| 578 | } |
| 579 | return result; |
| 580 | } |
| 581 | |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 582 | /** |
| 583 | * Returns true if assigning to this lvalue has no effect. |
| 584 | */ |
| 585 | static bool is_dead(const Expression& lvalue) { |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 586 | switch (lvalue.kind()) { |
| 587 | case Expression::Kind::kVariableReference: |
Ethan Nicholas | 7868692 | 2020-10-08 06:46:27 -0400 | [diff] [blame] | 588 | return lvalue.as<VariableReference>().variable()->dead(); |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 589 | case Expression::Kind::kSwizzle: |
Ethan Nicholas | 6b4d581 | 2020-10-12 16:11:51 -0400 | [diff] [blame] | 590 | return is_dead(*lvalue.as<Swizzle>().base()); |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 591 | case Expression::Kind::kFieldAccess: |
Ethan Nicholas | 7a95b20 | 2020-10-09 11:55:40 -0400 | [diff] [blame] | 592 | return is_dead(*lvalue.as<FieldAccess>().base()); |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 593 | case Expression::Kind::kIndex: { |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 594 | const IndexExpression& idx = lvalue.as<IndexExpression>(); |
Ethan Nicholas | 2a4952d | 2020-10-08 15:35:56 -0400 | [diff] [blame] | 595 | return is_dead(*idx.base()) && |
| 596 | !idx.index()->hasProperty(Expression::Property::kSideEffects); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 597 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 598 | case Expression::Kind::kTernary: { |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 599 | const TernaryExpression& t = lvalue.as<TernaryExpression>(); |
Ethan Nicholas | dd21816 | 2020-10-08 05:48:01 -0400 | [diff] [blame] | 600 | return !t.test()->hasSideEffects() && is_dead(*t.ifTrue()) && is_dead(*t.ifFalse()); |
Ethan Nicholas | a583b81 | 2018-01-18 13:32:11 -0500 | [diff] [blame] | 601 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 602 | case Expression::Kind::kExternalValue: |
Ethan Nicholas | 91164d1 | 2019-05-15 15:29:54 -0400 | [diff] [blame] | 603 | return false; |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 604 | default: |
Ethan Nicholas | 2a099da | 2020-01-02 14:40:54 -0500 | [diff] [blame] | 605 | #ifdef SK_DEBUG |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 606 | ABORT("invalid lvalue: %s\n", lvalue.description().c_str()); |
Ethan Nicholas | 2a099da | 2020-01-02 14:40:54 -0500 | [diff] [blame] | 607 | #endif |
| 608 | return false; |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 609 | } |
| 610 | } |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 611 | |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 612 | /** |
| 613 | * Returns true if this is an assignment which can be collapsed down to just the right hand side due |
| 614 | * to a dead target and lack of side effects on the left hand side. |
| 615 | */ |
| 616 | static bool dead_assignment(const BinaryExpression& b) { |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 617 | if (!Compiler::IsAssignment(b.getOperator())) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 618 | return false; |
| 619 | } |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 620 | return is_dead(b.left()); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 621 | } |
| 622 | |
| 623 | void Compiler::computeDataFlow(CFG* cfg) { |
| 624 | cfg->fBlocks[cfg->fStart].fBefore = compute_start_state(*cfg); |
John Stiles | e615000 | 2020-10-05 12:03:53 -0400 | [diff] [blame] | 625 | |
| 626 | // We set bits in the "processed" set after a block has been scanned. |
| 627 | SkBitSet processedSet(cfg->fBlocks.size()); |
| 628 | while (SkBitSet::OptionalIndex blockId = processedSet.findFirstUnset()) { |
| 629 | processedSet.set(*blockId); |
| 630 | this->scanCFG(cfg, *blockId, &processedSet); |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 631 | } |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 632 | } |
| 633 | |
| 634 | /** |
| 635 | * Attempts to replace the expression pointed to by iter with a new one (in both the CFG and the |
| 636 | * IR). If the expression can be cleanly removed, returns true and updates the iterator to point to |
| 637 | * the newly-inserted element. Otherwise updates only the IR and returns false (and the CFG will |
| 638 | * need to be regenerated). |
| 639 | */ |
John Stiles | afbf899 | 2020-08-18 10:08:21 -0400 | [diff] [blame] | 640 | static bool try_replace_expression(BasicBlock* b, |
| 641 | std::vector<BasicBlock::Node>::iterator* iter, |
| 642 | std::unique_ptr<Expression>* newExpression) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 643 | std::unique_ptr<Expression>* target = (*iter)->expression(); |
| 644 | if (!b->tryRemoveExpression(iter)) { |
| 645 | *target = std::move(*newExpression); |
| 646 | return false; |
| 647 | } |
| 648 | *target = std::move(*newExpression); |
| 649 | return b->tryInsertExpression(iter, target); |
| 650 | } |
| 651 | |
| 652 | /** |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 653 | * Returns true if the expression is a constant numeric literal with the specified value, or a |
| 654 | * constant vector with all elements equal to the specified value. |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 655 | */ |
Ethan Nicholas | a3f22f1 | 2020-10-01 12:13:17 -0400 | [diff] [blame] | 656 | template <typename T = SKSL_FLOAT> |
John Stiles | 9d94423 | 2020-08-19 09:56:49 -0400 | [diff] [blame] | 657 | static bool is_constant(const Expression& expr, T value) { |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 658 | switch (expr.kind()) { |
| 659 | case Expression::Kind::kIntLiteral: |
Ethan Nicholas | e96cdd1 | 2020-09-28 16:27:18 -0400 | [diff] [blame] | 660 | return expr.as<IntLiteral>().value() == value; |
John Stiles | 9d94423 | 2020-08-19 09:56:49 -0400 | [diff] [blame] | 661 | |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 662 | case Expression::Kind::kFloatLiteral: |
Ethan Nicholas | a3f22f1 | 2020-10-01 12:13:17 -0400 | [diff] [blame] | 663 | return expr.as<FloatLiteral>().value() == value; |
John Stiles | 9d94423 | 2020-08-19 09:56:49 -0400 | [diff] [blame] | 664 | |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 665 | case Expression::Kind::kConstructor: { |
John Stiles | 9d94423 | 2020-08-19 09:56:49 -0400 | [diff] [blame] | 666 | const Constructor& constructor = expr.as<Constructor>(); |
| 667 | if (constructor.isCompileTimeConstant()) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 668 | const Type& constructorType = constructor.type(); |
| 669 | bool isFloat = constructorType.columns() > 1 |
| 670 | ? constructorType.componentType().isFloat() |
| 671 | : constructorType.isFloat(); |
| 672 | switch (constructorType.typeKind()) { |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 673 | case Type::TypeKind::kVector: |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 674 | for (int i = 0; i < constructorType.columns(); ++i) { |
John Stiles | 9d94423 | 2020-08-19 09:56:49 -0400 | [diff] [blame] | 675 | if (isFloat) { |
| 676 | if (constructor.getFVecComponent(i) != value) { |
| 677 | return false; |
| 678 | } |
| 679 | } else { |
| 680 | if (constructor.getIVecComponent(i) != value) { |
| 681 | return false; |
| 682 | } |
| 683 | } |
Ethan Nicholas | d188c18 | 2019-06-10 15:55:38 -0400 | [diff] [blame] | 684 | } |
John Stiles | 9d94423 | 2020-08-19 09:56:49 -0400 | [diff] [blame] | 685 | return true; |
| 686 | |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 687 | case Type::TypeKind::kScalar: |
Ethan Nicholas | f70f044 | 2020-09-29 12:41:35 -0400 | [diff] [blame] | 688 | SkASSERT(constructor.arguments().size() == 1); |
| 689 | return is_constant<T>(*constructor.arguments()[0], value); |
John Stiles | 9d94423 | 2020-08-19 09:56:49 -0400 | [diff] [blame] | 690 | |
| 691 | default: |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 692 | return false; |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 693 | } |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 694 | } |
| 695 | return false; |
| 696 | } |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 697 | default: |
| 698 | return false; |
| 699 | } |
| 700 | } |
| 701 | |
| 702 | /** |
| 703 | * Collapses the binary expression pointed to by iter down to just the right side (in both the IR |
| 704 | * and CFG structures). |
| 705 | */ |
John Stiles | afbf899 | 2020-08-18 10:08:21 -0400 | [diff] [blame] | 706 | static void delete_left(BasicBlock* b, |
| 707 | std::vector<BasicBlock::Node>::iterator* iter, |
| 708 | bool* outUpdated, |
| 709 | bool* outNeedsRescan) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 710 | *outUpdated = true; |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 711 | std::unique_ptr<Expression>* target = (*iter)->expression(); |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 712 | BinaryExpression& bin = (*target)->as<BinaryExpression>(); |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 713 | Expression& left = bin.left(); |
| 714 | std::unique_ptr<Expression>& rightPointer = bin.rightPointer(); |
| 715 | SkASSERT(!left.hasSideEffects()); |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 716 | bool result; |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 717 | if (bin.getOperator() == Token::Kind::TK_EQ) { |
| 718 | result = b->tryRemoveLValueBefore(iter, &left); |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 719 | } else { |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 720 | result = b->tryRemoveExpressionBefore(iter, &left); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 721 | } |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 722 | *target = std::move(rightPointer); |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 723 | if (!result) { |
Ethan Nicholas | 4b330df | 2017-05-17 10:52:55 -0400 | [diff] [blame] | 724 | *outNeedsRescan = true; |
| 725 | return; |
| 726 | } |
| 727 | if (*iter == b->fNodes.begin()) { |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 728 | *outNeedsRescan = true; |
| 729 | return; |
| 730 | } |
| 731 | --(*iter); |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 732 | if (!(*iter)->isExpression() || (*iter)->expression() != &rightPointer) { |
Ethan Nicholas | 4b330df | 2017-05-17 10:52:55 -0400 | [diff] [blame] | 733 | *outNeedsRescan = true; |
| 734 | return; |
| 735 | } |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 736 | *iter = b->fNodes.erase(*iter); |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 737 | SkASSERT((*iter)->expression() == target); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 738 | } |
| 739 | |
| 740 | /** |
| 741 | * Collapses the binary expression pointed to by iter down to just the left side (in both the IR and |
| 742 | * CFG structures). |
| 743 | */ |
John Stiles | afbf899 | 2020-08-18 10:08:21 -0400 | [diff] [blame] | 744 | static void delete_right(BasicBlock* b, |
| 745 | std::vector<BasicBlock::Node>::iterator* iter, |
| 746 | bool* outUpdated, |
| 747 | bool* outNeedsRescan) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 748 | *outUpdated = true; |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 749 | std::unique_ptr<Expression>* target = (*iter)->expression(); |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 750 | BinaryExpression& bin = (*target)->as<BinaryExpression>(); |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 751 | std::unique_ptr<Expression>& leftPointer = bin.leftPointer(); |
| 752 | Expression& right = bin.right(); |
| 753 | SkASSERT(!right.hasSideEffects()); |
| 754 | if (!b->tryRemoveExpressionBefore(iter, &right)) { |
| 755 | *target = std::move(leftPointer); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 756 | *outNeedsRescan = true; |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 757 | return; |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 758 | } |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 759 | *target = std::move(leftPointer); |
Ethan Nicholas | 4b330df | 2017-05-17 10:52:55 -0400 | [diff] [blame] | 760 | if (*iter == b->fNodes.begin()) { |
| 761 | *outNeedsRescan = true; |
| 762 | return; |
| 763 | } |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 764 | --(*iter); |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 765 | if ((!(*iter)->isExpression() || (*iter)->expression() != &leftPointer)) { |
Ethan Nicholas | 4b330df | 2017-05-17 10:52:55 -0400 | [diff] [blame] | 766 | *outNeedsRescan = true; |
| 767 | return; |
| 768 | } |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 769 | *iter = b->fNodes.erase(*iter); |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 770 | SkASSERT((*iter)->expression() == target); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 771 | } |
| 772 | |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 773 | /** |
| 774 | * Constructs the specified type using a single argument. |
| 775 | */ |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 776 | static std::unique_ptr<Expression> construct(const Type* type, std::unique_ptr<Expression> v) { |
John Stiles | 8e3b6be | 2020-10-13 11:14:08 -0400 | [diff] [blame] | 777 | ExpressionArray args; |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 778 | args.push_back(std::move(v)); |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 779 | std::unique_ptr<Expression> result = std::make_unique<Constructor>(-1, type, std::move(args)); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 780 | return result; |
| 781 | } |
| 782 | |
| 783 | /** |
| 784 | * Used in the implementations of vectorize_left and vectorize_right. Given a vector type and an |
| 785 | * expression x, deletes the expression pointed to by iter and replaces it with <type>(x). |
| 786 | */ |
| 787 | static void vectorize(BasicBlock* b, |
| 788 | std::vector<BasicBlock::Node>::iterator* iter, |
| 789 | const Type& type, |
| 790 | std::unique_ptr<Expression>* otherExpression, |
| 791 | bool* outUpdated, |
| 792 | bool* outNeedsRescan) { |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 793 | SkASSERT((*(*iter)->expression())->kind() == Expression::Kind::kBinary); |
| 794 | SkASSERT(type.typeKind() == Type::TypeKind::kVector); |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 795 | SkASSERT((*otherExpression)->type().typeKind() == Type::TypeKind::kScalar); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 796 | *outUpdated = true; |
| 797 | std::unique_ptr<Expression>* target = (*iter)->expression(); |
| 798 | if (!b->tryRemoveExpression(iter)) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 799 | *target = construct(&type, std::move(*otherExpression)); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 800 | *outNeedsRescan = true; |
| 801 | } else { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 802 | *target = construct(&type, std::move(*otherExpression)); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 803 | if (!b->tryInsertExpression(iter, target)) { |
| 804 | *outNeedsRescan = true; |
| 805 | } |
| 806 | } |
| 807 | } |
| 808 | |
| 809 | /** |
| 810 | * Given a binary expression of the form x <op> vec<n>(y), deletes the right side and vectorizes the |
| 811 | * left to yield vec<n>(x). |
| 812 | */ |
| 813 | static void vectorize_left(BasicBlock* b, |
| 814 | std::vector<BasicBlock::Node>::iterator* iter, |
| 815 | bool* outUpdated, |
| 816 | bool* outNeedsRescan) { |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 817 | BinaryExpression& bin = (*(*iter)->expression())->as<BinaryExpression>(); |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 818 | vectorize(b, iter, bin.right().type(), &bin.leftPointer(), outUpdated, outNeedsRescan); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 819 | } |
| 820 | |
| 821 | /** |
| 822 | * Given a binary expression of the form vec<n>(x) <op> y, deletes the left side and vectorizes the |
| 823 | * right to yield vec<n>(y). |
| 824 | */ |
| 825 | static void vectorize_right(BasicBlock* b, |
| 826 | std::vector<BasicBlock::Node>::iterator* iter, |
| 827 | bool* outUpdated, |
| 828 | bool* outNeedsRescan) { |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 829 | BinaryExpression& bin = (*(*iter)->expression())->as<BinaryExpression>(); |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 830 | vectorize(b, iter, bin.left().type(), &bin.rightPointer(), outUpdated, outNeedsRescan); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 831 | } |
| 832 | |
| 833 | // Mark that an expression which we were writing to is no longer being written to |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 834 | static void clear_write(Expression& expr) { |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 835 | switch (expr.kind()) { |
| 836 | case Expression::Kind::kVariableReference: { |
Ethan Nicholas | 453f67f | 2020-10-09 10:43:45 -0400 | [diff] [blame] | 837 | expr.as<VariableReference>().setRefKind(VariableReference::RefKind::kRead); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 838 | break; |
| 839 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 840 | case Expression::Kind::kFieldAccess: |
Ethan Nicholas | 7a95b20 | 2020-10-09 11:55:40 -0400 | [diff] [blame] | 841 | clear_write(*expr.as<FieldAccess>().base()); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 842 | break; |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 843 | case Expression::Kind::kSwizzle: |
Ethan Nicholas | 6b4d581 | 2020-10-12 16:11:51 -0400 | [diff] [blame] | 844 | clear_write(*expr.as<Swizzle>().base()); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 845 | break; |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 846 | case Expression::Kind::kIndex: |
Ethan Nicholas | 2a4952d | 2020-10-08 15:35:56 -0400 | [diff] [blame] | 847 | clear_write(*expr.as<IndexExpression>().base()); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 848 | break; |
| 849 | default: |
| 850 | ABORT("shouldn't be writing to this kind of expression\n"); |
| 851 | break; |
| 852 | } |
| 853 | } |
| 854 | |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 855 | void Compiler::simplifyExpression(DefinitionMap& definitions, |
| 856 | BasicBlock& b, |
| 857 | std::vector<BasicBlock::Node>::iterator* iter, |
| 858 | std::unordered_set<const Variable*>* undefinedVariables, |
| 859 | bool* outUpdated, |
| 860 | bool* outNeedsRescan) { |
| 861 | Expression* expr = (*iter)->expression()->get(); |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 862 | SkASSERT(expr); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 863 | if ((*iter)->fConstantPropagation) { |
| 864 | std::unique_ptr<Expression> optimized = expr->constantPropagate(*fIRGenerator, definitions); |
| 865 | if (optimized) { |
Ethan Nicholas | 4b330df | 2017-05-17 10:52:55 -0400 | [diff] [blame] | 866 | *outUpdated = true; |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 867 | optimized = fIRGenerator->coerce(std::move(optimized), expr->type()); |
Ethan Nicholas | 1d88152 | 2020-09-11 09:32:54 -0400 | [diff] [blame] | 868 | SkASSERT(optimized); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 869 | if (!try_replace_expression(&b, iter, &optimized)) { |
| 870 | *outNeedsRescan = true; |
Ethan Nicholas | 4b330df | 2017-05-17 10:52:55 -0400 | [diff] [blame] | 871 | return; |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 872 | } |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 873 | SkASSERT((*iter)->isExpression()); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 874 | expr = (*iter)->expression()->get(); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 875 | } |
| 876 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 877 | switch (expr->kind()) { |
| 878 | case Expression::Kind::kVariableReference: { |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 879 | const VariableReference& ref = expr->as<VariableReference>(); |
Ethan Nicholas | 7868692 | 2020-10-08 06:46:27 -0400 | [diff] [blame] | 880 | const Variable* var = ref.variable(); |
Ethan Nicholas | 453f67f | 2020-10-09 10:43:45 -0400 | [diff] [blame] | 881 | if (ref.refKind() != VariableReference::RefKind::kWrite && |
| 882 | ref.refKind() != VariableReference::RefKind::kPointer && |
| 883 | var->storage() == Variable::Storage::kLocal && !definitions[var] && |
Brian Osman | 79457ef | 2020-09-24 15:01:27 -0400 | [diff] [blame] | 884 | (*undefinedVariables).find(var) == (*undefinedVariables).end()) { |
| 885 | (*undefinedVariables).insert(var); |
Ethan Nicholas | 82a62d2 | 2017-11-07 14:42:10 +0000 | [diff] [blame] | 886 | this->error(expr->fOffset, |
Ethan Nicholas | e2c4999 | 2020-10-05 11:49:11 -0400 | [diff] [blame] | 887 | "'" + var->name() + "' has not been assigned"); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 888 | } |
| 889 | break; |
| 890 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 891 | case Expression::Kind::kTernary: { |
John Stiles | 403a363 | 2020-08-20 12:11:48 -0400 | [diff] [blame] | 892 | TernaryExpression* t = &expr->as<TernaryExpression>(); |
Ethan Nicholas | dd21816 | 2020-10-08 05:48:01 -0400 | [diff] [blame] | 893 | if (t->test()->is<BoolLiteral>()) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 894 | // ternary has a constant test, replace it with either the true or |
| 895 | // false branch |
Ethan Nicholas | dd21816 | 2020-10-08 05:48:01 -0400 | [diff] [blame] | 896 | if (t->test()->as<BoolLiteral>().value()) { |
| 897 | (*iter)->setExpression(std::move(t->ifTrue())); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 898 | } else { |
Ethan Nicholas | dd21816 | 2020-10-08 05:48:01 -0400 | [diff] [blame] | 899 | (*iter)->setExpression(std::move(t->ifFalse())); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 900 | } |
| 901 | *outUpdated = true; |
| 902 | *outNeedsRescan = true; |
| 903 | } |
| 904 | break; |
| 905 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 906 | case Expression::Kind::kBinary: { |
John Stiles | 403a363 | 2020-08-20 12:11:48 -0400 | [diff] [blame] | 907 | BinaryExpression* bin = &expr->as<BinaryExpression>(); |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 908 | if (dead_assignment(*bin)) { |
| 909 | delete_left(&b, iter, outUpdated, outNeedsRescan); |
| 910 | break; |
| 911 | } |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 912 | Expression& left = bin->left(); |
| 913 | Expression& right = bin->right(); |
| 914 | const Type& leftType = left.type(); |
| 915 | const Type& rightType = right.type(); |
Ethan Nicholas | c2371a4 | 2017-05-05 10:04:06 -0400 | [diff] [blame] | 916 | // collapse useless expressions like x * 1 or x + 0 |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 917 | if (((leftType.typeKind() != Type::TypeKind::kScalar) && |
| 918 | (leftType.typeKind() != Type::TypeKind::kVector)) || |
| 919 | ((rightType.typeKind() != Type::TypeKind::kScalar) && |
| 920 | (rightType.typeKind() != Type::TypeKind::kVector))) { |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 921 | break; |
| 922 | } |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 923 | switch (bin->getOperator()) { |
Ethan Nicholas | 5a9e7fb | 2020-04-17 12:45:51 -0400 | [diff] [blame] | 924 | case Token::Kind::TK_STAR: |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 925 | if (is_constant(left, 1)) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 926 | if (leftType.typeKind() == Type::TypeKind::kVector && |
| 927 | rightType.typeKind() == Type::TypeKind::kScalar) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 928 | // float4(1) * x -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 929 | vectorize_right(&b, iter, outUpdated, outNeedsRescan); |
| 930 | } else { |
| 931 | // 1 * x -> x |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 932 | // 1 * float4(x) -> float4(x) |
| 933 | // float4(1) * float4(x) -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 934 | delete_left(&b, iter, outUpdated, outNeedsRescan); |
| 935 | } |
| 936 | } |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 937 | else if (is_constant(left, 0)) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 938 | if (leftType.typeKind() == Type::TypeKind::kScalar && |
| 939 | rightType.typeKind() == Type::TypeKind::kVector && |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 940 | !right.hasSideEffects()) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 941 | // 0 * float4(x) -> float4(0) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 942 | vectorize_left(&b, iter, outUpdated, outNeedsRescan); |
| 943 | } else { |
| 944 | // 0 * x -> 0 |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 945 | // float4(0) * x -> float4(0) |
| 946 | // float4(0) * float4(x) -> float4(0) |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 947 | if (!right.hasSideEffects()) { |
Ethan Nicholas | 51493ee | 2017-12-11 12:34:33 -0500 | [diff] [blame] | 948 | delete_right(&b, iter, outUpdated, outNeedsRescan); |
| 949 | } |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 950 | } |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 951 | } |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 952 | else if (is_constant(right, 1)) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 953 | if (leftType.typeKind() == Type::TypeKind::kScalar && |
| 954 | rightType.typeKind() == Type::TypeKind::kVector) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 955 | // x * float4(1) -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 956 | vectorize_left(&b, iter, outUpdated, outNeedsRescan); |
| 957 | } else { |
| 958 | // x * 1 -> x |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 959 | // float4(x) * 1 -> float4(x) |
| 960 | // float4(x) * float4(1) -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 961 | delete_right(&b, iter, outUpdated, outNeedsRescan); |
| 962 | } |
| 963 | } |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 964 | else if (is_constant(right, 0)) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 965 | if (leftType.typeKind() == Type::TypeKind::kVector && |
| 966 | rightType.typeKind() == Type::TypeKind::kScalar && |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 967 | !left.hasSideEffects()) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 968 | // float4(x) * 0 -> float4(0) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 969 | vectorize_right(&b, iter, outUpdated, outNeedsRescan); |
| 970 | } else { |
| 971 | // x * 0 -> 0 |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 972 | // x * float4(0) -> float4(0) |
| 973 | // float4(x) * float4(0) -> float4(0) |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 974 | if (!left.hasSideEffects()) { |
Ethan Nicholas | 51493ee | 2017-12-11 12:34:33 -0500 | [diff] [blame] | 975 | delete_left(&b, iter, outUpdated, outNeedsRescan); |
| 976 | } |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 977 | } |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 978 | } |
| 979 | break; |
Ethan Nicholas | 5a9e7fb | 2020-04-17 12:45:51 -0400 | [diff] [blame] | 980 | case Token::Kind::TK_PLUS: |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 981 | if (is_constant(left, 0)) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 982 | if (leftType.typeKind() == Type::TypeKind::kVector && |
| 983 | rightType.typeKind() == Type::TypeKind::kScalar) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 984 | // float4(0) + x -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 985 | vectorize_right(&b, iter, outUpdated, outNeedsRescan); |
| 986 | } else { |
| 987 | // 0 + x -> x |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 988 | // 0 + float4(x) -> float4(x) |
| 989 | // float4(0) + float4(x) -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 990 | delete_left(&b, iter, outUpdated, outNeedsRescan); |
| 991 | } |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 992 | } else if (is_constant(right, 0)) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 993 | if (leftType.typeKind() == Type::TypeKind::kScalar && |
| 994 | rightType.typeKind() == Type::TypeKind::kVector) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 995 | // x + float4(0) -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 996 | vectorize_left(&b, iter, outUpdated, outNeedsRescan); |
| 997 | } else { |
| 998 | // x + 0 -> x |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 999 | // float4(x) + 0 -> float4(x) |
| 1000 | // float4(x) + float4(0) -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 1001 | delete_right(&b, iter, outUpdated, outNeedsRescan); |
| 1002 | } |
Ethan Nicholas | 56e4271 | 2017-04-21 10:23:37 -0400 | [diff] [blame] | 1003 | } |
| 1004 | break; |
Ethan Nicholas | 5a9e7fb | 2020-04-17 12:45:51 -0400 | [diff] [blame] | 1005 | case Token::Kind::TK_MINUS: |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 1006 | if (is_constant(right, 0)) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 1007 | if (leftType.typeKind() == Type::TypeKind::kScalar && |
| 1008 | rightType.typeKind() == Type::TypeKind::kVector) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 1009 | // x - float4(0) -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 1010 | vectorize_left(&b, iter, outUpdated, outNeedsRescan); |
| 1011 | } else { |
| 1012 | // x - 0 -> x |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 1013 | // float4(x) - 0 -> float4(x) |
| 1014 | // float4(x) - float4(0) -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 1015 | delete_right(&b, iter, outUpdated, outNeedsRescan); |
| 1016 | } |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1017 | } |
| 1018 | break; |
Ethan Nicholas | 5a9e7fb | 2020-04-17 12:45:51 -0400 | [diff] [blame] | 1019 | case Token::Kind::TK_SLASH: |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 1020 | if (is_constant(right, 1)) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 1021 | if (leftType.typeKind() == Type::TypeKind::kScalar && |
| 1022 | rightType.typeKind() == Type::TypeKind::kVector) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 1023 | // x / float4(1) -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 1024 | vectorize_left(&b, iter, outUpdated, outNeedsRescan); |
| 1025 | } else { |
| 1026 | // x / 1 -> x |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 1027 | // float4(x) / 1 -> float4(x) |
| 1028 | // float4(x) / float4(1) -> float4(x) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 1029 | delete_right(&b, iter, outUpdated, outNeedsRescan); |
| 1030 | } |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 1031 | } else if (is_constant(left, 0)) { |
Ethan Nicholas | 30d3022 | 2020-09-11 12:27:26 -0400 | [diff] [blame] | 1032 | if (leftType.typeKind() == Type::TypeKind::kScalar && |
| 1033 | rightType.typeKind() == Type::TypeKind::kVector && |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 1034 | !right.hasSideEffects()) { |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 1035 | // 0 / float4(x) -> float4(0) |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 1036 | vectorize_left(&b, iter, outUpdated, outNeedsRescan); |
| 1037 | } else { |
| 1038 | // 0 / x -> 0 |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 1039 | // float4(0) / x -> float4(0) |
| 1040 | // float4(0) / float4(x) -> float4(0) |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 1041 | if (!right.hasSideEffects()) { |
Ethan Nicholas | 51493ee | 2017-12-11 12:34:33 -0500 | [diff] [blame] | 1042 | delete_right(&b, iter, outUpdated, outNeedsRescan); |
| 1043 | } |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 1044 | } |
| 1045 | } |
| 1046 | break; |
Ethan Nicholas | 5a9e7fb | 2020-04-17 12:45:51 -0400 | [diff] [blame] | 1047 | case Token::Kind::TK_PLUSEQ: |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 1048 | if (is_constant(right, 0)) { |
| 1049 | clear_write(left); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 1050 | delete_right(&b, iter, outUpdated, outNeedsRescan); |
| 1051 | } |
| 1052 | break; |
Ethan Nicholas | 5a9e7fb | 2020-04-17 12:45:51 -0400 | [diff] [blame] | 1053 | case Token::Kind::TK_MINUSEQ: |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 1054 | if (is_constant(right, 0)) { |
| 1055 | clear_write(left); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 1056 | delete_right(&b, iter, outUpdated, outNeedsRescan); |
| 1057 | } |
| 1058 | break; |
Ethan Nicholas | 5a9e7fb | 2020-04-17 12:45:51 -0400 | [diff] [blame] | 1059 | case Token::Kind::TK_STAREQ: |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 1060 | if (is_constant(right, 1)) { |
| 1061 | clear_write(left); |
Ethan Nicholas | fe53e58 | 2017-04-27 16:24:51 -0400 | [diff] [blame] | 1062 | delete_right(&b, iter, outUpdated, outNeedsRescan); |
| 1063 | } |
| 1064 | break; |
Ethan Nicholas | 5a9e7fb | 2020-04-17 12:45:51 -0400 | [diff] [blame] | 1065 | case Token::Kind::TK_SLASHEQ: |
Ethan Nicholas | c8d9c8e | 2020-09-22 15:05:37 -0400 | [diff] [blame] | 1066 | if (is_constant(right, 1)) { |
| 1067 | clear_write(left); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1068 | delete_right(&b, iter, outUpdated, outNeedsRescan); |
| 1069 | } |
| 1070 | break; |
| 1071 | default: |
| 1072 | break; |
| 1073 | } |
Ethan Nicholas | 409f6f0 | 2019-09-17 12:34:39 -0400 | [diff] [blame] | 1074 | break; |
| 1075 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1076 | case Expression::Kind::kSwizzle: { |
John Stiles | 403a363 | 2020-08-20 12:11:48 -0400 | [diff] [blame] | 1077 | Swizzle& s = expr->as<Swizzle>(); |
Ethan Nicholas | 409f6f0 | 2019-09-17 12:34:39 -0400 | [diff] [blame] | 1078 | // detect identity swizzles like foo.rgba |
Ethan Nicholas | 6b4d581 | 2020-10-12 16:11:51 -0400 | [diff] [blame] | 1079 | if ((int) s.components().size() == s.base()->type().columns()) { |
Ethan Nicholas | 409f6f0 | 2019-09-17 12:34:39 -0400 | [diff] [blame] | 1080 | bool identity = true; |
Ethan Nicholas | 6b4d581 | 2020-10-12 16:11:51 -0400 | [diff] [blame] | 1081 | for (int i = 0; i < (int) s.components().size(); ++i) { |
| 1082 | if (s.components()[i] != i) { |
Ethan Nicholas | 409f6f0 | 2019-09-17 12:34:39 -0400 | [diff] [blame] | 1083 | identity = false; |
| 1084 | break; |
| 1085 | } |
| 1086 | } |
| 1087 | if (identity) { |
| 1088 | *outUpdated = true; |
Ethan Nicholas | 6b4d581 | 2020-10-12 16:11:51 -0400 | [diff] [blame] | 1089 | if (!try_replace_expression(&b, iter, &s.base())) { |
Ethan Nicholas | 409f6f0 | 2019-09-17 12:34:39 -0400 | [diff] [blame] | 1090 | *outNeedsRescan = true; |
| 1091 | return; |
| 1092 | } |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 1093 | SkASSERT((*iter)->isExpression()); |
Ethan Nicholas | 409f6f0 | 2019-09-17 12:34:39 -0400 | [diff] [blame] | 1094 | break; |
| 1095 | } |
| 1096 | } |
| 1097 | // detect swizzles of swizzles, e.g. replace foo.argb.r000 with foo.a000 |
Ethan Nicholas | 6b4d581 | 2020-10-12 16:11:51 -0400 | [diff] [blame] | 1098 | if (s.base()->kind() == Expression::Kind::kSwizzle) { |
| 1099 | Swizzle& base = s.base()->as<Swizzle>(); |
Ethan Nicholas | 409f6f0 | 2019-09-17 12:34:39 -0400 | [diff] [blame] | 1100 | std::vector<int> final; |
Ethan Nicholas | 6b4d581 | 2020-10-12 16:11:51 -0400 | [diff] [blame] | 1101 | for (int c : s.components()) { |
| 1102 | final.push_back(base.components()[c]); |
Ethan Nicholas | 409f6f0 | 2019-09-17 12:34:39 -0400 | [diff] [blame] | 1103 | } |
| 1104 | *outUpdated = true; |
Ethan Nicholas | 6b4d581 | 2020-10-12 16:11:51 -0400 | [diff] [blame] | 1105 | std::unique_ptr<Expression> replacement(new Swizzle(*fContext, base.base()->clone(), |
Ethan Nicholas | 409f6f0 | 2019-09-17 12:34:39 -0400 | [diff] [blame] | 1106 | std::move(final))); |
| 1107 | if (!try_replace_expression(&b, iter, &replacement)) { |
| 1108 | *outNeedsRescan = true; |
| 1109 | return; |
| 1110 | } |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 1111 | SkASSERT((*iter)->isExpression()); |
Ethan Nicholas | 409f6f0 | 2019-09-17 12:34:39 -0400 | [diff] [blame] | 1112 | } |
John Stiles | 30212b7 | 2020-06-11 17:55:07 -0400 | [diff] [blame] | 1113 | break; |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1114 | } |
| 1115 | default: |
| 1116 | break; |
| 1117 | } |
| 1118 | } |
| 1119 | |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1120 | // Returns true if this statement could potentially execute a break at the current level. We ignore |
| 1121 | // nested loops and switches, since any breaks inside of them will merely break the loop / switch. |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 1122 | static bool contains_conditional_break(Statement& stmt) { |
| 1123 | class ContainsConditionalBreak : public ProgramVisitor { |
| 1124 | public: |
| 1125 | bool visitStatement(const Statement& stmt) override { |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1126 | switch (stmt.kind()) { |
| 1127 | case Statement::Kind::kBlock: |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 1128 | return this->INHERITED::visitStatement(stmt); |
| 1129 | |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1130 | case Statement::Kind::kBreak: |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 1131 | return fInConditional > 0; |
| 1132 | |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1133 | case Statement::Kind::kIf: { |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 1134 | ++fInConditional; |
| 1135 | bool result = this->INHERITED::visitStatement(stmt); |
| 1136 | --fInConditional; |
| 1137 | return result; |
| 1138 | } |
| 1139 | |
| 1140 | default: |
| 1141 | return false; |
| 1142 | } |
| 1143 | } |
| 1144 | |
| 1145 | int fInConditional = 0; |
| 1146 | using INHERITED = ProgramVisitor; |
| 1147 | }; |
| 1148 | |
| 1149 | return ContainsConditionalBreak{}.visitStatement(stmt); |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1150 | } |
| 1151 | |
Ethan Nicholas | 5005a22 | 2018-08-24 13:06:27 -0400 | [diff] [blame] | 1152 | // returns true if this statement definitely executes a break at the current level (we ignore |
| 1153 | // nested loops and switches, since any breaks inside of them will merely break the loop / switch) |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 1154 | static bool contains_unconditional_break(Statement& stmt) { |
| 1155 | class ContainsUnconditionalBreak : public ProgramVisitor { |
| 1156 | public: |
| 1157 | bool visitStatement(const Statement& stmt) override { |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1158 | switch (stmt.kind()) { |
| 1159 | case Statement::Kind::kBlock: |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 1160 | return this->INHERITED::visitStatement(stmt); |
| 1161 | |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1162 | case Statement::Kind::kBreak: |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1163 | return true; |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 1164 | |
| 1165 | default: |
| 1166 | return false; |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1167 | } |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 1168 | } |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1169 | |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 1170 | using INHERITED = ProgramVisitor; |
| 1171 | }; |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1172 | |
John Stiles | b92641c | 2020-08-31 18:09:01 -0400 | [diff] [blame] | 1173 | return ContainsUnconditionalBreak{}.visitStatement(stmt); |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1174 | } |
| 1175 | |
John Stiles | 8f2a0cf | 2020-10-13 12:48:21 -0400 | [diff] [blame] | 1176 | static void move_all_but_break(std::unique_ptr<Statement>& stmt, StatementArray* target) { |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1177 | switch (stmt->kind()) { |
| 1178 | case Statement::Kind::kBlock: { |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1179 | // Recurse into the block. |
| 1180 | Block& block = static_cast<Block&>(*stmt); |
| 1181 | |
John Stiles | 8f2a0cf | 2020-10-13 12:48:21 -0400 | [diff] [blame] | 1182 | StatementArray blockStmts; |
John Stiles | f4bda74 | 2020-10-14 16:57:41 -0400 | [diff] [blame] | 1183 | blockStmts.reserve_back(block.children().size()); |
Ethan Nicholas | 7bd6043 | 2020-09-25 14:31:59 -0400 | [diff] [blame] | 1184 | for (std::unique_ptr<Statement>& stmt : block.children()) { |
| 1185 | move_all_but_break(stmt, &blockStmts); |
Ethan Nicholas | 739e1ca | 2020-06-11 12:16:14 -0400 | [diff] [blame] | 1186 | } |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1187 | |
| 1188 | target->push_back(std::make_unique<Block>(block.fOffset, std::move(blockStmts), |
Ethan Nicholas | 7bd6043 | 2020-09-25 14:31:59 -0400 | [diff] [blame] | 1189 | block.symbolTable(), block.isScope())); |
Ethan Nicholas | 739e1ca | 2020-06-11 12:16:14 -0400 | [diff] [blame] | 1190 | break; |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1191 | } |
| 1192 | |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1193 | case Statement::Kind::kBreak: |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1194 | // Do not append a break to the target. |
| 1195 | break; |
| 1196 | |
Ethan Nicholas | 739e1ca | 2020-06-11 12:16:14 -0400 | [diff] [blame] | 1197 | default: |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1198 | // Append normal statements to the target. |
| 1199 | target->push_back(std::move(stmt)); |
| 1200 | break; |
Ethan Nicholas | 739e1ca | 2020-06-11 12:16:14 -0400 | [diff] [blame] | 1201 | } |
| 1202 | } |
| 1203 | |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1204 | // Returns a block containing all of the statements that will be run if the given case matches |
| 1205 | // (which, owing to the statements being owned by unique_ptrs, means the switch itself will be |
| 1206 | // broken by this call and must then be discarded). |
| 1207 | // Returns null (and leaves the switch unmodified) if no such simple reduction is possible, such as |
| 1208 | // when break statements appear inside conditionals. |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1209 | static std::unique_ptr<Statement> block_for_case(SwitchStatement* switchStatement, |
| 1210 | SwitchCase* caseToCapture) { |
| 1211 | // We have to be careful to not move any of the pointers until after we're sure we're going to |
| 1212 | // succeed, so before we make any changes at all, we check the switch-cases to decide on a plan |
| 1213 | // of action. First, find the switch-case we are interested in. |
| 1214 | auto iter = switchStatement->fCases.begin(); |
| 1215 | for (; iter != switchStatement->fCases.end(); ++iter) { |
| 1216 | if (iter->get() == caseToCapture) { |
| 1217 | break; |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1218 | } |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1219 | } |
| 1220 | |
| 1221 | // Next, walk forward through the rest of the switch. If we find a conditional break, we're |
| 1222 | // stuck and can't simplify at all. If we find an unconditional break, we have a range of |
| 1223 | // statements that we can use for simplification. |
| 1224 | auto startIter = iter; |
| 1225 | Statement* unconditionalBreakStmt = nullptr; |
| 1226 | for (; iter != switchStatement->fCases.end(); ++iter) { |
| 1227 | for (std::unique_ptr<Statement>& stmt : (*iter)->fStatements) { |
| 1228 | if (contains_conditional_break(*stmt)) { |
| 1229 | // We can't reduce switch-cases to a block when they have conditional breaks. |
| 1230 | return nullptr; |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1231 | } |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1232 | |
| 1233 | if (contains_unconditional_break(*stmt)) { |
| 1234 | // We found an unconditional break. We can use this block, but we need to strip |
| 1235 | // out the break statement. |
| 1236 | unconditionalBreakStmt = stmt.get(); |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1237 | break; |
| 1238 | } |
| 1239 | } |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1240 | |
| 1241 | if (unconditionalBreakStmt != nullptr) { |
| 1242 | break; |
| 1243 | } |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1244 | } |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1245 | |
| 1246 | // We fell off the bottom of the switch or encountered a break. We know the range of statements |
| 1247 | // that we need to move over, and we know it's safe to do so. |
John Stiles | 8f2a0cf | 2020-10-13 12:48:21 -0400 | [diff] [blame] | 1248 | StatementArray caseStmts; |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1249 | |
| 1250 | // We can move over most of the statements as-is. |
| 1251 | while (startIter != iter) { |
| 1252 | for (std::unique_ptr<Statement>& stmt : (*startIter)->fStatements) { |
| 1253 | caseStmts.push_back(std::move(stmt)); |
| 1254 | } |
| 1255 | ++startIter; |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1256 | } |
John Stiles | 92219b4 | 2020-06-15 12:32:24 -0400 | [diff] [blame] | 1257 | |
| 1258 | // If we found an unconditional break at the end, we need to move what we can while avoiding |
| 1259 | // that break. |
| 1260 | if (unconditionalBreakStmt != nullptr) { |
| 1261 | for (std::unique_ptr<Statement>& stmt : (*startIter)->fStatements) { |
| 1262 | if (stmt.get() == unconditionalBreakStmt) { |
| 1263 | move_all_but_break(stmt, &caseStmts); |
| 1264 | unconditionalBreakStmt = nullptr; |
| 1265 | break; |
| 1266 | } |
| 1267 | |
| 1268 | caseStmts.push_back(std::move(stmt)); |
| 1269 | } |
| 1270 | } |
| 1271 | |
| 1272 | SkASSERT(unconditionalBreakStmt == nullptr); // Verify that we fixed the unconditional break. |
| 1273 | |
| 1274 | // Return our newly-synthesized block. |
| 1275 | return std::make_unique<Block>(/*offset=*/-1, std::move(caseStmts), switchStatement->fSymbols); |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1276 | } |
| 1277 | |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1278 | void Compiler::simplifyStatement(DefinitionMap& definitions, |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1279 | BasicBlock& b, |
| 1280 | std::vector<BasicBlock::Node>::iterator* iter, |
| 1281 | std::unordered_set<const Variable*>* undefinedVariables, |
| 1282 | bool* outUpdated, |
| 1283 | bool* outNeedsRescan) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1284 | Statement* stmt = (*iter)->statement()->get(); |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1285 | switch (stmt->kind()) { |
| 1286 | case Statement::Kind::kVarDeclaration: { |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 1287 | const auto& varDecl = stmt->as<VarDeclaration>(); |
Ethan Nicholas | c51f33e | 2020-10-13 13:49:44 -0400 | [diff] [blame] | 1288 | if (varDecl.var().dead() && |
| 1289 | (!varDecl.value() || |
| 1290 | !varDecl.value()->hasSideEffects())) { |
| 1291 | if (varDecl.value()) { |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 1292 | SkASSERT((*iter)->statement()->get() == stmt); |
Ethan Nicholas | c51f33e | 2020-10-13 13:49:44 -0400 | [diff] [blame] | 1293 | if (!b.tryRemoveExpressionBefore(iter, varDecl.value().get())) { |
Ethan Nicholas | 82a62d2 | 2017-11-07 14:42:10 +0000 | [diff] [blame] | 1294 | *outNeedsRescan = true; |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1295 | } |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1296 | } |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1297 | (*iter)->setStatement(std::unique_ptr<Statement>(new Nop())); |
Ethan Nicholas | 82a62d2 | 2017-11-07 14:42:10 +0000 | [diff] [blame] | 1298 | *outUpdated = true; |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1299 | } |
| 1300 | break; |
| 1301 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1302 | case Statement::Kind::kIf: { |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 1303 | IfStatement& i = stmt->as<IfStatement>(); |
Ethan Nicholas | 8c44eca | 2020-10-07 16:47:09 -0400 | [diff] [blame] | 1304 | if (i.test()->kind() == Expression::Kind::kBoolLiteral) { |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1305 | // constant if, collapse down to a single branch |
Ethan Nicholas | 8c44eca | 2020-10-07 16:47:09 -0400 | [diff] [blame] | 1306 | if (i.test()->as<BoolLiteral>().value()) { |
| 1307 | SkASSERT(i.ifTrue()); |
| 1308 | (*iter)->setStatement(std::move(i.ifTrue())); |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1309 | } else { |
Ethan Nicholas | 8c44eca | 2020-10-07 16:47:09 -0400 | [diff] [blame] | 1310 | if (i.ifFalse()) { |
| 1311 | (*iter)->setStatement(std::move(i.ifFalse())); |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1312 | } else { |
| 1313 | (*iter)->setStatement(std::unique_ptr<Statement>(new Nop())); |
| 1314 | } |
| 1315 | } |
| 1316 | *outUpdated = true; |
| 1317 | *outNeedsRescan = true; |
| 1318 | break; |
| 1319 | } |
Ethan Nicholas | 8c44eca | 2020-10-07 16:47:09 -0400 | [diff] [blame] | 1320 | if (i.ifFalse() && i.ifFalse()->isEmpty()) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1321 | // else block doesn't do anything, remove it |
Ethan Nicholas | 8c44eca | 2020-10-07 16:47:09 -0400 | [diff] [blame] | 1322 | i.ifFalse().reset(); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1323 | *outUpdated = true; |
| 1324 | *outNeedsRescan = true; |
| 1325 | } |
Ethan Nicholas | 8c44eca | 2020-10-07 16:47:09 -0400 | [diff] [blame] | 1326 | if (!i.ifFalse() && i.ifTrue()->isEmpty()) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1327 | // if block doesn't do anything, no else block |
Ethan Nicholas | 8c44eca | 2020-10-07 16:47:09 -0400 | [diff] [blame] | 1328 | if (i.test()->hasSideEffects()) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1329 | // test has side effects, keep it |
| 1330 | (*iter)->setStatement(std::unique_ptr<Statement>( |
Ethan Nicholas | 8c44eca | 2020-10-07 16:47:09 -0400 | [diff] [blame] | 1331 | new ExpressionStatement(std::move(i.test())))); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1332 | } else { |
| 1333 | // no if, no else, no test side effects, kill the whole if |
| 1334 | // statement |
| 1335 | (*iter)->setStatement(std::unique_ptr<Statement>(new Nop())); |
| 1336 | } |
| 1337 | *outUpdated = true; |
| 1338 | *outNeedsRescan = true; |
| 1339 | } |
| 1340 | break; |
| 1341 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1342 | case Statement::Kind::kSwitch: { |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 1343 | SwitchStatement& s = stmt->as<SwitchStatement>(); |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1344 | int64_t switchValue; |
| 1345 | if (fIRGenerator->getConstantInt(*s.fValue, &switchValue)) { |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1346 | // switch is constant, replace it with the case that matches |
| 1347 | bool found = false; |
| 1348 | SwitchCase* defaultCase = nullptr; |
John Stiles | 9d94423 | 2020-08-19 09:56:49 -0400 | [diff] [blame] | 1349 | for (const std::unique_ptr<SwitchCase>& c : s.fCases) { |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1350 | if (!c->fValue) { |
| 1351 | defaultCase = c.get(); |
| 1352 | continue; |
| 1353 | } |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1354 | int64_t caseValue; |
| 1355 | SkAssertResult(fIRGenerator->getConstantInt(*c->fValue, &caseValue)); |
| 1356 | if (caseValue == switchValue) { |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1357 | std::unique_ptr<Statement> newBlock = block_for_case(&s, c.get()); |
| 1358 | if (newBlock) { |
| 1359 | (*iter)->setStatement(std::move(newBlock)); |
John Stiles | 9d94423 | 2020-08-19 09:56:49 -0400 | [diff] [blame] | 1360 | found = true; |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1361 | break; |
| 1362 | } else { |
Ethan Nicholas | 6e1cbc0 | 2017-07-14 10:12:15 -0400 | [diff] [blame] | 1363 | if (s.fIsStatic && !(fFlags & kPermitInvalidStaticTests_Flag)) { |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1364 | this->error(s.fOffset, |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1365 | "static switch contains non-static conditional break"); |
| 1366 | s.fIsStatic = false; |
| 1367 | } |
| 1368 | return; // can't simplify |
| 1369 | } |
| 1370 | } |
| 1371 | } |
| 1372 | if (!found) { |
| 1373 | // no matching case. use default if it exists, or kill the whole thing |
| 1374 | if (defaultCase) { |
| 1375 | std::unique_ptr<Statement> newBlock = block_for_case(&s, defaultCase); |
| 1376 | if (newBlock) { |
| 1377 | (*iter)->setStatement(std::move(newBlock)); |
| 1378 | } else { |
Ethan Nicholas | 6e1cbc0 | 2017-07-14 10:12:15 -0400 | [diff] [blame] | 1379 | if (s.fIsStatic && !(fFlags & kPermitInvalidStaticTests_Flag)) { |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1380 | this->error(s.fOffset, |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1381 | "static switch contains non-static conditional break"); |
| 1382 | s.fIsStatic = false; |
| 1383 | } |
| 1384 | return; // can't simplify |
| 1385 | } |
| 1386 | } else { |
| 1387 | (*iter)->setStatement(std::unique_ptr<Statement>(new Nop())); |
| 1388 | } |
| 1389 | } |
| 1390 | *outUpdated = true; |
| 1391 | *outNeedsRescan = true; |
| 1392 | } |
| 1393 | break; |
| 1394 | } |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1395 | case Statement::Kind::kExpression: { |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 1396 | ExpressionStatement& e = stmt->as<ExpressionStatement>(); |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 1397 | SkASSERT((*iter)->statement()->get() == &e); |
Ethan Nicholas | d503a5a | 2020-09-30 09:29:55 -0400 | [diff] [blame] | 1398 | if (!e.expression()->hasSideEffects()) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1399 | // Expression statement with no side effects, kill it |
Ethan Nicholas | d503a5a | 2020-09-30 09:29:55 -0400 | [diff] [blame] | 1400 | if (!b.tryRemoveExpressionBefore(iter, e.expression().get())) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1401 | *outNeedsRescan = true; |
| 1402 | } |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 1403 | SkASSERT((*iter)->statement()->get() == stmt); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1404 | (*iter)->setStatement(std::unique_ptr<Statement>(new Nop())); |
| 1405 | *outUpdated = true; |
| 1406 | } |
| 1407 | break; |
| 1408 | } |
| 1409 | default: |
| 1410 | break; |
| 1411 | } |
| 1412 | } |
| 1413 | |
John Stiles | 0cc193a | 2020-09-09 09:39:34 -0400 | [diff] [blame] | 1414 | bool Compiler::scanCFG(FunctionDefinition& f) { |
| 1415 | bool madeChanges = false; |
| 1416 | |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1417 | CFG cfg = CFGGenerator().getCFG(f); |
| 1418 | this->computeDataFlow(&cfg); |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 1419 | |
| 1420 | // check for unreachable code |
| 1421 | for (size_t i = 0; i < cfg.fBlocks.size(); i++) { |
John Stiles | 0cc193a | 2020-09-09 09:39:34 -0400 | [diff] [blame] | 1422 | const BasicBlock& block = cfg.fBlocks[i]; |
John Stiles | 61e75e3 | 2020-10-01 15:42:37 -0400 | [diff] [blame] | 1423 | if (i != cfg.fStart && !block.fIsReachable && block.fNodes.size()) { |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1424 | int offset; |
John Stiles | 0cc193a | 2020-09-09 09:39:34 -0400 | [diff] [blame] | 1425 | const BasicBlock::Node& node = block.fNodes[0]; |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 1426 | if (node.isStatement()) { |
| 1427 | offset = (*node.statement())->fOffset; |
| 1428 | } else { |
| 1429 | offset = (*node.expression())->fOffset; |
| 1430 | if ((*node.expression())->is<BoolLiteral>()) { |
| 1431 | // Function inlining can generate do { ... } while(false) loops which always |
| 1432 | // break, so the boolean condition is considered unreachable. Since not being |
| 1433 | // able to reach a literal is a non-issue in the first place, we don't report an |
| 1434 | // error in this case. |
| 1435 | continue; |
| 1436 | } |
Ethan Nicholas | 86a4340 | 2017-01-19 13:32:00 -0500 | [diff] [blame] | 1437 | } |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1438 | this->error(offset, String("unreachable")); |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 1439 | } |
| 1440 | } |
| 1441 | if (fErrorCount) { |
John Stiles | 0cc193a | 2020-09-09 09:39:34 -0400 | [diff] [blame] | 1442 | return madeChanges; |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 1443 | } |
| 1444 | |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1445 | // check for dead code & undefined variables, perform constant propagation |
| 1446 | std::unordered_set<const Variable*> undefinedVariables; |
| 1447 | bool updated; |
| 1448 | bool needsRescan = false; |
| 1449 | do { |
| 1450 | if (needsRescan) { |
| 1451 | cfg = CFGGenerator().getCFG(f); |
| 1452 | this->computeDataFlow(&cfg); |
| 1453 | needsRescan = false; |
Ethan Nicholas | 113628d | 2017-02-02 16:11:39 -0500 | [diff] [blame] | 1454 | } |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1455 | |
| 1456 | updated = false; |
Ethan Nicholas | 1de1481 | 2020-06-19 15:32:49 -0400 | [diff] [blame] | 1457 | bool first = true; |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1458 | for (BasicBlock& b : cfg.fBlocks) { |
John Stiles | 61e75e3 | 2020-10-01 15:42:37 -0400 | [diff] [blame] | 1459 | if (!first && !b.fIsReachable) { |
Ethan Nicholas | 1de1481 | 2020-06-19 15:32:49 -0400 | [diff] [blame] | 1460 | // Block was reachable before optimization, but has since become unreachable. In |
| 1461 | // addition to being dead code, it's broken - since control flow can't reach it, no |
| 1462 | // prior variable definitions can reach it, and therefore variables might look to |
Brian Osman | c021360 | 2020-10-06 14:43:32 -0400 | [diff] [blame] | 1463 | // have not been properly assigned. Kill it by replacing all statements with Nops. |
Ethan Nicholas | 1de1481 | 2020-06-19 15:32:49 -0400 | [diff] [blame] | 1464 | for (BasicBlock::Node& node : b.fNodes) { |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 1465 | if (node.isStatement() && !(*node.statement())->is<Nop>()) { |
John Stiles | 0cc193a | 2020-09-09 09:39:34 -0400 | [diff] [blame] | 1466 | node.setStatement(std::make_unique<Nop>()); |
| 1467 | madeChanges = true; |
Ethan Nicholas | 1de1481 | 2020-06-19 15:32:49 -0400 | [diff] [blame] | 1468 | } |
| 1469 | } |
| 1470 | continue; |
| 1471 | } |
| 1472 | first = false; |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1473 | DefinitionMap definitions = b.fBefore; |
| 1474 | |
| 1475 | for (auto iter = b.fNodes.begin(); iter != b.fNodes.end() && !needsRescan; ++iter) { |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 1476 | if (iter->isExpression()) { |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1477 | this->simplifyExpression(definitions, b, &iter, &undefinedVariables, &updated, |
| 1478 | &needsRescan); |
| 1479 | } else { |
| 1480 | this->simplifyStatement(definitions, b, &iter, &undefinedVariables, &updated, |
John Stiles | 0cc193a | 2020-09-09 09:39:34 -0400 | [diff] [blame] | 1481 | &needsRescan); |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1482 | } |
Ethan Nicholas | 4b330df | 2017-05-17 10:52:55 -0400 | [diff] [blame] | 1483 | if (needsRescan) { |
| 1484 | break; |
| 1485 | } |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1486 | this->addDefinitions(*iter, &definitions); |
| 1487 | } |
Brian Osman | 01a3eb4 | 2020-09-14 11:32:49 -0400 | [diff] [blame] | 1488 | |
| 1489 | if (needsRescan) { |
| 1490 | break; |
| 1491 | } |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1492 | } |
John Stiles | 0cc193a | 2020-09-09 09:39:34 -0400 | [diff] [blame] | 1493 | madeChanges |= updated; |
Ethan Nicholas | cb67096 | 2017-04-20 19:31:52 -0400 | [diff] [blame] | 1494 | } while (updated); |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 1495 | SkASSERT(!needsRescan); |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 1496 | |
Ethan Nicholas | 91a1053 | 2017-06-22 11:24:38 -0400 | [diff] [blame] | 1497 | // verify static ifs & switches, clean up dead variable decls |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1498 | for (BasicBlock& b : cfg.fBlocks) { |
Ethan Nicholas | 91a1053 | 2017-06-22 11:24:38 -0400 | [diff] [blame] | 1499 | for (auto iter = b.fNodes.begin(); iter != b.fNodes.end() && !needsRescan;) { |
John Stiles | 70025e5 | 2020-09-28 16:08:58 -0400 | [diff] [blame] | 1500 | if (iter->isStatement()) { |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1501 | const Statement& s = **iter->statement(); |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1502 | switch (s.kind()) { |
| 1503 | case Statement::Kind::kIf: |
Ethan Nicholas | 8c44eca | 2020-10-07 16:47:09 -0400 | [diff] [blame] | 1504 | if (s.as<IfStatement>().isStatic() && |
Ethan Nicholas | 6e1cbc0 | 2017-07-14 10:12:15 -0400 | [diff] [blame] | 1505 | !(fFlags & kPermitInvalidStaticTests_Flag)) { |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1506 | this->error(s.fOffset, "static if has non-static test"); |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1507 | } |
Ethan Nicholas | 91a1053 | 2017-06-22 11:24:38 -0400 | [diff] [blame] | 1508 | ++iter; |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1509 | break; |
Ethan Nicholas | e659214 | 2020-09-08 10:22:09 -0400 | [diff] [blame] | 1510 | case Statement::Kind::kSwitch: |
John Stiles | a5a97b4 | 2020-08-18 11:19:07 -0400 | [diff] [blame] | 1511 | if (s.as<SwitchStatement>().fIsStatic && |
John Stiles | 0cc193a | 2020-09-09 09:39:34 -0400 | [diff] [blame] | 1512 | !(fFlags & kPermitInvalidStaticTests_Flag)) { |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1513 | this->error(s.fOffset, "static switch has non-static test"); |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1514 | } |
Ethan Nicholas | 91a1053 | 2017-06-22 11:24:38 -0400 | [diff] [blame] | 1515 | ++iter; |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1516 | break; |
| 1517 | default: |
Ethan Nicholas | 91a1053 | 2017-06-22 11:24:38 -0400 | [diff] [blame] | 1518 | ++iter; |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1519 | break; |
| 1520 | } |
Ethan Nicholas | 91a1053 | 2017-06-22 11:24:38 -0400 | [diff] [blame] | 1521 | } else { |
| 1522 | ++iter; |
Ethan Nicholas | 5ac13c2 | 2017-05-10 15:06:17 -0400 | [diff] [blame] | 1523 | } |
| 1524 | } |
| 1525 | } |
| 1526 | |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 1527 | // check for missing return |
Ethan Nicholas | 0a5d096 | 2020-10-14 13:33:18 -0400 | [diff] [blame] | 1528 | if (f.declaration().returnType() != *fContext->fVoid_Type) { |
John Stiles | 61e75e3 | 2020-10-01 15:42:37 -0400 | [diff] [blame] | 1529 | if (cfg.fBlocks[cfg.fExit].fIsReachable) { |
Ethan Nicholas | 0a5d096 | 2020-10-14 13:33:18 -0400 | [diff] [blame] | 1530 | this->error(f.fOffset, String("function '" + String(f.declaration().name()) + |
Ethan Nicholas | db80f69 | 2019-11-22 14:06:12 -0500 | [diff] [blame] | 1531 | "' can exit without returning a value")); |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 1532 | } |
| 1533 | } |
John Stiles | 0cc193a | 2020-09-09 09:39:34 -0400 | [diff] [blame] | 1534 | |
| 1535 | return madeChanges; |
ethannicholas | 22f939e | 2016-10-13 13:25:34 -0700 | [diff] [blame] | 1536 | } |
| 1537 | |
Brian Osman | 32d5355 | 2020-09-23 13:55:20 -0400 | [diff] [blame] | 1538 | std::unique_ptr<Program> Compiler::convertProgram( |
| 1539 | Program::Kind kind, |
| 1540 | String text, |
| 1541 | const Program::Settings& settings, |
| 1542 | const std::vector<std::unique_ptr<ExternalValue>>* externalValues) { |
| 1543 | SkASSERT(!externalValues || (kind == Program::kGeneric_Kind)); |
Ethan Nicholas | 91164d1 | 2019-05-15 15:29:54 -0400 | [diff] [blame] | 1544 | |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 1545 | fErrorText = ""; |
| 1546 | fErrorCount = 0; |
Brian Osman | 3d87e9f | 2020-10-08 11:50:22 -0400 | [diff] [blame] | 1547 | fInliner.reset(fContext.get(), fIRGenerator->fModifiers.get(), &settings); |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 1548 | |
| 1549 | // Not using AutoSource, because caller is likely to call errorText() if we fail to compile |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1550 | std::unique_ptr<String> textPtr(new String(std::move(text))); |
| 1551 | fSource = textPtr.get(); |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 1552 | |
| 1553 | const ParsedModule& baseModule = this->moduleForProgramKind(kind); |
| 1554 | |
| 1555 | IRGenerator::IRBundle ir = |
| 1556 | fIRGenerator->convertProgram(kind, &settings, baseModule, /*isBuiltinCode=*/false, |
| 1557 | textPtr->c_str(), textPtr->size(), externalValues); |
John Stiles | fbd050b | 2020-08-03 13:21:46 -0400 | [diff] [blame] | 1558 | auto result = std::make_unique<Program>(kind, |
| 1559 | std::move(textPtr), |
| 1560 | settings, |
| 1561 | fContext, |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 1562 | std::move(ir.fElements), |
| 1563 | std::move(ir.fModifiers), |
| 1564 | std::move(ir.fSymbolTable), |
| 1565 | ir.fInputs); |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 1566 | if (fErrorCount) { |
| 1567 | return nullptr; |
| 1568 | } |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1569 | if (settings.fOptimize && !this->optimize(*result)) { |
| 1570 | return nullptr; |
| 1571 | } |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 1572 | return result; |
| 1573 | } |
| 1574 | |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1575 | bool Compiler::optimize(Program& program) { |
| 1576 | SkASSERT(!fErrorCount); |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1577 | fIRGenerator->fKind = program.fKind; |
| 1578 | fIRGenerator->fSettings = &program.fSettings; |
John Stiles | 7954d6c | 2020-09-01 10:53:02 -0400 | [diff] [blame] | 1579 | |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1580 | while (fErrorCount == 0) { |
| 1581 | bool madeChanges = false; |
John Stiles | 7954d6c | 2020-09-01 10:53:02 -0400 | [diff] [blame] | 1582 | |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1583 | // Scan and optimize based on the control-flow graph for each function. |
Brian Osman | 1179fcf | 2020-10-08 16:04:40 -0400 | [diff] [blame] | 1584 | for (const auto& element : program.elements()) { |
| 1585 | if (element->is<FunctionDefinition>()) { |
| 1586 | madeChanges |= this->scanCFG(element->as<FunctionDefinition>()); |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1587 | } |
| 1588 | } |
| 1589 | |
| 1590 | // Perform inline-candidate analysis and inline any functions deemed suitable. |
John Stiles | 881a10c | 2020-09-19 10:13:24 -0400 | [diff] [blame] | 1591 | madeChanges |= fInliner.analyze(program); |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1592 | |
| 1593 | // Remove dead functions. We wait until after analysis so that we still report errors, |
| 1594 | // even in unused code. |
| 1595 | if (program.fSettings.fRemoveDeadFunctions) { |
| 1596 | program.fElements.erase( |
| 1597 | std::remove_if(program.fElements.begin(), |
| 1598 | program.fElements.end(), |
| 1599 | [&](const std::unique_ptr<ProgramElement>& element) { |
| 1600 | if (!element->is<FunctionDefinition>()) { |
| 1601 | return false; |
| 1602 | } |
| 1603 | const auto& fn = element->as<FunctionDefinition>(); |
Ethan Nicholas | 0a5d096 | 2020-10-14 13:33:18 -0400 | [diff] [blame] | 1604 | bool dead = fn.declaration().callCount() == 0 && |
| 1605 | fn.declaration().name() != "main"; |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1606 | madeChanges |= dead; |
| 1607 | return dead; |
| 1608 | }), |
| 1609 | program.fElements.end()); |
| 1610 | } |
| 1611 | |
| 1612 | if (program.fKind != Program::kFragmentProcessor_Kind) { |
Brian Osman | c021360 | 2020-10-06 14:43:32 -0400 | [diff] [blame] | 1613 | // Remove declarations of dead global variables |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1614 | program.fElements.erase( |
| 1615 | std::remove_if(program.fElements.begin(), program.fElements.end(), |
| 1616 | [&](const std::unique_ptr<ProgramElement>& element) { |
Brian Osman | c021360 | 2020-10-06 14:43:32 -0400 | [diff] [blame] | 1617 | if (!element->is<GlobalVarDeclaration>()) { |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1618 | return false; |
| 1619 | } |
Ethan Nicholas | c51f33e | 2020-10-13 13:49:44 -0400 | [diff] [blame] | 1620 | const auto& global = element->as<GlobalVarDeclaration>(); |
| 1621 | const auto& varDecl = |
| 1622 | global.declaration()->as<VarDeclaration>(); |
| 1623 | bool dead = varDecl.var().dead(); |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1624 | madeChanges |= dead; |
| 1625 | return dead; |
| 1626 | }), |
| 1627 | program.fElements.end()); |
| 1628 | } |
John Stiles | 73a6bff | 2020-09-09 13:40:37 -0400 | [diff] [blame] | 1629 | |
Ethan Nicholas | 34b19c5 | 2020-09-14 11:33:47 -0400 | [diff] [blame] | 1630 | if (!madeChanges) { |
| 1631 | break; |
Ethan Nicholas | 0dc8087 | 2019-02-08 15:46:24 -0500 | [diff] [blame] | 1632 | } |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1633 | } |
| 1634 | return fErrorCount == 0; |
| 1635 | } |
| 1636 | |
Brian Osman | fb32ddf | 2019-06-18 10:14:20 -0400 | [diff] [blame] | 1637 | #if defined(SKSL_STANDALONE) || SK_SUPPORT_GPU |
| 1638 | |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1639 | bool Compiler::toSPIRV(Program& program, OutputStream& out) { |
Ethan Nicholas | a6ae1f7 | 2017-03-16 09:56:54 -0400 | [diff] [blame] | 1640 | #ifdef SK_ENABLE_SPIRV_VALIDATION |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 1641 | StringStream buffer; |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 1642 | AutoSource as(this, program.fSource.get()); |
Brian Osman | 8b43dad | 2020-10-09 13:31:42 -0400 | [diff] [blame] | 1643 | SPIRVCodeGenerator cg(fContext.get(), &program, this, &buffer); |
Ethan Nicholas | a6ae1f7 | 2017-03-16 09:56:54 -0400 | [diff] [blame] | 1644 | bool result = cg.generateCode(); |
| 1645 | if (result) { |
Ethan Nicholas | a6ae1f7 | 2017-03-16 09:56:54 -0400 | [diff] [blame] | 1646 | spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_0); |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 1647 | const String& data = buffer.str(); |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 1648 | SkASSERT(0 == data.size() % 4); |
Ethan Nicholas | a6ae1f7 | 2017-03-16 09:56:54 -0400 | [diff] [blame] | 1649 | auto dumpmsg = [](spv_message_level_t, const char*, const spv_position_t&, const char* m) { |
| 1650 | SkDebugf("SPIR-V validation error: %s\n", m); |
| 1651 | }; |
| 1652 | tools.SetMessageConsumer(dumpmsg); |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 1653 | // Verify that the SPIR-V we produced is valid. If this SkASSERT fails, check the logs prior |
Ethan Nicholas | a6ae1f7 | 2017-03-16 09:56:54 -0400 | [diff] [blame] | 1654 | // to the failure to see the validation errors. |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 1655 | SkAssertResult(tools.Validate((const uint32_t*) data.c_str(), data.size() / 4)); |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 1656 | out.write(data.c_str(), data.size()); |
Ethan Nicholas | a6ae1f7 | 2017-03-16 09:56:54 -0400 | [diff] [blame] | 1657 | } |
| 1658 | #else |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 1659 | AutoSource as(this, program.fSource.get()); |
Brian Osman | 8b43dad | 2020-10-09 13:31:42 -0400 | [diff] [blame] | 1660 | SPIRVCodeGenerator cg(fContext.get(), &program, this, &out); |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 1661 | bool result = cg.generateCode(); |
Ethan Nicholas | a6ae1f7 | 2017-03-16 09:56:54 -0400 | [diff] [blame] | 1662 | #endif |
Ethan Nicholas | ce33f10 | 2016-12-09 17:22:59 -0500 | [diff] [blame] | 1663 | return result; |
| 1664 | } |
| 1665 | |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1666 | bool Compiler::toSPIRV(Program& program, String* out) { |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 1667 | StringStream buffer; |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 1668 | bool result = this->toSPIRV(program, buffer); |
| 1669 | if (result) { |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 1670 | *out = buffer.str(); |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 1671 | } |
| 1672 | return result; |
| 1673 | } |
| 1674 | |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1675 | bool Compiler::toGLSL(Program& program, OutputStream& out) { |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 1676 | AutoSource as(this, program.fSource.get()); |
Ethan Nicholas | 26a9aad | 2018-03-27 14:10:52 -0400 | [diff] [blame] | 1677 | GLSLCodeGenerator cg(fContext.get(), &program, this, &out); |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 1678 | bool result = cg.generateCode(); |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 1679 | return result; |
| 1680 | } |
| 1681 | |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1682 | bool Compiler::toGLSL(Program& program, String* out) { |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 1683 | StringStream buffer; |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 1684 | bool result = this->toGLSL(program, buffer); |
| 1685 | if (result) { |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 1686 | *out = buffer.str(); |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 1687 | } |
| 1688 | return result; |
| 1689 | } |
| 1690 | |
Brian Osman | c024391 | 2020-02-19 15:35:26 -0500 | [diff] [blame] | 1691 | bool Compiler::toHLSL(Program& program, String* out) { |
| 1692 | String spirv; |
| 1693 | if (!this->toSPIRV(program, &spirv)) { |
| 1694 | return false; |
| 1695 | } |
| 1696 | |
| 1697 | return SPIRVtoHLSL(spirv, out); |
| 1698 | } |
| 1699 | |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1700 | bool Compiler::toMetal(Program& program, OutputStream& out) { |
Ethan Nicholas | 26a9aad | 2018-03-27 14:10:52 -0400 | [diff] [blame] | 1701 | MetalCodeGenerator cg(fContext.get(), &program, this, &out); |
Ethan Nicholas | cc30577 | 2017-10-13 16:17:45 -0400 | [diff] [blame] | 1702 | bool result = cg.generateCode(); |
Ethan Nicholas | cc30577 | 2017-10-13 16:17:45 -0400 | [diff] [blame] | 1703 | return result; |
| 1704 | } |
| 1705 | |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1706 | bool Compiler::toMetal(Program& program, String* out) { |
Timothy Liang | b8eeb80 | 2018-07-23 16:46:16 -0400 | [diff] [blame] | 1707 | StringStream buffer; |
| 1708 | bool result = this->toMetal(program, buffer); |
| 1709 | if (result) { |
| 1710 | *out = buffer.str(); |
| 1711 | } |
| 1712 | return result; |
| 1713 | } |
| 1714 | |
Greg Daniel | a28ea67 | 2020-09-25 11:12:56 -0400 | [diff] [blame] | 1715 | #if defined(SKSL_STANDALONE) || GR_TEST_UTILS |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1716 | bool Compiler::toCPP(Program& program, String name, OutputStream& out) { |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 1717 | AutoSource as(this, program.fSource.get()); |
Ethan Nicholas | 26a9aad | 2018-03-27 14:10:52 -0400 | [diff] [blame] | 1718 | CPPCodeGenerator cg(fContext.get(), &program, this, name, &out); |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 1719 | bool result = cg.generateCode(); |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 1720 | return result; |
| 1721 | } |
| 1722 | |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1723 | bool Compiler::toH(Program& program, String name, OutputStream& out) { |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 1724 | AutoSource as(this, program.fSource.get()); |
Ethan Nicholas | 26a9aad | 2018-03-27 14:10:52 -0400 | [diff] [blame] | 1725 | HCodeGenerator cg(fContext.get(), &program, this, name, &out); |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 1726 | bool result = cg.generateCode(); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1727 | return result; |
| 1728 | } |
Greg Daniel | a28ea67 | 2020-09-25 11:12:56 -0400 | [diff] [blame] | 1729 | #endif // defined(SKSL_STANDALONE) || GR_TEST_UTILS |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1730 | |
Ethan Nicholas | 2a479a5 | 2020-08-18 16:29:45 -0400 | [diff] [blame] | 1731 | #endif // defined(SKSL_STANDALONE) || SK_SUPPORT_GPU |
Brian Osman | 2e29ab5 | 2019-09-20 12:19:11 -0400 | [diff] [blame] | 1732 | |
| 1733 | #if !defined(SKSL_STANDALONE) && SK_SUPPORT_GPU |
Brian Osman | a4b9169 | 2020-08-10 14:26:16 -0400 | [diff] [blame] | 1734 | bool Compiler::toPipelineStage(Program& program, PipelineStageArgs* outArgs) { |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 1735 | AutoSource as(this, program.fSource.get()); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1736 | StringStream buffer; |
Brian Osman | 300fe1d | 2020-01-23 15:42:43 -0500 | [diff] [blame] | 1737 | PipelineStageCodeGenerator cg(fContext.get(), &program, this, &buffer, outArgs); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1738 | bool result = cg.generateCode(); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1739 | if (result) { |
Brian Osman | 107c666 | 2019-12-30 15:02:30 -0500 | [diff] [blame] | 1740 | outArgs->fCode = buffer.str(); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1741 | } |
Ethan Nicholas | 762466e | 2017-06-29 10:03:38 -0400 | [diff] [blame] | 1742 | return result; |
| 1743 | } |
Brian Osman | fb32ddf | 2019-06-18 10:14:20 -0400 | [diff] [blame] | 1744 | #endif |
| 1745 | |
Ethan Nicholas | 0e9401d | 2019-03-21 11:05:37 -0400 | [diff] [blame] | 1746 | std::unique_ptr<ByteCode> Compiler::toByteCode(Program& program) { |
Mike Klein | 853d4ed | 2020-08-20 00:41:00 +0000 | [diff] [blame] | 1747 | #if defined(SK_ENABLE_SKSL_INTERPRETER) |
Brian Osman | 88cda17 | 2020-10-09 12:05:16 -0400 | [diff] [blame] | 1748 | AutoSource as(this, program.fSource.get()); |
Ethan Nicholas | 0e9401d | 2019-03-21 11:05:37 -0400 | [diff] [blame] | 1749 | std::unique_ptr<ByteCode> result(new ByteCode()); |
Brian Osman | b08cc02 | 2020-04-02 11:38:40 -0400 | [diff] [blame] | 1750 | ByteCodeGenerator cg(fContext.get(), &program, this, result.get()); |
| 1751 | bool success = cg.generateCode(); |
Brian Osman | b08cc02 | 2020-04-02 11:38:40 -0400 | [diff] [blame] | 1752 | if (success) { |
Ethan Nicholas | 0e9401d | 2019-03-21 11:05:37 -0400 | [diff] [blame] | 1753 | return result; |
| 1754 | } |
Mike Klein | 853d4ed | 2020-08-20 00:41:00 +0000 | [diff] [blame] | 1755 | #else |
| 1756 | ABORT("ByteCode interpreter not enabled"); |
| 1757 | #endif |
Ethan Nicholas | 0e9401d | 2019-03-21 11:05:37 -0400 | [diff] [blame] | 1758 | return nullptr; |
| 1759 | } |
| 1760 | |
Brian Osman | 401a009 | 2020-09-10 14:47:24 -0400 | [diff] [blame] | 1761 | const char* Compiler::OperatorName(Token::Kind op) { |
| 1762 | switch (op) { |
Ethan Nicholas | 5a9e7fb | 2020-04-17 12:45:51 -0400 | [diff] [blame] | 1763 | case Token::Kind::TK_PLUS: return "+"; |
| 1764 | case Token::Kind::TK_MINUS: return "-"; |
| 1765 | case Token::Kind::TK_STAR: return "*"; |
| 1766 | case Token::Kind::TK_SLASH: return "/"; |
| 1767 | case Token::Kind::TK_PERCENT: return "%"; |
| 1768 | case Token::Kind::TK_SHL: return "<<"; |
| 1769 | case Token::Kind::TK_SHR: return ">>"; |
| 1770 | case Token::Kind::TK_LOGICALNOT: return "!"; |
| 1771 | case Token::Kind::TK_LOGICALAND: return "&&"; |
| 1772 | case Token::Kind::TK_LOGICALOR: return "||"; |
| 1773 | case Token::Kind::TK_LOGICALXOR: return "^^"; |
| 1774 | case Token::Kind::TK_BITWISENOT: return "~"; |
| 1775 | case Token::Kind::TK_BITWISEAND: return "&"; |
| 1776 | case Token::Kind::TK_BITWISEOR: return "|"; |
| 1777 | case Token::Kind::TK_BITWISEXOR: return "^"; |
| 1778 | case Token::Kind::TK_EQ: return "="; |
| 1779 | case Token::Kind::TK_EQEQ: return "=="; |
| 1780 | case Token::Kind::TK_NEQ: return "!="; |
| 1781 | case Token::Kind::TK_LT: return "<"; |
| 1782 | case Token::Kind::TK_GT: return ">"; |
| 1783 | case Token::Kind::TK_LTEQ: return "<="; |
| 1784 | case Token::Kind::TK_GTEQ: return ">="; |
| 1785 | case Token::Kind::TK_PLUSEQ: return "+="; |
| 1786 | case Token::Kind::TK_MINUSEQ: return "-="; |
| 1787 | case Token::Kind::TK_STAREQ: return "*="; |
| 1788 | case Token::Kind::TK_SLASHEQ: return "/="; |
| 1789 | case Token::Kind::TK_PERCENTEQ: return "%="; |
| 1790 | case Token::Kind::TK_SHLEQ: return "<<="; |
| 1791 | case Token::Kind::TK_SHREQ: return ">>="; |
| 1792 | case Token::Kind::TK_LOGICALANDEQ: return "&&="; |
| 1793 | case Token::Kind::TK_LOGICALOREQ: return "||="; |
| 1794 | case Token::Kind::TK_LOGICALXOREQ: return "^^="; |
| 1795 | case Token::Kind::TK_BITWISEANDEQ: return "&="; |
| 1796 | case Token::Kind::TK_BITWISEOREQ: return "|="; |
| 1797 | case Token::Kind::TK_BITWISEXOREQ: return "^="; |
| 1798 | case Token::Kind::TK_PLUSPLUS: return "++"; |
| 1799 | case Token::Kind::TK_MINUSMINUS: return "--"; |
| 1800 | case Token::Kind::TK_COMMA: return ","; |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1801 | default: |
Brian Osman | 401a009 | 2020-09-10 14:47:24 -0400 | [diff] [blame] | 1802 | ABORT("unsupported operator: %d\n", (int) op); |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1803 | } |
| 1804 | } |
| 1805 | |
| 1806 | |
| 1807 | bool Compiler::IsAssignment(Token::Kind op) { |
| 1808 | switch (op) { |
Ethan Nicholas | 5a9e7fb | 2020-04-17 12:45:51 -0400 | [diff] [blame] | 1809 | case Token::Kind::TK_EQ: // fall through |
| 1810 | case Token::Kind::TK_PLUSEQ: // fall through |
| 1811 | case Token::Kind::TK_MINUSEQ: // fall through |
| 1812 | case Token::Kind::TK_STAREQ: // fall through |
| 1813 | case Token::Kind::TK_SLASHEQ: // fall through |
| 1814 | case Token::Kind::TK_PERCENTEQ: // fall through |
| 1815 | case Token::Kind::TK_SHLEQ: // fall through |
| 1816 | case Token::Kind::TK_SHREQ: // fall through |
| 1817 | case Token::Kind::TK_BITWISEOREQ: // fall through |
| 1818 | case Token::Kind::TK_BITWISEXOREQ: // fall through |
| 1819 | case Token::Kind::TK_BITWISEANDEQ: // fall through |
| 1820 | case Token::Kind::TK_LOGICALOREQ: // fall through |
| 1821 | case Token::Kind::TK_LOGICALXOREQ: // fall through |
| 1822 | case Token::Kind::TK_LOGICALANDEQ: |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1823 | return true; |
| 1824 | default: |
| 1825 | return false; |
| 1826 | } |
| 1827 | } |
| 1828 | |
Brian Osman | 401a009 | 2020-09-10 14:47:24 -0400 | [diff] [blame] | 1829 | Token::Kind Compiler::RemoveAssignment(Token::Kind op) { |
| 1830 | switch (op) { |
| 1831 | case Token::Kind::TK_PLUSEQ: return Token::Kind::TK_PLUS; |
| 1832 | case Token::Kind::TK_MINUSEQ: return Token::Kind::TK_MINUS; |
| 1833 | case Token::Kind::TK_STAREQ: return Token::Kind::TK_STAR; |
| 1834 | case Token::Kind::TK_SLASHEQ: return Token::Kind::TK_SLASH; |
| 1835 | case Token::Kind::TK_PERCENTEQ: return Token::Kind::TK_PERCENT; |
| 1836 | case Token::Kind::TK_SHLEQ: return Token::Kind::TK_SHL; |
| 1837 | case Token::Kind::TK_SHREQ: return Token::Kind::TK_SHR; |
| 1838 | case Token::Kind::TK_BITWISEOREQ: return Token::Kind::TK_BITWISEOR; |
| 1839 | case Token::Kind::TK_BITWISEXOREQ: return Token::Kind::TK_BITWISEXOR; |
| 1840 | case Token::Kind::TK_BITWISEANDEQ: return Token::Kind::TK_BITWISEAND; |
| 1841 | case Token::Kind::TK_LOGICALOREQ: return Token::Kind::TK_LOGICALOR; |
| 1842 | case Token::Kind::TK_LOGICALXOREQ: return Token::Kind::TK_LOGICALXOR; |
| 1843 | case Token::Kind::TK_LOGICALANDEQ: return Token::Kind::TK_LOGICALAND; |
| 1844 | default: return op; |
| 1845 | } |
| 1846 | } |
| 1847 | |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1848 | Position Compiler::position(int offset) { |
Ethan Nicholas | d9d33c3 | 2018-06-12 11:05:59 -0400 | [diff] [blame] | 1849 | SkASSERT(fSource); |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1850 | int line = 1; |
| 1851 | int column = 1; |
| 1852 | for (int i = 0; i < offset; i++) { |
| 1853 | if ((*fSource)[i] == '\n') { |
| 1854 | ++line; |
| 1855 | column = 1; |
| 1856 | } |
| 1857 | else { |
| 1858 | ++column; |
| 1859 | } |
| 1860 | } |
| 1861 | return Position(line, column); |
| 1862 | } |
| 1863 | |
| 1864 | void Compiler::error(int offset, String msg) { |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 1865 | fErrorCount++; |
Ethan Nicholas | 5b5f096 | 2017-09-11 13:50:14 -0700 | [diff] [blame] | 1866 | Position pos = this->position(offset); |
| 1867 | fErrorText += "error: " + to_string(pos.fLine) + ": " + msg.c_str() + "\n"; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 1868 | } |
| 1869 | |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 1870 | String Compiler::errorText() { |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1871 | this->writeErrorCount(); |
| 1872 | fErrorCount = 0; |
Ethan Nicholas | 0df1b04 | 2017-03-31 13:56:23 -0400 | [diff] [blame] | 1873 | String result = fErrorText; |
ethannicholas | b3058bd | 2016-07-01 08:22:01 -0700 | [diff] [blame] | 1874 | return result; |
| 1875 | } |
| 1876 | |
| 1877 | void Compiler::writeErrorCount() { |
| 1878 | if (fErrorCount) { |
| 1879 | fErrorText += to_string(fErrorCount) + " error"; |
| 1880 | if (fErrorCount > 1) { |
| 1881 | fErrorText += "s"; |
| 1882 | } |
| 1883 | fErrorText += "\n"; |
| 1884 | } |
| 1885 | } |
| 1886 | |
John Stiles | a6841be | 2020-08-06 14:11:56 -0400 | [diff] [blame] | 1887 | } // namespace SkSL |