// Copyright (c) 2019 Google LLC

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#ifndef SOURCE_OPT_GRAPHICS_ROBUST_ACCESS_PASS_H_

#define SOURCE_OPT_GRAPHICS_ROBUST_ACCESS_PASS_H_

#include <map>

#include <unordered_map>

#include "constants.h"

#include "def_use_manager.h"

#include "instruction.h"

#include "module.h"

#include "pass.h"

#include "source/diagnostic.h"

#include "type_manager.h"

namespace spvtools {

namespace opt {

// See optimizer.hpp for documentation.

class GraphicsRobustAccessPass : public Pass {

 public:

  GraphicsRobustAccessPass();

  const char* name() const override { return "graphics-robust-access"; }

  Status Process() override;

  IRContext::Analysis GetPreservedAnalyses() override {

    return IRContext::kAnalysisDefUse |

           IRContext::kAnalysisInstrToBlockMapping |

           IRContext::kAnalysisConstants | IRContext::kAnalysisTypes |

           IRContext::kAnalysisIdToFuncMapping;

  }

 private:

  // Records failure for the current module, and returns a stream

  // that can be used to provide user error information to the message

  // consumer.

  spvtools::DiagnosticStream Fail();

  // Returns SPV_SUCCESS if this pass can correctly process the module,

  // as far as we can tell from capabilities and the memory model.

  // Otherwise logs a message and returns a failure code.

  spv_result_t IsCompatibleModule();

  // Transform the current module, if possible. Failure and modification

  // status is recorded in the |_| member. On failure, error information is

  // posted to the message consumer.  The return value has no significance.

  spv_result_t ProcessCurrentModule();

  // Process the given function.  Updates the state value |_|.  Returns true

  // if the module was modified.  This can log a failure.

  bool ProcessAFunction(opt::Function*);

  // Clamps indices in the OpAccessChain or OpInBoundsAccessChain instruction

  // |access_chain|. Inserts instructions before the given instruction.  Updates

  // analyses and records that the module is modified.  This can log a failure.

  void ClampIndicesForAccessChain(Instruction* access_chain);

  // Returns the id of the instruction importing the "GLSL.std.450" extended

  // instruction set. If it does not yet exist, the import instruction is

  // created and inserted into the module, and updates |_.modified| and

  // |_.glsl_insts_id|.

  uint32_t GetGlslInsts();

  // Returns an instruction which is constant with the given value of the given

  // type. Ignores any value bits beyond the width of the type.

  Instruction* GetValueForType(uint64_t value, const analysis::Integer* type);

  // Converts an integer value to an unsigned wider integer type, using either

  // sign extension or zero extension.  The new instruction is inserted

  // immediately before |before_inst|, and is analyzed for definitions and uses.

  // Returns the newly inserted instruction.  Assumes the |value| is an integer

  // scalar of a narrower type than |bit_width| bits.

  Instruction* WidenInteger(bool sign_extend, uint32_t bit_width,

                            Instruction* value, Instruction* before_inst);

  // Returns a new instruction that invokes the UMin GLSL.std.450 extended

  // instruction with the two given operands.  That is, the result of the

  // instruction is:

  //  - |x| if |x| is unsigned-less than |y|

  //  - |y| otherwise

  // We assume that |x| and |y| are scalar integer types with the same

  // width.  The instruction is inserted before |where|.

  opt::Instruction* MakeUMinInst(const analysis::TypeManager& tm,

                                 Instruction* x, Instruction* y,

                                 Instruction* where);

  // Returns a new instruction that invokes the SClamp GLSL.std.450 extended

  // instruction with the three given operands.  That is, the result of the

  // instruction is:

  //  - |min| if |x| is signed-less than |min|

  //  - |max| if |x| is signed-more than |max|

  //  - |x| otherwise.

  // We assume that |min| is signed-less-or-equal to |max|, and that the

  // operands all have the same scalar integer type.  The instruction is

  // inserted before |where|.

  opt::Instruction* MakeSClampInst(const analysis::TypeManager& tm,

                                   Instruction* x, Instruction* min,

                                   Instruction* max, Instruction* where);

  // Returns a new instruction which evaluates to the length the runtime array

  // referenced by the access chain at the specified index.  The instruction is

  // inserted before the access chain instruction.  Returns a null pointer in

  // some cases if assumptions are violated (rather than asserting out).

  opt::Instruction* MakeRuntimeArrayLengthInst(Instruction* access_chain,

                                               uint32_t operand_index);

  // Clamps the coordinate for an OpImageTexelPointer so it stays within

  // the bounds of the size of the image.  Updates analyses and records that

  // the module is modified.  Returns a status code to indicate success

  // or failure.  If assumptions are not met, returns an error status code

  // and emits a diagnostic.

  spv_result_t ClampCoordinateForImageTexelPointer(

      opt::Instruction* image_texel_pointer);

  // Gets the instruction that defines the given id.

  opt::Instruction* GetDef(uint32_t id) {

    return context()->get_def_use_mgr()->GetDef(id);

  }

  // Returns a new instruction inserted before |where_inst|, and created from

  // the remaining arguments. Registers the definitions and uses of the new

  // instruction and also records its block.

  opt::Instruction* InsertInst(opt::Instruction* where_inst, spv::Op opcode,

                               uint32_t type_id, uint32_t result_id,

                               const Instruction::OperandList& operands);

  // State required for the current module.

  struct PerModuleState {

    // This pass modified the module.

    bool modified = false;

    // True if there is an error processing the current module, e.g. if

    // preconditions are not met.

    bool failed = false;

    // The id of the GLSL.std.450 extended instruction set.  Zero if it does

    // not exist.

    uint32_t glsl_insts_id = 0;

  } module_status_;

};

}  // namespace opt

}  // namespace spvtools

#endif  // SOURCE_OPT_GRAPHICS_ROBUST_ACCESS_PASS_H_