| 1 |
// Copyright (c) 2019 Google LLC |
| 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 |
#ifndef SOURCE_OPT_GRAPHICS_ROBUST_ACCESS_PASS_H_ |
| 16 |
#define SOURCE_OPT_GRAPHICS_ROBUST_ACCESS_PASS_H_ |
| 17 |
|
| 18 |
#include <map> |
| 19 |
#include <unordered_map> |
| 20 |
|
| 21 |
#include "constants.h" |
| 22 |
#include "def_use_manager.h" |
| 23 |
#include "instruction.h" |
| 24 |
#include "module.h" |
| 25 |
#include "pass.h" |
| 26 |
#include "source/diagnostic.h" |
| 27 |
#include "type_manager.h" |
| 28 |
|
| 29 |
namespace spvtools { |
| 30 |
namespace opt { |
| 31 |
|
| 32 |
// See optimizer.hpp for documentation. |
| 33 |
class GraphicsRobustAccessPass : public Pass { |
| 34 |
public: |
| 35 |
GraphicsRobustAccessPass(); |
| 36 |
const char* name() const override { return "graphics-robust-access"; } |
| 37 |
Status Process() override; |
| 38 |
|
| 39 |
IRContext::Analysis GetPreservedAnalyses() override { |
| 40 |
return IRContext::kAnalysisDefUse | |
| 41 |
IRContext::kAnalysisInstrToBlockMapping | |
| 42 |
IRContext::kAnalysisConstants | IRContext::kAnalysisTypes | |
| 43 |
IRContext::kAnalysisIdToFuncMapping; |
| 44 |
} |
| 45 |
|
| 46 |
private: |
| 47 |
// Records failure for the current module, and returns a stream |
| 48 |
// that can be used to provide user error information to the message |
| 49 |
// consumer. |
| 50 |
spvtools::DiagnosticStream Fail(); |
| 51 |
|
| 52 |
// Returns SPV_SUCCESS if this pass can correctly process the module, |
| 53 |
// as far as we can tell from capabilities and the memory model. |
| 54 |
// Otherwise logs a message and returns a failure code. |
| 55 |
spv_result_t IsCompatibleModule(); |
| 56 |
|
| 57 |
// Transform the current module, if possible. Failure and modification |
| 58 |
// status is recorded in the |_| member. On failure, error information is |
| 59 |
// posted to the message consumer. The return value has no significance. |
| 60 |
spv_result_t ProcessCurrentModule(); |
| 61 |
|
| 62 |
// Process the given function. Updates the state value |_|. Returns true |
| 63 |
// if the module was modified. This can log a failure. |
| 64 |
bool ProcessAFunction(opt::Function*); |
| 65 |
|
| 66 |
// Clamps indices in the OpAccessChain or OpInBoundsAccessChain instruction |
| 67 |
// |access_chain|. Inserts instructions before the given instruction. Updates |
| 68 |
// analyses and records that the module is modified. This can log a failure. |
| 69 |
void ClampIndicesForAccessChain(Instruction* access_chain); |
| 70 |
|
| 71 |
// Returns the id of the instruction importing the "GLSL.std.450" extended |
| 72 |
// instruction set. If it does not yet exist, the import instruction is |
| 73 |
// created and inserted into the module, and updates |_.modified| and |
| 74 |
// |_.glsl_insts_id|. |
| 75 |
uint32_t GetGlslInsts(); |
| 76 |
|
| 77 |
// Returns an instruction which is constant with the given value of the given |
| 78 |
// type. Ignores any value bits beyond the width of the type. |
| 79 |
Instruction* GetValueForType(uint64_t value, const analysis::Integer* type); |
| 80 |
|
| 81 |
// Converts an integer value to an unsigned wider integer type, using either |
| 82 |
// sign extension or zero extension. The new instruction is inserted |
| 83 |
// immediately before |before_inst|, and is analyzed for definitions and uses. |
| 84 |
// Returns the newly inserted instruction. Assumes the |value| is an integer |
| 85 |
// scalar of a narrower type than |bit_width| bits. |
| 86 |
Instruction* WidenInteger(bool sign_extend, uint32_t bit_width, |
| 87 |
Instruction* value, Instruction* before_inst); |
| 88 |
|
| 89 |
// Returns a new instruction that invokes the UMin GLSL.std.450 extended |
| 90 |
// instruction with the two given operands. That is, the result of the |
| 91 |
// instruction is: |
| 92 |
// - |x| if |x| is unsigned-less than |y| |
| 93 |
// - |y| otherwise |
| 94 |
// We assume that |x| and |y| are scalar integer types with the same |
| 95 |
// width. The instruction is inserted before |where|. |
| 96 |
opt::Instruction* MakeUMinInst(const analysis::TypeManager& tm, |
| 97 |
Instruction* x, Instruction* y, |
| 98 |
Instruction* where); |
| 99 |
|
| 100 |
// Returns a new instruction that invokes the SClamp GLSL.std.450 extended |
| 101 |
// instruction with the three given operands. That is, the result of the |
| 102 |
// instruction is: |
| 103 |
// - |min| if |x| is signed-less than |min| |
| 104 |
// - |max| if |x| is signed-more than |max| |
| 105 |
// - |x| otherwise. |
| 106 |
// We assume that |min| is signed-less-or-equal to |max|, and that the |
| 107 |
// operands all have the same scalar integer type. The instruction is |
| 108 |
// inserted before |where|. |
| 109 |
opt::Instruction* MakeSClampInst(const analysis::TypeManager& tm, |
| 110 |
Instruction* x, Instruction* min, |
| 111 |
Instruction* max, Instruction* where); |
| 112 |
|
| 113 |
// Returns a new instruction which evaluates to the length the runtime array |
| 114 |
// referenced by the access chain at the specfied index. The instruction is |
| 115 |
// inserted before the access chain instruction. Returns a null pointer in |
| 116 |
// some cases if assumptions are violated (rather than asserting out). |
| 117 |
opt::Instruction* MakeRuntimeArrayLengthInst(Instruction* access_chain, |
| 118 |
uint32_t operand_index); |
| 119 |
|
| 120 |
// Clamps the coordinate for an OpImageTexelPointer so it stays within |
| 121 |
// the bounds of the size of the image. Updates analyses and records that |
| 122 |
// the module is modified. Returns a status code to indicate success |
| 123 |
// or failure. If assumptions are not met, returns an error status code |
| 124 |
// and emits a diagnostic. |
| 125 |
spv_result_t ClampCoordinateForImageTexelPointer( |
| 126 |
opt::Instruction* image_texel_pointer); |
| 127 |
|
| 128 |
// Gets the instruction that defines the given id. |
| 129 |
opt::Instruction* GetDef(uint32_t id) { |
| 130 |
return context()->get_def_use_mgr()->GetDef(id); |
| 131 |
} |
| 132 |
|
| 133 |
// Returns a new instruction inserted before |where_inst|, and created from |
| 134 |
// the remaining arguments. Registers the definitions and uses of the new |
| 135 |
// instruction and also records its block. |
| 136 |
opt::Instruction* InsertInst(opt::Instruction* where_inst, SpvOp opcode, |
| 137 |
uint32_t type_id, uint32_t result_id, |
| 138 |
const Instruction::OperandList& operands); |
| 139 |
|
| 140 |
// State required for the current module. |
| 141 |
struct PerModuleState { |
| 142 |
// This pass modified the module. |
| 143 |
bool modified = false; |
| 144 |
// True if there is an error processing the current module, e.g. if |
| 145 |
// preconditions are not met. |
| 146 |
bool failed = false; |
| 147 |
// The id of the GLSL.std.450 extended instruction set. Zero if it does |
| 148 |
// not exist. |
| 149 |
uint32_t glsl_insts_id = 0; |
| 150 |
} module_status_; |
| 151 |
}; |
| 152 |
|
| 153 |
} // namespace opt |
| 154 |
} // namespace spvtools |
| 155 |
|
| 156 |
#endif // SOURCE_OPT_GRAPHICS_ROBUST_ACCESS_PASS_H_ |