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();
name()36   const char* name() const override { return "graphics-robust-access"; }
37   Status Process() override;
38 
GetPreservedAnalyses()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.
GetDef(uint32_t 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_
157