Debian Codegraph @

third_party/spirv-tools/source/opt/optimizer.cpp

raw
1 // Copyright (c) 2016 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "spirv-tools/optimizer.hpp"
16
17 #include <cassert>
18 #include <memory>
19 #include <string>
20 #include <unordered_map>
21 #include <utility>
22 #include <vector>
23
24 #include "source/opt/build_module.h"
25 #include "source/opt/graphics_robust_access_pass.h"
26 #include "source/opt/log.h"
27 #include "source/opt/pass_manager.h"
28 #include "source/opt/passes.h"
29 #include "source/spirv_optimizer_options.h"
30 #include "source/util/make_unique.h"
31 #include "source/util/string_utils.h"
32
33 namespace spvtools {
34
35 struct Optimizer::PassToken::Impl {
36 Impl(std::unique_ptr<opt::Pass> p) : pass(std::move(p)) {}
37
38 std::unique_ptr<opt::Pass> pass; // Internal implementation pass.
39 };
40
41 Optimizer::PassToken::PassToken(
42 std::unique_ptr<Optimizer::PassToken::Impl> impl)
43 : impl_(std::move(impl)) {}
44
45 Optimizer::PassToken::PassToken(std::unique_ptr<opt::Pass>&& pass)
46 : impl_(MakeUnique<Optimizer::PassToken::Impl>(std::move(pass))) {}
47
48 Optimizer::PassToken::PassToken(PassToken&& that)
49 : impl_(std::move(that.impl_)) {}
50
51 Optimizer::PassToken& Optimizer::PassToken::operator=(PassToken&& that) {
52 impl_ = std::move(that.impl_);
53 return *this;
54 }
55
56 Optimizer::PassToken::~PassToken() {}
57
58 struct Optimizer::Impl {
59 explicit Impl(spv_target_env env) : target_env(env), pass_manager() {}
60
61 spv_target_env target_env; // Target environment.
62 opt::PassManager pass_manager; // Internal implementation pass manager.
63 };
64
65 Optimizer::Optimizer(spv_target_env env) : impl_(new Impl(env)) {}
66
67 Optimizer::~Optimizer() {}
68
69 void Optimizer::SetMessageConsumer(MessageConsumer c) {
70 // All passes' message consumer needs to be updated.
71 for (uint32_t i = 0; i < impl_->pass_manager.NumPasses(); ++i) {
72 impl_->pass_manager.GetPass(i)->SetMessageConsumer(c);
73 }
74 impl_->pass_manager.SetMessageConsumer(std::move(c));
75 }
76
77 const MessageConsumer& Optimizer::consumer() const {
78 return impl_->pass_manager.consumer();
79 }
80
81 Optimizer& Optimizer::RegisterPass(PassToken&& p) {
82 // Change to use the pass manager's consumer.
83 p.impl_->pass->SetMessageConsumer(consumer());
84 impl_->pass_manager.AddPass(std::move(p.impl_->pass));
85 return *this;
86 }
87
88 // The legalization passes take a spir-v shader generated by an HLSL front-end
89 // and turn it into a valid vulkan spir-v shader. There are two ways in which
90 // the code will be invalid at the start:
91 //
92 // 1) There will be opaque objects, like images, which will be passed around
93 // in intermediate objects. Valid spir-v will have to replace the use of
94 // the opaque object with an intermediate object that is the result of the
95 // load of the global opaque object.
96 //
97 // 2) There will be variables that contain pointers to structured or uniform
98 // buffers. It be legal, the variables must be eliminated, and the
99 // references to the structured buffers must use the result of OpVariable
100 // in the Uniform storage class.
101 //
102 // Optimization in this list must accept shaders with these relaxation of the
103 // rules. There is not guarantee that this list of optimizations is able to
104 // legalize all inputs, but it is on a best effort basis.
105 //
106 // The legalization problem is essentially a very general copy propagation
107 // problem. The optimization we use are all used to either do copy propagation
108 // or enable more copy propagation.
109 Optimizer& Optimizer::RegisterLegalizationPasses() {
110 return
111 // Wrap OpKill instructions so all other code can be inlined.
112 RegisterPass(CreateWrapOpKillPass())
113 // Remove unreachable block so that merge return works.
114 .RegisterPass(CreateDeadBranchElimPass())
115 // Merge the returns so we can inline.
116 .RegisterPass(CreateMergeReturnPass())
117 // Make sure uses and definitions are in the same function.
118 .RegisterPass(CreateInlineExhaustivePass())
119 // Make private variable function scope
120 .RegisterPass(CreateEliminateDeadFunctionsPass())
121 .RegisterPass(CreatePrivateToLocalPass())
122 // Fix up the storage classes that DXC may have purposely generated
123 // incorrectly. All functions are inlined, and a lot of dead code has
124 // been removed.
125 .RegisterPass(CreateFixStorageClassPass())
126 // Propagate the value stored to the loads in very simple cases.
127 .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
128 .RegisterPass(CreateLocalSingleStoreElimPass())
129 .RegisterPass(CreateAggressiveDCEPass())
130 // Split up aggregates so they are easier to deal with.
131 .RegisterPass(CreateScalarReplacementPass(0))
132 // Remove loads and stores so everything is in intermediate values.
133 // Takes care of copy propagation of non-members.
134 .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
135 .RegisterPass(CreateLocalSingleStoreElimPass())
136 .RegisterPass(CreateAggressiveDCEPass())
137 .RegisterPass(CreateLocalMultiStoreElimPass())
138 .RegisterPass(CreateAggressiveDCEPass())
139 // Propagate constants to get as many constant conditions on branches
140 // as possible.
141 .RegisterPass(CreateCCPPass())
142 .RegisterPass(CreateLoopUnrollPass(true))
143 .RegisterPass(CreateDeadBranchElimPass())
144 // Copy propagate members. Cleans up code sequences generated by
145 // scalar replacement. Also important for removing OpPhi nodes.
146 .RegisterPass(CreateSimplificationPass())
147 .RegisterPass(CreateAggressiveDCEPass())
148 .RegisterPass(CreateCopyPropagateArraysPass())
149 // May need loop unrolling here see
150 // https://github.com/Microsoft/DirectXShaderCompiler/pull/930
151 // Get rid of unused code that contain traces of illegal code
152 // or unused references to unbound external objects
153 .RegisterPass(CreateVectorDCEPass())
154 .RegisterPass(CreateDeadInsertElimPass())
155 .RegisterPass(CreateReduceLoadSizePass())
156 .RegisterPass(CreateAggressiveDCEPass());
157 }
158
159 Optimizer& Optimizer::RegisterPerformancePasses() {
160 return RegisterPass(CreateWrapOpKillPass())
161 .RegisterPass(CreateDeadBranchElimPass())
162 .RegisterPass(CreateMergeReturnPass())
163 .RegisterPass(CreateInlineExhaustivePass())
164 .RegisterPass(CreateEliminateDeadFunctionsPass())
165 .RegisterPass(CreateAggressiveDCEPass())
166 .RegisterPass(CreatePrivateToLocalPass())
167 .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
168 .RegisterPass(CreateLocalSingleStoreElimPass())
169 .RegisterPass(CreateAggressiveDCEPass())
170 .RegisterPass(CreateScalarReplacementPass())
171 .RegisterPass(CreateLocalAccessChainConvertPass())
172 .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
173 .RegisterPass(CreateLocalSingleStoreElimPass())
174 .RegisterPass(CreateAggressiveDCEPass())
175 .RegisterPass(CreateLocalMultiStoreElimPass())
176 .RegisterPass(CreateAggressiveDCEPass())
177 .RegisterPass(CreateCCPPass())
178 .RegisterPass(CreateAggressiveDCEPass())
179 .RegisterPass(CreateLoopUnrollPass(true))
180 .RegisterPass(CreateDeadBranchElimPass())
181 .RegisterPass(CreateRedundancyEliminationPass())
182 .RegisterPass(CreateCombineAccessChainsPass())
183 .RegisterPass(CreateSimplificationPass())
184 .RegisterPass(CreateScalarReplacementPass())
185 .RegisterPass(CreateLocalAccessChainConvertPass())
186 .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
187 .RegisterPass(CreateLocalSingleStoreElimPass())
188 .RegisterPass(CreateAggressiveDCEPass())
189 .RegisterPass(CreateSSARewritePass())
190 .RegisterPass(CreateAggressiveDCEPass())
191 .RegisterPass(CreateVectorDCEPass())
192 .RegisterPass(CreateDeadInsertElimPass())
193 .RegisterPass(CreateDeadBranchElimPass())
194 .RegisterPass(CreateSimplificationPass())
195 .RegisterPass(CreateIfConversionPass())
196 .RegisterPass(CreateCopyPropagateArraysPass())
197 .RegisterPass(CreateReduceLoadSizePass())
198 .RegisterPass(CreateAggressiveDCEPass())
199 .RegisterPass(CreateBlockMergePass())
200 .RegisterPass(CreateRedundancyEliminationPass())
201 .RegisterPass(CreateDeadBranchElimPass())
202 .RegisterPass(CreateBlockMergePass())
203 .RegisterPass(CreateSimplificationPass());
204 }
205
206 Optimizer& Optimizer::RegisterSizePasses() {
207 return RegisterPass(CreateWrapOpKillPass())
208 .RegisterPass(CreateDeadBranchElimPass())
209 .RegisterPass(CreateMergeReturnPass())
210 .RegisterPass(CreateInlineExhaustivePass())
211 .RegisterPass(CreateEliminateDeadFunctionsPass())
212 .RegisterPass(CreatePrivateToLocalPass())
213 .RegisterPass(CreateScalarReplacementPass(0))
214 .RegisterPass(CreateLocalMultiStoreElimPass())
215 .RegisterPass(CreateCCPPass())
216 .RegisterPass(CreateLoopUnrollPass(true))
217 .RegisterPass(CreateDeadBranchElimPass())
218 .RegisterPass(CreateSimplificationPass())
219 .RegisterPass(CreateScalarReplacementPass(0))
220 .RegisterPass(CreateLocalSingleStoreElimPass())
221 .RegisterPass(CreateIfConversionPass())
222 .RegisterPass(CreateSimplificationPass())
223 .RegisterPass(CreateAggressiveDCEPass())
224 .RegisterPass(CreateDeadBranchElimPass())
225 .RegisterPass(CreateBlockMergePass())
226 .RegisterPass(CreateLocalAccessChainConvertPass())
227 .RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
228 .RegisterPass(CreateAggressiveDCEPass())
229 .RegisterPass(CreateCopyPropagateArraysPass())
230 .RegisterPass(CreateVectorDCEPass())
231 .RegisterPass(CreateDeadInsertElimPass())
232 .RegisterPass(CreateEliminateDeadMembersPass())
233 .RegisterPass(CreateLocalSingleStoreElimPass())
234 .RegisterPass(CreateBlockMergePass())
235 .RegisterPass(CreateLocalMultiStoreElimPass())
236 .RegisterPass(CreateRedundancyEliminationPass())
237 .RegisterPass(CreateSimplificationPass())
238 .RegisterPass(CreateAggressiveDCEPass())
239 .RegisterPass(CreateCFGCleanupPass());
240 }
241
242 Optimizer& Optimizer::RegisterVulkanToWebGPUPasses() {
243 return RegisterPass(CreateStripAtomicCounterMemoryPass())
244 .RegisterPass(CreateGenerateWebGPUInitializersPass())
245 .RegisterPass(CreateLegalizeVectorShufflePass())
246 .RegisterPass(CreateSplitInvalidUnreachablePass())
247 .RegisterPass(CreateEliminateDeadConstantPass())
248 .RegisterPass(CreateFlattenDecorationPass())
249 .RegisterPass(CreateAggressiveDCEPass())
250 .RegisterPass(CreateDeadBranchElimPass())
251 .RegisterPass(CreateCompactIdsPass());
252 }
253
254 Optimizer& Optimizer::RegisterWebGPUToVulkanPasses() {
255 return RegisterPass(CreateDecomposeInitializedVariablesPass())
256 .RegisterPass(CreateCompactIdsPass());
257 }
258
259 bool Optimizer::RegisterPassesFromFlags(const std::vector<std::string>& flags) {
260 for (const auto& flag : flags) {
261 if (!RegisterPassFromFlag(flag)) {
262 return false;
263 }
264 }
265
266 return true;
267 }
268
269 bool Optimizer::FlagHasValidForm(const std::string& flag) const {
270 if (flag == "-O" || flag == "-Os") {
271 return true;
272 } else if (flag.size() > 2 && flag.substr(0, 2) == "--") {
273 return true;
274 }
275
276 Errorf(consumer(), nullptr, {},
277 "%s is not a valid flag. Flag passes should have the form "
278 "'--pass_name[=pass_args]'. Special flag names also accepted: -O "
279 "and -Os.",
280 flag.c_str());
281 return false;
282 }
283
284 bool Optimizer::RegisterPassFromFlag(const std::string& flag) {
285 if (!FlagHasValidForm(flag)) {
286 return false;
287 }
288
289 // Split flags of the form --pass_name=pass_args.
290 auto p = utils::SplitFlagArgs(flag);
291 std::string pass_name = p.first;
292 std::string pass_args = p.second;
293
294 // FIXME(dnovillo): This should be re-factored so that pass names can be
295 // automatically checked against Pass::name() and PassToken instances created
296 // via a template function. Additionally, class Pass should have a desc()
297 // method that describes the pass (so it can be used in --help).
298 //
299 // Both Pass::name() and Pass::desc() should be static class members so they
300 // can be invoked without creating a pass instance.
301 if (pass_name == "strip-atomic-counter-memory") {
302 RegisterPass(CreateStripAtomicCounterMemoryPass());
303 } else if (pass_name == "strip-debug") {
304 RegisterPass(CreateStripDebugInfoPass());
305 } else if (pass_name == "strip-reflect") {
306 RegisterPass(CreateStripReflectInfoPass());
307 } else if (pass_name == "set-spec-const-default-value") {
308 if (pass_args.size() > 0) {
309 auto spec_ids_vals =
310 opt::SetSpecConstantDefaultValuePass::ParseDefaultValuesString(
311 pass_args.c_str());
312 if (!spec_ids_vals) {
313 Errorf(consumer(), nullptr, {},
314 "Invalid argument for --set-spec-const-default-value: %s",
315 pass_args.c_str());
316 return false;
317 }
318 RegisterPass(
319 CreateSetSpecConstantDefaultValuePass(std::move(*spec_ids_vals)));
320 } else {
321 Errorf(consumer(), nullptr, {},
322 "Invalid spec constant value string '%s'. Expected a string of "
323 "<spec id>:<default value> pairs.",
324 pass_args.c_str());
325 return false;
326 }
327 } else if (pass_name == "if-conversion") {
328 RegisterPass(CreateIfConversionPass());
329 } else if (pass_name == "freeze-spec-const") {
330 RegisterPass(CreateFreezeSpecConstantValuePass());
331 } else if (pass_name == "inline-entry-points-exhaustive") {
332 RegisterPass(CreateInlineExhaustivePass());
333 } else if (pass_name == "inline-entry-points-opaque") {
334 RegisterPass(CreateInlineOpaquePass());
335 } else if (pass_name == "combine-access-chains") {
336 RegisterPass(CreateCombineAccessChainsPass());
337 } else if (pass_name == "convert-local-access-chains") {
338 RegisterPass(CreateLocalAccessChainConvertPass());
339 } else if (pass_name == "descriptor-scalar-replacement") {
340 RegisterPass(CreateDescriptorScalarReplacementPass());
341 } else if (pass_name == "eliminate-dead-code-aggressive") {
342 RegisterPass(CreateAggressiveDCEPass());
343 } else if (pass_name == "eliminate-insert-extract") {
344 RegisterPass(CreateInsertExtractElimPass());
345 } else if (pass_name == "eliminate-local-single-block") {
346 RegisterPass(CreateLocalSingleBlockLoadStoreElimPass());
347 } else if (pass_name == "eliminate-local-single-store") {
348 RegisterPass(CreateLocalSingleStoreElimPass());
349 } else if (pass_name == "merge-blocks") {
350 RegisterPass(CreateBlockMergePass());
351 } else if (pass_name == "merge-return") {
352 RegisterPass(CreateMergeReturnPass());
353 } else if (pass_name == "eliminate-dead-branches") {
354 RegisterPass(CreateDeadBranchElimPass());
355 } else if (pass_name == "eliminate-dead-functions") {
356 RegisterPass(CreateEliminateDeadFunctionsPass());
357 } else if (pass_name == "eliminate-local-multi-store") {
358 RegisterPass(CreateLocalMultiStoreElimPass());
359 } else if (pass_name == "eliminate-dead-const") {
360 RegisterPass(CreateEliminateDeadConstantPass());
361 } else if (pass_name == "eliminate-dead-inserts") {
362 RegisterPass(CreateDeadInsertElimPass());
363 } else if (pass_name == "eliminate-dead-variables") {
364 RegisterPass(CreateDeadVariableEliminationPass());
365 } else if (pass_name == "eliminate-dead-members") {
366 RegisterPass(CreateEliminateDeadMembersPass());
367 } else if (pass_name == "fold-spec-const-op-composite") {
368 RegisterPass(CreateFoldSpecConstantOpAndCompositePass());
369 } else if (pass_name == "loop-unswitch") {
370 RegisterPass(CreateLoopUnswitchPass());
371 } else if (pass_name == "scalar-replacement") {
372 if (pass_args.size() == 0) {
373 RegisterPass(CreateScalarReplacementPass());
374 } else {
375 int limit = -1;
376 if (pass_args.find_first_not_of("0123456789") == std::string::npos) {
377 limit = atoi(pass_args.c_str());
378 }
379
380 if (limit >= 0) {
381 RegisterPass(CreateScalarReplacementPass(limit));
382 } else {
383 Error(consumer(), nullptr, {},
384 "--scalar-replacement must have no arguments or a non-negative "
385 "integer argument");
386 return false;
387 }
388 }
389 } else if (pass_name == "strength-reduction") {
390 RegisterPass(CreateStrengthReductionPass());
391 } else if (pass_name == "unify-const") {
392 RegisterPass(CreateUnifyConstantPass());
393 } else if (pass_name == "flatten-decorations") {
394 RegisterPass(CreateFlattenDecorationPass());
395 } else if (pass_name == "compact-ids") {
396 RegisterPass(CreateCompactIdsPass());
397 } else if (pass_name == "cfg-cleanup") {
398 RegisterPass(CreateCFGCleanupPass());
399 } else if (pass_name == "local-redundancy-elimination") {
400 RegisterPass(CreateLocalRedundancyEliminationPass());
401 } else if (pass_name == "loop-invariant-code-motion") {
402 RegisterPass(CreateLoopInvariantCodeMotionPass());
403 } else if (pass_name == "reduce-load-size") {
404 RegisterPass(CreateReduceLoadSizePass());
405 } else if (pass_name == "redundancy-elimination") {
406 RegisterPass(CreateRedundancyEliminationPass());
407 } else if (pass_name == "private-to-local") {
408 RegisterPass(CreatePrivateToLocalPass());
409 } else if (pass_name == "remove-duplicates") {
410 RegisterPass(CreateRemoveDuplicatesPass());
411 } else if (pass_name == "workaround-1209") {
412 RegisterPass(CreateWorkaround1209Pass());
413 } else if (pass_name == "replace-invalid-opcode") {
414 RegisterPass(CreateReplaceInvalidOpcodePass());
415 } else if (pass_name == "inst-bindless-check") {
416 RegisterPass(CreateInstBindlessCheckPass(7, 23, false, false));
417 RegisterPass(CreateSimplificationPass());
418 RegisterPass(CreateDeadBranchElimPass());
419 RegisterPass(CreateBlockMergePass());
420 RegisterPass(CreateAggressiveDCEPass());
421 } else if (pass_name == "inst-desc-idx-check") {
422 RegisterPass(CreateInstBindlessCheckPass(7, 23, true, true));
423 RegisterPass(CreateSimplificationPass());
424 RegisterPass(CreateDeadBranchElimPass());
425 RegisterPass(CreateBlockMergePass());
426 RegisterPass(CreateAggressiveDCEPass());
427 } else if (pass_name == "inst-buff-oob-check") {
428 RegisterPass(CreateInstBindlessCheckPass(7, 23, false, false, true));
429 RegisterPass(CreateSimplificationPass());
430 RegisterPass(CreateDeadBranchElimPass());
431 RegisterPass(CreateBlockMergePass());
432 RegisterPass(CreateAggressiveDCEPass());
433 } else if (pass_name == "inst-buff-addr-check") {
434 RegisterPass(CreateInstBuffAddrCheckPass(7, 23));
435 RegisterPass(CreateAggressiveDCEPass());
436 } else if (pass_name == "convert-relaxed-to-half") {
437 RegisterPass(CreateConvertRelaxedToHalfPass());
438 } else if (pass_name == "relax-float-ops") {
439 RegisterPass(CreateRelaxFloatOpsPass());
440 } else if (pass_name == "inst-debug-printf") {
441 RegisterPass(CreateInstDebugPrintfPass(7, 23));
442 } else if (pass_name == "simplify-instructions") {
443 RegisterPass(CreateSimplificationPass());
444 } else if (pass_name == "ssa-rewrite") {
445 RegisterPass(CreateSSARewritePass());
446 } else if (pass_name == "copy-propagate-arrays") {
447 RegisterPass(CreateCopyPropagateArraysPass());
448 } else if (pass_name == "loop-fission") {
449 int register_threshold_to_split =
450 (pass_args.size() > 0) ? atoi(pass_args.c_str()) : -1;
451 if (register_threshold_to_split > 0) {
452 RegisterPass(CreateLoopFissionPass(
453 static_cast<size_t>(register_threshold_to_split)));
454 } else {
455 Error(consumer(), nullptr, {},
456 "--loop-fission must have a positive integer argument");
457 return false;
458 }
459 } else if (pass_name == "loop-fusion") {
460 int max_registers_per_loop =
461 (pass_args.size() > 0) ? atoi(pass_args.c_str()) : -1;
462 if (max_registers_per_loop > 0) {
463 RegisterPass(
464 CreateLoopFusionPass(static_cast<size_t>(max_registers_per_loop)));
465 } else {
466 Error(consumer(), nullptr, {},
467 "--loop-fusion must have a positive integer argument");
468 return false;
469 }
470 } else if (pass_name == "loop-unroll") {
471 RegisterPass(CreateLoopUnrollPass(true));
472 } else if (pass_name == "upgrade-memory-model") {
473 RegisterPass(CreateUpgradeMemoryModelPass());
474 } else if (pass_name == "vector-dce") {
475 RegisterPass(CreateVectorDCEPass());
476 } else if (pass_name == "loop-unroll-partial") {
477 int factor = (pass_args.size() > 0) ? atoi(pass_args.c_str()) : 0;
478 if (factor > 0) {
479 RegisterPass(CreateLoopUnrollPass(false, factor));
480 } else {
481 Error(consumer(), nullptr, {},
482 "--loop-unroll-partial must have a positive integer argument");
483 return false;
484 }
485 } else if (pass_name == "loop-peeling") {
486 RegisterPass(CreateLoopPeelingPass());
487 } else if (pass_name == "loop-peeling-threshold") {
488 int factor = (pass_args.size() > 0) ? atoi(pass_args.c_str()) : 0;
489 if (factor > 0) {
490 opt::LoopPeelingPass::SetLoopPeelingThreshold(factor);
491 } else {
492 Error(consumer(), nullptr, {},
493 "--loop-peeling-threshold must have a positive integer argument");
494 return false;
495 }
496 } else if (pass_name == "ccp") {
497 RegisterPass(CreateCCPPass());
498 } else if (pass_name == "code-sink") {
499 RegisterPass(CreateCodeSinkingPass());
500 } else if (pass_name == "fix-storage-class") {
501 RegisterPass(CreateFixStorageClassPass());
502 } else if (pass_name == "O") {
503 RegisterPerformancePasses();
504 } else if (pass_name == "Os") {
505 RegisterSizePasses();
506 } else if (pass_name == "legalize-hlsl") {
507 RegisterLegalizationPasses();
508 } else if (pass_name == "generate-webgpu-initializers") {
509 RegisterPass(CreateGenerateWebGPUInitializersPass());
510 } else if (pass_name == "legalize-vector-shuffle") {
511 RegisterPass(CreateLegalizeVectorShufflePass());
512 } else if (pass_name == "split-invalid-unreachable") {
513 RegisterPass(CreateSplitInvalidUnreachablePass());
514 } else if (pass_name == "decompose-initialized-variables") {
515 RegisterPass(CreateDecomposeInitializedVariablesPass());
516 } else if (pass_name == "graphics-robust-access") {
517 RegisterPass(CreateGraphicsRobustAccessPass());
518 } else if (pass_name == "wrap-opkill") {
519 RegisterPass(CreateWrapOpKillPass());
520 } else if (pass_name == "amd-ext-to-khr") {
521 RegisterPass(CreateAmdExtToKhrPass());
522 } else {
523 Errorf(consumer(), nullptr, {},
524 "Unknown flag '--%s'. Use --help for a list of valid flags",
525 pass_name.c_str());
526 return false;
527 }
528
529 return true;
530 }
531
532 void Optimizer::SetTargetEnv(const spv_target_env env) {
533 impl_->target_env = env;
534 }
535
536 bool Optimizer::Run(const uint32_t* original_binary,
537 const size_t original_binary_size,
538 std::vector<uint32_t>* optimized_binary) const {
539 return Run(original_binary, original_binary_size, optimized_binary,
540 OptimizerOptions());
541 }
542
543 bool Optimizer::Run(const uint32_t* original_binary,
544 const size_t original_binary_size,
545 std::vector<uint32_t>* optimized_binary,
546 const ValidatorOptions& validator_options,
547 bool skip_validation) const {
548 OptimizerOptions opt_options;
549 opt_options.set_run_validator(!skip_validation);
550 opt_options.set_validator_options(validator_options);
551 return Run(original_binary, original_binary_size, optimized_binary,
552 opt_options);
553 }
554
555 bool Optimizer::Run(const uint32_t* original_binary,
556 const size_t original_binary_size,
557 std::vector<uint32_t>* optimized_binary,
558 const spv_optimizer_options opt_options) const {
559 spvtools::SpirvTools tools(impl_->target_env);
560 tools.SetMessageConsumer(impl_->pass_manager.consumer());
561 if (opt_options->run_validator_ &&
562 !tools.Validate(original_binary, original_binary_size,
563 &opt_options->val_options_)) {
564 return false;
565 }
566
567 std::unique_ptr<opt::IRContext> context = BuildModule(
568 impl_->target_env, consumer(), original_binary, original_binary_size);
569 if (context == nullptr) return false;
570
571 context->set_max_id_bound(opt_options->max_id_bound_);
572 context->set_preserve_bindings(opt_options->preserve_bindings_);
573 context->set_preserve_spec_constants(opt_options->preserve_spec_constants_);
574
575 impl_->pass_manager.SetValidatorOptions(&opt_options->val_options_);
576 impl_->pass_manager.SetTargetEnv(impl_->target_env);
577 auto status = impl_->pass_manager.Run(context.get());
578
579 if (status == opt::Pass::Status::Failure) {
580 return false;
581 }
582
583 #ifndef NDEBUG
584 // We do not keep the result id of DebugScope in struct DebugScope.
585 // Instead, we assign random ids for them, which results in integrity
586 // check failures. We want to skip the integrity check when the module
587 // contains DebugScope instructions.
588 if (status == opt::Pass::Status::SuccessWithoutChange &&
589 !context->module()->ContainsDebugScope()) {
590 std::vector<uint32_t> optimized_binary_with_nop;
591 context->module()->ToBinary(&optimized_binary_with_nop,
592 /* skip_nop = */ false);
593 assert(optimized_binary_with_nop.size() == original_binary_size &&
594 "Binary size unexpectedly changed despite the optimizer saying "
595 "there was no change");
596 assert(memcmp(optimized_binary_with_nop.data(), original_binary,
597 original_binary_size) == 0 &&
598 "Binary content unexpectedly changed despite the optimizer saying "
599 "there was no change");
600 }
601 #endif // !NDEBUG
602
603 // Note that |original_binary| and |optimized_binary| may share the same
604 // buffer and the below will invalidate |original_binary|.
605 optimized_binary->clear();
606 context->module()->ToBinary(optimized_binary, /* skip_nop = */ true);
607
608 return true;
609 }
610
611 Optimizer& Optimizer::SetPrintAll(std::ostream* out) {
612 impl_->pass_manager.SetPrintAll(out);
613 return *this;
614 }
615
616 Optimizer& Optimizer::SetTimeReport(std::ostream* out) {
617 impl_->pass_manager.SetTimeReport(out);
618 return *this;
619 }
620
621 Optimizer& Optimizer::SetValidateAfterAll(bool validate) {
622 impl_->pass_manager.SetValidateAfterAll(validate);
623 return *this;
624 }
625
626 Optimizer::PassToken CreateNullPass() {
627 return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::NullPass>());
628 }
629
630 Optimizer::PassToken CreateStripAtomicCounterMemoryPass() {
631 return MakeUnique<Optimizer::PassToken::Impl>(
632 MakeUnique<opt::StripAtomicCounterMemoryPass>());
633 }
634
635 Optimizer::PassToken CreateStripDebugInfoPass() {
636 return MakeUnique<Optimizer::PassToken::Impl>(
637 MakeUnique<opt::StripDebugInfoPass>());
638 }
639
640 Optimizer::PassToken CreateStripReflectInfoPass() {
641 return MakeUnique<Optimizer::PassToken::Impl>(
642 MakeUnique<opt::StripReflectInfoPass>());
643 }
644
645 Optimizer::PassToken CreateEliminateDeadFunctionsPass() {
646 return MakeUnique<Optimizer::PassToken::Impl>(
647 MakeUnique<opt::EliminateDeadFunctionsPass>());
648 }
649
650 Optimizer::PassToken CreateEliminateDeadMembersPass() {
651 return MakeUnique<Optimizer::PassToken::Impl>(
652 MakeUnique<opt::EliminateDeadMembersPass>());
653 }
654
655 Optimizer::PassToken CreateSetSpecConstantDefaultValuePass(
656 const std::unordered_map<uint32_t, std::string>& id_value_map) {
657 return MakeUnique<Optimizer::PassToken::Impl>(
658 MakeUnique<opt::SetSpecConstantDefaultValuePass>(id_value_map));
659 }
660
661 Optimizer::PassToken CreateSetSpecConstantDefaultValuePass(
662 const std::unordered_map<uint32_t, std::vector<uint32_t>>& id_value_map) {
663 return MakeUnique<Optimizer::PassToken::Impl>(
664 MakeUnique<opt::SetSpecConstantDefaultValuePass>(id_value_map));
665 }
666
667 Optimizer::PassToken CreateFlattenDecorationPass() {
668 return MakeUnique<Optimizer::PassToken::Impl>(
669 MakeUnique<opt::FlattenDecorationPass>());
670 }
671
672 Optimizer::PassToken CreateFreezeSpecConstantValuePass() {
673 return MakeUnique<Optimizer::PassToken::Impl>(
674 MakeUnique<opt::FreezeSpecConstantValuePass>());
675 }
676
677 Optimizer::PassToken CreateFoldSpecConstantOpAndCompositePass() {
678 return MakeUnique<Optimizer::PassToken::Impl>(
679 MakeUnique<opt::FoldSpecConstantOpAndCompositePass>());
680 }
681
682 Optimizer::PassToken CreateUnifyConstantPass() {
683 return MakeUnique<Optimizer::PassToken::Impl>(
684 MakeUnique<opt::UnifyConstantPass>());
685 }
686
687 Optimizer::PassToken CreateEliminateDeadConstantPass() {
688 return MakeUnique<Optimizer::PassToken::Impl>(
689 MakeUnique<opt::EliminateDeadConstantPass>());
690 }
691
692 Optimizer::PassToken CreateDeadVariableEliminationPass() {
693 return MakeUnique<Optimizer::PassToken::Impl>(
694 MakeUnique<opt::DeadVariableElimination>());
695 }
696
697 Optimizer::PassToken CreateStrengthReductionPass() {
698 return MakeUnique<Optimizer::PassToken::Impl>(
699 MakeUnique<opt::StrengthReductionPass>());
700 }
701
702 Optimizer::PassToken CreateBlockMergePass() {
703 return MakeUnique<Optimizer::PassToken::Impl>(
704 MakeUnique<opt::BlockMergePass>());
705 }
706
707 Optimizer::PassToken CreateInlineExhaustivePass() {
708 return MakeUnique<Optimizer::PassToken::Impl>(
709 MakeUnique<opt::InlineExhaustivePass>());
710 }
711
712 Optimizer::PassToken CreateInlineOpaquePass() {
713 return MakeUnique<Optimizer::PassToken::Impl>(
714 MakeUnique<opt::InlineOpaquePass>());
715 }
716
717 Optimizer::PassToken CreateLocalAccessChainConvertPass() {
718 return MakeUnique<Optimizer::PassToken::Impl>(
719 MakeUnique<opt::LocalAccessChainConvertPass>());
720 }
721
722 Optimizer::PassToken CreateLocalSingleBlockLoadStoreElimPass() {
723 return MakeUnique<Optimizer::PassToken::Impl>(
724 MakeUnique<opt::LocalSingleBlockLoadStoreElimPass>());
725 }
726
727 Optimizer::PassToken CreateLocalSingleStoreElimPass() {
728 return MakeUnique<Optimizer::PassToken::Impl>(
729 MakeUnique<opt::LocalSingleStoreElimPass>());
730 }
731
732 Optimizer::PassToken CreateInsertExtractElimPass() {
733 return MakeUnique<Optimizer::PassToken::Impl>(
734 MakeUnique<opt::SimplificationPass>());
735 }
736
737 Optimizer::PassToken CreateDeadInsertElimPass() {
738 return MakeUnique<Optimizer::PassToken::Impl>(
739 MakeUnique<opt::DeadInsertElimPass>());
740 }
741
742 Optimizer::PassToken CreateDeadBranchElimPass() {
743 return MakeUnique<Optimizer::PassToken::Impl>(
744 MakeUnique<opt::DeadBranchElimPass>());
745 }
746
747 Optimizer::PassToken CreateLocalMultiStoreElimPass() {
748 return MakeUnique<Optimizer::PassToken::Impl>(
749 MakeUnique<opt::SSARewritePass>());
750 }
751
752 Optimizer::PassToken CreateAggressiveDCEPass() {
753 return MakeUnique<Optimizer::PassToken::Impl>(
754 MakeUnique<opt::AggressiveDCEPass>());
755 }
756
757 Optimizer::PassToken CreatePropagateLineInfoPass() {
758 return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::EmptyPass>());
759 }
760
761 Optimizer::PassToken CreateRedundantLineInfoElimPass() {
762 return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::EmptyPass>());
763 }
764
765 Optimizer::PassToken CreateCompactIdsPass() {
766 return MakeUnique<Optimizer::PassToken::Impl>(
767 MakeUnique<opt::CompactIdsPass>());
768 }
769
770 Optimizer::PassToken CreateMergeReturnPass() {
771 return MakeUnique<Optimizer::PassToken::Impl>(
772 MakeUnique<opt::MergeReturnPass>());
773 }
774
775 std::vector<const char*> Optimizer::GetPassNames() const {
776 std::vector<const char*> v;
777 for (uint32_t i = 0; i < impl_->pass_manager.NumPasses(); i++) {
778 v.push_back(impl_->pass_manager.GetPass(i)->name());
779 }
780 return v;
781 }
782
783 Optimizer::PassToken CreateCFGCleanupPass() {
784 return MakeUnique<Optimizer::PassToken::Impl>(
785 MakeUnique<opt::CFGCleanupPass>());
786 }
787
788 Optimizer::PassToken CreateLocalRedundancyEliminationPass() {
789 return MakeUnique<Optimizer::PassToken::Impl>(
790 MakeUnique<opt::LocalRedundancyEliminationPass>());
791 }
792
793 Optimizer::PassToken CreateLoopFissionPass(size_t threshold) {
794 return MakeUnique<Optimizer::PassToken::Impl>(
795 MakeUnique<opt::LoopFissionPass>(threshold));
796 }
797
798 Optimizer::PassToken CreateLoopFusionPass(size_t max_registers_per_loop) {
799 return MakeUnique<Optimizer::PassToken::Impl>(
800 MakeUnique<opt::LoopFusionPass>(max_registers_per_loop));
801 }
802
803 Optimizer::PassToken CreateLoopInvariantCodeMotionPass() {
804 return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::LICMPass>());
805 }
806
807 Optimizer::PassToken CreateLoopPeelingPass() {
808 return MakeUnique<Optimizer::PassToken::Impl>(
809 MakeUnique<opt::LoopPeelingPass>());
810 }
811
812 Optimizer::PassToken CreateLoopUnswitchPass() {
813 return MakeUnique<Optimizer::PassToken::Impl>(
814 MakeUnique<opt::LoopUnswitchPass>());
815 }
816
817 Optimizer::PassToken CreateRedundancyEliminationPass() {
818 return MakeUnique<Optimizer::PassToken::Impl>(
819 MakeUnique<opt::RedundancyEliminationPass>());
820 }
821
822 Optimizer::PassToken CreateRemoveDuplicatesPass() {
823 return MakeUnique<Optimizer::PassToken::Impl>(
824 MakeUnique<opt::RemoveDuplicatesPass>());
825 }
826
827 Optimizer::PassToken CreateScalarReplacementPass(uint32_t size_limit) {
828 return MakeUnique<Optimizer::PassToken::Impl>(
829 MakeUnique<opt::ScalarReplacementPass>(size_limit));
830 }
831
832 Optimizer::PassToken CreatePrivateToLocalPass() {
833 return MakeUnique<Optimizer::PassToken::Impl>(
834 MakeUnique<opt::PrivateToLocalPass>());
835 }
836
837 Optimizer::PassToken CreateCCPPass() {
838 return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::CCPPass>());
839 }
840
841 Optimizer::PassToken CreateWorkaround1209Pass() {
842 return MakeUnique<Optimizer::PassToken::Impl>(
843 MakeUnique<opt::Workaround1209>());
844 }
845
846 Optimizer::PassToken CreateIfConversionPass() {
847 return MakeUnique<Optimizer::PassToken::Impl>(
848 MakeUnique<opt::IfConversion>());
849 }
850
851 Optimizer::PassToken CreateReplaceInvalidOpcodePass() {
852 return MakeUnique<Optimizer::PassToken::Impl>(
853 MakeUnique<opt::ReplaceInvalidOpcodePass>());
854 }
855
856 Optimizer::PassToken CreateSimplificationPass() {
857 return MakeUnique<Optimizer::PassToken::Impl>(
858 MakeUnique<opt::SimplificationPass>());
859 }
860
861 Optimizer::PassToken CreateLoopUnrollPass(bool fully_unroll, int factor) {
862 return MakeUnique<Optimizer::PassToken::Impl>(
863 MakeUnique<opt::LoopUnroller>(fully_unroll, factor));
864 }
865
866 Optimizer::PassToken CreateSSARewritePass() {
867 return MakeUnique<Optimizer::PassToken::Impl>(
868 MakeUnique<opt::SSARewritePass>());
869 }
870
871 Optimizer::PassToken CreateCopyPropagateArraysPass() {
872 return MakeUnique<Optimizer::PassToken::Impl>(
873 MakeUnique<opt::CopyPropagateArrays>());
874 }
875
876 Optimizer::PassToken CreateVectorDCEPass() {
877 return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::VectorDCE>());
878 }
879
880 Optimizer::PassToken CreateReduceLoadSizePass() {
881 return MakeUnique<Optimizer::PassToken::Impl>(
882 MakeUnique<opt::ReduceLoadSize>());
883 }
884
885 Optimizer::PassToken CreateCombineAccessChainsPass() {
886 return MakeUnique<Optimizer::PassToken::Impl>(
887 MakeUnique<opt::CombineAccessChains>());
888 }
889
890 Optimizer::PassToken CreateUpgradeMemoryModelPass() {
891 return MakeUnique<Optimizer::PassToken::Impl>(
892 MakeUnique<opt::UpgradeMemoryModel>());
893 }
894
895 Optimizer::PassToken CreateInstBindlessCheckPass(uint32_t desc_set,
896 uint32_t shader_id,
897 bool input_length_enable,
898 bool input_init_enable,
899 bool input_buff_oob_enable) {
900 return MakeUnique<Optimizer::PassToken::Impl>(
901 MakeUnique<opt::InstBindlessCheckPass>(
902 desc_set, shader_id, input_length_enable, input_init_enable,
903 input_buff_oob_enable));
904 }
905
906 Optimizer::PassToken CreateInstDebugPrintfPass(uint32_t desc_set,
907 uint32_t shader_id) {
908 return MakeUnique<Optimizer::PassToken::Impl>(
909 MakeUnique<opt::InstDebugPrintfPass>(desc_set, shader_id));
910 }
911
912 Optimizer::PassToken CreateInstBuffAddrCheckPass(uint32_t desc_set,
913 uint32_t shader_id) {
914 return MakeUnique<Optimizer::PassToken::Impl>(
915 MakeUnique<opt::InstBuffAddrCheckPass>(desc_set, shader_id));
916 }
917
918 Optimizer::PassToken CreateConvertRelaxedToHalfPass() {
919 return MakeUnique<Optimizer::PassToken::Impl>(
920 MakeUnique<opt::ConvertToHalfPass>());
921 }
922
923 Optimizer::PassToken CreateRelaxFloatOpsPass() {
924 return MakeUnique<Optimizer::PassToken::Impl>(
925 MakeUnique<opt::RelaxFloatOpsPass>());
926 }
927
928 Optimizer::PassToken CreateCodeSinkingPass() {
929 return MakeUnique<Optimizer::PassToken::Impl>(
930 MakeUnique<opt::CodeSinkingPass>());
931 }
932
933 Optimizer::PassToken CreateGenerateWebGPUInitializersPass() {
934 return MakeUnique<Optimizer::PassToken::Impl>(
935 MakeUnique<opt::GenerateWebGPUInitializersPass>());
936 }
937
938 Optimizer::PassToken CreateFixStorageClassPass() {
939 return MakeUnique<Optimizer::PassToken::Impl>(
940 MakeUnique<opt::FixStorageClass>());
941 }
942
943 Optimizer::PassToken CreateLegalizeVectorShufflePass() {
944 return MakeUnique<Optimizer::PassToken::Impl>(
945 MakeUnique<opt::LegalizeVectorShufflePass>());
946 }
947
948 Optimizer::PassToken CreateDecomposeInitializedVariablesPass() {
949 return MakeUnique<Optimizer::PassToken::Impl>(
950 MakeUnique<opt::DecomposeInitializedVariablesPass>());
951 }
952
953 Optimizer::PassToken CreateSplitInvalidUnreachablePass() {
954 return MakeUnique<Optimizer::PassToken::Impl>(
955 MakeUnique<opt::SplitInvalidUnreachablePass>());
956 }
957
958 Optimizer::PassToken CreateGraphicsRobustAccessPass() {
959 return MakeUnique<Optimizer::PassToken::Impl>(
960 MakeUnique<opt::GraphicsRobustAccessPass>());
961 }
962
963 Optimizer::PassToken CreateDescriptorScalarReplacementPass() {
964 return MakeUnique<Optimizer::PassToken::Impl>(
965 MakeUnique<opt::DescriptorScalarReplacement>());
966 }
967
968 Optimizer::PassToken CreateWrapOpKillPass() {
969 return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::WrapOpKill>());
970 }
971
972 Optimizer::PassToken CreateAmdExtToKhrPass() {
973 return MakeUnique<Optimizer::PassToken::Impl>(
974 MakeUnique<opt::AmdExtensionToKhrPass>());
975 }
976
977 } // namespace spvtools