blob: ec0266b1ea8ebd89be5028f9c2b3402354ec54a8 [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"
ethannicholasb3058bd2016-07-01 08:22:01 -070036
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -040037#include <fstream>
38
Ethan Nicholasa11035b2019-11-26 16:27:47 -050039#if !defined(SKSL_STANDALONE) & SK_SUPPORT_GPU
40#include "include/gpu/GrContextOptions.h"
41#include "src/gpu/GrShaderCaps.h"
42#endif
43
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -040044#ifdef SK_ENABLE_SPIRV_VALIDATION
45#include "spirv-tools/libspirv.hpp"
46#endif
47
Brian Osmandd496172020-08-08 08:17:18 -040048#if !SKSL_STANDALONE
Ethan Nicholasc18bb512020-07-28 14:46:53 -040049
50#include "src/sksl/generated/sksl_fp.dehydrated.sksl"
51#include "src/sksl/generated/sksl_frag.dehydrated.sksl"
52#include "src/sksl/generated/sksl_geom.dehydrated.sksl"
53#include "src/sksl/generated/sksl_gpu.dehydrated.sksl"
54#include "src/sksl/generated/sksl_interp.dehydrated.sksl"
55#include "src/sksl/generated/sksl_pipeline.dehydrated.sksl"
56#include "src/sksl/generated/sksl_vert.dehydrated.sksl"
57
58#else
59
Brian Osmandd496172020-08-08 08:17:18 -040060// GN generates or copies all of these files to the skslc executable directory
61static const char SKSL_GPU_INCLUDE[] = "sksl_gpu.sksl";
62static const char SKSL_INTERP_INCLUDE[] = "sksl_interp.sksl";
63static const char SKSL_VERT_INCLUDE[] = "sksl_vert.sksl";
64static const char SKSL_FRAG_INCLUDE[] = "sksl_frag.sksl";
65static const char SKSL_GEOM_INCLUDE[] = "sksl_geom.sksl";
66static const char SKSL_FP_INCLUDE[] = "sksl_fp.sksl";
67static const char SKSL_PIPELINE_INCLUDE[] = "sksl_pipeline.sksl";
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
Ethan Nicholasdb80f692019-11-22 14:06:12 -050073static void grab_intrinsics(std::vector<std::unique_ptr<ProgramElement>>* src,
John Stiles810c8cf2020-08-26 19:46:27 -040074 IRIntrinsicMap* target) {
Brian Osman08f986d2020-05-13 17:06:46 -040075 for (auto iter = src->begin(); iter != src->end(); ) {
76 std::unique_ptr<ProgramElement>& element = *iter;
Ethan Nicholase6592142020-09-08 10:22:09 -040077 switch (element->kind()) {
78 case ProgramElement::Kind::kFunction: {
John Stiles3dc0da62020-08-19 17:48:31 -040079 FunctionDefinition& f = element->as<FunctionDefinition>();
Brian Osman08f986d2020-05-13 17:06:46 -040080 SkASSERT(f.fDeclaration.fBuiltin);
Ethan Nicholasc18bb512020-07-28 14:46:53 -040081 String key = f.fDeclaration.description();
Brian Osman08f986d2020-05-13 17:06:46 -040082 SkASSERT(target->find(key) == target->end());
John Stiles810c8cf2020-08-26 19:46:27 -040083 (*target)[key] = IRIntrinsic{std::move(element), /*fAlreadyIncluded=*/false};
Brian Osman08f986d2020-05-13 17:06:46 -040084 iter = src->erase(iter);
Ethan Nicholasdb80f692019-11-22 14:06:12 -050085 break;
86 }
Ethan Nicholase6592142020-09-08 10:22:09 -040087 case ProgramElement::Kind::kEnum: {
John Stiles3dc0da62020-08-19 17:48:31 -040088 Enum& e = element->as<Enum>();
Ethan Nicholasdb80f692019-11-22 14:06:12 -050089 StringFragment name = e.fTypeName;
90 SkASSERT(target->find(name) == target->end());
John Stiles810c8cf2020-08-26 19:46:27 -040091 (*target)[name] = IRIntrinsic{std::move(element), /*fAlreadyIncluded=*/false};
Brian Osman08f986d2020-05-13 17:06:46 -040092 iter = src->erase(iter);
Ethan Nicholasdb80f692019-11-22 14:06:12 -050093 break;
94 }
95 default:
96 printf("unsupported include file element\n");
97 SkASSERT(false);
98 }
99 }
100}
101
Ethan Nicholas6e1cbc02017-07-14 10:12:15 -0400102Compiler::Compiler(Flags flags)
John Stiles810c8cf2020-08-26 19:46:27 -0400103: fGPUIntrinsics(std::make_unique<IRIntrinsicMap>())
104, fInterpreterIntrinsics(std::make_unique<IRIntrinsicMap>())
105, fFlags(flags)
106, fContext(std::make_shared<Context>())
Ethan Nicholas6e1cbc02017-07-14 10:12:15 -0400107, fErrorCount(0) {
John Stiles656427a2020-08-27 15:26:26 -0400108 auto symbols = std::make_shared<SymbolTable>(this);
John Stiles7b463002020-08-31 17:29:21 -0400109 fIRGenerator = std::make_unique<IRGenerator>(fContext.get(), &fInliner, symbols, *this);
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400110 #define ADD_TYPE(t) symbols->addWithoutOwnership(fContext->f ## t ## _Type->fName, \
111 fContext->f ## t ## _Type.get())
ethannicholasb3058bd2016-07-01 08:22:01 -0700112 ADD_TYPE(Void);
113 ADD_TYPE(Float);
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400114 ADD_TYPE(Float2);
115 ADD_TYPE(Float3);
116 ADD_TYPE(Float4);
Ethan Nicholasdcba08e2017-08-02 10:52:54 -0400117 ADD_TYPE(Half);
118 ADD_TYPE(Half2);
119 ADD_TYPE(Half3);
120 ADD_TYPE(Half4);
ethannicholasb3058bd2016-07-01 08:22:01 -0700121 ADD_TYPE(Int);
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400122 ADD_TYPE(Int2);
123 ADD_TYPE(Int3);
124 ADD_TYPE(Int4);
ethannicholasb3058bd2016-07-01 08:22:01 -0700125 ADD_TYPE(UInt);
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400126 ADD_TYPE(UInt2);
127 ADD_TYPE(UInt3);
128 ADD_TYPE(UInt4);
Ethan Nicholasdcba08e2017-08-02 10:52:54 -0400129 ADD_TYPE(Short);
130 ADD_TYPE(Short2);
131 ADD_TYPE(Short3);
132 ADD_TYPE(Short4);
133 ADD_TYPE(UShort);
134 ADD_TYPE(UShort2);
135 ADD_TYPE(UShort3);
136 ADD_TYPE(UShort4);
Ruiqi Maob609e6d2018-07-17 10:19:38 -0400137 ADD_TYPE(Byte);
138 ADD_TYPE(Byte2);
139 ADD_TYPE(Byte3);
140 ADD_TYPE(Byte4);
141 ADD_TYPE(UByte);
142 ADD_TYPE(UByte2);
143 ADD_TYPE(UByte3);
144 ADD_TYPE(UByte4);
ethannicholasb3058bd2016-07-01 08:22:01 -0700145 ADD_TYPE(Bool);
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400146 ADD_TYPE(Bool2);
147 ADD_TYPE(Bool3);
148 ADD_TYPE(Bool4);
149 ADD_TYPE(Float2x2);
150 ADD_TYPE(Float2x3);
151 ADD_TYPE(Float2x4);
152 ADD_TYPE(Float3x2);
153 ADD_TYPE(Float3x3);
154 ADD_TYPE(Float3x4);
155 ADD_TYPE(Float4x2);
156 ADD_TYPE(Float4x3);
157 ADD_TYPE(Float4x4);
Ethan Nicholasdcba08e2017-08-02 10:52:54 -0400158 ADD_TYPE(Half2x2);
159 ADD_TYPE(Half2x3);
160 ADD_TYPE(Half2x4);
161 ADD_TYPE(Half3x2);
162 ADD_TYPE(Half3x3);
163 ADD_TYPE(Half3x4);
164 ADD_TYPE(Half4x2);
165 ADD_TYPE(Half4x3);
166 ADD_TYPE(Half4x4);
ethannicholasb3058bd2016-07-01 08:22:01 -0700167 ADD_TYPE(GenType);
Ethan Nicholasdcba08e2017-08-02 10:52:54 -0400168 ADD_TYPE(GenHType);
ethannicholasb3058bd2016-07-01 08:22:01 -0700169 ADD_TYPE(GenIType);
170 ADD_TYPE(GenUType);
171 ADD_TYPE(GenBType);
172 ADD_TYPE(Mat);
173 ADD_TYPE(Vec);
174 ADD_TYPE(GVec);
175 ADD_TYPE(GVec2);
176 ADD_TYPE(GVec3);
177 ADD_TYPE(GVec4);
Ethan Nicholasdcba08e2017-08-02 10:52:54 -0400178 ADD_TYPE(HVec);
ethannicholasb3058bd2016-07-01 08:22:01 -0700179 ADD_TYPE(IVec);
180 ADD_TYPE(UVec);
Ethan Nicholasdcba08e2017-08-02 10:52:54 -0400181 ADD_TYPE(SVec);
182 ADD_TYPE(USVec);
Ruiqi Maob609e6d2018-07-17 10:19:38 -0400183 ADD_TYPE(ByteVec);
184 ADD_TYPE(UByteVec);
ethannicholasb3058bd2016-07-01 08:22:01 -0700185 ADD_TYPE(BVec);
186
187 ADD_TYPE(Sampler1D);
188 ADD_TYPE(Sampler2D);
189 ADD_TYPE(Sampler3D);
ethannicholas5961bc92016-10-12 06:39:56 -0700190 ADD_TYPE(SamplerExternalOES);
ethannicholasb3058bd2016-07-01 08:22:01 -0700191 ADD_TYPE(SamplerCube);
192 ADD_TYPE(Sampler2DRect);
193 ADD_TYPE(Sampler1DArray);
194 ADD_TYPE(Sampler2DArray);
195 ADD_TYPE(SamplerCubeArray);
196 ADD_TYPE(SamplerBuffer);
197 ADD_TYPE(Sampler2DMS);
198 ADD_TYPE(Sampler2DMSArray);
199
Brian Salomonbf7b6202016-11-11 16:08:03 -0500200 ADD_TYPE(ISampler2D);
201
Brian Salomon2a51de82016-11-16 12:06:01 -0500202 ADD_TYPE(Image2D);
203 ADD_TYPE(IImage2D);
204
Greg Daniel64773e62016-11-22 09:44:03 -0500205 ADD_TYPE(SubpassInput);
206 ADD_TYPE(SubpassInputMS);
207
ethannicholasb3058bd2016-07-01 08:22:01 -0700208 ADD_TYPE(GSampler1D);
209 ADD_TYPE(GSampler2D);
210 ADD_TYPE(GSampler3D);
211 ADD_TYPE(GSamplerCube);
212 ADD_TYPE(GSampler2DRect);
213 ADD_TYPE(GSampler1DArray);
214 ADD_TYPE(GSampler2DArray);
215 ADD_TYPE(GSamplerCubeArray);
216 ADD_TYPE(GSamplerBuffer);
217 ADD_TYPE(GSampler2DMS);
218 ADD_TYPE(GSampler2DMSArray);
219
220 ADD_TYPE(Sampler1DShadow);
221 ADD_TYPE(Sampler2DShadow);
222 ADD_TYPE(SamplerCubeShadow);
223 ADD_TYPE(Sampler2DRectShadow);
224 ADD_TYPE(Sampler1DArrayShadow);
225 ADD_TYPE(Sampler2DArrayShadow);
226 ADD_TYPE(SamplerCubeArrayShadow);
227 ADD_TYPE(GSampler2DArrayShadow);
228 ADD_TYPE(GSamplerCubeArrayShadow);
Ethan Nicholasc9472af2017-10-10 16:30:21 -0400229 ADD_TYPE(FragmentProcessor);
Stephen Whiteff5d7a22019-07-26 17:42:06 -0400230 ADD_TYPE(Sampler);
231 ADD_TYPE(Texture2D);
ethannicholasb3058bd2016-07-01 08:22:01 -0700232
Brian Osman28590d52020-03-23 16:59:08 -0400233 StringFragment fpAliasName("shader");
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400234 symbols->addWithoutOwnership(fpAliasName, fContext->fFragmentProcessor_Type.get());
Brian Osman28590d52020-03-23 16:59:08 -0400235
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700236 StringFragment skCapsName("sk_Caps");
John Stiles311dd9d2020-08-13 17:09:29 -0400237 fIRGenerator->fSymbolTable->add(
238 skCapsName,
239 std::make_unique<Variable>(/*offset=*/-1, Modifiers(), skCapsName,
Ethan Nicholas30d30222020-09-11 12:27:26 -0400240 fContext->fSkCaps_Type.get(), Variable::kGlobal_Storage));
Ethan Nicholas3605ace2016-11-21 15:59:48 -0500241
John Stiles810c8cf2020-08-26 19:46:27 -0400242 fIRGenerator->fIntrinsics = fGPUIntrinsics.get();
Ethan Nicholasdb80f692019-11-22 14:06:12 -0500243 std::vector<std::unique_ptr<ProgramElement>> gpuIntrinsics;
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400244 std::vector<std::unique_ptr<ProgramElement>> interpIntrinsics;
Brian Osmandd496172020-08-08 08:17:18 -0400245#if SKSL_STANDALONE
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -0400246 this->processIncludeFile(Program::kFragment_Kind, SKSL_GPU_INCLUDE, symbols, &gpuIntrinsics,
247 &fGpuSymbolTable);
248 this->processIncludeFile(Program::kVertex_Kind, SKSL_VERT_INCLUDE, fGpuSymbolTable,
249 &fVertexInclude, &fVertexSymbolTable);
250 this->processIncludeFile(Program::kFragment_Kind, SKSL_FRAG_INCLUDE, fGpuSymbolTable,
251 &fFragmentInclude, &fFragmentSymbolTable);
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400252#else
253 {
254 Rehydrator rehydrator(fContext.get(), symbols, this, SKSL_INCLUDE_sksl_gpu,
255 SKSL_INCLUDE_sksl_gpu_LENGTH);
256 fGpuSymbolTable = rehydrator.symbolTable();
257 gpuIntrinsics = rehydrator.elements();
258 }
259 {
260 Rehydrator rehydrator(fContext.get(), fGpuSymbolTable, this, SKSL_INCLUDE_sksl_vert,
261 SKSL_INCLUDE_sksl_vert_LENGTH);
262 fVertexSymbolTable = rehydrator.symbolTable();
263 fVertexInclude = rehydrator.elements();
264 }
265 {
266 Rehydrator rehydrator(fContext.get(), fGpuSymbolTable, this, SKSL_INCLUDE_sksl_frag,
267 SKSL_INCLUDE_sksl_frag_LENGTH);
268 fFragmentSymbolTable = rehydrator.symbolTable();
269 fFragmentInclude = rehydrator.elements();
270 }
271#endif
John Stiles810c8cf2020-08-26 19:46:27 -0400272 grab_intrinsics(&gpuIntrinsics, fGPUIntrinsics.get());
273 grab_intrinsics(&interpIntrinsics, fInterpreterIntrinsics.get());
ethannicholasb3058bd2016-07-01 08:22:01 -0700274}
275
John Stiles656427a2020-08-27 15:26:26 -0400276Compiler::~Compiler() {}
ethannicholasb3058bd2016-07-01 08:22:01 -0700277
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400278void Compiler::loadGeometryIntrinsics() {
279 if (fGeometrySymbolTable) {
280 return;
281 }
Brian Osmandd496172020-08-08 08:17:18 -0400282 #if !SKSL_STANDALONE
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400283 {
284 Rehydrator rehydrator(fContext.get(), fGpuSymbolTable, this, SKSL_INCLUDE_sksl_geom,
285 SKSL_INCLUDE_sksl_geom_LENGTH);
286 fGeometrySymbolTable = rehydrator.symbolTable();
287 fGeometryInclude = rehydrator.elements();
288 }
289 #else
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -0400290 this->processIncludeFile(Program::kGeometry_Kind, SKSL_GEOM_INCLUDE, fGpuSymbolTable,
291 &fGeometryInclude, &fGeometrySymbolTable);
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400292 #endif
293}
294
295void Compiler::loadPipelineIntrinsics() {
296 if (fPipelineSymbolTable) {
297 return;
298 }
Brian Osmandd496172020-08-08 08:17:18 -0400299 #if !SKSL_STANDALONE
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400300 {
301 Rehydrator rehydrator(fContext.get(), fGpuSymbolTable, this,
302 SKSL_INCLUDE_sksl_pipeline,
303 SKSL_INCLUDE_sksl_pipeline_LENGTH);
304 fPipelineSymbolTable = rehydrator.symbolTable();
305 fPipelineInclude = rehydrator.elements();
306 }
307 #else
308 this->processIncludeFile(Program::kPipelineStage_Kind, SKSL_PIPELINE_INCLUDE,
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -0400309 fGpuSymbolTable, &fPipelineInclude, &fPipelineSymbolTable);
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400310 #endif
311}
312
313void Compiler::loadInterpreterIntrinsics() {
314 if (fInterpreterSymbolTable) {
315 return;
316 }
317 this->loadPipelineIntrinsics();
Brian Osmandd496172020-08-08 08:17:18 -0400318 #if !SKSL_STANDALONE
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400319 {
320 Rehydrator rehydrator(fContext.get(), fPipelineSymbolTable, this,
321 SKSL_INCLUDE_sksl_interp,
322 SKSL_INCLUDE_sksl_interp_LENGTH);
323 fInterpreterSymbolTable = rehydrator.symbolTable();
324 fInterpreterInclude = rehydrator.elements();
325 }
326 #else
327 this->processIncludeFile(Program::kGeneric_Kind, SKSL_INTERP_INCLUDE,
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -0400328 fIRGenerator->fSymbolTable, &fInterpreterInclude,
329 &fInterpreterSymbolTable);
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400330 #endif
331}
332
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -0400333void Compiler::processIncludeFile(Program::Kind kind, const char* path,
Ethan Nicholas8da1e652019-05-24 11:01:59 -0400334 std::shared_ptr<SymbolTable> base,
335 std::vector<std::unique_ptr<ProgramElement>>* outElements,
336 std::shared_ptr<SymbolTable>* outSymbolTable) {
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -0400337 std::ifstream in(path);
338 std::string stdText{std::istreambuf_iterator<char>(in),
339 std::istreambuf_iterator<char>()};
340 if (in.rdstate()) {
341 printf("error reading %s\n", path);
342 abort();
343 }
344 if (!base) {
345 base = fIRGenerator->fSymbolTable;
346 }
347 SkASSERT(base);
348 const String* source = base->takeOwnershipOfString(std::make_unique<String>(stdText.c_str()));
349 fSource = source;
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400350 std::shared_ptr<SymbolTable> old = fIRGenerator->fSymbolTable;
351 if (base) {
352 fIRGenerator->fSymbolTable = std::move(base);
353 }
Ethan Nicholas8da1e652019-05-24 11:01:59 -0400354 Program::Settings settings;
Ethan Nicholasa11035b2019-11-26 16:27:47 -0500355#if !defined(SKSL_STANDALONE) & SK_SUPPORT_GPU
356 GrContextOptions opts;
357 GrShaderCaps caps(opts);
358 settings.fCaps = &caps;
359#endif
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400360 SkASSERT(fIRGenerator->fCanInline);
361 fIRGenerator->fCanInline = false;
362 fIRGenerator->start(&settings, nullptr, true);
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -0400363 fIRGenerator->convertProgram(kind, source->c_str(), source->length(), outElements);
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400364 fIRGenerator->fCanInline = true;
Ethan Nicholas8da1e652019-05-24 11:01:59 -0400365 if (this->fErrorCount) {
366 printf("Unexpected errors: %s\n", this->fErrorText.c_str());
367 }
368 SkASSERT(!fErrorCount);
Ethan Nicholas8da1e652019-05-24 11:01:59 -0400369 *outSymbolTable = fIRGenerator->fSymbolTable;
Ethan Nicholasa11035b2019-11-26 16:27:47 -0500370#ifdef SK_DEBUG
371 fSource = nullptr;
372#endif
Ethan Nicholasc18bb512020-07-28 14:46:53 -0400373 fIRGenerator->fSymbolTable = std::move(old);
Ethan Nicholas8da1e652019-05-24 11:01:59 -0400374}
375
ethannicholas22f939e2016-10-13 13:25:34 -0700376// add the definition created by assigning to the lvalue to the definition set
Ethan Nicholas86a43402017-01-19 13:32:00 -0500377void Compiler::addDefinition(const Expression* lvalue, std::unique_ptr<Expression>* expr,
378 DefinitionMap* definitions) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400379 switch (lvalue->kind()) {
380 case Expression::Kind::kVariableReference: {
John Stilesa5a97b42020-08-18 11:19:07 -0400381 const Variable& var = lvalue->as<VariableReference>().fVariable;
ethannicholas22f939e2016-10-13 13:25:34 -0700382 if (var.fStorage == Variable::kLocal_Storage) {
383 (*definitions)[&var] = expr;
384 }
385 break;
386 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400387 case Expression::Kind::kSwizzle:
ethannicholas22f939e2016-10-13 13:25:34 -0700388 // We consider the variable written to as long as at least some of its components have
389 // been written to. This will lead to some false negatives (we won't catch it if you
390 // write to foo.x and then read foo.y), but being stricter could lead to false positives
Mike Klein6ad99092016-10-26 10:35:22 -0400391 // (we write to foo.x, and then pass foo to a function which happens to only read foo.x,
392 // 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 -0700393 // more complicated whole-program analysis. This is probably good enough.
John Stilesa5a97b42020-08-18 11:19:07 -0400394 this->addDefinition(lvalue->as<Swizzle>().fBase.get(),
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400395 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
ethannicholas22f939e2016-10-13 13:25:34 -0700396 definitions);
397 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400398 case Expression::Kind::kIndex:
ethannicholas22f939e2016-10-13 13:25:34 -0700399 // see comments in Swizzle
John Stilesa5a97b42020-08-18 11:19:07 -0400400 this->addDefinition(lvalue->as<IndexExpression>().fBase.get(),
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400401 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
ethannicholas22f939e2016-10-13 13:25:34 -0700402 definitions);
403 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400404 case Expression::Kind::kFieldAccess:
ethannicholas22f939e2016-10-13 13:25:34 -0700405 // see comments in Swizzle
John Stilesa5a97b42020-08-18 11:19:07 -0400406 this->addDefinition(lvalue->as<FieldAccess>().fBase.get(),
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400407 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
ethannicholas22f939e2016-10-13 13:25:34 -0700408 definitions);
409 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400410 case Expression::Kind::kTernary:
Ethan Nicholasa583b812018-01-18 13:32:11 -0500411 // To simplify analysis, we just pretend that we write to both sides of the ternary.
412 // This allows for false positives (meaning we fail to detect that a variable might not
413 // have been assigned), but is preferable to false negatives.
John Stilesa5a97b42020-08-18 11:19:07 -0400414 this->addDefinition(lvalue->as<TernaryExpression>().fIfTrue.get(),
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400415 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
Ethan Nicholasa583b812018-01-18 13:32:11 -0500416 definitions);
John Stilesa5a97b42020-08-18 11:19:07 -0400417 this->addDefinition(lvalue->as<TernaryExpression>().fIfFalse.get(),
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400418 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
Ethan Nicholasa583b812018-01-18 13:32:11 -0500419 definitions);
420 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400421 case Expression::Kind::kExternalValue:
Ethan Nicholas91164d12019-05-15 15:29:54 -0400422 break;
ethannicholas22f939e2016-10-13 13:25:34 -0700423 default:
424 // not an lvalue, can't happen
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400425 SkASSERT(false);
ethannicholas22f939e2016-10-13 13:25:34 -0700426 }
427}
428
429// add local variables defined by this node to the set
Mike Klein6ad99092016-10-26 10:35:22 -0400430void Compiler::addDefinitions(const BasicBlock::Node& node,
Ethan Nicholas86a43402017-01-19 13:32:00 -0500431 DefinitionMap* definitions) {
ethannicholas22f939e2016-10-13 13:25:34 -0700432 switch (node.fKind) {
433 case BasicBlock::Node::kExpression_Kind: {
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400434 SkASSERT(node.expression());
John Stilesa5a97b42020-08-18 11:19:07 -0400435 Expression* expr = node.expression()->get();
Ethan Nicholase6592142020-09-08 10:22:09 -0400436 switch (expr->kind()) {
437 case Expression::Kind::kBinary: {
John Stilesa5a97b42020-08-18 11:19:07 -0400438 BinaryExpression* b = &expr->as<BinaryExpression>();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400439 if (b->fOperator == Token::Kind::TK_EQ) {
Ethan Nicholas86a43402017-01-19 13:32:00 -0500440 this->addDefinition(b->fLeft.get(), &b->fRight, definitions);
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700441 } else if (Compiler::IsAssignment(b->fOperator)) {
Ethan Nicholas86a43402017-01-19 13:32:00 -0500442 this->addDefinition(
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400443 b->fLeft.get(),
444 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
445 definitions);
Ethan Nicholas86a43402017-01-19 13:32:00 -0500446
447 }
448 break;
ethannicholas22f939e2016-10-13 13:25:34 -0700449 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400450 case Expression::Kind::kFunctionCall: {
John Stilesa5a97b42020-08-18 11:19:07 -0400451 const FunctionCall& c = expr->as<FunctionCall>();
Ethan Nicholasc6a19f12018-03-29 16:46:56 -0400452 for (size_t i = 0; i < c.fFunction.fParameters.size(); ++i) {
453 if (c.fFunction.fParameters[i]->fModifiers.fFlags & Modifiers::kOut_Flag) {
454 this->addDefinition(
455 c.fArguments[i].get(),
456 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
457 definitions);
458 }
459 }
460 break;
461 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400462 case Expression::Kind::kPrefix: {
John Stilesa5a97b42020-08-18 11:19:07 -0400463 const PrefixExpression* p = &expr->as<PrefixExpression>();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400464 if (p->fOperator == Token::Kind::TK_MINUSMINUS ||
465 p->fOperator == Token::Kind::TK_PLUSPLUS) {
Ethan Nicholas86a43402017-01-19 13:32:00 -0500466 this->addDefinition(
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400467 p->fOperand.get(),
468 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
469 definitions);
Ethan Nicholas86a43402017-01-19 13:32:00 -0500470 }
471 break;
472 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400473 case Expression::Kind::kPostfix: {
John Stilesa5a97b42020-08-18 11:19:07 -0400474 const PostfixExpression* p = &expr->as<PostfixExpression>();
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400475 if (p->fOperator == Token::Kind::TK_MINUSMINUS ||
476 p->fOperator == Token::Kind::TK_PLUSPLUS) {
Ethan Nicholas86a43402017-01-19 13:32:00 -0500477 this->addDefinition(
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400478 p->fOperand.get(),
479 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
480 definitions);
Ethan Nicholas86a43402017-01-19 13:32:00 -0500481 }
482 break;
483 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400484 case Expression::Kind::kVariableReference: {
John Stilesa5a97b42020-08-18 11:19:07 -0400485 const VariableReference* v = &expr->as<VariableReference>();
Ethan Nicholascb670962017-04-20 19:31:52 -0400486 if (v->fRefKind != VariableReference::kRead_RefKind) {
487 this->addDefinition(
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400488 v,
489 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression,
490 definitions);
Ethan Nicholascb670962017-04-20 19:31:52 -0400491 }
John Stiles30212b72020-06-11 17:55:07 -0400492 break;
Ethan Nicholascb670962017-04-20 19:31:52 -0400493 }
Ethan Nicholas86a43402017-01-19 13:32:00 -0500494 default:
495 break;
ethannicholas22f939e2016-10-13 13:25:34 -0700496 }
497 break;
498 }
499 case BasicBlock::Node::kStatement_Kind: {
John Stilesa5a97b42020-08-18 11:19:07 -0400500 Statement* stmt = node.statement()->get();
Ethan Nicholase6592142020-09-08 10:22:09 -0400501 if (stmt->kind() == Statement::Kind::kVarDeclaration) {
John Stilesa5a97b42020-08-18 11:19:07 -0400502 VarDeclaration& vd = stmt->as<VarDeclaration>();
Ethan Nicholas82a62d22017-11-07 14:42:10 +0000503 if (vd.fValue) {
504 (*definitions)[vd.fVar] = &vd.fValue;
ethannicholas22f939e2016-10-13 13:25:34 -0700505 }
506 }
507 break;
508 }
509 }
510}
511
512void Compiler::scanCFG(CFG* cfg, BlockId blockId, std::set<BlockId>* workList) {
513 BasicBlock& block = cfg->fBlocks[blockId];
514
515 // compute definitions after this block
Ethan Nicholas86a43402017-01-19 13:32:00 -0500516 DefinitionMap after = block.fBefore;
ethannicholas22f939e2016-10-13 13:25:34 -0700517 for (const BasicBlock::Node& n : block.fNodes) {
518 this->addDefinitions(n, &after);
519 }
520
521 // propagate definitions to exits
522 for (BlockId exitId : block.fExits) {
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400523 if (exitId == blockId) {
524 continue;
525 }
ethannicholas22f939e2016-10-13 13:25:34 -0700526 BasicBlock& exit = cfg->fBlocks[exitId];
527 for (const auto& pair : after) {
Ethan Nicholas86a43402017-01-19 13:32:00 -0500528 std::unique_ptr<Expression>* e1 = pair.second;
529 auto found = exit.fBefore.find(pair.first);
530 if (found == exit.fBefore.end()) {
531 // exit has no definition for it, just copy it
532 workList->insert(exitId);
ethannicholas22f939e2016-10-13 13:25:34 -0700533 exit.fBefore[pair.first] = e1;
534 } else {
Ethan Nicholas86a43402017-01-19 13:32:00 -0500535 // exit has a (possibly different) value already defined
536 std::unique_ptr<Expression>* e2 = exit.fBefore[pair.first];
ethannicholas22f939e2016-10-13 13:25:34 -0700537 if (e1 != e2) {
538 // definition has changed, merge and add exit block to worklist
539 workList->insert(exitId);
Ethan Nicholasaf197692017-02-27 13:26:45 -0500540 if (e1 && e2) {
541 exit.fBefore[pair.first] =
Ethan Nicholas26a9aad2018-03-27 14:10:52 -0400542 (std::unique_ptr<Expression>*) &fContext->fDefined_Expression;
Ethan Nicholasaf197692017-02-27 13:26:45 -0500543 } else {
544 exit.fBefore[pair.first] = nullptr;
545 }
ethannicholas22f939e2016-10-13 13:25:34 -0700546 }
547 }
548 }
549 }
550}
551
552// returns a map which maps all local variables in the function to null, indicating that their value
553// is initially unknown
Ethan Nicholas86a43402017-01-19 13:32:00 -0500554static DefinitionMap compute_start_state(const CFG& cfg) {
555 DefinitionMap result;
Mike Klein6ad99092016-10-26 10:35:22 -0400556 for (const auto& block : cfg.fBlocks) {
557 for (const auto& node : block.fNodes) {
ethannicholas22f939e2016-10-13 13:25:34 -0700558 if (node.fKind == BasicBlock::Node::kStatement_Kind) {
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400559 SkASSERT(node.statement());
Ethan Nicholascb670962017-04-20 19:31:52 -0400560 const Statement* s = node.statement()->get();
Ethan Nicholase6592142020-09-08 10:22:09 -0400561 if (s->kind() == Statement::Kind::kVarDeclarations) {
John Stilesa5a97b42020-08-18 11:19:07 -0400562 const VarDeclarationsStatement* vd = &s->as<VarDeclarationsStatement>();
Ethan Nicholas82a62d22017-11-07 14:42:10 +0000563 for (const auto& decl : vd->fDeclaration->fVars) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400564 if (decl->kind() == Statement::Kind::kVarDeclaration) {
John Stilesa5a97b42020-08-18 11:19:07 -0400565 result[decl->as<VarDeclaration>().fVar] = nullptr;
Ethan Nicholas82a62d22017-11-07 14:42:10 +0000566 }
Mike Klein6ad99092016-10-26 10:35:22 -0400567 }
ethannicholas22f939e2016-10-13 13:25:34 -0700568 }
569 }
570 }
571 }
572 return result;
573}
574
Ethan Nicholascb670962017-04-20 19:31:52 -0400575/**
576 * Returns true if assigning to this lvalue has no effect.
577 */
578static bool is_dead(const Expression& lvalue) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400579 switch (lvalue.kind()) {
580 case Expression::Kind::kVariableReference:
John Stilesa5a97b42020-08-18 11:19:07 -0400581 return lvalue.as<VariableReference>().fVariable.dead();
Ethan Nicholase6592142020-09-08 10:22:09 -0400582 case Expression::Kind::kSwizzle:
John Stilesa5a97b42020-08-18 11:19:07 -0400583 return is_dead(*lvalue.as<Swizzle>().fBase);
Ethan Nicholase6592142020-09-08 10:22:09 -0400584 case Expression::Kind::kFieldAccess:
John Stilesa5a97b42020-08-18 11:19:07 -0400585 return is_dead(*lvalue.as<FieldAccess>().fBase);
Ethan Nicholase6592142020-09-08 10:22:09 -0400586 case Expression::Kind::kIndex: {
John Stilesa5a97b42020-08-18 11:19:07 -0400587 const IndexExpression& idx = lvalue.as<IndexExpression>();
Ethan Nicholas2a099da2020-01-02 14:40:54 -0500588 return is_dead(*idx.fBase) &&
589 !idx.fIndex->hasProperty(Expression::Property::kSideEffects);
Ethan Nicholascb670962017-04-20 19:31:52 -0400590 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400591 case Expression::Kind::kTernary: {
John Stilesa5a97b42020-08-18 11:19:07 -0400592 const TernaryExpression& t = lvalue.as<TernaryExpression>();
Ethan Nicholasa583b812018-01-18 13:32:11 -0500593 return !t.fTest->hasSideEffects() && is_dead(*t.fIfTrue) && is_dead(*t.fIfFalse);
594 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400595 case Expression::Kind::kExternalValue:
Ethan Nicholas91164d12019-05-15 15:29:54 -0400596 return false;
Ethan Nicholascb670962017-04-20 19:31:52 -0400597 default:
Ethan Nicholas2a099da2020-01-02 14:40:54 -0500598#ifdef SK_DEBUG
Ethan Nicholascb670962017-04-20 19:31:52 -0400599 ABORT("invalid lvalue: %s\n", lvalue.description().c_str());
Ethan Nicholas2a099da2020-01-02 14:40:54 -0500600#endif
601 return false;
Ethan Nicholascb670962017-04-20 19:31:52 -0400602 }
603}
ethannicholas22f939e2016-10-13 13:25:34 -0700604
Ethan Nicholascb670962017-04-20 19:31:52 -0400605/**
606 * Returns true if this is an assignment which can be collapsed down to just the right hand side due
607 * to a dead target and lack of side effects on the left hand side.
608 */
609static bool dead_assignment(const BinaryExpression& b) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -0700610 if (!Compiler::IsAssignment(b.fOperator)) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400611 return false;
612 }
613 return is_dead(*b.fLeft);
614}
615
616void Compiler::computeDataFlow(CFG* cfg) {
617 cfg->fBlocks[cfg->fStart].fBefore = compute_start_state(*cfg);
ethannicholas22f939e2016-10-13 13:25:34 -0700618 std::set<BlockId> workList;
Ethan Nicholascb670962017-04-20 19:31:52 -0400619 for (BlockId i = 0; i < cfg->fBlocks.size(); i++) {
ethannicholas22f939e2016-10-13 13:25:34 -0700620 workList.insert(i);
621 }
622 while (workList.size()) {
623 BlockId next = *workList.begin();
624 workList.erase(workList.begin());
Ethan Nicholascb670962017-04-20 19:31:52 -0400625 this->scanCFG(cfg, next, &workList);
ethannicholas22f939e2016-10-13 13:25:34 -0700626 }
Ethan Nicholascb670962017-04-20 19:31:52 -0400627}
628
629/**
630 * Attempts to replace the expression pointed to by iter with a new one (in both the CFG and the
631 * IR). If the expression can be cleanly removed, returns true and updates the iterator to point to
632 * the newly-inserted element. Otherwise updates only the IR and returns false (and the CFG will
633 * need to be regenerated).
634 */
John Stilesafbf8992020-08-18 10:08:21 -0400635static bool try_replace_expression(BasicBlock* b,
636 std::vector<BasicBlock::Node>::iterator* iter,
637 std::unique_ptr<Expression>* newExpression) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400638 std::unique_ptr<Expression>* target = (*iter)->expression();
639 if (!b->tryRemoveExpression(iter)) {
640 *target = std::move(*newExpression);
641 return false;
642 }
643 *target = std::move(*newExpression);
644 return b->tryInsertExpression(iter, target);
645}
646
647/**
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400648 * Returns true if the expression is a constant numeric literal with the specified value, or a
649 * constant vector with all elements equal to the specified value.
Ethan Nicholascb670962017-04-20 19:31:52 -0400650 */
John Stiles9d944232020-08-19 09:56:49 -0400651template <typename T = double>
652static bool is_constant(const Expression& expr, T value) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400653 switch (expr.kind()) {
654 case Expression::Kind::kIntLiteral:
John Stiles81365af2020-08-18 09:24:00 -0400655 return expr.as<IntLiteral>().fValue == value;
John Stiles9d944232020-08-19 09:56:49 -0400656
Ethan Nicholase6592142020-09-08 10:22:09 -0400657 case Expression::Kind::kFloatLiteral:
John Stiles81365af2020-08-18 09:24:00 -0400658 return expr.as<FloatLiteral>().fValue == value;
John Stiles9d944232020-08-19 09:56:49 -0400659
Ethan Nicholase6592142020-09-08 10:22:09 -0400660 case Expression::Kind::kConstructor: {
John Stiles9d944232020-08-19 09:56:49 -0400661 const Constructor& constructor = expr.as<Constructor>();
662 if (constructor.isCompileTimeConstant()) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400663 const Type& constructorType = constructor.type();
664 bool isFloat = constructorType.columns() > 1
665 ? constructorType.componentType().isFloat()
666 : constructorType.isFloat();
667 switch (constructorType.typeKind()) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400668 case Type::TypeKind::kVector:
Ethan Nicholas30d30222020-09-11 12:27:26 -0400669 for (int i = 0; i < constructorType.columns(); ++i) {
John Stiles9d944232020-08-19 09:56:49 -0400670 if (isFloat) {
671 if (constructor.getFVecComponent(i) != value) {
672 return false;
673 }
674 } else {
675 if (constructor.getIVecComponent(i) != value) {
676 return false;
677 }
678 }
Ethan Nicholasd188c182019-06-10 15:55:38 -0400679 }
John Stiles9d944232020-08-19 09:56:49 -0400680 return true;
681
Ethan Nicholase6592142020-09-08 10:22:09 -0400682 case Type::TypeKind::kScalar:
John Stiles9d944232020-08-19 09:56:49 -0400683 SkASSERT(constructor.fArguments.size() == 1);
684 return is_constant<T>(*constructor.fArguments[0], value);
685
686 default:
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400687 return false;
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400688 }
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400689 }
690 return false;
691 }
Ethan Nicholascb670962017-04-20 19:31:52 -0400692 default:
693 return false;
694 }
695}
696
697/**
698 * Collapses the binary expression pointed to by iter down to just the right side (in both the IR
699 * and CFG structures).
700 */
John Stilesafbf8992020-08-18 10:08:21 -0400701static void delete_left(BasicBlock* b,
702 std::vector<BasicBlock::Node>::iterator* iter,
703 bool* outUpdated,
704 bool* outNeedsRescan) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400705 *outUpdated = true;
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400706 std::unique_ptr<Expression>* target = (*iter)->expression();
John Stilesa5a97b42020-08-18 11:19:07 -0400707 BinaryExpression& bin = (*target)->as<BinaryExpression>();
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400708 SkASSERT(!bin.fLeft->hasSideEffects());
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400709 bool result;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400710 if (bin.fOperator == Token::Kind::TK_EQ) {
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400711 result = b->tryRemoveLValueBefore(iter, bin.fLeft.get());
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400712 } else {
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400713 result = b->tryRemoveExpressionBefore(iter, bin.fLeft.get());
Ethan Nicholascb670962017-04-20 19:31:52 -0400714 }
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400715 *target = std::move(bin.fRight);
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400716 if (!result) {
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400717 *outNeedsRescan = true;
718 return;
719 }
720 if (*iter == b->fNodes.begin()) {
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400721 *outNeedsRescan = true;
722 return;
723 }
724 --(*iter);
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400725 if ((*iter)->fKind != BasicBlock::Node::kExpression_Kind ||
726 (*iter)->expression() != &bin.fRight) {
727 *outNeedsRescan = true;
728 return;
729 }
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400730 *iter = b->fNodes.erase(*iter);
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400731 SkASSERT((*iter)->expression() == target);
Ethan Nicholascb670962017-04-20 19:31:52 -0400732}
733
734/**
735 * Collapses the binary expression pointed to by iter down to just the left side (in both the IR and
736 * CFG structures).
737 */
John Stilesafbf8992020-08-18 10:08:21 -0400738static void delete_right(BasicBlock* b,
739 std::vector<BasicBlock::Node>::iterator* iter,
740 bool* outUpdated,
741 bool* outNeedsRescan) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400742 *outUpdated = true;
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400743 std::unique_ptr<Expression>* target = (*iter)->expression();
John Stilesa5a97b42020-08-18 11:19:07 -0400744 BinaryExpression& bin = (*target)->as<BinaryExpression>();
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400745 SkASSERT(!bin.fRight->hasSideEffects());
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400746 if (!b->tryRemoveExpressionBefore(iter, bin.fRight.get())) {
747 *target = std::move(bin.fLeft);
Ethan Nicholascb670962017-04-20 19:31:52 -0400748 *outNeedsRescan = true;
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400749 return;
Ethan Nicholascb670962017-04-20 19:31:52 -0400750 }
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400751 *target = std::move(bin.fLeft);
752 if (*iter == b->fNodes.begin()) {
753 *outNeedsRescan = true;
754 return;
755 }
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400756 --(*iter);
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400757 if (((*iter)->fKind != BasicBlock::Node::kExpression_Kind ||
758 (*iter)->expression() != &bin.fLeft)) {
759 *outNeedsRescan = true;
760 return;
761 }
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400762 *iter = b->fNodes.erase(*iter);
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400763 SkASSERT((*iter)->expression() == target);
Ethan Nicholascb670962017-04-20 19:31:52 -0400764}
765
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400766/**
767 * Constructs the specified type using a single argument.
768 */
Ethan Nicholas30d30222020-09-11 12:27:26 -0400769static std::unique_ptr<Expression> construct(const Type* type, std::unique_ptr<Expression> v) {
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400770 std::vector<std::unique_ptr<Expression>> args;
771 args.push_back(std::move(v));
Ethan Nicholase6592142020-09-08 10:22:09 -0400772 std::unique_ptr<Expression> result = std::make_unique<Constructor>(-1, type, std::move(args));
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400773 return result;
774}
775
776/**
777 * Used in the implementations of vectorize_left and vectorize_right. Given a vector type and an
778 * expression x, deletes the expression pointed to by iter and replaces it with <type>(x).
779 */
780static void vectorize(BasicBlock* b,
781 std::vector<BasicBlock::Node>::iterator* iter,
782 const Type& type,
783 std::unique_ptr<Expression>* otherExpression,
784 bool* outUpdated,
785 bool* outNeedsRescan) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400786 SkASSERT((*(*iter)->expression())->kind() == Expression::Kind::kBinary);
787 SkASSERT(type.typeKind() == Type::TypeKind::kVector);
Ethan Nicholas30d30222020-09-11 12:27:26 -0400788 SkASSERT((*otherExpression)->type().typeKind() == Type::TypeKind::kScalar);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400789 *outUpdated = true;
790 std::unique_ptr<Expression>* target = (*iter)->expression();
791 if (!b->tryRemoveExpression(iter)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400792 *target = construct(&type, std::move(*otherExpression));
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400793 *outNeedsRescan = true;
794 } else {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400795 *target = construct(&type, std::move(*otherExpression));
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400796 if (!b->tryInsertExpression(iter, target)) {
797 *outNeedsRescan = true;
798 }
799 }
800}
801
802/**
803 * Given a binary expression of the form x <op> vec<n>(y), deletes the right side and vectorizes the
804 * left to yield vec<n>(x).
805 */
806static void vectorize_left(BasicBlock* b,
807 std::vector<BasicBlock::Node>::iterator* iter,
808 bool* outUpdated,
809 bool* outNeedsRescan) {
John Stilesa5a97b42020-08-18 11:19:07 -0400810 BinaryExpression& bin = (*(*iter)->expression())->as<BinaryExpression>();
Ethan Nicholas30d30222020-09-11 12:27:26 -0400811 vectorize(b, iter, bin.fRight->type(), &bin.fLeft, outUpdated, outNeedsRescan);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400812}
813
814/**
815 * Given a binary expression of the form vec<n>(x) <op> y, deletes the left side and vectorizes the
816 * right to yield vec<n>(y).
817 */
818static void vectorize_right(BasicBlock* b,
819 std::vector<BasicBlock::Node>::iterator* iter,
820 bool* outUpdated,
821 bool* outNeedsRescan) {
John Stilesa5a97b42020-08-18 11:19:07 -0400822 BinaryExpression& bin = (*(*iter)->expression())->as<BinaryExpression>();
Ethan Nicholas30d30222020-09-11 12:27:26 -0400823 vectorize(b, iter, bin.fLeft->type(), &bin.fRight, outUpdated, outNeedsRescan);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400824}
825
826// Mark that an expression which we were writing to is no longer being written to
John Stilesa5a97b42020-08-18 11:19:07 -0400827static void clear_write(Expression& expr) {
Ethan Nicholase6592142020-09-08 10:22:09 -0400828 switch (expr.kind()) {
829 case Expression::Kind::kVariableReference: {
John Stilesa5a97b42020-08-18 11:19:07 -0400830 expr.as<VariableReference>().setRefKind(VariableReference::kRead_RefKind);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400831 break;
832 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400833 case Expression::Kind::kFieldAccess:
John Stilesa5a97b42020-08-18 11:19:07 -0400834 clear_write(*expr.as<FieldAccess>().fBase);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400835 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400836 case Expression::Kind::kSwizzle:
John Stilesa5a97b42020-08-18 11:19:07 -0400837 clear_write(*expr.as<Swizzle>().fBase);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400838 break;
Ethan Nicholase6592142020-09-08 10:22:09 -0400839 case Expression::Kind::kIndex:
John Stilesa5a97b42020-08-18 11:19:07 -0400840 clear_write(*expr.as<IndexExpression>().fBase);
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400841 break;
842 default:
843 ABORT("shouldn't be writing to this kind of expression\n");
844 break;
845 }
846}
847
Ethan Nicholascb670962017-04-20 19:31:52 -0400848void Compiler::simplifyExpression(DefinitionMap& definitions,
849 BasicBlock& b,
850 std::vector<BasicBlock::Node>::iterator* iter,
851 std::unordered_set<const Variable*>* undefinedVariables,
852 bool* outUpdated,
853 bool* outNeedsRescan) {
854 Expression* expr = (*iter)->expression()->get();
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400855 SkASSERT(expr);
Ethan Nicholascb670962017-04-20 19:31:52 -0400856 if ((*iter)->fConstantPropagation) {
857 std::unique_ptr<Expression> optimized = expr->constantPropagate(*fIRGenerator, definitions);
858 if (optimized) {
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400859 *outUpdated = true;
Ethan Nicholas30d30222020-09-11 12:27:26 -0400860 optimized = fIRGenerator->coerce(std::move(optimized), expr->type());
Ethan Nicholas1d881522020-09-11 09:32:54 -0400861 SkASSERT(optimized);
Ethan Nicholascb670962017-04-20 19:31:52 -0400862 if (!try_replace_expression(&b, iter, &optimized)) {
863 *outNeedsRescan = true;
Ethan Nicholas4b330df2017-05-17 10:52:55 -0400864 return;
Ethan Nicholascb670962017-04-20 19:31:52 -0400865 }
Ethan Nicholasd9d33c32018-06-12 11:05:59 -0400866 SkASSERT((*iter)->fKind == BasicBlock::Node::kExpression_Kind);
Ethan Nicholascb670962017-04-20 19:31:52 -0400867 expr = (*iter)->expression()->get();
Ethan Nicholascb670962017-04-20 19:31:52 -0400868 }
869 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400870 switch (expr->kind()) {
871 case Expression::Kind::kVariableReference: {
John Stilesa5a97b42020-08-18 11:19:07 -0400872 const VariableReference& ref = expr->as<VariableReference>();
Ethan Nicholas8f7e28f2018-03-26 14:24:27 -0400873 const Variable& var = ref.fVariable;
874 if (ref.refKind() != VariableReference::kWrite_RefKind &&
875 ref.refKind() != VariableReference::kPointer_RefKind &&
876 var.fStorage == Variable::kLocal_Storage && !definitions[&var] &&
Ethan Nicholascb670962017-04-20 19:31:52 -0400877 (*undefinedVariables).find(&var) == (*undefinedVariables).end()) {
878 (*undefinedVariables).insert(&var);
Ethan Nicholas82a62d22017-11-07 14:42:10 +0000879 this->error(expr->fOffset,
880 "'" + var.fName + "' has not been assigned");
Ethan Nicholascb670962017-04-20 19:31:52 -0400881 }
882 break;
883 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400884 case Expression::Kind::kTernary: {
John Stiles403a3632020-08-20 12:11:48 -0400885 TernaryExpression* t = &expr->as<TernaryExpression>();
Ethan Nicholase6592142020-09-08 10:22:09 -0400886 if (t->fTest->kind() == Expression::Kind::kBoolLiteral) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400887 // ternary has a constant test, replace it with either the true or
888 // false branch
John Stiles403a3632020-08-20 12:11:48 -0400889 if (t->fTest->as<BoolLiteral>().fValue) {
Ethan Nicholascb670962017-04-20 19:31:52 -0400890 (*iter)->setExpression(std::move(t->fIfTrue));
891 } else {
892 (*iter)->setExpression(std::move(t->fIfFalse));
893 }
894 *outUpdated = true;
895 *outNeedsRescan = true;
896 }
897 break;
898 }
Ethan Nicholase6592142020-09-08 10:22:09 -0400899 case Expression::Kind::kBinary: {
John Stiles403a3632020-08-20 12:11:48 -0400900 BinaryExpression* bin = &expr->as<BinaryExpression>();
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400901 if (dead_assignment(*bin)) {
902 delete_left(&b, iter, outUpdated, outNeedsRescan);
903 break;
904 }
Ethan Nicholas30d30222020-09-11 12:27:26 -0400905 const Type& leftType = bin->fLeft->type();
906 const Type& rightType = bin->fRight->type();
Ethan Nicholasc2371a42017-05-05 10:04:06 -0400907 // collapse useless expressions like x * 1 or x + 0
Ethan Nicholas30d30222020-09-11 12:27:26 -0400908 if (((leftType.typeKind() != Type::TypeKind::kScalar) &&
909 (leftType.typeKind() != Type::TypeKind::kVector)) ||
910 ((rightType.typeKind() != Type::TypeKind::kScalar) &&
911 (rightType.typeKind() != Type::TypeKind::kVector))) {
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400912 break;
913 }
Ethan Nicholascb670962017-04-20 19:31:52 -0400914 switch (bin->fOperator) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400915 case Token::Kind::TK_STAR:
Ethan Nicholascb670962017-04-20 19:31:52 -0400916 if (is_constant(*bin->fLeft, 1)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400917 if (leftType.typeKind() == Type::TypeKind::kVector &&
918 rightType.typeKind() == Type::TypeKind::kScalar) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400919 // float4(1) * x -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400920 vectorize_right(&b, iter, outUpdated, outNeedsRescan);
921 } else {
922 // 1 * x -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400923 // 1 * float4(x) -> float4(x)
924 // float4(1) * float4(x) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400925 delete_left(&b, iter, outUpdated, outNeedsRescan);
926 }
927 }
928 else if (is_constant(*bin->fLeft, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400929 if (leftType.typeKind() == Type::TypeKind::kScalar &&
930 rightType.typeKind() == Type::TypeKind::kVector &&
Ethan Nicholas08dae922018-01-23 10:31:56 -0500931 !bin->fRight->hasSideEffects()) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400932 // 0 * float4(x) -> float4(0)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400933 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
934 } else {
935 // 0 * x -> 0
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400936 // float4(0) * x -> float4(0)
937 // float4(0) * float4(x) -> float4(0)
Ethan Nicholas51493ee2017-12-11 12:34:33 -0500938 if (!bin->fRight->hasSideEffects()) {
939 delete_right(&b, iter, outUpdated, outNeedsRescan);
940 }
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400941 }
Ethan Nicholascb670962017-04-20 19:31:52 -0400942 }
943 else if (is_constant(*bin->fRight, 1)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400944 if (leftType.typeKind() == Type::TypeKind::kScalar &&
945 rightType.typeKind() == Type::TypeKind::kVector) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400946 // x * float4(1) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400947 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
948 } else {
949 // x * 1 -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400950 // float4(x) * 1 -> float4(x)
951 // float4(x) * float4(1) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400952 delete_right(&b, iter, outUpdated, outNeedsRescan);
953 }
954 }
955 else if (is_constant(*bin->fRight, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400956 if (leftType.typeKind() == Type::TypeKind::kVector &&
957 rightType.typeKind() == Type::TypeKind::kScalar &&
Ethan Nicholas08dae922018-01-23 10:31:56 -0500958 !bin->fLeft->hasSideEffects()) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400959 // float4(x) * 0 -> float4(0)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400960 vectorize_right(&b, iter, outUpdated, outNeedsRescan);
961 } else {
962 // x * 0 -> 0
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400963 // x * float4(0) -> float4(0)
964 // float4(x) * float4(0) -> float4(0)
Ethan Nicholas51493ee2017-12-11 12:34:33 -0500965 if (!bin->fLeft->hasSideEffects()) {
966 delete_left(&b, iter, outUpdated, outNeedsRescan);
967 }
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400968 }
Ethan Nicholascb670962017-04-20 19:31:52 -0400969 }
970 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400971 case Token::Kind::TK_PLUS:
Ethan Nicholascb670962017-04-20 19:31:52 -0400972 if (is_constant(*bin->fLeft, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400973 if (leftType.typeKind() == Type::TypeKind::kVector &&
974 rightType.typeKind() == Type::TypeKind::kScalar) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400975 // float4(0) + x -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400976 vectorize_right(&b, iter, outUpdated, outNeedsRescan);
977 } else {
978 // 0 + x -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400979 // 0 + float4(x) -> float4(x)
980 // float4(0) + float4(x) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400981 delete_left(&b, iter, outUpdated, outNeedsRescan);
982 }
983 } else if (is_constant(*bin->fRight, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400984 if (leftType.typeKind() == Type::TypeKind::kScalar &&
985 rightType.typeKind() == Type::TypeKind::kVector) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400986 // x + float4(0) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400987 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
988 } else {
989 // x + 0 -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -0400990 // float4(x) + 0 -> float4(x)
991 // float4(x) + float4(0) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -0400992 delete_right(&b, iter, outUpdated, outNeedsRescan);
993 }
Ethan Nicholas56e42712017-04-21 10:23:37 -0400994 }
995 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -0400996 case Token::Kind::TK_MINUS:
Ethan Nicholas56e42712017-04-21 10:23:37 -0400997 if (is_constant(*bin->fRight, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -0400998 if (leftType.typeKind() == Type::TypeKind::kScalar &&
999 rightType.typeKind() == Type::TypeKind::kVector) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001000 // x - float4(0) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001001 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
1002 } else {
1003 // x - 0 -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001004 // float4(x) - 0 -> float4(x)
1005 // float4(x) - float4(0) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001006 delete_right(&b, iter, outUpdated, outNeedsRescan);
1007 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001008 }
1009 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001010 case Token::Kind::TK_SLASH:
Ethan Nicholascb670962017-04-20 19:31:52 -04001011 if (is_constant(*bin->fRight, 1)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -04001012 if (leftType.typeKind() == Type::TypeKind::kScalar &&
1013 rightType.typeKind() == Type::TypeKind::kVector) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001014 // x / float4(1) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001015 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
1016 } else {
1017 // x / 1 -> x
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001018 // float4(x) / 1 -> float4(x)
1019 // float4(x) / float4(1) -> float4(x)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001020 delete_right(&b, iter, outUpdated, outNeedsRescan);
1021 }
1022 } else if (is_constant(*bin->fLeft, 0)) {
Ethan Nicholas30d30222020-09-11 12:27:26 -04001023 if (leftType.typeKind() == Type::TypeKind::kScalar &&
1024 rightType.typeKind() == Type::TypeKind::kVector &&
Ethan Nicholas08dae922018-01-23 10:31:56 -05001025 !bin->fRight->hasSideEffects()) {
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001026 // 0 / float4(x) -> float4(0)
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001027 vectorize_left(&b, iter, outUpdated, outNeedsRescan);
1028 } else {
1029 // 0 / x -> 0
Ethan Nicholas5af9ea32017-07-28 15:19:46 -04001030 // float4(0) / x -> float4(0)
1031 // float4(0) / float4(x) -> float4(0)
Ethan Nicholas51493ee2017-12-11 12:34:33 -05001032 if (!bin->fRight->hasSideEffects()) {
1033 delete_right(&b, iter, outUpdated, outNeedsRescan);
1034 }
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001035 }
1036 }
1037 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001038 case Token::Kind::TK_PLUSEQ:
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001039 if (is_constant(*bin->fRight, 0)) {
1040 clear_write(*bin->fLeft);
1041 delete_right(&b, iter, outUpdated, outNeedsRescan);
1042 }
1043 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001044 case Token::Kind::TK_MINUSEQ:
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001045 if (is_constant(*bin->fRight, 0)) {
1046 clear_write(*bin->fLeft);
1047 delete_right(&b, iter, outUpdated, outNeedsRescan);
1048 }
1049 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001050 case Token::Kind::TK_STAREQ:
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001051 if (is_constant(*bin->fRight, 1)) {
1052 clear_write(*bin->fLeft);
1053 delete_right(&b, iter, outUpdated, outNeedsRescan);
1054 }
1055 break;
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001056 case Token::Kind::TK_SLASHEQ:
Ethan Nicholasfe53e582017-04-27 16:24:51 -04001057 if (is_constant(*bin->fRight, 1)) {
1058 clear_write(*bin->fLeft);
Ethan Nicholascb670962017-04-20 19:31:52 -04001059 delete_right(&b, iter, outUpdated, outNeedsRescan);
1060 }
1061 break;
1062 default:
1063 break;
1064 }
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001065 break;
1066 }
Ethan Nicholase6592142020-09-08 10:22:09 -04001067 case Expression::Kind::kSwizzle: {
John Stiles403a3632020-08-20 12:11:48 -04001068 Swizzle& s = expr->as<Swizzle>();
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001069 // detect identity swizzles like foo.rgba
Ethan Nicholas30d30222020-09-11 12:27:26 -04001070 if ((int) s.fComponents.size() == s.fBase->type().columns()) {
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001071 bool identity = true;
1072 for (int i = 0; i < (int) s.fComponents.size(); ++i) {
1073 if (s.fComponents[i] != i) {
1074 identity = false;
1075 break;
1076 }
1077 }
1078 if (identity) {
1079 *outUpdated = true;
1080 if (!try_replace_expression(&b, iter, &s.fBase)) {
1081 *outNeedsRescan = true;
1082 return;
1083 }
1084 SkASSERT((*iter)->fKind == BasicBlock::Node::kExpression_Kind);
1085 break;
1086 }
1087 }
1088 // detect swizzles of swizzles, e.g. replace foo.argb.r000 with foo.a000
Ethan Nicholase6592142020-09-08 10:22:09 -04001089 if (s.fBase->kind() == Expression::Kind::kSwizzle) {
John Stilesa5a97b42020-08-18 11:19:07 -04001090 Swizzle& base = s.fBase->as<Swizzle>();
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001091 std::vector<int> final;
1092 for (int c : s.fComponents) {
1093 if (c == SKSL_SWIZZLE_0 || c == SKSL_SWIZZLE_1) {
1094 final.push_back(c);
1095 } else {
1096 final.push_back(base.fComponents[c]);
1097 }
1098 }
1099 *outUpdated = true;
1100 std::unique_ptr<Expression> replacement(new Swizzle(*fContext, base.fBase->clone(),
1101 std::move(final)));
1102 if (!try_replace_expression(&b, iter, &replacement)) {
1103 *outNeedsRescan = true;
1104 return;
1105 }
1106 SkASSERT((*iter)->fKind == BasicBlock::Node::kExpression_Kind);
Ethan Nicholas409f6f02019-09-17 12:34:39 -04001107 }
John Stiles30212b72020-06-11 17:55:07 -04001108 break;
Ethan Nicholascb670962017-04-20 19:31:52 -04001109 }
1110 default:
1111 break;
1112 }
1113}
1114
John Stiles92219b42020-06-15 12:32:24 -04001115// Returns true if this statement could potentially execute a break at the current level. We ignore
1116// nested loops and switches, since any breaks inside of them will merely break the loop / switch.
John Stilesb92641c2020-08-31 18:09:01 -04001117static bool contains_conditional_break(Statement& stmt) {
1118 class ContainsConditionalBreak : public ProgramVisitor {
1119 public:
1120 bool visitStatement(const Statement& stmt) override {
Ethan Nicholase6592142020-09-08 10:22:09 -04001121 switch (stmt.kind()) {
1122 case Statement::Kind::kBlock:
John Stilesb92641c2020-08-31 18:09:01 -04001123 return this->INHERITED::visitStatement(stmt);
1124
Ethan Nicholase6592142020-09-08 10:22:09 -04001125 case Statement::Kind::kBreak:
John Stilesb92641c2020-08-31 18:09:01 -04001126 return fInConditional > 0;
1127
Ethan Nicholase6592142020-09-08 10:22:09 -04001128 case Statement::Kind::kIf: {
John Stilesb92641c2020-08-31 18:09:01 -04001129 ++fInConditional;
1130 bool result = this->INHERITED::visitStatement(stmt);
1131 --fInConditional;
1132 return result;
1133 }
1134
1135 default:
1136 return false;
1137 }
1138 }
1139
1140 int fInConditional = 0;
1141 using INHERITED = ProgramVisitor;
1142 };
1143
1144 return ContainsConditionalBreak{}.visitStatement(stmt);
John Stiles92219b42020-06-15 12:32:24 -04001145}
1146
Ethan Nicholas5005a222018-08-24 13:06:27 -04001147// returns true if this statement definitely executes a break at the current level (we ignore
1148// nested loops and switches, since any breaks inside of them will merely break the loop / switch)
John Stilesb92641c2020-08-31 18:09:01 -04001149static bool contains_unconditional_break(Statement& stmt) {
1150 class ContainsUnconditionalBreak : public ProgramVisitor {
1151 public:
1152 bool visitStatement(const Statement& stmt) override {
Ethan Nicholase6592142020-09-08 10:22:09 -04001153 switch (stmt.kind()) {
1154 case Statement::Kind::kBlock:
John Stilesb92641c2020-08-31 18:09:01 -04001155 return this->INHERITED::visitStatement(stmt);
1156
Ethan Nicholase6592142020-09-08 10:22:09 -04001157 case Statement::Kind::kBreak:
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001158 return true;
John Stilesb92641c2020-08-31 18:09:01 -04001159
1160 default:
1161 return false;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001162 }
John Stilesb92641c2020-08-31 18:09:01 -04001163 }
John Stiles92219b42020-06-15 12:32:24 -04001164
John Stilesb92641c2020-08-31 18:09:01 -04001165 using INHERITED = ProgramVisitor;
1166 };
John Stiles92219b42020-06-15 12:32:24 -04001167
John Stilesb92641c2020-08-31 18:09:01 -04001168 return ContainsUnconditionalBreak{}.visitStatement(stmt);
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001169}
1170
John Stiles92219b42020-06-15 12:32:24 -04001171static void move_all_but_break(std::unique_ptr<Statement>& stmt,
1172 std::vector<std::unique_ptr<Statement>>* target) {
Ethan Nicholase6592142020-09-08 10:22:09 -04001173 switch (stmt->kind()) {
1174 case Statement::Kind::kBlock: {
John Stiles92219b42020-06-15 12:32:24 -04001175 // Recurse into the block.
1176 Block& block = static_cast<Block&>(*stmt);
1177
1178 std::vector<std::unique_ptr<Statement>> blockStmts;
1179 blockStmts.reserve(block.fStatements.size());
1180 for (std::unique_ptr<Statement>& statementInBlock : block.fStatements) {
1181 move_all_but_break(statementInBlock, &blockStmts);
Ethan Nicholas739e1ca2020-06-11 12:16:14 -04001182 }
John Stiles92219b42020-06-15 12:32:24 -04001183
1184 target->push_back(std::make_unique<Block>(block.fOffset, std::move(blockStmts),
1185 block.fSymbols, block.fIsScope));
Ethan Nicholas739e1ca2020-06-11 12:16:14 -04001186 break;
John Stiles92219b42020-06-15 12:32:24 -04001187 }
1188
Ethan Nicholase6592142020-09-08 10:22:09 -04001189 case Statement::Kind::kBreak:
John Stiles92219b42020-06-15 12:32:24 -04001190 // Do not append a break to the target.
1191 break;
1192
Ethan Nicholas739e1ca2020-06-11 12:16:14 -04001193 default:
John Stiles92219b42020-06-15 12:32:24 -04001194 // Append normal statements to the target.
1195 target->push_back(std::move(stmt));
1196 break;
Ethan Nicholas739e1ca2020-06-11 12:16:14 -04001197 }
1198}
1199
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001200// Returns a block containing all of the statements that will be run if the given case matches
1201// (which, owing to the statements being owned by unique_ptrs, means the switch itself will be
1202// broken by this call and must then be discarded).
1203// Returns null (and leaves the switch unmodified) if no such simple reduction is possible, such as
1204// when break statements appear inside conditionals.
John Stiles92219b42020-06-15 12:32:24 -04001205static std::unique_ptr<Statement> block_for_case(SwitchStatement* switchStatement,
1206 SwitchCase* caseToCapture) {
1207 // We have to be careful to not move any of the pointers until after we're sure we're going to
1208 // succeed, so before we make any changes at all, we check the switch-cases to decide on a plan
1209 // of action. First, find the switch-case we are interested in.
1210 auto iter = switchStatement->fCases.begin();
1211 for (; iter != switchStatement->fCases.end(); ++iter) {
1212 if (iter->get() == caseToCapture) {
1213 break;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001214 }
John Stiles92219b42020-06-15 12:32:24 -04001215 }
1216
1217 // Next, walk forward through the rest of the switch. If we find a conditional break, we're
1218 // stuck and can't simplify at all. If we find an unconditional break, we have a range of
1219 // statements that we can use for simplification.
1220 auto startIter = iter;
1221 Statement* unconditionalBreakStmt = nullptr;
1222 for (; iter != switchStatement->fCases.end(); ++iter) {
1223 for (std::unique_ptr<Statement>& stmt : (*iter)->fStatements) {
1224 if (contains_conditional_break(*stmt)) {
1225 // We can't reduce switch-cases to a block when they have conditional breaks.
1226 return nullptr;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001227 }
John Stiles92219b42020-06-15 12:32:24 -04001228
1229 if (contains_unconditional_break(*stmt)) {
1230 // We found an unconditional break. We can use this block, but we need to strip
1231 // out the break statement.
1232 unconditionalBreakStmt = stmt.get();
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001233 break;
1234 }
1235 }
John Stiles92219b42020-06-15 12:32:24 -04001236
1237 if (unconditionalBreakStmt != nullptr) {
1238 break;
1239 }
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001240 }
John Stiles92219b42020-06-15 12:32:24 -04001241
1242 // We fell off the bottom of the switch or encountered a break. We know the range of statements
1243 // that we need to move over, and we know it's safe to do so.
1244 std::vector<std::unique_ptr<Statement>> caseStmts;
1245
1246 // We can move over most of the statements as-is.
1247 while (startIter != iter) {
1248 for (std::unique_ptr<Statement>& stmt : (*startIter)->fStatements) {
1249 caseStmts.push_back(std::move(stmt));
1250 }
1251 ++startIter;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001252 }
John Stiles92219b42020-06-15 12:32:24 -04001253
1254 // If we found an unconditional break at the end, we need to move what we can while avoiding
1255 // that break.
1256 if (unconditionalBreakStmt != nullptr) {
1257 for (std::unique_ptr<Statement>& stmt : (*startIter)->fStatements) {
1258 if (stmt.get() == unconditionalBreakStmt) {
1259 move_all_but_break(stmt, &caseStmts);
1260 unconditionalBreakStmt = nullptr;
1261 break;
1262 }
1263
1264 caseStmts.push_back(std::move(stmt));
1265 }
1266 }
1267
1268 SkASSERT(unconditionalBreakStmt == nullptr); // Verify that we fixed the unconditional break.
1269
1270 // Return our newly-synthesized block.
1271 return std::make_unique<Block>(/*offset=*/-1, std::move(caseStmts), switchStatement->fSymbols);
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001272}
1273
Ethan Nicholascb670962017-04-20 19:31:52 -04001274void Compiler::simplifyStatement(DefinitionMap& definitions,
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001275 BasicBlock& b,
1276 std::vector<BasicBlock::Node>::iterator* iter,
1277 std::unordered_set<const Variable*>* undefinedVariables,
1278 bool* outUpdated,
1279 bool* outNeedsRescan) {
Ethan Nicholascb670962017-04-20 19:31:52 -04001280 Statement* stmt = (*iter)->statement()->get();
Ethan Nicholase6592142020-09-08 10:22:09 -04001281 switch (stmt->kind()) {
1282 case Statement::Kind::kVarDeclaration: {
John Stilesa5a97b42020-08-18 11:19:07 -04001283 const auto& varDecl = stmt->as<VarDeclaration>();
Ethan Nicholas82a62d22017-11-07 14:42:10 +00001284 if (varDecl.fVar->dead() &&
1285 (!varDecl.fValue ||
1286 !varDecl.fValue->hasSideEffects())) {
1287 if (varDecl.fValue) {
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001288 SkASSERT((*iter)->statement()->get() == stmt);
Ethan Nicholas82a62d22017-11-07 14:42:10 +00001289 if (!b.tryRemoveExpressionBefore(iter, varDecl.fValue.get())) {
1290 *outNeedsRescan = true;
Ethan Nicholascb670962017-04-20 19:31:52 -04001291 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001292 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001293 (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
Ethan Nicholas82a62d22017-11-07 14:42:10 +00001294 *outUpdated = true;
Ethan Nicholascb670962017-04-20 19:31:52 -04001295 }
1296 break;
1297 }
Ethan Nicholase6592142020-09-08 10:22:09 -04001298 case Statement::Kind::kIf: {
John Stilesa5a97b42020-08-18 11:19:07 -04001299 IfStatement& i = stmt->as<IfStatement>();
Ethan Nicholase6592142020-09-08 10:22:09 -04001300 if (i.fTest->kind() == Expression::Kind::kBoolLiteral) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001301 // constant if, collapse down to a single branch
John Stilesa5a97b42020-08-18 11:19:07 -04001302 if (i.fTest->as<BoolLiteral>().fValue) {
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001303 SkASSERT(i.fIfTrue);
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001304 (*iter)->setStatement(std::move(i.fIfTrue));
1305 } else {
1306 if (i.fIfFalse) {
1307 (*iter)->setStatement(std::move(i.fIfFalse));
1308 } else {
1309 (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
1310 }
1311 }
1312 *outUpdated = true;
1313 *outNeedsRescan = true;
1314 break;
1315 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001316 if (i.fIfFalse && i.fIfFalse->isEmpty()) {
1317 // else block doesn't do anything, remove it
1318 i.fIfFalse.reset();
1319 *outUpdated = true;
1320 *outNeedsRescan = true;
1321 }
1322 if (!i.fIfFalse && i.fIfTrue->isEmpty()) {
1323 // if block doesn't do anything, no else block
1324 if (i.fTest->hasSideEffects()) {
1325 // test has side effects, keep it
1326 (*iter)->setStatement(std::unique_ptr<Statement>(
1327 new ExpressionStatement(std::move(i.fTest))));
1328 } else {
1329 // no if, no else, no test side effects, kill the whole if
1330 // statement
1331 (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
1332 }
1333 *outUpdated = true;
1334 *outNeedsRescan = true;
1335 }
1336 break;
1337 }
Ethan Nicholase6592142020-09-08 10:22:09 -04001338 case Statement::Kind::kSwitch: {
John Stilesa5a97b42020-08-18 11:19:07 -04001339 SwitchStatement& s = stmt->as<SwitchStatement>();
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001340 int64_t switchValue;
1341 if (fIRGenerator->getConstantInt(*s.fValue, &switchValue)) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001342 // switch is constant, replace it with the case that matches
1343 bool found = false;
1344 SwitchCase* defaultCase = nullptr;
John Stiles9d944232020-08-19 09:56:49 -04001345 for (const std::unique_ptr<SwitchCase>& c : s.fCases) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001346 if (!c->fValue) {
1347 defaultCase = c.get();
1348 continue;
1349 }
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001350 int64_t caseValue;
1351 SkAssertResult(fIRGenerator->getConstantInt(*c->fValue, &caseValue));
1352 if (caseValue == switchValue) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001353 std::unique_ptr<Statement> newBlock = block_for_case(&s, c.get());
1354 if (newBlock) {
1355 (*iter)->setStatement(std::move(newBlock));
John Stiles9d944232020-08-19 09:56:49 -04001356 found = true;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001357 break;
1358 } else {
Ethan Nicholas6e1cbc02017-07-14 10:12:15 -04001359 if (s.fIsStatic && !(fFlags & kPermitInvalidStaticTests_Flag)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001360 this->error(s.fOffset,
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001361 "static switch contains non-static conditional break");
1362 s.fIsStatic = false;
1363 }
1364 return; // can't simplify
1365 }
1366 }
1367 }
1368 if (!found) {
1369 // no matching case. use default if it exists, or kill the whole thing
1370 if (defaultCase) {
1371 std::unique_ptr<Statement> newBlock = block_for_case(&s, defaultCase);
1372 if (newBlock) {
1373 (*iter)->setStatement(std::move(newBlock));
1374 } else {
Ethan Nicholas6e1cbc02017-07-14 10:12:15 -04001375 if (s.fIsStatic && !(fFlags & kPermitInvalidStaticTests_Flag)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001376 this->error(s.fOffset,
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001377 "static switch contains non-static conditional break");
1378 s.fIsStatic = false;
1379 }
1380 return; // can't simplify
1381 }
1382 } else {
1383 (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
1384 }
1385 }
1386 *outUpdated = true;
1387 *outNeedsRescan = true;
1388 }
1389 break;
1390 }
Ethan Nicholase6592142020-09-08 10:22:09 -04001391 case Statement::Kind::kExpression: {
John Stilesa5a97b42020-08-18 11:19:07 -04001392 ExpressionStatement& e = stmt->as<ExpressionStatement>();
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001393 SkASSERT((*iter)->statement()->get() == &e);
Ethan Nicholascb670962017-04-20 19:31:52 -04001394 if (!e.fExpression->hasSideEffects()) {
1395 // Expression statement with no side effects, kill it
1396 if (!b.tryRemoveExpressionBefore(iter, e.fExpression.get())) {
1397 *outNeedsRescan = true;
1398 }
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001399 SkASSERT((*iter)->statement()->get() == stmt);
Ethan Nicholascb670962017-04-20 19:31:52 -04001400 (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
1401 *outUpdated = true;
1402 }
1403 break;
1404 }
1405 default:
1406 break;
1407 }
1408}
1409
John Stiles0cc193a2020-09-09 09:39:34 -04001410bool Compiler::scanCFG(FunctionDefinition& f) {
1411 bool madeChanges = false;
1412
Ethan Nicholascb670962017-04-20 19:31:52 -04001413 CFG cfg = CFGGenerator().getCFG(f);
1414 this->computeDataFlow(&cfg);
ethannicholas22f939e2016-10-13 13:25:34 -07001415
1416 // check for unreachable code
1417 for (size_t i = 0; i < cfg.fBlocks.size(); i++) {
John Stiles0cc193a2020-09-09 09:39:34 -04001418 const BasicBlock& block = cfg.fBlocks[i];
1419 if (i != cfg.fStart && !block.fEntrances.size() && block.fNodes.size()) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001420 int offset;
John Stiles0cc193a2020-09-09 09:39:34 -04001421 const BasicBlock::Node& node = block.fNodes[0];
1422 switch (node.fKind) {
Ethan Nicholas86a43402017-01-19 13:32:00 -05001423 case BasicBlock::Node::kStatement_Kind:
John Stiles0cc193a2020-09-09 09:39:34 -04001424 offset = (*node.statement())->fOffset;
Ethan Nicholas86a43402017-01-19 13:32:00 -05001425 break;
1426 case BasicBlock::Node::kExpression_Kind:
John Stiles0cc193a2020-09-09 09:39:34 -04001427 offset = (*node.expression())->fOffset;
1428 if ((*node.expression())->is<BoolLiteral>()) {
Ethan Nicholas70728ef2020-05-28 07:09:00 -04001429 // Function inlining can generate do { ... } while(false) loops which always
1430 // break, so the boolean condition is considered unreachable. Since not
1431 // being able to reach a literal is a non-issue in the first place, we
1432 // don't report an error in this case.
1433 continue;
1434 }
Ethan Nicholas86a43402017-01-19 13:32:00 -05001435 break;
1436 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001437 this->error(offset, String("unreachable"));
ethannicholas22f939e2016-10-13 13:25:34 -07001438 }
1439 }
1440 if (fErrorCount) {
John Stiles0cc193a2020-09-09 09:39:34 -04001441 return madeChanges;
ethannicholas22f939e2016-10-13 13:25:34 -07001442 }
1443
Ethan Nicholascb670962017-04-20 19:31:52 -04001444 // check for dead code & undefined variables, perform constant propagation
1445 std::unordered_set<const Variable*> undefinedVariables;
1446 bool updated;
1447 bool needsRescan = false;
1448 do {
1449 if (needsRescan) {
1450 cfg = CFGGenerator().getCFG(f);
1451 this->computeDataFlow(&cfg);
1452 needsRescan = false;
Ethan Nicholas113628d2017-02-02 16:11:39 -05001453 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001454
1455 updated = false;
Ethan Nicholas1de14812020-06-19 15:32:49 -04001456 bool first = true;
Ethan Nicholascb670962017-04-20 19:31:52 -04001457 for (BasicBlock& b : cfg.fBlocks) {
Ethan Nicholas1de14812020-06-19 15:32:49 -04001458 if (!first && b.fEntrances.empty()) {
1459 // Block was reachable before optimization, but has since become unreachable. In
1460 // addition to being dead code, it's broken - since control flow can't reach it, no
1461 // prior variable definitions can reach it, and therefore variables might look to
1462 // have not been properly assigned. Kill it.
Brian Osmandb16c482020-09-09 15:15:06 -04001463
1464 // We need to do this in two steps. For any variable declarations, the node list
1465 // will contain statement nodes for each VarDeclaration, and then a statement for
1466 // the VarDeclarationsStatement. When we replace the VDS with a Nop, we delete the
1467 // storage of the unique_ptr that the VD nodes are pointing to. So we remove those
1468 // from the node list entirely, first.
1469 b.fNodes.erase(
1470 std::remove_if(b.fNodes.begin(), b.fNodes.end(),
1471 [](const BasicBlock::Node& node) {
1472 return node.fKind == BasicBlock::Node::kStatement_Kind &&
1473 (*node.statement())->is<VarDeclaration>();
1474 }),
1475 b.fNodes.end());
1476
1477 // Now replace any remaining statements in the block with Nops.
Ethan Nicholas1de14812020-06-19 15:32:49 -04001478 for (BasicBlock::Node& node : b.fNodes) {
1479 if (node.fKind == BasicBlock::Node::kStatement_Kind &&
John Stiles0cc193a2020-09-09 09:39:34 -04001480 !(*node.statement())->is<Nop>()) {
1481 node.setStatement(std::make_unique<Nop>());
1482 madeChanges = true;
Ethan Nicholas1de14812020-06-19 15:32:49 -04001483 }
1484 }
1485 continue;
1486 }
1487 first = false;
Ethan Nicholascb670962017-04-20 19:31:52 -04001488 DefinitionMap definitions = b.fBefore;
1489
1490 for (auto iter = b.fNodes.begin(); iter != b.fNodes.end() && !needsRescan; ++iter) {
1491 if (iter->fKind == BasicBlock::Node::kExpression_Kind) {
1492 this->simplifyExpression(definitions, b, &iter, &undefinedVariables, &updated,
1493 &needsRescan);
1494 } else {
1495 this->simplifyStatement(definitions, b, &iter, &undefinedVariables, &updated,
John Stiles0cc193a2020-09-09 09:39:34 -04001496 &needsRescan);
Ethan Nicholascb670962017-04-20 19:31:52 -04001497 }
Ethan Nicholas4b330df2017-05-17 10:52:55 -04001498 if (needsRescan) {
1499 break;
1500 }
Ethan Nicholascb670962017-04-20 19:31:52 -04001501 this->addDefinitions(*iter, &definitions);
1502 }
1503 }
John Stiles0cc193a2020-09-09 09:39:34 -04001504 madeChanges |= updated;
Ethan Nicholascb670962017-04-20 19:31:52 -04001505 } while (updated);
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001506 SkASSERT(!needsRescan);
ethannicholas22f939e2016-10-13 13:25:34 -07001507
Ethan Nicholas91a10532017-06-22 11:24:38 -04001508 // verify static ifs & switches, clean up dead variable decls
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001509 for (BasicBlock& b : cfg.fBlocks) {
1510 DefinitionMap definitions = b.fBefore;
1511
Ethan Nicholas91a10532017-06-22 11:24:38 -04001512 for (auto iter = b.fNodes.begin(); iter != b.fNodes.end() && !needsRescan;) {
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001513 if (iter->fKind == BasicBlock::Node::kStatement_Kind) {
1514 const Statement& s = **iter->statement();
Ethan Nicholase6592142020-09-08 10:22:09 -04001515 switch (s.kind()) {
1516 case Statement::Kind::kIf:
John Stilesa5a97b42020-08-18 11:19:07 -04001517 if (s.as<IfStatement>().fIsStatic &&
Ethan Nicholas6e1cbc02017-07-14 10:12:15 -04001518 !(fFlags & kPermitInvalidStaticTests_Flag)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001519 this->error(s.fOffset, "static if has non-static test");
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001520 }
Ethan Nicholas91a10532017-06-22 11:24:38 -04001521 ++iter;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001522 break;
Ethan Nicholase6592142020-09-08 10:22:09 -04001523 case Statement::Kind::kSwitch:
John Stilesa5a97b42020-08-18 11:19:07 -04001524 if (s.as<SwitchStatement>().fIsStatic &&
John Stiles0cc193a2020-09-09 09:39:34 -04001525 !(fFlags & kPermitInvalidStaticTests_Flag)) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001526 this->error(s.fOffset, "static switch has non-static test");
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001527 }
Ethan Nicholas91a10532017-06-22 11:24:38 -04001528 ++iter;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001529 break;
Ethan Nicholase6592142020-09-08 10:22:09 -04001530 case Statement::Kind::kVarDeclarations: {
John Stilesa5a97b42020-08-18 11:19:07 -04001531 VarDeclarations& decls = *s.as<VarDeclarationsStatement>().fDeclaration;
John Stiles0cc193a2020-09-09 09:39:34 -04001532 decls.fVars.erase(
1533 std::remove_if(decls.fVars.begin(), decls.fVars.end(),
1534 [&](const std::unique_ptr<Statement>& var) {
1535 bool nop = var->is<Nop>();
1536 madeChanges |= nop;
1537 return nop;
1538 }),
1539 decls.fVars.end());
1540 if (decls.fVars.empty()) {
Ethan Nicholas82a62d22017-11-07 14:42:10 +00001541 iter = b.fNodes.erase(iter);
1542 } else {
1543 ++iter;
1544 }
1545 break;
1546 }
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001547 default:
Ethan Nicholas91a10532017-06-22 11:24:38 -04001548 ++iter;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001549 break;
1550 }
Ethan Nicholas91a10532017-06-22 11:24:38 -04001551 } else {
1552 ++iter;
Ethan Nicholas5ac13c22017-05-10 15:06:17 -04001553 }
1554 }
1555 }
1556
ethannicholas22f939e2016-10-13 13:25:34 -07001557 // check for missing return
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001558 if (f.fDeclaration.fReturnType != *fContext->fVoid_Type) {
ethannicholas22f939e2016-10-13 13:25:34 -07001559 if (cfg.fBlocks[cfg.fExit].fEntrances.size()) {
Ethan Nicholasdb80f692019-11-22 14:06:12 -05001560 this->error(f.fOffset, String("function '" + String(f.fDeclaration.fName) +
1561 "' can exit without returning a value"));
ethannicholas22f939e2016-10-13 13:25:34 -07001562 }
1563 }
John Stiles0cc193a2020-09-09 09:39:34 -04001564
1565 return madeChanges;
ethannicholas22f939e2016-10-13 13:25:34 -07001566}
1567
Ethan Nicholas91164d12019-05-15 15:29:54 -04001568void Compiler::registerExternalValue(ExternalValue* value) {
1569 fIRGenerator->fRootSymbolTable->addWithoutOwnership(value->fName, value);
1570}
1571
Ethan Nicholasc18bb512020-07-28 14:46:53 -04001572const Symbol* Compiler::takeOwnership(std::unique_ptr<const Symbol> symbol) {
John Stiles3ae071e2020-08-05 15:29:29 -04001573 return fIRGenerator->fRootSymbolTable->takeOwnershipOfSymbol(std::move(symbol));
Ethan Nicholas91164d12019-05-15 15:29:54 -04001574}
1575
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001576std::unique_ptr<Program> Compiler::convertProgram(Program::Kind kind, String text,
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001577 const Program::Settings& settings) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001578 fErrorText = "";
1579 fErrorCount = 0;
John Stiles7b463002020-08-31 17:29:21 -04001580 fInliner.reset(context(), settings);
Ethan Nicholas3c6ae622018-04-24 13:06:09 -04001581 std::vector<std::unique_ptr<ProgramElement>>* inherited;
ethannicholasd598f792016-07-25 10:08:54 -07001582 std::vector<std::unique_ptr<ProgramElement>> elements;
ethannicholasb3058bd2016-07-01 08:22:01 -07001583 switch (kind) {
1584 case Program::kVertex_Kind:
Ethan Nicholas3c6ae622018-04-24 13:06:09 -04001585 inherited = &fVertexInclude;
1586 fIRGenerator->fSymbolTable = fVertexSymbolTable;
John Stiles810c8cf2020-08-26 19:46:27 -04001587 fIRGenerator->fIntrinsics = fGPUIntrinsics.get();
Ethan Nicholas3c6ae622018-04-24 13:06:09 -04001588 fIRGenerator->start(&settings, inherited);
ethannicholasb3058bd2016-07-01 08:22:01 -07001589 break;
1590 case Program::kFragment_Kind:
Ethan Nicholas3c6ae622018-04-24 13:06:09 -04001591 inherited = &fFragmentInclude;
1592 fIRGenerator->fSymbolTable = fFragmentSymbolTable;
John Stiles810c8cf2020-08-26 19:46:27 -04001593 fIRGenerator->fIntrinsics = fGPUIntrinsics.get();
Ethan Nicholas3c6ae622018-04-24 13:06:09 -04001594 fIRGenerator->start(&settings, inherited);
ethannicholasb3058bd2016-07-01 08:22:01 -07001595 break;
Ethan Nicholas52cad152017-02-16 16:37:32 -05001596 case Program::kGeometry_Kind:
Ethan Nicholasc18bb512020-07-28 14:46:53 -04001597 this->loadGeometryIntrinsics();
Ethan Nicholas3c6ae622018-04-24 13:06:09 -04001598 inherited = &fGeometryInclude;
1599 fIRGenerator->fSymbolTable = fGeometrySymbolTable;
John Stiles810c8cf2020-08-26 19:46:27 -04001600 fIRGenerator->fIntrinsics = fGPUIntrinsics.get();
Ethan Nicholas3c6ae622018-04-24 13:06:09 -04001601 fIRGenerator->start(&settings, inherited);
Ethan Nicholas52cad152017-02-16 16:37:32 -05001602 break;
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -04001603 case Program::kFragmentProcessor_Kind: {
Brian Osmandd496172020-08-08 08:17:18 -04001604#if !SKSL_STANDALONE
Ethan Nicholasc18bb512020-07-28 14:46:53 -04001605 {
1606 Rehydrator rehydrator(fContext.get(), fGpuSymbolTable, this,
1607 SKSL_INCLUDE_sksl_fp,
1608 SKSL_INCLUDE_sksl_fp_LENGTH);
1609 fFPSymbolTable = rehydrator.symbolTable();
1610 fFPInclude = rehydrator.elements();
1611 }
1612 inherited = &fFPInclude;
1613 fIRGenerator->fSymbolTable = fFPSymbolTable;
John Stiles810c8cf2020-08-26 19:46:27 -04001614 fIRGenerator->fIntrinsics = fGPUIntrinsics.get();
Ethan Nicholasc18bb512020-07-28 14:46:53 -04001615 fIRGenerator->start(&settings, inherited);
1616 break;
1617#else
Ethan Nicholas3c6ae622018-04-24 13:06:09 -04001618 inherited = nullptr;
Ethan Nicholas8da1e652019-05-24 11:01:59 -04001619 fIRGenerator->fSymbolTable = fGpuSymbolTable;
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -04001620 fIRGenerator->start(&settings, /*inherited=*/nullptr, /*builtin=*/true);
John Stiles810c8cf2020-08-26 19:46:27 -04001621 fIRGenerator->fIntrinsics = fGPUIntrinsics.get();
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -04001622 std::ifstream in(SKSL_FP_INCLUDE);
1623 std::string stdText{std::istreambuf_iterator<char>(in),
1624 std::istreambuf_iterator<char>()};
1625 if (in.rdstate()) {
1626 printf("error reading %s\n", SKSL_FP_INCLUDE);
1627 abort();
1628 }
1629 const String* source = fGpuSymbolTable->takeOwnershipOfString(
1630 std::make_unique<String>(stdText.c_str()));
1631 fIRGenerator->convertProgram(kind, source->c_str(), source->length(), &elements);
Ethan Nicholasc18bb512020-07-28 14:46:53 -04001632 fIRGenerator->fIsBuiltinCode = false;
Ethan Nicholas762466e2017-06-29 10:03:38 -04001633 break;
Ethan Nicholasc18bb512020-07-28 14:46:53 -04001634#endif
Ethan Nicholasb33fa3f2020-08-06 13:00:19 -04001635 }
Ethan Nicholas8da1e652019-05-24 11:01:59 -04001636 case Program::kPipelineStage_Kind:
Ethan Nicholasc18bb512020-07-28 14:46:53 -04001637 this->loadPipelineIntrinsics();
Ethan Nicholas8da1e652019-05-24 11:01:59 -04001638 inherited = &fPipelineInclude;
1639 fIRGenerator->fSymbolTable = fPipelineSymbolTable;
John Stiles810c8cf2020-08-26 19:46:27 -04001640 fIRGenerator->fIntrinsics = fGPUIntrinsics.get();
Ethan Nicholas8da1e652019-05-24 11:01:59 -04001641 fIRGenerator->start(&settings, inherited);
1642 break;
Ethan Nicholas746035a2019-04-23 13:31:09 -04001643 case Program::kGeneric_Kind:
Ethan Nicholasc18bb512020-07-28 14:46:53 -04001644 this->loadInterpreterIntrinsics();
Ethan Nicholas8da1e652019-05-24 11:01:59 -04001645 inherited = &fInterpreterInclude;
1646 fIRGenerator->fSymbolTable = fInterpreterSymbolTable;
John Stiles810c8cf2020-08-26 19:46:27 -04001647 fIRGenerator->fIntrinsics = fInterpreterIntrinsics.get();
Ethan Nicholas8da1e652019-05-24 11:01:59 -04001648 fIRGenerator->start(&settings, inherited);
Ethan Nicholas0d997662019-04-08 09:46:01 -04001649 break;
ethannicholasb3058bd2016-07-01 08:22:01 -07001650 }
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001651 std::unique_ptr<String> textPtr(new String(std::move(text)));
1652 fSource = textPtr.get();
Ethan Nicholasc18bb512020-07-28 14:46:53 -04001653 fIRGenerator->convertProgram(kind, textPtr->c_str(), textPtr->size(), &elements);
John Stilesfbd050b2020-08-03 13:21:46 -04001654 auto result = std::make_unique<Program>(kind,
1655 std::move(textPtr),
1656 settings,
1657 fContext,
1658 inherited,
1659 std::move(elements),
1660 fIRGenerator->fSymbolTable,
1661 fIRGenerator->fInputs);
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001662 if (fErrorCount) {
1663 return nullptr;
1664 }
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001665 if (settings.fOptimize && !this->optimize(*result)) {
1666 return nullptr;
1667 }
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001668 return result;
1669}
1670
Ethan Nicholas00543112018-07-31 09:44:36 -04001671bool Compiler::optimize(Program& program) {
1672 SkASSERT(!fErrorCount);
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001673 fIRGenerator->fKind = program.fKind;
1674 fIRGenerator->fSettings = &program.fSettings;
John Stiles7954d6c2020-09-01 10:53:02 -04001675
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001676 while (fErrorCount == 0) {
1677 bool madeChanges = false;
John Stiles7954d6c2020-09-01 10:53:02 -04001678
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001679 // Scan and optimize based on the control-flow graph for each function.
1680 for (ProgramElement& element : program) {
1681 if (element.is<FunctionDefinition>()) {
1682 madeChanges |= this->scanCFG(element.as<FunctionDefinition>());
1683 }
1684 }
1685
1686 // Perform inline-candidate analysis and inline any functions deemed suitable.
1687 madeChanges |= fInliner.analyze(program);
1688
1689 // Remove dead functions. We wait until after analysis so that we still report errors,
1690 // even in unused code.
1691 if (program.fSettings.fRemoveDeadFunctions) {
1692 program.fElements.erase(
1693 std::remove_if(program.fElements.begin(),
1694 program.fElements.end(),
1695 [&](const std::unique_ptr<ProgramElement>& element) {
1696 if (!element->is<FunctionDefinition>()) {
1697 return false;
1698 }
1699 const auto& fn = element->as<FunctionDefinition>();
1700 bool dead = fn.fDeclaration.fCallCount == 0 &&
1701 fn.fDeclaration.fName != "main";
1702 madeChanges |= dead;
1703 return dead;
1704 }),
1705 program.fElements.end());
1706 }
1707
1708 if (program.fKind != Program::kFragmentProcessor_Kind) {
1709 // Remove dead variables.
John Stileseadfc3b2020-09-02 14:12:41 -04001710 for (ProgramElement& element : program) {
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001711 if (!element.is<VarDeclarations>()) {
1712 continue;
Ethan Nicholas0dc80872019-02-08 15:46:24 -05001713 }
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001714 VarDeclarations& vars = element.as<VarDeclarations>();
1715 vars.fVars.erase(
1716 std::remove_if(vars.fVars.begin(), vars.fVars.end(),
1717 [&](const std::unique_ptr<Statement>& stmt) {
1718 bool dead = stmt->as<VarDeclaration>().fVar->dead();
John Stiles73a6bff2020-09-09 13:40:37 -04001719 madeChanges |= dead;
1720 return dead;
1721 }),
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001722 vars.fVars.end());
John Stiles73a6bff2020-09-09 13:40:37 -04001723 }
1724
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001725 // Remove empty variable declarations with no variables left inside of them.
1726 program.fElements.erase(
1727 std::remove_if(program.fElements.begin(), program.fElements.end(),
1728 [&](const std::unique_ptr<ProgramElement>& element) {
1729 if (!element->is<VarDeclarations>()) {
1730 return false;
1731 }
1732 bool dead = element->as<VarDeclarations>().fVars.empty();
1733 madeChanges |= dead;
1734 return dead;
1735 }),
1736 program.fElements.end());
1737 }
John Stiles73a6bff2020-09-09 13:40:37 -04001738
Ethan Nicholas34b19c52020-09-14 11:33:47 -04001739 if (!madeChanges) {
1740 break;
Ethan Nicholas0dc80872019-02-08 15:46:24 -05001741 }
Ethan Nicholas00543112018-07-31 09:44:36 -04001742 }
1743 return fErrorCount == 0;
1744}
1745
Brian Osmanfb32ddf2019-06-18 10:14:20 -04001746#if defined(SKSL_STANDALONE) || SK_SUPPORT_GPU
1747
Ethan Nicholas00543112018-07-31 09:44:36 -04001748bool Compiler::toSPIRV(Program& program, OutputStream& out) {
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001749#ifdef SK_ENABLE_SPIRV_VALIDATION
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001750 StringStream buffer;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001751 fSource = program.fSource.get();
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001752 SPIRVCodeGenerator cg(fContext.get(), &program, this, &buffer);
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001753 bool result = cg.generateCode();
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001754 fSource = nullptr;
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001755 if (result) {
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001756 spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_0);
Ethan Nicholas762466e2017-06-29 10:03:38 -04001757 const String& data = buffer.str();
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001758 SkASSERT(0 == data.size() % 4);
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001759 auto dumpmsg = [](spv_message_level_t, const char*, const spv_position_t&, const char* m) {
1760 SkDebugf("SPIR-V validation error: %s\n", m);
1761 };
1762 tools.SetMessageConsumer(dumpmsg);
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001763 // Verify that the SPIR-V we produced is valid. If this SkASSERT fails, check the logs prior
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001764 // to the failure to see the validation errors.
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001765 SkAssertResult(tools.Validate((const uint32_t*) data.c_str(), data.size() / 4));
Ethan Nicholas762466e2017-06-29 10:03:38 -04001766 out.write(data.c_str(), data.size());
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001767 }
1768#else
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001769 fSource = program.fSource.get();
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001770 SPIRVCodeGenerator cg(fContext.get(), &program, this, &out);
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001771 bool result = cg.generateCode();
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001772 fSource = nullptr;
Ethan Nicholasa6ae1f72017-03-16 09:56:54 -04001773#endif
Ethan Nicholasce33f102016-12-09 17:22:59 -05001774 return result;
1775}
1776
Ethan Nicholas00543112018-07-31 09:44:36 -04001777bool Compiler::toSPIRV(Program& program, String* out) {
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001778 StringStream buffer;
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001779 bool result = this->toSPIRV(program, buffer);
1780 if (result) {
Ethan Nicholas762466e2017-06-29 10:03:38 -04001781 *out = buffer.str();
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001782 }
1783 return result;
1784}
1785
Ethan Nicholas00543112018-07-31 09:44:36 -04001786bool Compiler::toGLSL(Program& program, OutputStream& out) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001787 fSource = program.fSource.get();
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001788 GLSLCodeGenerator cg(fContext.get(), &program, this, &out);
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001789 bool result = cg.generateCode();
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001790 fSource = nullptr;
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001791 return result;
1792}
1793
Ethan Nicholas00543112018-07-31 09:44:36 -04001794bool Compiler::toGLSL(Program& program, String* out) {
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001795 StringStream buffer;
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001796 bool result = this->toGLSL(program, buffer);
1797 if (result) {
Ethan Nicholas762466e2017-06-29 10:03:38 -04001798 *out = buffer.str();
Ethan Nicholas941e7e22016-12-12 15:33:30 -05001799 }
1800 return result;
1801}
1802
Brian Osmanc0243912020-02-19 15:35:26 -05001803bool Compiler::toHLSL(Program& program, String* out) {
1804 String spirv;
1805 if (!this->toSPIRV(program, &spirv)) {
1806 return false;
1807 }
1808
1809 return SPIRVtoHLSL(spirv, out);
1810}
1811
Ethan Nicholas00543112018-07-31 09:44:36 -04001812bool Compiler::toMetal(Program& program, OutputStream& out) {
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001813 MetalCodeGenerator cg(fContext.get(), &program, this, &out);
Ethan Nicholascc305772017-10-13 16:17:45 -04001814 bool result = cg.generateCode();
Ethan Nicholascc305772017-10-13 16:17:45 -04001815 return result;
1816}
1817
Ethan Nicholas00543112018-07-31 09:44:36 -04001818bool Compiler::toMetal(Program& program, String* out) {
Timothy Liangb8eeb802018-07-23 16:46:16 -04001819 StringStream buffer;
1820 bool result = this->toMetal(program, buffer);
1821 if (result) {
1822 *out = buffer.str();
1823 }
1824 return result;
1825}
1826
Ethan Nicholas2a479a52020-08-18 16:29:45 -04001827#if defined(SKSL_STANDALONE) || defined(GR_TEST_UTILS)
Ethan Nicholas00543112018-07-31 09:44:36 -04001828bool Compiler::toCPP(Program& program, String name, OutputStream& out) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001829 fSource = program.fSource.get();
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001830 CPPCodeGenerator cg(fContext.get(), &program, this, name, &out);
Ethan Nicholas762466e2017-06-29 10:03:38 -04001831 bool result = cg.generateCode();
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001832 fSource = nullptr;
Ethan Nicholas762466e2017-06-29 10:03:38 -04001833 return result;
1834}
1835
Ethan Nicholas00543112018-07-31 09:44:36 -04001836bool Compiler::toH(Program& program, String name, OutputStream& out) {
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001837 fSource = program.fSource.get();
Ethan Nicholas26a9aad2018-03-27 14:10:52 -04001838 HCodeGenerator cg(fContext.get(), &program, this, name, &out);
Ethan Nicholas762466e2017-06-29 10:03:38 -04001839 bool result = cg.generateCode();
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001840 fSource = nullptr;
Ethan Nicholas00543112018-07-31 09:44:36 -04001841 return result;
1842}
Ethan Nicholas2a479a52020-08-18 16:29:45 -04001843#endif // defined(SKSL_STANDALONE) || defined(GR_TEST_UTILS)
Ethan Nicholas00543112018-07-31 09:44:36 -04001844
Ethan Nicholas2a479a52020-08-18 16:29:45 -04001845#endif // defined(SKSL_STANDALONE) || SK_SUPPORT_GPU
Brian Osman2e29ab52019-09-20 12:19:11 -04001846
1847#if !defined(SKSL_STANDALONE) && SK_SUPPORT_GPU
Brian Osmana4b91692020-08-10 14:26:16 -04001848bool Compiler::toPipelineStage(Program& program, PipelineStageArgs* outArgs) {
Ethan Nicholas00543112018-07-31 09:44:36 -04001849 fSource = program.fSource.get();
1850 StringStream buffer;
Brian Osman300fe1d2020-01-23 15:42:43 -05001851 PipelineStageCodeGenerator cg(fContext.get(), &program, this, &buffer, outArgs);
Ethan Nicholas00543112018-07-31 09:44:36 -04001852 bool result = cg.generateCode();
1853 fSource = nullptr;
1854 if (result) {
Brian Osman107c6662019-12-30 15:02:30 -05001855 outArgs->fCode = buffer.str();
Ethan Nicholas00543112018-07-31 09:44:36 -04001856 }
Ethan Nicholas762466e2017-06-29 10:03:38 -04001857 return result;
1858}
Brian Osmanfb32ddf2019-06-18 10:14:20 -04001859#endif
1860
Ethan Nicholas0e9401d2019-03-21 11:05:37 -04001861std::unique_ptr<ByteCode> Compiler::toByteCode(Program& program) {
Mike Klein853d4ed2020-08-20 00:41:00 +00001862#if defined(SK_ENABLE_SKSL_INTERPRETER)
Brian Osman808f0212020-01-21 15:36:47 -05001863 fSource = program.fSource.get();
Ethan Nicholas0e9401d2019-03-21 11:05:37 -04001864 std::unique_ptr<ByteCode> result(new ByteCode());
Brian Osmanb08cc022020-04-02 11:38:40 -04001865 ByteCodeGenerator cg(fContext.get(), &program, this, result.get());
1866 bool success = cg.generateCode();
1867 fSource = nullptr;
1868 if (success) {
Ethan Nicholas0e9401d2019-03-21 11:05:37 -04001869 return result;
1870 }
Mike Klein853d4ed2020-08-20 00:41:00 +00001871#else
1872 ABORT("ByteCode interpreter not enabled");
1873#endif
Ethan Nicholas0e9401d2019-03-21 11:05:37 -04001874 return nullptr;
1875}
1876
Brian Osman401a0092020-09-10 14:47:24 -04001877const char* Compiler::OperatorName(Token::Kind op) {
1878 switch (op) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001879 case Token::Kind::TK_PLUS: return "+";
1880 case Token::Kind::TK_MINUS: return "-";
1881 case Token::Kind::TK_STAR: return "*";
1882 case Token::Kind::TK_SLASH: return "/";
1883 case Token::Kind::TK_PERCENT: return "%";
1884 case Token::Kind::TK_SHL: return "<<";
1885 case Token::Kind::TK_SHR: return ">>";
1886 case Token::Kind::TK_LOGICALNOT: return "!";
1887 case Token::Kind::TK_LOGICALAND: return "&&";
1888 case Token::Kind::TK_LOGICALOR: return "||";
1889 case Token::Kind::TK_LOGICALXOR: return "^^";
1890 case Token::Kind::TK_BITWISENOT: return "~";
1891 case Token::Kind::TK_BITWISEAND: return "&";
1892 case Token::Kind::TK_BITWISEOR: return "|";
1893 case Token::Kind::TK_BITWISEXOR: return "^";
1894 case Token::Kind::TK_EQ: return "=";
1895 case Token::Kind::TK_EQEQ: return "==";
1896 case Token::Kind::TK_NEQ: return "!=";
1897 case Token::Kind::TK_LT: return "<";
1898 case Token::Kind::TK_GT: return ">";
1899 case Token::Kind::TK_LTEQ: return "<=";
1900 case Token::Kind::TK_GTEQ: return ">=";
1901 case Token::Kind::TK_PLUSEQ: return "+=";
1902 case Token::Kind::TK_MINUSEQ: return "-=";
1903 case Token::Kind::TK_STAREQ: return "*=";
1904 case Token::Kind::TK_SLASHEQ: return "/=";
1905 case Token::Kind::TK_PERCENTEQ: return "%=";
1906 case Token::Kind::TK_SHLEQ: return "<<=";
1907 case Token::Kind::TK_SHREQ: return ">>=";
1908 case Token::Kind::TK_LOGICALANDEQ: return "&&=";
1909 case Token::Kind::TK_LOGICALOREQ: return "||=";
1910 case Token::Kind::TK_LOGICALXOREQ: return "^^=";
1911 case Token::Kind::TK_BITWISEANDEQ: return "&=";
1912 case Token::Kind::TK_BITWISEOREQ: return "|=";
1913 case Token::Kind::TK_BITWISEXOREQ: return "^=";
1914 case Token::Kind::TK_PLUSPLUS: return "++";
1915 case Token::Kind::TK_MINUSMINUS: return "--";
1916 case Token::Kind::TK_COMMA: return ",";
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001917 default:
Brian Osman401a0092020-09-10 14:47:24 -04001918 ABORT("unsupported operator: %d\n", (int) op);
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001919 }
1920}
1921
1922
1923bool Compiler::IsAssignment(Token::Kind op) {
1924 switch (op) {
Ethan Nicholas5a9e7fb2020-04-17 12:45:51 -04001925 case Token::Kind::TK_EQ: // fall through
1926 case Token::Kind::TK_PLUSEQ: // fall through
1927 case Token::Kind::TK_MINUSEQ: // fall through
1928 case Token::Kind::TK_STAREQ: // fall through
1929 case Token::Kind::TK_SLASHEQ: // fall through
1930 case Token::Kind::TK_PERCENTEQ: // fall through
1931 case Token::Kind::TK_SHLEQ: // fall through
1932 case Token::Kind::TK_SHREQ: // fall through
1933 case Token::Kind::TK_BITWISEOREQ: // fall through
1934 case Token::Kind::TK_BITWISEXOREQ: // fall through
1935 case Token::Kind::TK_BITWISEANDEQ: // fall through
1936 case Token::Kind::TK_LOGICALOREQ: // fall through
1937 case Token::Kind::TK_LOGICALXOREQ: // fall through
1938 case Token::Kind::TK_LOGICALANDEQ:
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001939 return true;
1940 default:
1941 return false;
1942 }
1943}
1944
Brian Osman401a0092020-09-10 14:47:24 -04001945Token::Kind Compiler::RemoveAssignment(Token::Kind op) {
1946 switch (op) {
1947 case Token::Kind::TK_PLUSEQ: return Token::Kind::TK_PLUS;
1948 case Token::Kind::TK_MINUSEQ: return Token::Kind::TK_MINUS;
1949 case Token::Kind::TK_STAREQ: return Token::Kind::TK_STAR;
1950 case Token::Kind::TK_SLASHEQ: return Token::Kind::TK_SLASH;
1951 case Token::Kind::TK_PERCENTEQ: return Token::Kind::TK_PERCENT;
1952 case Token::Kind::TK_SHLEQ: return Token::Kind::TK_SHL;
1953 case Token::Kind::TK_SHREQ: return Token::Kind::TK_SHR;
1954 case Token::Kind::TK_BITWISEOREQ: return Token::Kind::TK_BITWISEOR;
1955 case Token::Kind::TK_BITWISEXOREQ: return Token::Kind::TK_BITWISEXOR;
1956 case Token::Kind::TK_BITWISEANDEQ: return Token::Kind::TK_BITWISEAND;
1957 case Token::Kind::TK_LOGICALOREQ: return Token::Kind::TK_LOGICALOR;
1958 case Token::Kind::TK_LOGICALXOREQ: return Token::Kind::TK_LOGICALXOR;
1959 case Token::Kind::TK_LOGICALANDEQ: return Token::Kind::TK_LOGICALAND;
1960 default: return op;
1961 }
1962}
1963
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001964Position Compiler::position(int offset) {
Ethan Nicholasd9d33c32018-06-12 11:05:59 -04001965 SkASSERT(fSource);
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001966 int line = 1;
1967 int column = 1;
1968 for (int i = 0; i < offset; i++) {
1969 if ((*fSource)[i] == '\n') {
1970 ++line;
1971 column = 1;
1972 }
1973 else {
1974 ++column;
1975 }
1976 }
1977 return Position(line, column);
1978}
1979
1980void Compiler::error(int offset, String msg) {
ethannicholasb3058bd2016-07-01 08:22:01 -07001981 fErrorCount++;
Ethan Nicholas5b5f0962017-09-11 13:50:14 -07001982 Position pos = this->position(offset);
1983 fErrorText += "error: " + to_string(pos.fLine) + ": " + msg.c_str() + "\n";
ethannicholasb3058bd2016-07-01 08:22:01 -07001984}
1985
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001986String Compiler::errorText() {
Ethan Nicholas00543112018-07-31 09:44:36 -04001987 this->writeErrorCount();
1988 fErrorCount = 0;
Ethan Nicholas0df1b042017-03-31 13:56:23 -04001989 String result = fErrorText;
ethannicholasb3058bd2016-07-01 08:22:01 -07001990 return result;
1991}
1992
1993void Compiler::writeErrorCount() {
1994 if (fErrorCount) {
1995 fErrorText += to_string(fErrorCount) + " error";
1996 if (fErrorCount > 1) {
1997 fErrorText += "s";
1998 }
1999 fErrorText += "\n";
2000 }
2001}
2002
John Stilesa6841be2020-08-06 14:11:56 -04002003} // namespace SkSL