blob: 5c9f60210f3dea14fe43cf57af36f8d475376b8d [file] [log] [blame]
ethannicholasb3058bd2016-07-01 08:22:01 -07001/*
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 Klein6ad99092016-10-26 10:35:22 -04007
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "src/sksl/SkSLCompiler.h"
ethannicholasb3058bd2016-07-01 08:22:01 -07009
John Stilesfbd050b2020-08-03 13:21:46 -040010#include <memory>
John Stilesb8e010c2020-08-11 18:05:39 -040011#include <unordered_set>
John Stilesfbd050b2020-08-03 13:21:46 -040012
John Stilesb92641c2020-08-31 18:09:01 -040013#include "src/sksl/SkSLAnalysis.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050014#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 Nicholasc18bb512020-07-28 14:46:53 -040022#include "src/sksl/SkSLRehydrator.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050023#include "src/sksl/SkSLSPIRVCodeGenerator.h"
Brian Osmanc0243912020-02-19 15:35:26 -050024#include "src/sksl/SkSLSPIRVtoHLSL.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050025#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 Stilese6150002020-10-05 12:03:53 -040036#include "src/utils/SkBitSet.h"
ethannicholasb3058bd2016-07-01 08:22:01 -070037
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -040038#include <fstream>
39
Ethan Nicholasa11035b2019-11-26 16:27:47 -050040#if !defined(SKSL_STANDALONE) & SK_SUPPORT_GPU
41#include "include/gpu/GrContextOptions.h"
42#include "src/gpu/GrShaderCaps.h"
43#endif
44
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -040045#ifdef SK_ENABLE_SPIRV_VALIDATION
46#include "spirv-tools/libspirv.hpp"
47#endif
48
Brian Osman3d87e9f2020-10-08 11:50:22 -040049#if defined(SKSL_STANDALONE)
Ethan Nicholasc18bb512020-07-28 14:46:53 -040050
Brian Osman3d87e9f2020-10-08 11:50:22 -040051// 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 Nicholasc18bb512020-07-28 14:46:53 -040058#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 Osman3d87e9f2020-10-08 11:50:22 -040066#define MODULE_DATA(name) MakeModuleData(SKSL_INCLUDE_sksl_##name,\
67 SKSL_INCLUDE_sksl_##name##_LENGTH)
Ethan Nicholasc18bb512020-07-28 14:46:53 -040068
69#endif
Ethan Nicholas0d997662019-04-08 09:46:01 -040070
ethannicholasb3058bd2016-07-01 08:22:01 -070071namespace SkSL {
72
Brian Osman88cda172020-10-09 12:05:16 -040073class AutoSource {
74public:
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 Nicholas6e1cbc02017-07-14 10:12:15 -040086Compiler::Compiler(Flags flags)
Brian Osman00a8b5b2020-10-02 09:06:04 -040087: fFlags(flags)
John Stiles810c8cf2020-08-26 19:46:27 -040088, fContext(std::make_shared<Context>())
Ethan Nicholas6e1cbc02017-07-14 10:12:15 -040089, fErrorCount(0) {
Brian Osmaneac49832020-09-18 11:49:22 -040090 fRootSymbolTable = std::make_shared<SymbolTable>(this);
John Stiles4c412bc2020-10-13 11:19:41 -040091 fIRGenerator = std::make_unique<IRGenerator>(fContext.get(), &fInliner, *this);
Brian Osman88cda172020-10-09 12:05:16 -040092#define ADD_TYPE(t) fRootSymbolTable->addWithoutOwnership(fContext->f##t##_Type.get())
ethannicholasb3058bd2016-07-01 08:22:01 -070093 ADD_TYPE(Void);
94 ADD_TYPE(Float);
Ethan Nicholas5af9ea32017-07-28 15:19:46 -040095 ADD_TYPE(Float2);
96 ADD_TYPE(Float3);
97 ADD_TYPE(Float4);
Ethan Nicholasdcba08e2017-08-02 10:52:54 -040098 ADD_TYPE(Half);
99 ADD_TYPE(Half2);
100 ADD_TYPE(Half3);
101 ADD_TYPE(Half4);
ethannicholasb3058bd2016-07-01 08:22:01 -0700102 ADD_TYPE(Int);
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400103 ADD_TYPE(Int2);
104 ADD_TYPE(Int3);
105 ADD_TYPE(Int4);
ethannicholasb3058bd2016-07-01 08:22:01 -0700106 ADD_TYPE(UInt);
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400107 ADD_TYPE(UInt2);
108 ADD_TYPE(UInt3);
109 ADD_TYPE(UInt4);
Ethan Nicholasdcba08e2017-08-02 10:52:54 -0400110 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 Maob609e6d2018-07-17 10:19:38 -0400118 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);
ethannicholasb3058bd2016-07-01 08:22:01 -0700126 ADD_TYPE(Bool);
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400127 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 Nicholasdcba08e2017-08-02 10:52:54 -0400139 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);
ethannicholasb3058bd2016-07-01 08:22:01 -0700148 ADD_TYPE(GenType);
Ethan Nicholasdcba08e2017-08-02 10:52:54 -0400149 ADD_TYPE(GenHType);
ethannicholasb3058bd2016-07-01 08:22:01 -0700150 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 Nicholasdcba08e2017-08-02 10:52:54 -0400159 ADD_TYPE(HVec);
ethannicholasb3058bd2016-07-01 08:22:01 -0700160 ADD_TYPE(IVec);
161 ADD_TYPE(UVec);
Ethan Nicholasdcba08e2017-08-02 10:52:54 -0400162 ADD_TYPE(SVec);
163 ADD_TYPE(USVec);
Ruiqi Maob609e6d2018-07-17 10:19:38 -0400164 ADD_TYPE(ByteVec);
165 ADD_TYPE(UByteVec);
ethannicholasb3058bd2016-07-01 08:22:01 -0700166 ADD_TYPE(BVec);
167
168 ADD_TYPE(Sampler1D);
169 ADD_TYPE(Sampler2D);
170 ADD_TYPE(Sampler3D);
ethannicholas5961bc92016-10-12 06:39:56 -0700171 ADD_TYPE(SamplerExternalOES);
ethannicholasb3058bd2016-07-01 08:22:01 -0700172 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 Salomonbf7b6202016-11-11 16:08:03 -0500181 ADD_TYPE(ISampler2D);
182
Brian Salomon2a51de82016-11-16 12:06:01 -0500183 ADD_TYPE(Image2D);
184 ADD_TYPE(IImage2D);
185
Greg Daniel64773e62016-11-22 09:44:03 -0500186 ADD_TYPE(SubpassInput);
187 ADD_TYPE(SubpassInputMS);
188
ethannicholasb3058bd2016-07-01 08:22:01 -0700189 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 Nicholasc9472af2017-10-10 16:30:21 -0400210 ADD_TYPE(FragmentProcessor);
Stephen Whiteff5d7a22019-07-26 17:42:06 -0400211 ADD_TYPE(Sampler);
212 ADD_TYPE(Texture2D);
ethannicholasb3058bd2016-07-01 08:22:01 -0700213
Brian Osman3887a012020-09-30 13:22:27 -0400214 // 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 Nicholas5b5f0962017-09-11 13:50:14 -0700216 StringFragment skCapsName("sk_Caps");
John Stilesb8cc6652020-10-08 09:12:07 -0400217 fRootSymbolTable->add(std::make_unique<Variable>(/*offset=*/-1,
Ethan Nicholas041fd0a2020-10-07 16:42:04 -0400218 fIRGenerator->fModifiers->handle(Modifiers()),
Ethan Nicholas453f67f2020-10-09 10:43:45 -0400219 skCapsName,
220 fContext->fSkCaps_Type.get(),
221 /*builtin=*/false,
222 Variable::Storage::kGlobal));
Ethan Nicholas3605ace2016-11-21 15:59:48 -0500223
Brian Osman3d87e9f2020-10-08 11:50:22 -0400224 fRootModule = {fRootSymbolTable, /*fIntrinsics=*/nullptr};
John Stilesbc0c29e2020-09-28 13:13:40 -0400225
Brian Osman3d87e9f2020-10-08 11:50:22 -0400226 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);
ethannicholasb3058bd2016-07-01 08:22:01 -0700229}
230
John Stiles656427a2020-08-27 15:26:26 -0400231Compiler::~Compiler() {}
ethannicholasb3058bd2016-07-01 08:22:01 -0700232
Brian Osman88cda172020-10-09 12:05:16 -0400233const ParsedModule& Compiler::loadGeometryModule() {
Brian Osman3d87e9f2020-10-08 11:50:22 -0400234 if (!fGeometryModule.fSymbols) {
235 fGeometryModule = this->parseModule(Program::kGeometry_Kind, MODULE_DATA(geom), fGPUModule);
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400236 }
Brian Osman88cda172020-10-09 12:05:16 -0400237 return fGeometryModule;
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400238}
239
Brian Osman88cda172020-10-09 12:05:16 -0400240const ParsedModule& Compiler::loadFPModule() {
Brian Osman3d87e9f2020-10-08 11:50:22 -0400241 if (!fFPModule.fSymbols) {
242 fFPModule =
243 this->parseModule(Program::kFragmentProcessor_Kind, MODULE_DATA(fp), fGPUModule);
Brian Osman8e2ef022020-09-30 13:26:43 -0400244 }
Brian Osman88cda172020-10-09 12:05:16 -0400245 return fFPModule;
Brian Osman8e2ef022020-09-30 13:26:43 -0400246}
247
Brian Osman88cda172020-10-09 12:05:16 -0400248const ParsedModule& Compiler::loadPipelineModule() {
Brian Osman3d87e9f2020-10-08 11:50:22 -0400249 if (!fPipelineModule.fSymbols) {
250 fPipelineModule =
251 this->parseModule(Program::kPipelineStage_Kind, MODULE_DATA(pipeline), fGPUModule);
Brian Osmanf1319c32020-10-13 09:34:23 -0400252
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 Nicholasc18bb512020-07-28 14:46:53 -0400279 }
Brian Osman88cda172020-10-09 12:05:16 -0400280 return fPipelineModule;
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400281}
282
Brian Osman88cda172020-10-09 12:05:16 -0400283const ParsedModule& Compiler::loadInterpreterModule() {
Brian Osman3d87e9f2020-10-08 11:50:22 -0400284 if (!fInterpreterModule.fSymbols) {
285 fInterpreterModule =
286 this->parseModule(Program::kGeneric_Kind, MODULE_DATA(interp), fRootModule);
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400287 }
Brian Osman88cda172020-10-09 12:05:16 -0400288 return fInterpreterModule;
289}
290
291const 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 Nicholasc18bb512020-07-28 14:46:53 -0400301}
302
Brian Osman3d87e9f2020-10-08 11:50:22 -0400303LoadedModule Compiler::loadModule(Program::Kind kind,
304 ModuleData data,
305 std::shared_ptr<SymbolTable> base) {
Brian Osman3d87e9f2020-10-08 11:50:22 -0400306 if (!base) {
307 base = fRootSymbolTable;
308 }
309
310#if defined(SKSL_STANDALONE)
311 SkASSERT(data.fPath);
312 std::ifstream in(data.fPath);
Brian Osmane498b3c2020-09-23 14:42:11 -0400313 std::unique_ptr<String> text = std::make_unique<String>(std::istreambuf_iterator<char>(in),
314 std::istreambuf_iterator<char>());
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -0400315 if (in.rdstate()) {
Brian Osman3d87e9f2020-10-08 11:50:22 -0400316 printf("error reading %s\n", data.fPath);
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -0400317 abort();
318 }
Brian Osmane498b3c2020-09-23 14:42:11 -0400319 const String* source = fRootSymbolTable->takeOwnershipOfString(std::move(text));
Brian Osman88cda172020-10-09 12:05:16 -0400320 AutoSource as(this, source);
Ethan Nicholas8da1e652019-05-24 11:01:59 -0400321 Program::Settings settings;
John Stiles881a10c2020-09-19 10:13:24 -0400322 SkASSERT(fIRGenerator->fCanInline);
323 fIRGenerator->fCanInline = false;
Brian Osman88cda172020-10-09 12:05:16 -0400324 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 Stiles881a10c2020-09-19 10:13:24 -0400329 fIRGenerator->fCanInline = true;
Ethan Nicholas8da1e652019-05-24 11:01:59 -0400330 if (this->fErrorCount) {
331 printf("Unexpected errors: %s\n", this->fErrorText.c_str());
Brian Osman3d87e9f2020-10-08 11:50:22 -0400332 SkDEBUGFAILF("%s %s\n", data.fPath, this->fErrorText.c_str());
Ethan Nicholas8da1e652019-05-24 11:01:59 -0400333 }
Brian Osman88cda172020-10-09 12:05:16 -0400334 fModifiers.push_back(std::move(ir.fModifiers));
Brian Osman3d87e9f2020-10-08 11:50:22 -0400335#else
336 SkASSERT(data.fData && (data.fSize != 0));
337 Rehydrator rehydrator(fContext.get(), fIRGenerator->fModifiers.get(), base, this,
338 data.fData, data.fSize);
Brian Osman88cda172020-10-09 12:05:16 -0400339 LoadedModule module = { rehydrator.symbolTable(), rehydrator.elements() };
Brian Osman3d87e9f2020-10-08 11:50:22 -0400340 fModifiers.push_back(fIRGenerator->releaseModifiers());
341#endif
342
343 return module;
344}
345
346ParsedModule 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 Nicholas0a5d0962020-10-14 13:33:18 -0400363 SkASSERT(f.declaration().isBuiltin());
364 intrinsics->insertOrDie(f.declaration().description(), std::move(element));
Brian Osman3d87e9f2020-10-08 11:50:22 -0400365 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 Nicholasc51f33e2020-10-13 13:49:44 -0400374 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 Osman3d87e9f2020-10-08 11:50:22 -0400378 break;
379 }
380 case ProgramElement::Kind::kInterfaceBlock: {
Ethan Nicholaseaf47882020-10-15 10:10:08 -0400381 const Variable& var = element->as<InterfaceBlock>().variable();
382 SkASSERT(var.isBuiltin());
383 intrinsics->insertOrDie(var.name(), std::move(element));
Brian Osman3d87e9f2020-10-08 11:50:22 -0400384 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 Nicholas8da1e652019-05-24 11:01:59 -0400394}
395
ethannicholas22f939e2016-10-13 13:25:34 -0700396// add the definition created by assigning to the lvalue to the definition set
Ethan Nicholas86a43402017-01-19 13:32:00 -0500397void Compiler::addDefinition(const Expression* lvalue, std::unique_ptr<Expression>* expr,
398 DefinitionMap* definitions) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400399 switch (lvalue->kind()) {
400 case Expression::Kind::kVariableReference: {
Ethan Nicholas78686922020-10-08 06:46:27 -0400401 const Variable& var = *lvalue->as<VariableReference>().variable();
Ethan Nicholas453f67f2020-10-09 10:43:45 -0400402 if (var.storage() == Variable::Storage::kLocal) {
John Stiles796cdb72020-10-08 12:06:53 -0400403 definitions->set(&var, expr);
ethannicholas22f939e2016-10-13 13:25:34 -0700404 }
405 break;
406 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400407 case Expression::Kind::kSwizzle:
ethannicholas22f939e2016-10-13 13:25:34 -0700408 // 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 Klein6ad99092016-10-26 10:35:22 -0400411 // (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
ethannicholas22f939e2016-10-13 13:25:34 -0700413 // more complicated whole-program analysis. This is probably good enough.
Ethan Nicholas6b4d5812020-10-12 16:11:51 -0400414 this->addDefinition(lvalue->as<Swizzle>().base().get(),
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400415 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
ethannicholas22f939e2016-10-13 13:25:34 -0700416 definitions);
417 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400418 case Expression::Kind::kIndex:
ethannicholas22f939e2016-10-13 13:25:34 -0700419 // see comments in Swizzle
Ethan Nicholas2a4952d2020-10-08 15:35:56 -0400420 this->addDefinition(lvalue->as<IndexExpression>().base().get(),
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400421 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
ethannicholas22f939e2016-10-13 13:25:34 -0700422 definitions);
423 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400424 case Expression::Kind::kFieldAccess:
ethannicholas22f939e2016-10-13 13:25:34 -0700425 // see comments in Swizzle
Ethan Nicholas7a95b202020-10-09 11:55:40 -0400426 this->addDefinition(lvalue->as<FieldAccess>().base().get(),
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400427 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
ethannicholas22f939e2016-10-13 13:25:34 -0700428 definitions);
429 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400430 case Expression::Kind::kTernary:
Ethan Nicholasa583b812018-01-18 13:32:11 -0500431 // 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 Nicholasdd218162020-10-08 05:48:01 -0400434 this->addDefinition(lvalue->as<TernaryExpression>().ifTrue().get(),
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400435 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
Ethan Nicholasa583b812018-01-18 13:32:11 -0500436 definitions);
Ethan Nicholasdd218162020-10-08 05:48:01 -0400437 this->addDefinition(lvalue->as<TernaryExpression>().ifFalse().get(),
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400438 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
Ethan Nicholasa583b812018-01-18 13:32:11 -0500439 definitions);
440 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400441 case Expression::Kind::kExternalValue:
Ethan Nicholas91164d12019-05-15 15:29:54 -0400442 break;
ethannicholas22f939e2016-10-13 13:25:34 -0700443 default:
444 // not an lvalue, can't happen
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400445 SkASSERT(false);
ethannicholas22f939e2016-10-13 13:25:34 -0700446 }
447}
448
449// add local variables defined by this node to the set
John Stiles796cdb72020-10-08 12:06:53 -0400450void Compiler::addDefinitions(const BasicBlock::Node& node, DefinitionMap* definitions) {
John Stiles70025e52020-09-28 16:08:58 -0400451 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 Nicholas86a43402017-01-19 13:32:00 -0500463
ethannicholas22f939e2016-10-13 13:25:34 -0700464 }
John Stiles70025e52020-09-28 16:08:58 -0400465 break;
ethannicholas22f939e2016-10-13 13:25:34 -0700466 }
John Stiles70025e52020-09-28 16:08:58 -0400467 case Expression::Kind::kFunctionCall: {
468 const FunctionCall& c = expr->as<FunctionCall>();
Brian Osman5bf3e202020-10-13 10:34:18 -0400469 const std::vector<const Variable*>& parameters = c.function().parameters();
Ethan Nicholased84b732020-10-08 11:45:44 -0400470 for (size_t i = 0; i < parameters.size(); ++i) {
471 if (parameters[i]->modifiers().fFlags & Modifiers::kOut_Flag) {
John Stiles70025e52020-09-28 16:08:58 -0400472 this->addDefinition(
Ethan Nicholas0dec9922020-10-05 15:51:52 -0400473 c.arguments()[i].get(),
John Stiles70025e52020-09-28 16:08:58 -0400474 (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 Nicholas444ccc62020-10-09 10:16:22 -0400482 if (p->getOperator() == Token::Kind::TK_MINUSMINUS ||
483 p->getOperator() == Token::Kind::TK_PLUSPLUS) {
John Stiles70025e52020-09-28 16:08:58 -0400484 this->addDefinition(
Ethan Nicholas444ccc62020-10-09 10:16:22 -0400485 p->operand().get(),
John Stiles70025e52020-09-28 16:08:58 -0400486 (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 Nicholas444ccc62020-10-09 10:16:22 -0400493 if (p->getOperator() == Token::Kind::TK_MINUSMINUS ||
494 p->getOperator() == Token::Kind::TK_PLUSPLUS) {
John Stiles70025e52020-09-28 16:08:58 -0400495 this->addDefinition(
Ethan Nicholas444ccc62020-10-09 10:16:22 -0400496 p->operand().get(),
John Stiles70025e52020-09-28 16:08:58 -0400497 (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 Nicholas453f67f2020-10-09 10:43:45 -0400504 if (v->refKind() != VariableReference::RefKind::kRead) {
John Stiles70025e52020-09-28 16:08:58 -0400505 this->addDefinition(
506 v,
507 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
508 definitions);
509 }
510 break;
511 }
512 default:
513 break;
ethannicholas22f939e2016-10-13 13:25:34 -0700514 }
John Stiles70025e52020-09-28 16:08:58 -0400515 } else if (node.isStatement()) {
516 Statement* stmt = node.statement()->get();
517 if (stmt->is<VarDeclaration>()) {
518 VarDeclaration& vd = stmt->as<VarDeclaration>();
Ethan Nicholasc51f33e2020-10-13 13:49:44 -0400519 if (vd.value()) {
520 definitions->set(&vd.var(), &vd.value());
ethannicholas22f939e2016-10-13 13:25:34 -0700521 }
ethannicholas22f939e2016-10-13 13:25:34 -0700522 }
523 }
524}
525
John Stilese6150002020-10-05 12:03:53 -0400526void Compiler::scanCFG(CFG* cfg, BlockId blockId, SkBitSet* processedSet) {
ethannicholas22f939e2016-10-13 13:25:34 -0700527 BasicBlock& block = cfg->fBlocks[blockId];
528
529 // compute definitions after this block
Ethan Nicholas86a43402017-01-19 13:32:00 -0500530 DefinitionMap after = block.fBefore;
ethannicholas22f939e2016-10-13 13:25:34 -0700531 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 Nicholas26a9aad2018-03-27 14:10:52 -0400537 if (exitId == blockId) {
538 continue;
539 }
ethannicholas22f939e2016-10-13 13:25:34 -0700540 BasicBlock& exit = cfg->fBlocks[exitId];
John Stiles796cdb72020-10-08 12:06:53 -0400541 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 Stilese6150002020-10-05 12:03:53 -0400545 // exit has no definition for it, just copy it and reprocess exit block
546 processedSet->reset(exitId);
John Stiles796cdb72020-10-08 12:06:53 -0400547 exit.fBefore[var] = e1;
ethannicholas22f939e2016-10-13 13:25:34 -0700548 } else {
Ethan Nicholas86a43402017-01-19 13:32:00 -0500549 // exit has a (possibly different) value already defined
John Stiles796cdb72020-10-08 12:06:53 -0400550 std::unique_ptr<Expression>* e2 = *exitDef;
ethannicholas22f939e2016-10-13 13:25:34 -0700551 if (e1 != e2) {
John Stilese6150002020-10-05 12:03:53 -0400552 // definition has changed, merge and reprocess the exit block
553 processedSet->reset(exitId);
Ethan Nicholasaf197692017-02-27 13:26:45 -0500554 if (e1 && e2) {
John Stiles796cdb72020-10-08 12:06:53 -0400555 *exitDef = (std::unique_ptr<Expression>*)&fContext->fDefined_Expression;
Ethan Nicholasaf197692017-02-27 13:26:45 -0500556 } else {
John Stiles796cdb72020-10-08 12:06:53 -0400557 *exitDef = nullptr;
Ethan Nicholasaf197692017-02-27 13:26:45 -0500558 }
ethannicholas22f939e2016-10-13 13:25:34 -0700559 }
560 }
John Stiles796cdb72020-10-08 12:06:53 -0400561 });
ethannicholas22f939e2016-10-13 13:25:34 -0700562 }
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 Nicholas86a43402017-01-19 13:32:00 -0500567static DefinitionMap compute_start_state(const CFG& cfg) {
568 DefinitionMap result;
Mike Klein6ad99092016-10-26 10:35:22 -0400569 for (const auto& block : cfg.fBlocks) {
570 for (const auto& node : block.fNodes) {
John Stiles70025e52020-09-28 16:08:58 -0400571 if (node.isStatement()) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400572 const Statement* s = node.statement()->get();
Brian Osmanc0213602020-10-06 14:43:32 -0400573 if (s->is<VarDeclaration>()) {
Ethan Nicholasc51f33e2020-10-13 13:49:44 -0400574 result[&s->as<VarDeclaration>().var()] = nullptr;
ethannicholas22f939e2016-10-13 13:25:34 -0700575 }
576 }
577 }
578 }
579 return result;
580}
581
Ethan Nicholascb670962017-04-20 19:31:52 -0400582/**
583 * Returns true if assigning to this lvalue has no effect.
584 */
585static bool is_dead(const Expression& lvalue) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400586 switch (lvalue.kind()) {
587 case Expression::Kind::kVariableReference:
Ethan Nicholas78686922020-10-08 06:46:27 -0400588 return lvalue.as<VariableReference>().variable()->dead();
Ethan Nicholase6592142020-09-08 10:22:09 -0400589 case Expression::Kind::kSwizzle:
Ethan Nicholas6b4d5812020-10-12 16:11:51 -0400590 return is_dead(*lvalue.as<Swizzle>().base());
Ethan Nicholase6592142020-09-08 10:22:09 -0400591 case Expression::Kind::kFieldAccess:
Ethan Nicholas7a95b202020-10-09 11:55:40 -0400592 return is_dead(*lvalue.as<FieldAccess>().base());
Ethan Nicholase6592142020-09-08 10:22:09 -0400593 case Expression::Kind::kIndex: {
John Stilesa5a97b42020-08-18 11:19:07 -0400594 const IndexExpression& idx = lvalue.as<IndexExpression>();
Ethan Nicholas2a4952d2020-10-08 15:35:56 -0400595 return is_dead(*idx.base()) &&
596 !idx.index()->hasProperty(Expression::Property::kSideEffects);
Ethan Nicholascb670962017-04-20 19:31:52 -0400597 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400598 case Expression::Kind::kTernary: {
John Stilesa5a97b42020-08-18 11:19:07 -0400599 const TernaryExpression& t = lvalue.as<TernaryExpression>();
Ethan Nicholasdd218162020-10-08 05:48:01 -0400600 return !t.test()->hasSideEffects() && is_dead(*t.ifTrue()) && is_dead(*t.ifFalse());
Ethan Nicholasa583b812018-01-18 13:32:11 -0500601 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400602 case Expression::Kind::kExternalValue:
Ethan Nicholas91164d12019-05-15 15:29:54 -0400603 return false;
Ethan Nicholascb670962017-04-20 19:31:52 -0400604 default:
Ethan Nicholas2a099da2020-01-02 14:40:54 -0500605#ifdef SK_DEBUG
Ethan Nicholascb670962017-04-20 19:31:52 -0400606 ABORT("invalid lvalue: %s\n", lvalue.description().c_str());
Ethan Nicholas2a099da2020-01-02 14:40:54 -0500607#endif
608 return false;
Ethan Nicholascb670962017-04-20 19:31:52 -0400609 }
610}
ethannicholas22f939e2016-10-13 13:25:34 -0700611
Ethan Nicholascb670962017-04-20 19:31:52 -0400612/**
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 */
616static bool dead_assignment(const BinaryExpression& b) {
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400617 if (!Compiler::IsAssignment(b.getOperator())) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400618 return false;
619 }
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400620 return is_dead(b.left());
Ethan Nicholascb670962017-04-20 19:31:52 -0400621}
622
623void Compiler::computeDataFlow(CFG* cfg) {
624 cfg->fBlocks[cfg->fStart].fBefore = compute_start_state(*cfg);
John Stilese6150002020-10-05 12:03:53 -0400625
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);
ethannicholas22f939e2016-10-13 13:25:34 -0700631 }
Ethan Nicholascb670962017-04-20 19:31:52 -0400632}
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 Stilesafbf8992020-08-18 10:08:21 -0400640static bool try_replace_expression(BasicBlock* b,
641 std::vector<BasicBlock::Node>::iterator* iter,
642 std::unique_ptr<Expression>* newExpression) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400643 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 Nicholasfe53e582017-04-27 16:24:51 -0400653 * 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 Nicholascb670962017-04-20 19:31:52 -0400655 */
Ethan Nicholasa3f22f12020-10-01 12:13:17 -0400656template <typename T = SKSL_FLOAT>
John Stiles9d944232020-08-19 09:56:49 -0400657static bool is_constant(const Expression& expr, T value) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400658 switch (expr.kind()) {
659 case Expression::Kind::kIntLiteral:
Ethan Nicholase96cdd12020-09-28 16:27:18 -0400660 return expr.as<IntLiteral>().value() == value;
John Stiles9d944232020-08-19 09:56:49 -0400661
Ethan Nicholase6592142020-09-08 10:22:09 -0400662 case Expression::Kind::kFloatLiteral:
Ethan Nicholasa3f22f12020-10-01 12:13:17 -0400663 return expr.as<FloatLiteral>().value() == value;
John Stiles9d944232020-08-19 09:56:49 -0400664
Ethan Nicholase6592142020-09-08 10:22:09 -0400665 case Expression::Kind::kConstructor: {
John Stiles9d944232020-08-19 09:56:49 -0400666 const Constructor& constructor = expr.as<Constructor>();
667 if (constructor.isCompileTimeConstant()) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400668 const Type& constructorType = constructor.type();
669 bool isFloat = constructorType.columns() > 1
670 ? constructorType.componentType().isFloat()
671 : constructorType.isFloat();
672 switch (constructorType.typeKind()) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400673 case Type::TypeKind::kVector:
Ethan Nicholas30d30222020-09-11 12:27:26 -0400674 for (int i = 0; i < constructorType.columns(); ++i) {
John Stiles9d944232020-08-19 09:56:49 -0400675 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 Nicholasd188c182019-06-10 15:55:38 -0400684 }
John Stiles9d944232020-08-19 09:56:49 -0400685 return true;
686
Ethan Nicholase6592142020-09-08 10:22:09 -0400687 case Type::TypeKind::kScalar:
Ethan Nicholasf70f0442020-09-29 12:41:35 -0400688 SkASSERT(constructor.arguments().size() == 1);
689 return is_constant<T>(*constructor.arguments()[0], value);
John Stiles9d944232020-08-19 09:56:49 -0400690
691 default:
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400692 return false;
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400693 }
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400694 }
695 return false;
696 }
Ethan Nicholascb670962017-04-20 19:31:52 -0400697 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 Stilesafbf8992020-08-18 10:08:21 -0400706static void delete_left(BasicBlock* b,
707 std::vector<BasicBlock::Node>::iterator* iter,
708 bool* outUpdated,
709 bool* outNeedsRescan) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400710 *outUpdated = true;
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400711 std::unique_ptr<Expression>* target = (*iter)->expression();
John Stilesa5a97b42020-08-18 11:19:07 -0400712 BinaryExpression& bin = (*target)->as<BinaryExpression>();
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400713 Expression& left = bin.left();
714 std::unique_ptr<Expression>& rightPointer = bin.rightPointer();
715 SkASSERT(!left.hasSideEffects());
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400716 bool result;
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400717 if (bin.getOperator() == Token::Kind::TK_EQ) {
718 result = b->tryRemoveLValueBefore(iter, &left);
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400719 } else {
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400720 result = b->tryRemoveExpressionBefore(iter, &left);
Ethan Nicholascb670962017-04-20 19:31:52 -0400721 }
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400722 *target = std::move(rightPointer);
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400723 if (!result) {
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400724 *outNeedsRescan = true;
725 return;
726 }
727 if (*iter == b->fNodes.begin()) {
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400728 *outNeedsRescan = true;
729 return;
730 }
731 --(*iter);
John Stiles70025e52020-09-28 16:08:58 -0400732 if (!(*iter)->isExpression() || (*iter)->expression() != &rightPointer) {
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400733 *outNeedsRescan = true;
734 return;
735 }
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400736 *iter = b->fNodes.erase(*iter);
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400737 SkASSERT((*iter)->expression() == target);
Ethan Nicholascb670962017-04-20 19:31:52 -0400738}
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 Stilesafbf8992020-08-18 10:08:21 -0400744static void delete_right(BasicBlock* b,
745 std::vector<BasicBlock::Node>::iterator* iter,
746 bool* outUpdated,
747 bool* outNeedsRescan) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400748 *outUpdated = true;
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400749 std::unique_ptr<Expression>* target = (*iter)->expression();
John Stilesa5a97b42020-08-18 11:19:07 -0400750 BinaryExpression& bin = (*target)->as<BinaryExpression>();
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400751 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 Nicholascb670962017-04-20 19:31:52 -0400756 *outNeedsRescan = true;
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400757 return;
Ethan Nicholascb670962017-04-20 19:31:52 -0400758 }
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400759 *target = std::move(leftPointer);
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400760 if (*iter == b->fNodes.begin()) {
761 *outNeedsRescan = true;
762 return;
763 }
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400764 --(*iter);
John Stiles70025e52020-09-28 16:08:58 -0400765 if ((!(*iter)->isExpression() || (*iter)->expression() != &leftPointer)) {
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400766 *outNeedsRescan = true;
767 return;
768 }
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400769 *iter = b->fNodes.erase(*iter);
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400770 SkASSERT((*iter)->expression() == target);
Ethan Nicholascb670962017-04-20 19:31:52 -0400771}
772
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400773/**
774 * Constructs the specified type using a single argument.
775 */
Ethan Nicholas30d30222020-09-11 12:27:26 -0400776static std::unique_ptr<Expression> construct(const Type* type, std::unique_ptr<Expression> v) {
John Stiles8e3b6be2020-10-13 11:14:08 -0400777 ExpressionArray args;
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400778 args.push_back(std::move(v));
Ethan Nicholase6592142020-09-08 10:22:09 -0400779 std::unique_ptr<Expression> result = std::make_unique<Constructor>(-1, type, std::move(args));
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400780 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 */
787static 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 Nicholase6592142020-09-08 10:22:09 -0400793 SkASSERT((*(*iter)->expression())->kind() == Expression::Kind::kBinary);
794 SkASSERT(type.typeKind() == Type::TypeKind::kVector);
Ethan Nicholas30d30222020-09-11 12:27:26 -0400795 SkASSERT((*otherExpression)->type().typeKind() == Type::TypeKind::kScalar);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400796 *outUpdated = true;
797 std::unique_ptr<Expression>* target = (*iter)->expression();
798 if (!b->tryRemoveExpression(iter)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400799 *target = construct(&type, std::move(*otherExpression));
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400800 *outNeedsRescan = true;
801 } else {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400802 *target = construct(&type, std::move(*otherExpression));
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400803 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 */
813static void vectorize_left(BasicBlock* b,
814 std::vector<BasicBlock::Node>::iterator* iter,
815 bool* outUpdated,
816 bool* outNeedsRescan) {
John Stilesa5a97b42020-08-18 11:19:07 -0400817 BinaryExpression& bin = (*(*iter)->expression())->as<BinaryExpression>();
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400818 vectorize(b, iter, bin.right().type(), &bin.leftPointer(), outUpdated, outNeedsRescan);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400819}
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 */
825static void vectorize_right(BasicBlock* b,
826 std::vector<BasicBlock::Node>::iterator* iter,
827 bool* outUpdated,
828 bool* outNeedsRescan) {
John Stilesa5a97b42020-08-18 11:19:07 -0400829 BinaryExpression& bin = (*(*iter)->expression())->as<BinaryExpression>();
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400830 vectorize(b, iter, bin.left().type(), &bin.rightPointer(), outUpdated, outNeedsRescan);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400831}
832
833// Mark that an expression which we were writing to is no longer being written to
John Stilesa5a97b42020-08-18 11:19:07 -0400834static void clear_write(Expression& expr) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400835 switch (expr.kind()) {
836 case Expression::Kind::kVariableReference: {
Ethan Nicholas453f67f2020-10-09 10:43:45 -0400837 expr.as<VariableReference>().setRefKind(VariableReference::RefKind::kRead);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400838 break;
839 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400840 case Expression::Kind::kFieldAccess:
Ethan Nicholas7a95b202020-10-09 11:55:40 -0400841 clear_write(*expr.as<FieldAccess>().base());
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400842 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400843 case Expression::Kind::kSwizzle:
Ethan Nicholas6b4d5812020-10-12 16:11:51 -0400844 clear_write(*expr.as<Swizzle>().base());
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400845 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400846 case Expression::Kind::kIndex:
Ethan Nicholas2a4952d2020-10-08 15:35:56 -0400847 clear_write(*expr.as<IndexExpression>().base());
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400848 break;
849 default:
850 ABORT("shouldn't be writing to this kind of expression\n");
851 break;
852 }
853}
854
Ethan Nicholascb670962017-04-20 19:31:52 -0400855void 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 Nicholasd9d33c32018-06-12 11:05:59 -0400862 SkASSERT(expr);
Ethan Nicholascb670962017-04-20 19:31:52 -0400863 if ((*iter)->fConstantPropagation) {
864 std::unique_ptr<Expression> optimized = expr->constantPropagate(*fIRGenerator, definitions);
865 if (optimized) {
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400866 *outUpdated = true;
Ethan Nicholas30d30222020-09-11 12:27:26 -0400867 optimized = fIRGenerator->coerce(std::move(optimized), expr->type());
Ethan Nicholas1d881522020-09-11 09:32:54 -0400868 SkASSERT(optimized);
Ethan Nicholascb670962017-04-20 19:31:52 -0400869 if (!try_replace_expression(&b, iter, &optimized)) {
870 *outNeedsRescan = true;
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400871 return;
Ethan Nicholascb670962017-04-20 19:31:52 -0400872 }
John Stiles70025e52020-09-28 16:08:58 -0400873 SkASSERT((*iter)->isExpression());
Ethan Nicholascb670962017-04-20 19:31:52 -0400874 expr = (*iter)->expression()->get();
Ethan Nicholascb670962017-04-20 19:31:52 -0400875 }
876 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400877 switch (expr->kind()) {
878 case Expression::Kind::kVariableReference: {
John Stilesa5a97b42020-08-18 11:19:07 -0400879 const VariableReference& ref = expr->as<VariableReference>();
Ethan Nicholas78686922020-10-08 06:46:27 -0400880 const Variable* var = ref.variable();
Ethan Nicholas453f67f2020-10-09 10:43:45 -0400881 if (ref.refKind() != VariableReference::RefKind::kWrite &&
882 ref.refKind() != VariableReference::RefKind::kPointer &&
883 var->storage() == Variable::Storage::kLocal && !definitions[var] &&
Brian Osman79457ef2020-09-24 15:01:27 -0400884 (*undefinedVariables).find(var) == (*undefinedVariables).end()) {
885 (*undefinedVariables).insert(var);
Ethan Nicholas82a62d22017-11-07 14:42:10 +0000886 this->error(expr->fOffset,
Ethan Nicholase2c49992020-10-05 11:49:11 -0400887 "'" + var->name() + "' has not been assigned");
Ethan Nicholascb670962017-04-20 19:31:52 -0400888 }
889 break;
890 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400891 case Expression::Kind::kTernary: {
John Stiles403a3632020-08-20 12:11:48 -0400892 TernaryExpression* t = &expr->as<TernaryExpression>();
Ethan Nicholasdd218162020-10-08 05:48:01 -0400893 if (t->test()->is<BoolLiteral>()) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400894 // ternary has a constant test, replace it with either the true or
895 // false branch
Ethan Nicholasdd218162020-10-08 05:48:01 -0400896 if (t->test()->as<BoolLiteral>().value()) {
897 (*iter)->setExpression(std::move(t->ifTrue()));
Ethan Nicholascb670962017-04-20 19:31:52 -0400898 } else {
Ethan Nicholasdd218162020-10-08 05:48:01 -0400899 (*iter)->setExpression(std::move(t->ifFalse()));
Ethan Nicholascb670962017-04-20 19:31:52 -0400900 }
901 *outUpdated = true;
902 *outNeedsRescan = true;
903 }
904 break;
905 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400906 case Expression::Kind::kBinary: {
John Stiles403a3632020-08-20 12:11:48 -0400907 BinaryExpression* bin = &expr->as<BinaryExpression>();
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400908 if (dead_assignment(*bin)) {
909 delete_left(&b, iter, outUpdated, outNeedsRescan);
910 break;
911 }
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400912 Expression& left = bin->left();
913 Expression& right = bin->right();
914 const Type& leftType = left.type();
915 const Type& rightType = right.type();
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400916 // collapse useless expressions like x * 1 or x + 0
Ethan Nicholas30d30222020-09-11 12:27:26 -0400917 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 Nicholasfe53e582017-04-27 16:24:51 -0400921 break;
922 }
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400923 switch (bin->getOperator()) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400924 case Token::Kind::TK_STAR:
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400925 if (is_constant(left, 1)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400926 if (leftType.typeKind() == Type::TypeKind::kVector &&
927 rightType.typeKind() == Type::TypeKind::kScalar) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400928 // float4(1) * x -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400929 vectorize_right(&b, iter, outUpdated, outNeedsRescan);
930 } else {
931 // 1 * x -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400932 // 1 * float4(x) -> float4(x)
933 // float4(1) * float4(x) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400934 delete_left(&b, iter, outUpdated, outNeedsRescan);
935 }
936 }
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400937 else if (is_constant(left, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400938 if (leftType.typeKind() == Type::TypeKind::kScalar &&
939 rightType.typeKind() == Type::TypeKind::kVector &&
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400940 !right.hasSideEffects()) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400941 // 0 * float4(x) -> float4(0)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400942 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
943 } else {
944 // 0 * x -> 0
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400945 // float4(0) * x -> float4(0)
946 // float4(0) * float4(x) -> float4(0)
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400947 if (!right.hasSideEffects()) {
Ethan Nicholas51493ee2017-12-11 12:34:33 -0500948 delete_right(&b, iter, outUpdated, outNeedsRescan);
949 }
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400950 }
Ethan Nicholascb670962017-04-20 19:31:52 -0400951 }
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400952 else if (is_constant(right, 1)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400953 if (leftType.typeKind() == Type::TypeKind::kScalar &&
954 rightType.typeKind() == Type::TypeKind::kVector) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400955 // x * float4(1) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400956 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
957 } else {
958 // x * 1 -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400959 // float4(x) * 1 -> float4(x)
960 // float4(x) * float4(1) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400961 delete_right(&b, iter, outUpdated, outNeedsRescan);
962 }
963 }
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400964 else if (is_constant(right, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400965 if (leftType.typeKind() == Type::TypeKind::kVector &&
966 rightType.typeKind() == Type::TypeKind::kScalar &&
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400967 !left.hasSideEffects()) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400968 // float4(x) * 0 -> float4(0)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400969 vectorize_right(&b, iter, outUpdated, outNeedsRescan);
970 } else {
971 // x * 0 -> 0
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400972 // x * float4(0) -> float4(0)
973 // float4(x) * float4(0) -> float4(0)
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400974 if (!left.hasSideEffects()) {
Ethan Nicholas51493ee2017-12-11 12:34:33 -0500975 delete_left(&b, iter, outUpdated, outNeedsRescan);
976 }
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400977 }
Ethan Nicholascb670962017-04-20 19:31:52 -0400978 }
979 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400980 case Token::Kind::TK_PLUS:
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400981 if (is_constant(left, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400982 if (leftType.typeKind() == Type::TypeKind::kVector &&
983 rightType.typeKind() == Type::TypeKind::kScalar) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400984 // float4(0) + x -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400985 vectorize_right(&b, iter, outUpdated, outNeedsRescan);
986 } else {
987 // 0 + x -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400988 // 0 + float4(x) -> float4(x)
989 // float4(0) + float4(x) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400990 delete_left(&b, iter, outUpdated, outNeedsRescan);
991 }
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -0400992 } else if (is_constant(right, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400993 if (leftType.typeKind() == Type::TypeKind::kScalar &&
994 rightType.typeKind() == Type::TypeKind::kVector) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400995 // x + float4(0) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400996 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
997 } else {
998 // x + 0 -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400999 // float4(x) + 0 -> float4(x)
1000 // float4(x) + float4(0) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001001 delete_right(&b, iter, outUpdated, outNeedsRescan);
1002 }
Ethan Nicholas56e42712017-04-21 10:23:37 -04001003 }
1004 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001005 case Token::Kind::TK_MINUS:
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -04001006 if (is_constant(right, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -04001007 if (leftType.typeKind() == Type::TypeKind::kScalar &&
1008 rightType.typeKind() == Type::TypeKind::kVector) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001009 // x - float4(0) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001010 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
1011 } else {
1012 // x - 0 -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001013 // float4(x) - 0 -> float4(x)
1014 // float4(x) - float4(0) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001015 delete_right(&b, iter, outUpdated, outNeedsRescan);
1016 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001017 }
1018 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001019 case Token::Kind::TK_SLASH:
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -04001020 if (is_constant(right, 1)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -04001021 if (leftType.typeKind() == Type::TypeKind::kScalar &&
1022 rightType.typeKind() == Type::TypeKind::kVector) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001023 // x / float4(1) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001024 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
1025 } else {
1026 // x / 1 -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001027 // float4(x) / 1 -> float4(x)
1028 // float4(x) / float4(1) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001029 delete_right(&b, iter, outUpdated, outNeedsRescan);
1030 }
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -04001031 } else if (is_constant(left, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -04001032 if (leftType.typeKind() == Type::TypeKind::kScalar &&
1033 rightType.typeKind() == Type::TypeKind::kVector &&
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -04001034 !right.hasSideEffects()) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001035 // 0 / float4(x) -> float4(0)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001036 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
1037 } else {
1038 // 0 / x -> 0
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001039 // float4(0) / x -> float4(0)
1040 // float4(0) / float4(x) -> float4(0)
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -04001041 if (!right.hasSideEffects()) {
Ethan Nicholas51493ee2017-12-11 12:34:33 -05001042 delete_right(&b, iter, outUpdated, outNeedsRescan);
1043 }
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001044 }
1045 }
1046 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001047 case Token::Kind::TK_PLUSEQ:
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -04001048 if (is_constant(right, 0)) {
1049 clear_write(left);
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001050 delete_right(&b, iter, outUpdated, outNeedsRescan);
1051 }
1052 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001053 case Token::Kind::TK_MINUSEQ:
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -04001054 if (is_constant(right, 0)) {
1055 clear_write(left);
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001056 delete_right(&b, iter, outUpdated, outNeedsRescan);
1057 }
1058 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001059 case Token::Kind::TK_STAREQ:
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -04001060 if (is_constant(right, 1)) {
1061 clear_write(left);
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001062 delete_right(&b, iter, outUpdated, outNeedsRescan);
1063 }
1064 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001065 case Token::Kind::TK_SLASHEQ:
Ethan Nicholasc8d9c8e2020-09-22 15:05:37 -04001066 if (is_constant(right, 1)) {
1067 clear_write(left);
Ethan Nicholascb670962017-04-20 19:31:52 -04001068 delete_right(&b, iter, outUpdated, outNeedsRescan);
1069 }
1070 break;
1071 default:
1072 break;
1073 }
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001074 break;
1075 }
Ethan Nicholase6592142020-09-08 10:22:09 -04001076 case Expression::Kind::kSwizzle: {
John Stiles403a3632020-08-20 12:11:48 -04001077 Swizzle& s = expr->as<Swizzle>();
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001078 // detect identity swizzles like foo.rgba
Ethan Nicholas6b4d5812020-10-12 16:11:51 -04001079 if ((int) s.components().size() == s.base()->type().columns()) {
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001080 bool identity = true;
Ethan Nicholas6b4d5812020-10-12 16:11:51 -04001081 for (int i = 0; i < (int) s.components().size(); ++i) {
1082 if (s.components()[i] != i) {
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001083 identity = false;
1084 break;
1085 }
1086 }
1087 if (identity) {
1088 *outUpdated = true;
Ethan Nicholas6b4d5812020-10-12 16:11:51 -04001089 if (!try_replace_expression(&b, iter, &s.base())) {
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001090 *outNeedsRescan = true;
1091 return;
1092 }
John Stiles70025e52020-09-28 16:08:58 -04001093 SkASSERT((*iter)->isExpression());
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001094 break;
1095 }
1096 }
1097 // detect swizzles of swizzles, e.g. replace foo.argb.r000 with foo.a000
Ethan Nicholas6b4d5812020-10-12 16:11:51 -04001098 if (s.base()->kind() == Expression::Kind::kSwizzle) {
1099 Swizzle& base = s.base()->as<Swizzle>();
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001100 std::vector<int> final;
Ethan Nicholas6b4d5812020-10-12 16:11:51 -04001101 for (int c : s.components()) {
1102 final.push_back(base.components()[c]);
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001103 }
1104 *outUpdated = true;
Ethan Nicholas6b4d5812020-10-12 16:11:51 -04001105 std::unique_ptr<Expression> replacement(new Swizzle(*fContext, base.base()->clone(),
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001106 std::move(final)));
1107 if (!try_replace_expression(&b, iter, &replacement)) {
1108 *outNeedsRescan = true;
1109 return;
1110 }
John Stiles70025e52020-09-28 16:08:58 -04001111 SkASSERT((*iter)->isExpression());
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001112 }
John Stiles30212b72020-06-11 17:55:07 -04001113 break;
Ethan Nicholascb670962017-04-20 19:31:52 -04001114 }
1115 default:
1116 break;
1117 }
1118}
1119
John Stiles92219b42020-06-15 12:32:24 -04001120// 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 Stilesb92641c2020-08-31 18:09:01 -04001122static bool contains_conditional_break(Statement& stmt) {
1123 class ContainsConditionalBreak : public ProgramVisitor {
1124 public:
1125 bool visitStatement(const Statement& stmt) override {
Ethan Nicholase6592142020-09-08 10:22:09 -04001126 switch (stmt.kind()) {
1127 case Statement::Kind::kBlock:
John Stilesb92641c2020-08-31 18:09:01 -04001128 return this->INHERITED::visitStatement(stmt);
1129
Ethan Nicholase6592142020-09-08 10:22:09 -04001130 case Statement::Kind::kBreak:
John Stilesb92641c2020-08-31 18:09:01 -04001131 return fInConditional > 0;
1132
Ethan Nicholase6592142020-09-08 10:22:09 -04001133 case Statement::Kind::kIf: {
John Stilesb92641c2020-08-31 18:09:01 -04001134 ++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 Stiles92219b42020-06-15 12:32:24 -04001150}
1151
Ethan Nicholas5005a222018-08-24 13:06:27 -04001152// 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 Stilesb92641c2020-08-31 18:09:01 -04001154static bool contains_unconditional_break(Statement& stmt) {
1155 class ContainsUnconditionalBreak : public ProgramVisitor {
1156 public:
1157 bool visitStatement(const Statement& stmt) override {
Ethan Nicholase6592142020-09-08 10:22:09 -04001158 switch (stmt.kind()) {
1159 case Statement::Kind::kBlock:
John Stilesb92641c2020-08-31 18:09:01 -04001160 return this->INHERITED::visitStatement(stmt);
1161
Ethan Nicholase6592142020-09-08 10:22:09 -04001162 case Statement::Kind::kBreak:
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001163 return true;
John Stilesb92641c2020-08-31 18:09:01 -04001164
1165 default:
1166 return false;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001167 }
John Stilesb92641c2020-08-31 18:09:01 -04001168 }
John Stiles92219b42020-06-15 12:32:24 -04001169
John Stilesb92641c2020-08-31 18:09:01 -04001170 using INHERITED = ProgramVisitor;
1171 };
John Stiles92219b42020-06-15 12:32:24 -04001172
John Stilesb92641c2020-08-31 18:09:01 -04001173 return ContainsUnconditionalBreak{}.visitStatement(stmt);
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001174}
1175
John Stiles8f2a0cf2020-10-13 12:48:21 -04001176static void move_all_but_break(std::unique_ptr<Statement>& stmt, StatementArray* target) {
Ethan Nicholase6592142020-09-08 10:22:09 -04001177 switch (stmt->kind()) {
1178 case Statement::Kind::kBlock: {
John Stiles92219b42020-06-15 12:32:24 -04001179 // Recurse into the block.
1180 Block& block = static_cast<Block&>(*stmt);
1181
John Stiles8f2a0cf2020-10-13 12:48:21 -04001182 StatementArray blockStmts;
John Stilesf4bda742020-10-14 16:57:41 -04001183 blockStmts.reserve_back(block.children().size());
Ethan Nicholas7bd60432020-09-25 14:31:59 -04001184 for (std::unique_ptr<Statement>& stmt : block.children()) {
1185 move_all_but_break(stmt, &blockStmts);
Ethan Nicholas739e1ca2020-06-11 12:16:14 -04001186 }
John Stiles92219b42020-06-15 12:32:24 -04001187
1188 target->push_back(std::make_unique<Block>(block.fOffset, std::move(blockStmts),
Ethan Nicholas7bd60432020-09-25 14:31:59 -04001189 block.symbolTable(), block.isScope()));
Ethan Nicholas739e1ca2020-06-11 12:16:14 -04001190 break;
John Stiles92219b42020-06-15 12:32:24 -04001191 }
1192
Ethan Nicholase6592142020-09-08 10:22:09 -04001193 case Statement::Kind::kBreak:
John Stiles92219b42020-06-15 12:32:24 -04001194 // Do not append a break to the target.
1195 break;
1196
Ethan Nicholas739e1ca2020-06-11 12:16:14 -04001197 default:
John Stiles92219b42020-06-15 12:32:24 -04001198 // Append normal statements to the target.
1199 target->push_back(std::move(stmt));
1200 break;
Ethan Nicholas739e1ca2020-06-11 12:16:14 -04001201 }
1202}
1203
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001204// 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 Stiles92219b42020-06-15 12:32:24 -04001209static 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 Nicholas5ac13c22017-05-10 15:06:17 -04001218 }
John Stiles92219b42020-06-15 12:32:24 -04001219 }
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 Nicholas5ac13c22017-05-10 15:06:17 -04001231 }
John Stiles92219b42020-06-15 12:32:24 -04001232
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 Nicholas5ac13c22017-05-10 15:06:17 -04001237 break;
1238 }
1239 }
John Stiles92219b42020-06-15 12:32:24 -04001240
1241 if (unconditionalBreakStmt != nullptr) {
1242 break;
1243 }
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001244 }
John Stiles92219b42020-06-15 12:32:24 -04001245
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 Stiles8f2a0cf2020-10-13 12:48:21 -04001248 StatementArray caseStmts;
John Stiles92219b42020-06-15 12:32:24 -04001249
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 Nicholas5ac13c22017-05-10 15:06:17 -04001256 }
John Stiles92219b42020-06-15 12:32:24 -04001257
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 Nicholas5ac13c22017-05-10 15:06:17 -04001276}
1277
Ethan Nicholascb670962017-04-20 19:31:52 -04001278void Compiler::simplifyStatement(DefinitionMap& definitions,
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001279 BasicBlock& b,
1280 std::vector<BasicBlock::Node>::iterator* iter,
1281 std::unordered_set<const Variable*>* undefinedVariables,
1282 bool* outUpdated,
1283 bool* outNeedsRescan) {
Ethan Nicholascb670962017-04-20 19:31:52 -04001284 Statement* stmt = (*iter)->statement()->get();
Ethan Nicholase6592142020-09-08 10:22:09 -04001285 switch (stmt->kind()) {
1286 case Statement::Kind::kVarDeclaration: {
John Stilesa5a97b42020-08-18 11:19:07 -04001287 const auto& varDecl = stmt->as<VarDeclaration>();
Ethan Nicholasc51f33e2020-10-13 13:49:44 -04001288 if (varDecl.var().dead() &&
1289 (!varDecl.value() ||
1290 !varDecl.value()->hasSideEffects())) {
1291 if (varDecl.value()) {
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001292 SkASSERT((*iter)->statement()->get() == stmt);
Ethan Nicholasc51f33e2020-10-13 13:49:44 -04001293 if (!b.tryRemoveExpressionBefore(iter, varDecl.value().get())) {
Ethan Nicholas82a62d22017-11-07 14:42:10 +00001294 *outNeedsRescan = true;
Ethan Nicholascb670962017-04-20 19:31:52 -04001295 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001296 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001297 (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
Ethan Nicholas82a62d22017-11-07 14:42:10 +00001298 *outUpdated = true;
Ethan Nicholascb670962017-04-20 19:31:52 -04001299 }
1300 break;
1301 }
Ethan Nicholase6592142020-09-08 10:22:09 -04001302 case Statement::Kind::kIf: {
John Stilesa5a97b42020-08-18 11:19:07 -04001303 IfStatement& i = stmt->as<IfStatement>();
Ethan Nicholas8c44eca2020-10-07 16:47:09 -04001304 if (i.test()->kind() == Expression::Kind::kBoolLiteral) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001305 // constant if, collapse down to a single branch
Ethan Nicholas8c44eca2020-10-07 16:47:09 -04001306 if (i.test()->as<BoolLiteral>().value()) {
1307 SkASSERT(i.ifTrue());
1308 (*iter)->setStatement(std::move(i.ifTrue()));
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001309 } else {
Ethan Nicholas8c44eca2020-10-07 16:47:09 -04001310 if (i.ifFalse()) {
1311 (*iter)->setStatement(std::move(i.ifFalse()));
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001312 } else {
1313 (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
1314 }
1315 }
1316 *outUpdated = true;
1317 *outNeedsRescan = true;
1318 break;
1319 }
Ethan Nicholas8c44eca2020-10-07 16:47:09 -04001320 if (i.ifFalse() && i.ifFalse()->isEmpty()) {
Ethan Nicholascb670962017-04-20 19:31:52 -04001321 // else block doesn't do anything, remove it
Ethan Nicholas8c44eca2020-10-07 16:47:09 -04001322 i.ifFalse().reset();
Ethan Nicholascb670962017-04-20 19:31:52 -04001323 *outUpdated = true;
1324 *outNeedsRescan = true;
1325 }
Ethan Nicholas8c44eca2020-10-07 16:47:09 -04001326 if (!i.ifFalse() && i.ifTrue()->isEmpty()) {
Ethan Nicholascb670962017-04-20 19:31:52 -04001327 // if block doesn't do anything, no else block
Ethan Nicholas8c44eca2020-10-07 16:47:09 -04001328 if (i.test()->hasSideEffects()) {
Ethan Nicholascb670962017-04-20 19:31:52 -04001329 // test has side effects, keep it
1330 (*iter)->setStatement(std::unique_ptr<Statement>(
Ethan Nicholas8c44eca2020-10-07 16:47:09 -04001331 new ExpressionStatement(std::move(i.test()))));
Ethan Nicholascb670962017-04-20 19:31:52 -04001332 } 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 Nicholase6592142020-09-08 10:22:09 -04001342 case Statement::Kind::kSwitch: {
John Stilesa5a97b42020-08-18 11:19:07 -04001343 SwitchStatement& s = stmt->as<SwitchStatement>();
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001344 int64_t switchValue;
1345 if (fIRGenerator->getConstantInt(*s.fValue, &switchValue)) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001346 // switch is constant, replace it with the case that matches
1347 bool found = false;
1348 SwitchCase* defaultCase = nullptr;
John Stiles9d944232020-08-19 09:56:49 -04001349 for (const std::unique_ptr<SwitchCase>& c : s.fCases) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001350 if (!c->fValue) {
1351 defaultCase = c.get();
1352 continue;
1353 }
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001354 int64_t caseValue;
1355 SkAssertResult(fIRGenerator->getConstantInt(*c->fValue, &caseValue));
1356 if (caseValue == switchValue) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001357 std::unique_ptr<Statement> newBlock = block_for_case(&s, c.get());
1358 if (newBlock) {
1359 (*iter)->setStatement(std::move(newBlock));
John Stiles9d944232020-08-19 09:56:49 -04001360 found = true;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001361 break;
1362 } else {
Ethan Nicholas6e1cbc02017-07-14 10:12:15 -04001363 if (s.fIsStatic && !(fFlags & kPermitInvalidStaticTests_Flag)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001364 this->error(s.fOffset,
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001365 "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 Nicholas6e1cbc02017-07-14 10:12:15 -04001379 if (s.fIsStatic && !(fFlags & kPermitInvalidStaticTests_Flag)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001380 this->error(s.fOffset,
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001381 "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 Nicholase6592142020-09-08 10:22:09 -04001395 case Statement::Kind::kExpression: {
John Stilesa5a97b42020-08-18 11:19:07 -04001396 ExpressionStatement& e = stmt->as<ExpressionStatement>();
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001397 SkASSERT((*iter)->statement()->get() == &e);
Ethan Nicholasd503a5a2020-09-30 09:29:55 -04001398 if (!e.expression()->hasSideEffects()) {
Ethan Nicholascb670962017-04-20 19:31:52 -04001399 // Expression statement with no side effects, kill it
Ethan Nicholasd503a5a2020-09-30 09:29:55 -04001400 if (!b.tryRemoveExpressionBefore(iter, e.expression().get())) {
Ethan Nicholascb670962017-04-20 19:31:52 -04001401 *outNeedsRescan = true;
1402 }
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001403 SkASSERT((*iter)->statement()->get() == stmt);
Ethan Nicholascb670962017-04-20 19:31:52 -04001404 (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
1405 *outUpdated = true;
1406 }
1407 break;
1408 }
1409 default:
1410 break;
1411 }
1412}
1413
John Stiles0cc193a2020-09-09 09:39:34 -04001414bool Compiler::scanCFG(FunctionDefinition& f) {
1415 bool madeChanges = false;
1416
Ethan Nicholascb670962017-04-20 19:31:52 -04001417 CFG cfg = CFGGenerator().getCFG(f);
1418 this->computeDataFlow(&cfg);
ethannicholas22f939e2016-10-13 13:25:34 -07001419
1420 // check for unreachable code
1421 for (size_t i = 0; i < cfg.fBlocks.size(); i++) {
John Stiles0cc193a2020-09-09 09:39:34 -04001422 const BasicBlock& block = cfg.fBlocks[i];
John Stiles61e75e32020-10-01 15:42:37 -04001423 if (i != cfg.fStart && !block.fIsReachable && block.fNodes.size()) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001424 int offset;
John Stiles0cc193a2020-09-09 09:39:34 -04001425 const BasicBlock::Node& node = block.fNodes[0];
John Stiles70025e52020-09-28 16:08:58 -04001426 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 Nicholas86a43402017-01-19 13:32:00 -05001437 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001438 this->error(offset, String("unreachable"));
ethannicholas22f939e2016-10-13 13:25:34 -07001439 }
1440 }
1441 if (fErrorCount) {
John Stiles0cc193a2020-09-09 09:39:34 -04001442 return madeChanges;
ethannicholas22f939e2016-10-13 13:25:34 -07001443 }
1444
Ethan Nicholascb670962017-04-20 19:31:52 -04001445 // 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 Nicholas113628d2017-02-02 16:11:39 -05001454 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001455
1456 updated = false;
Ethan Nicholas1de14812020-06-19 15:32:49 -04001457 bool first = true;
Ethan Nicholascb670962017-04-20 19:31:52 -04001458 for (BasicBlock& b : cfg.fBlocks) {
John Stiles61e75e32020-10-01 15:42:37 -04001459 if (!first && !b.fIsReachable) {
Ethan Nicholas1de14812020-06-19 15:32:49 -04001460 // 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 Osmanc0213602020-10-06 14:43:32 -04001463 // have not been properly assigned. Kill it by replacing all statements with Nops.
Ethan Nicholas1de14812020-06-19 15:32:49 -04001464 for (BasicBlock::Node& node : b.fNodes) {
John Stiles70025e52020-09-28 16:08:58 -04001465 if (node.isStatement() && !(*node.statement())->is<Nop>()) {
John Stiles0cc193a2020-09-09 09:39:34 -04001466 node.setStatement(std::make_unique<Nop>());
1467 madeChanges = true;
Ethan Nicholas1de14812020-06-19 15:32:49 -04001468 }
1469 }
1470 continue;
1471 }
1472 first = false;
Ethan Nicholascb670962017-04-20 19:31:52 -04001473 DefinitionMap definitions = b.fBefore;
1474
1475 for (auto iter = b.fNodes.begin(); iter != b.fNodes.end() && !needsRescan; ++iter) {
John Stiles70025e52020-09-28 16:08:58 -04001476 if (iter->isExpression()) {
Ethan Nicholascb670962017-04-20 19:31:52 -04001477 this->simplifyExpression(definitions, b, &iter, &undefinedVariables, &updated,
1478 &needsRescan);
1479 } else {
1480 this->simplifyStatement(definitions, b, &iter, &undefinedVariables, &updated,
John Stiles0cc193a2020-09-09 09:39:34 -04001481 &needsRescan);
Ethan Nicholascb670962017-04-20 19:31:52 -04001482 }
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001483 if (needsRescan) {
1484 break;
1485 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001486 this->addDefinitions(*iter, &definitions);
1487 }
Brian Osman01a3eb42020-09-14 11:32:49 -04001488
1489 if (needsRescan) {
1490 break;
1491 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001492 }
John Stiles0cc193a2020-09-09 09:39:34 -04001493 madeChanges |= updated;
Ethan Nicholascb670962017-04-20 19:31:52 -04001494 } while (updated);
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001495 SkASSERT(!needsRescan);
ethannicholas22f939e2016-10-13 13:25:34 -07001496
Ethan Nicholas91a10532017-06-22 11:24:38 -04001497 // verify static ifs & switches, clean up dead variable decls
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001498 for (BasicBlock& b : cfg.fBlocks) {
Ethan Nicholas91a10532017-06-22 11:24:38 -04001499 for (auto iter = b.fNodes.begin(); iter != b.fNodes.end() && !needsRescan;) {
John Stiles70025e52020-09-28 16:08:58 -04001500 if (iter->isStatement()) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001501 const Statement& s = **iter->statement();
Ethan Nicholase6592142020-09-08 10:22:09 -04001502 switch (s.kind()) {
1503 case Statement::Kind::kIf:
Ethan Nicholas8c44eca2020-10-07 16:47:09 -04001504 if (s.as<IfStatement>().isStatic() &&
Ethan Nicholas6e1cbc02017-07-14 10:12:15 -04001505 !(fFlags & kPermitInvalidStaticTests_Flag)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001506 this->error(s.fOffset, "static if has non-static test");
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001507 }
Ethan Nicholas91a10532017-06-22 11:24:38 -04001508 ++iter;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001509 break;
Ethan Nicholase6592142020-09-08 10:22:09 -04001510 case Statement::Kind::kSwitch:
John Stilesa5a97b42020-08-18 11:19:07 -04001511 if (s.as<SwitchStatement>().fIsStatic &&
John Stiles0cc193a2020-09-09 09:39:34 -04001512 !(fFlags & kPermitInvalidStaticTests_Flag)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001513 this->error(s.fOffset, "static switch has non-static test");
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001514 }
Ethan Nicholas91a10532017-06-22 11:24:38 -04001515 ++iter;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001516 break;
1517 default:
Ethan Nicholas91a10532017-06-22 11:24:38 -04001518 ++iter;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001519 break;
1520 }
Ethan Nicholas91a10532017-06-22 11:24:38 -04001521 } else {
1522 ++iter;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001523 }
1524 }
1525 }
1526
ethannicholas22f939e2016-10-13 13:25:34 -07001527 // check for missing return
Ethan Nicholas0a5d0962020-10-14 13:33:18 -04001528 if (f.declaration().returnType() != *fContext->fVoid_Type) {
John Stiles61e75e32020-10-01 15:42:37 -04001529 if (cfg.fBlocks[cfg.fExit].fIsReachable) {
Ethan Nicholas0a5d0962020-10-14 13:33:18 -04001530 this->error(f.fOffset, String("function '" + String(f.declaration().name()) +
Ethan Nicholasdb80f692019-11-22 14:06:12 -05001531 "' can exit without returning a value"));
ethannicholas22f939e2016-10-13 13:25:34 -07001532 }
1533 }
John Stiles0cc193a2020-09-09 09:39:34 -04001534
1535 return madeChanges;
ethannicholas22f939e2016-10-13 13:25:34 -07001536}
1537
Brian Osman32d53552020-09-23 13:55:20 -04001538std::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 Nicholas91164d12019-05-15 15:29:54 -04001544
ethannicholasb3058bd2016-07-01 08:22:01 -07001545 fErrorText = "";
1546 fErrorCount = 0;
Brian Osman3d87e9f2020-10-08 11:50:22 -04001547 fInliner.reset(fContext.get(), fIRGenerator->fModifiers.get(), &settings);
Brian Osman88cda172020-10-09 12:05:16 -04001548
1549 // Not using AutoSource, because caller is likely to call errorText() if we fail to compile
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001550 std::unique_ptr<String> textPtr(new String(std::move(text)));
1551 fSource = textPtr.get();
Brian Osman88cda172020-10-09 12:05:16 -04001552
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 Stilesfbd050b2020-08-03 13:21:46 -04001558 auto result = std::make_unique<Program>(kind,
1559 std::move(textPtr),
1560 settings,
1561 fContext,
Brian Osman88cda172020-10-09 12:05:16 -04001562 std::move(ir.fElements),
1563 std::move(ir.fModifiers),
1564 std::move(ir.fSymbolTable),
1565 ir.fInputs);
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001566 if (fErrorCount) {
1567 return nullptr;
1568 }
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001569 if (settings.fOptimize && !this->optimize(*result)) {
1570 return nullptr;
1571 }
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001572 return result;
1573}
1574
Ethan Nicholas00543112018-07-31 09:44:36 -04001575bool Compiler::optimize(Program& program) {
1576 SkASSERT(!fErrorCount);
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001577 fIRGenerator->fKind = program.fKind;
1578 fIRGenerator->fSettings = &program.fSettings;
John Stiles7954d6c2020-09-01 10:53:02 -04001579
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001580 while (fErrorCount == 0) {
1581 bool madeChanges = false;
John Stiles7954d6c2020-09-01 10:53:02 -04001582
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001583 // Scan and optimize based on the control-flow graph for each function.
Brian Osman1179fcf2020-10-08 16:04:40 -04001584 for (const auto& element : program.elements()) {
1585 if (element->is<FunctionDefinition>()) {
1586 madeChanges |= this->scanCFG(element->as<FunctionDefinition>());
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001587 }
1588 }
1589
1590 // Perform inline-candidate analysis and inline any functions deemed suitable.
John Stiles881a10c2020-09-19 10:13:24 -04001591 madeChanges |= fInliner.analyze(program);
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001592
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 Nicholas0a5d0962020-10-14 13:33:18 -04001604 bool dead = fn.declaration().callCount() == 0 &&
1605 fn.declaration().name() != "main";
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001606 madeChanges |= dead;
1607 return dead;
1608 }),
1609 program.fElements.end());
1610 }
1611
1612 if (program.fKind != Program::kFragmentProcessor_Kind) {
Brian Osmanc0213602020-10-06 14:43:32 -04001613 // Remove declarations of dead global variables
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001614 program.fElements.erase(
1615 std::remove_if(program.fElements.begin(), program.fElements.end(),
1616 [&](const std::unique_ptr<ProgramElement>& element) {
Brian Osmanc0213602020-10-06 14:43:32 -04001617 if (!element->is<GlobalVarDeclaration>()) {
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001618 return false;
1619 }
Ethan Nicholasc51f33e2020-10-13 13:49:44 -04001620 const auto& global = element->as<GlobalVarDeclaration>();
1621 const auto& varDecl =
1622 global.declaration()->as<VarDeclaration>();
1623 bool dead = varDecl.var().dead();
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001624 madeChanges |= dead;
1625 return dead;
1626 }),
1627 program.fElements.end());
1628 }
John Stiles73a6bff2020-09-09 13:40:37 -04001629
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001630 if (!madeChanges) {
1631 break;
Ethan Nicholas0dc80872019-02-08 15:46:24 -05001632 }
Ethan Nicholas00543112018-07-31 09:44:36 -04001633 }
1634 return fErrorCount == 0;
1635}
1636
Brian Osmanfb32ddf2019-06-18 10:14:20 -04001637#if defined(SKSL_STANDALONE) || SK_SUPPORT_GPU
1638
Ethan Nicholas00543112018-07-31 09:44:36 -04001639bool Compiler::toSPIRV(Program& program, OutputStream& out) {
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001640#ifdef SK_ENABLE_SPIRV_VALIDATION
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001641 StringStream buffer;
Brian Osman88cda172020-10-09 12:05:16 -04001642 AutoSource as(this, program.fSource.get());
Brian Osman8b43dad2020-10-09 13:31:42 -04001643 SPIRVCodeGenerator cg(fContext.get(), &program, this, &buffer);
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001644 bool result = cg.generateCode();
1645 if (result) {
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001646 spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_0);
Ethan Nicholas762466e2017-06-29 10:03:38 -04001647 const String& data = buffer.str();
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001648 SkASSERT(0 == data.size() % 4);
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001649 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 Nicholasd9d33c32018-06-12 11:05:59 -04001653 // Verify that the SPIR-V we produced is valid. If this SkASSERT fails, check the logs prior
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001654 // to the failure to see the validation errors.
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001655 SkAssertResult(tools.Validate((const uint32_t*) data.c_str(), data.size() / 4));
Ethan Nicholas762466e2017-06-29 10:03:38 -04001656 out.write(data.c_str(), data.size());
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001657 }
1658#else
Brian Osman88cda172020-10-09 12:05:16 -04001659 AutoSource as(this, program.fSource.get());
Brian Osman8b43dad2020-10-09 13:31:42 -04001660 SPIRVCodeGenerator cg(fContext.get(), &program, this, &out);
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001661 bool result = cg.generateCode();
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001662#endif
Ethan Nicholasce33f102016-12-09 17:22:59 -05001663 return result;
1664}
1665
Ethan Nicholas00543112018-07-31 09:44:36 -04001666bool Compiler::toSPIRV(Program& program, String* out) {
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001667 StringStream buffer;
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001668 bool result = this->toSPIRV(program, buffer);
1669 if (result) {
Ethan Nicholas762466e2017-06-29 10:03:38 -04001670 *out = buffer.str();
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001671 }
1672 return result;
1673}
1674
Ethan Nicholas00543112018-07-31 09:44:36 -04001675bool Compiler::toGLSL(Program& program, OutputStream& out) {
Brian Osman88cda172020-10-09 12:05:16 -04001676 AutoSource as(this, program.fSource.get());
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001677 GLSLCodeGenerator cg(fContext.get(), &program, this, &out);
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001678 bool result = cg.generateCode();
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001679 return result;
1680}
1681
Ethan Nicholas00543112018-07-31 09:44:36 -04001682bool Compiler::toGLSL(Program& program, String* out) {
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001683 StringStream buffer;
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001684 bool result = this->toGLSL(program, buffer);
1685 if (result) {
Ethan Nicholas762466e2017-06-29 10:03:38 -04001686 *out = buffer.str();
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001687 }
1688 return result;
1689}
1690
Brian Osmanc0243912020-02-19 15:35:26 -05001691bool 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 Nicholas00543112018-07-31 09:44:36 -04001700bool Compiler::toMetal(Program& program, OutputStream& out) {
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001701 MetalCodeGenerator cg(fContext.get(), &program, this, &out);
Ethan Nicholascc305772017-10-13 16:17:45 -04001702 bool result = cg.generateCode();
Ethan Nicholascc305772017-10-13 16:17:45 -04001703 return result;
1704}
1705
Ethan Nicholas00543112018-07-31 09:44:36 -04001706bool Compiler::toMetal(Program& program, String* out) {
Timothy Liangb8eeb802018-07-23 16:46:16 -04001707 StringStream buffer;
1708 bool result = this->toMetal(program, buffer);
1709 if (result) {
1710 *out = buffer.str();
1711 }
1712 return result;
1713}
1714
Greg Daniela28ea672020-09-25 11:12:56 -04001715#if defined(SKSL_STANDALONE) || GR_TEST_UTILS
Ethan Nicholas00543112018-07-31 09:44:36 -04001716bool Compiler::toCPP(Program& program, String name, OutputStream& out) {
Brian Osman88cda172020-10-09 12:05:16 -04001717 AutoSource as(this, program.fSource.get());
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001718 CPPCodeGenerator cg(fContext.get(), &program, this, name, &out);
Ethan Nicholas762466e2017-06-29 10:03:38 -04001719 bool result = cg.generateCode();
Ethan Nicholas762466e2017-06-29 10:03:38 -04001720 return result;
1721}
1722
Ethan Nicholas00543112018-07-31 09:44:36 -04001723bool Compiler::toH(Program& program, String name, OutputStream& out) {
Brian Osman88cda172020-10-09 12:05:16 -04001724 AutoSource as(this, program.fSource.get());
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001725 HCodeGenerator cg(fContext.get(), &program, this, name, &out);
Ethan Nicholas762466e2017-06-29 10:03:38 -04001726 bool result = cg.generateCode();
Ethan Nicholas00543112018-07-31 09:44:36 -04001727 return result;
1728}
Greg Daniela28ea672020-09-25 11:12:56 -04001729#endif // defined(SKSL_STANDALONE) || GR_TEST_UTILS
Ethan Nicholas00543112018-07-31 09:44:36 -04001730
Ethan Nicholas2a479a52020-08-18 16:29:45 -04001731#endif // defined(SKSL_STANDALONE) || SK_SUPPORT_GPU
Brian Osman2e29ab52019-09-20 12:19:11 -04001732
1733#if !defined(SKSL_STANDALONE) && SK_SUPPORT_GPU
Brian Osmana4b91692020-08-10 14:26:16 -04001734bool Compiler::toPipelineStage(Program& program, PipelineStageArgs* outArgs) {
Brian Osman88cda172020-10-09 12:05:16 -04001735 AutoSource as(this, program.fSource.get());
Ethan Nicholas00543112018-07-31 09:44:36 -04001736 StringStream buffer;
Brian Osman300fe1d2020-01-23 15:42:43 -05001737 PipelineStageCodeGenerator cg(fContext.get(), &program, this, &buffer, outArgs);
Ethan Nicholas00543112018-07-31 09:44:36 -04001738 bool result = cg.generateCode();
Ethan Nicholas00543112018-07-31 09:44:36 -04001739 if (result) {
Brian Osman107c6662019-12-30 15:02:30 -05001740 outArgs->fCode = buffer.str();
Ethan Nicholas00543112018-07-31 09:44:36 -04001741 }
Ethan Nicholas762466e2017-06-29 10:03:38 -04001742 return result;
1743}
Brian Osmanfb32ddf2019-06-18 10:14:20 -04001744#endif
1745
Ethan Nicholas0e9401d2019-03-21 11:05:37 -04001746std::unique_ptr<ByteCode> Compiler::toByteCode(Program& program) {
Mike Klein853d4ed2020-08-20 00:41:00 +00001747#if defined(SK_ENABLE_SKSL_INTERPRETER)
Brian Osman88cda172020-10-09 12:05:16 -04001748 AutoSource as(this, program.fSource.get());
Ethan Nicholas0e9401d2019-03-21 11:05:37 -04001749 std::unique_ptr<ByteCode> result(new ByteCode());
Brian Osmanb08cc022020-04-02 11:38:40 -04001750 ByteCodeGenerator cg(fContext.get(), &program, this, result.get());
1751 bool success = cg.generateCode();
Brian Osmanb08cc022020-04-02 11:38:40 -04001752 if (success) {
Ethan Nicholas0e9401d2019-03-21 11:05:37 -04001753 return result;
1754 }
Mike Klein853d4ed2020-08-20 00:41:00 +00001755#else
1756 ABORT("ByteCode interpreter not enabled");
1757#endif
Ethan Nicholas0e9401d2019-03-21 11:05:37 -04001758 return nullptr;
1759}
1760
Brian Osman401a0092020-09-10 14:47:24 -04001761const char* Compiler::OperatorName(Token::Kind op) {
1762 switch (op) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001763 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 Nicholas5b5f0962017-09-11 13:50:14 -07001801 default:
Brian Osman401a0092020-09-10 14:47:24 -04001802 ABORT("unsupported operator: %d\n", (int) op);
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001803 }
1804}
1805
1806
1807bool Compiler::IsAssignment(Token::Kind op) {
1808 switch (op) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001809 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 Nicholas5b5f0962017-09-11 13:50:14 -07001823 return true;
1824 default:
1825 return false;
1826 }
1827}
1828
Brian Osman401a0092020-09-10 14:47:24 -04001829Token::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 Nicholas5b5f0962017-09-11 13:50:14 -07001848Position Compiler::position(int offset) {
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001849 SkASSERT(fSource);
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001850 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
1864void Compiler::error(int offset, String msg) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001865 fErrorCount++;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001866 Position pos = this->position(offset);
1867 fErrorText += "error: " + to_string(pos.fLine) + ": " + msg.c_str() + "\n";
ethannicholasb3058bd2016-07-01 08:22:01 -07001868}
1869
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001870String Compiler::errorText() {
Ethan Nicholas00543112018-07-31 09:44:36 -04001871 this->writeErrorCount();
1872 fErrorCount = 0;
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001873 String result = fErrorText;
ethannicholasb3058bd2016-07-01 08:22:01 -07001874 return result;
1875}
1876
1877void 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 Stilesa6841be2020-08-06 14:11:56 -04001887} // namespace SkSL