SPIRV-Tools/source/opt/instruction.h
Nathan Gauër 1a7f71afb4
clean: constexpr-ify and unify anon namespace use (#4991)
Constexpr guaranteed no runtime init in addition to const semantics.
Moving all opt/ to constexpr.
Moving all compile-unit statics to anonymous namespaces to uniformize
the method used (anonymous namespace vs static has the same behavior
here AFAIK).

Signed-off-by: Nathan Gauër <brioche@google.com>
2022-11-17 19:02:50 +01:00

915 lines
34 KiB
C++

// Copyright (c) 2016 Google Inc.
//
// 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_INSTRUCTION_H_
#define SOURCE_OPT_INSTRUCTION_H_
#include <cassert>
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "NonSemanticShaderDebugInfo100.h"
#include "OpenCLDebugInfo100.h"
#include "source/binary.h"
#include "source/common_debug_info.h"
#include "source/latest_version_glsl_std_450_header.h"
#include "source/latest_version_spirv_header.h"
#include "source/opcode.h"
#include "source/operand.h"
#include "source/opt/reflect.h"
#include "source/util/ilist_node.h"
#include "source/util/small_vector.h"
#include "source/util/string_utils.h"
#include "spirv-tools/libspirv.h"
constexpr uint32_t kNoDebugScope = 0;
constexpr uint32_t kNoInlinedAt = 0;
namespace spvtools {
namespace opt {
class Function;
class IRContext;
class Module;
class InstructionList;
// Relaxed logical addressing:
//
// In the logical addressing model, pointers cannot be stored or loaded. This
// is a useful assumption because it simplifies the aliasing significantly.
// However, for the purpose of legalizing code generated from HLSL, we will have
// to allow storing and loading of pointers to opaque objects and runtime
// arrays. This relaxation of the rule still implies that function and private
// scope variables do not have any aliasing, so we can treat them as before.
// This will be call the relaxed logical addressing model.
//
// This relaxation of the rule will be allowed by |GetBaseAddress|, but it will
// enforce that no other pointers are stored or loaded.
// About operand:
//
// In the SPIR-V specification, the term "operand" is used to mean any single
// SPIR-V word following the leading wordcount-opcode word. Here, the term
// "operand" is used to mean a *logical* operand. A logical operand may consist
// of multiple SPIR-V words, which together make up the same component. For
// example, a logical operand of a 64-bit integer needs two words to express.
//
// Further, we categorize logical operands into *in* and *out* operands.
// In operands are operands actually serve as input to operations, while out
// operands are operands that represent ids generated from operations (result
// type id or result id). For example, for "OpIAdd %rtype %rid %inop1 %inop2",
// "%inop1" and "%inop2" are in operands, while "%rtype" and "%rid" are out
// operands.
// A *logical* operand to a SPIR-V instruction. It can be the type id, result
// id, or other additional operands carried in an instruction.
struct Operand {
using OperandData = utils::SmallVector<uint32_t, 2>;
Operand(spv_operand_type_t t, OperandData&& w)
: type(t), words(std::move(w)) {}
Operand(spv_operand_type_t t, const OperandData& w) : type(t), words(w) {}
template <class InputIt>
Operand(spv_operand_type_t t, InputIt firstOperandData,
InputIt lastOperandData)
: type(t), words(firstOperandData, lastOperandData) {}
spv_operand_type_t type; // Type of this logical operand.
OperandData words; // Binary segments of this logical operand.
uint32_t AsId() const {
assert(spvIsIdType(type));
assert(words.size() == 1);
return words[0];
}
// Returns a string operand as a std::string.
std::string AsString() const {
assert(type == SPV_OPERAND_TYPE_LITERAL_STRING);
return spvtools::utils::MakeString(words);
}
// Returns a literal integer operand as a uint64_t
uint64_t AsLiteralUint64() const {
assert(type == SPV_OPERAND_TYPE_LITERAL_INTEGER ||
type == SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER ||
type == SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER ||
type == SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER);
assert(1 <= words.size());
assert(words.size() <= 2);
uint64_t result = 0;
if (words.size() > 0) { // Needed to avoid maybe-uninitialized GCC warning
uint32_t low = words[0];
result = uint64_t(low);
}
if (words.size() > 1) {
uint32_t high = words[1];
result = result | (uint64_t(high) << 32);
}
return result;
}
friend bool operator==(const Operand& o1, const Operand& o2) {
return o1.type == o2.type && o1.words == o2.words;
}
// TODO(antiagainst): create fields for literal number kind, width, etc.
};
inline bool operator!=(const Operand& o1, const Operand& o2) {
return !(o1 == o2);
}
// This structure is used to represent a DebugScope instruction from
// the OpenCL.100.DebugInfo extended instruction set. Note that we can
// ignore the result id of DebugScope instruction because it is not
// used for anything. We do not keep it to reduce the size of
// structure.
// TODO: Let validator check that the result id is not used anywhere.
class DebugScope {
public:
DebugScope(uint32_t lexical_scope, uint32_t inlined_at)
: lexical_scope_(lexical_scope), inlined_at_(inlined_at) {}
inline bool operator!=(const DebugScope& d) const {
return lexical_scope_ != d.lexical_scope_ || inlined_at_ != d.inlined_at_;
}
// Accessor functions for |lexical_scope_|.
uint32_t GetLexicalScope() const { return lexical_scope_; }
void SetLexicalScope(uint32_t scope) { lexical_scope_ = scope; }
// Accessor functions for |inlined_at_|.
uint32_t GetInlinedAt() const { return inlined_at_; }
void SetInlinedAt(uint32_t at) { inlined_at_ = at; }
// Pushes the binary segments for this DebugScope instruction into
// the back of *|binary|.
void ToBinary(uint32_t type_id, uint32_t result_id, uint32_t ext_set,
std::vector<uint32_t>* binary) const;
private:
// The result id of the lexical scope in which this debug scope is
// contained. The value is kNoDebugScope if there is no scope.
uint32_t lexical_scope_;
// The result id of DebugInlinedAt if instruction in this debug scope
// is inlined. The value is kNoInlinedAt if it is not inlined.
uint32_t inlined_at_;
};
// A SPIR-V instruction. It contains the opcode and any additional logical
// operand, including the result id (if any) and result type id (if any). It
// may also contain line-related debug instruction (OpLine, OpNoLine) directly
// appearing before this instruction. Note that the result id of an instruction
// should never change after the instruction being built. If the result id
// needs to change, the user should create a new instruction instead.
class Instruction : public utils::IntrusiveNodeBase<Instruction> {
public:
using OperandList = std::vector<Operand>;
using iterator = OperandList::iterator;
using const_iterator = OperandList::const_iterator;
// Creates a default OpNop instruction.
// This exists solely for containers that can't do without. Should be removed.
Instruction()
: utils::IntrusiveNodeBase<Instruction>(),
context_(nullptr),
opcode_(spv::Op::OpNop),
has_type_id_(false),
has_result_id_(false),
unique_id_(0),
dbg_scope_(kNoDebugScope, kNoInlinedAt) {}
// Creates a default OpNop instruction.
Instruction(IRContext*);
// Creates an instruction with the given opcode |op| and no additional logical
// operands.
Instruction(IRContext*, spv::Op);
// Creates an instruction using the given spv_parsed_instruction_t |inst|. All
// the data inside |inst| will be copied and owned in this instance. And keep
// record of line-related debug instructions |dbg_line| ahead of this
// instruction, if any.
Instruction(IRContext* c, const spv_parsed_instruction_t& inst,
std::vector<Instruction>&& dbg_line = {});
Instruction(IRContext* c, const spv_parsed_instruction_t& inst,
const DebugScope& dbg_scope);
// Creates an instruction with the given opcode |op|, type id: |ty_id|,
// result id: |res_id| and input operands: |in_operands|.
Instruction(IRContext* c, spv::Op op, uint32_t ty_id, uint32_t res_id,
const OperandList& in_operands);
// TODO: I will want to remove these, but will first have to remove the use of
// std::vector<Instruction>.
Instruction(const Instruction&) = default;
Instruction& operator=(const Instruction&) = default;
Instruction(Instruction&&);
Instruction& operator=(Instruction&&);
~Instruction() override = default;
// Returns a newly allocated instruction that has the same operands, result,
// and type as |this|. The new instruction is not linked into any list.
// It is the responsibility of the caller to make sure that the storage is
// removed. It is the caller's responsibility to make sure that there is only
// one instruction for each result id.
Instruction* Clone(IRContext* c) const;
IRContext* context() const { return context_; }
spv::Op opcode() const { return opcode_; }
// Sets the opcode of this instruction to a specific opcode. Note this may
// invalidate the instruction.
// TODO(qining): Remove this function when instruction building and insertion
// is well implemented.
void SetOpcode(spv::Op op) { opcode_ = op; }
uint32_t type_id() const {
return has_type_id_ ? GetSingleWordOperand(0) : 0;
}
uint32_t result_id() const {
return has_result_id_ ? GetSingleWordOperand(has_type_id_ ? 1 : 0) : 0;
}
uint32_t unique_id() const {
assert(unique_id_ != 0);
return unique_id_;
}
// Returns the vector of line-related debug instructions attached to this
// instruction and the caller can directly modify them.
std::vector<Instruction>& dbg_line_insts() { return dbg_line_insts_; }
const std::vector<Instruction>& dbg_line_insts() const {
return dbg_line_insts_;
}
const Instruction* dbg_line_inst() const {
return dbg_line_insts_.empty() ? nullptr : &dbg_line_insts_[0];
}
// Clear line-related debug instructions attached to this instruction.
void clear_dbg_line_insts() { dbg_line_insts_.clear(); }
// Same semantics as in the base class except the list the InstructionList
// containing |pos| will now assume ownership of |this|.
// inline void MoveBefore(Instruction* pos);
// inline void InsertAfter(Instruction* pos);
// Begin and end iterators for operands.
iterator begin() { return operands_.begin(); }
iterator end() { return operands_.end(); }
const_iterator begin() const { return operands_.cbegin(); }
const_iterator end() const { return operands_.cend(); }
// Const begin and end iterators for operands.
const_iterator cbegin() const { return operands_.cbegin(); }
const_iterator cend() const { return operands_.cend(); }
// Gets the number of logical operands.
uint32_t NumOperands() const {
return static_cast<uint32_t>(operands_.size());
}
// Gets the number of SPIR-V words occupied by all logical operands.
uint32_t NumOperandWords() const {
return NumInOperandWords() + TypeResultIdCount();
}
// Gets the |index|-th logical operand.
inline Operand& GetOperand(uint32_t index);
inline const Operand& GetOperand(uint32_t index) const;
// Adds |operand| to the list of operands of this instruction.
// It is the responsibility of the caller to make sure
// that the instruction remains valid.
inline void AddOperand(Operand&& operand);
// Gets the |index|-th logical operand as a single SPIR-V word. This method is
// not expected to be used with logical operands consisting of multiple SPIR-V
// words.
uint32_t GetSingleWordOperand(uint32_t index) const;
// Sets the |index|-th in-operand's data to the given |data|.
inline void SetInOperand(uint32_t index, Operand::OperandData&& data);
// Sets the |index|-th operand's data to the given |data|.
// This is for in-operands modification only, but with |index| expressed in
// terms of operand index rather than in-operand index.
inline void SetOperand(uint32_t index, Operand::OperandData&& data);
// Replace all of the in operands with those in |new_operands|.
inline void SetInOperands(OperandList&& new_operands);
// Sets the result type id.
inline void SetResultType(uint32_t ty_id);
inline bool HasResultType() const { return has_type_id_; }
// Sets the result id
inline void SetResultId(uint32_t res_id);
inline bool HasResultId() const { return has_result_id_; }
// Sets DebugScope.
inline void SetDebugScope(const DebugScope& scope);
inline const DebugScope& GetDebugScope() const { return dbg_scope_; }
// Add debug line inst. Renew result id if Debug[No]Line
void AddDebugLine(const Instruction* inst);
// Updates DebugInlinedAt of DebugScope and OpLine.
void UpdateDebugInlinedAt(uint32_t new_inlined_at);
// Clear line-related debug instructions attached to this instruction
// along with def-use entries.
void ClearDbgLineInsts();
// Return true if Shader100:Debug[No]Line
bool IsDebugLineInst() const;
// Return true if Op[No]Line or Shader100:Debug[No]Line
bool IsLineInst() const;
// Return true if OpLine or Shader100:DebugLine
bool IsLine() const;
// Return true if OpNoLine or Shader100:DebugNoLine
bool IsNoLine() const;
inline uint32_t GetDebugInlinedAt() const {
return dbg_scope_.GetInlinedAt();
}
// Updates lexical scope of DebugScope and OpLine.
void UpdateLexicalScope(uint32_t scope);
// Updates OpLine and DebugScope based on the information of |from|.
void UpdateDebugInfoFrom(const Instruction* from);
// Remove the |index|-th operand
void RemoveOperand(uint32_t index) {
operands_.erase(operands_.begin() + index);
}
// Insert an operand before the |index|-th operand
void InsertOperand(uint32_t index, Operand&& operand) {
operands_.insert(operands_.begin() + index, operand);
}
// The following methods are similar to the above, but are for in operands.
uint32_t NumInOperands() const {
return static_cast<uint32_t>(operands_.size() - TypeResultIdCount());
}
uint32_t NumInOperandWords() const;
Operand& GetInOperand(uint32_t index) {
return GetOperand(index + TypeResultIdCount());
}
const Operand& GetInOperand(uint32_t index) const {
return GetOperand(index + TypeResultIdCount());
}
uint32_t GetSingleWordInOperand(uint32_t index) const {
return GetSingleWordOperand(index + TypeResultIdCount());
}
void RemoveInOperand(uint32_t index) {
operands_.erase(operands_.begin() + index + TypeResultIdCount());
}
// Returns true if this instruction is OpNop.
inline bool IsNop() const;
// Turns this instruction to OpNop. This does not clear out all preceding
// line-related debug instructions.
inline void ToNop();
// Runs the given function |f| on this instruction and optionally on the
// preceding debug line instructions. The function will always be run
// if this is itself a debug line instruction.
inline void ForEachInst(const std::function<void(Instruction*)>& f,
bool run_on_debug_line_insts = false);
inline void ForEachInst(const std::function<void(const Instruction*)>& f,
bool run_on_debug_line_insts = false) const;
// Runs the given function |f| on this instruction and optionally on the
// preceding debug line instructions. The function will always be run
// if this is itself a debug line instruction. If |f| returns false,
// iteration is terminated and this function returns false.
inline bool WhileEachInst(const std::function<bool(Instruction*)>& f,
bool run_on_debug_line_insts = false);
inline bool WhileEachInst(const std::function<bool(const Instruction*)>& f,
bool run_on_debug_line_insts = false) const;
// Runs the given function |f| on all operand ids.
//
// |f| should not transform an ID into 0, as 0 is an invalid ID.
inline void ForEachId(const std::function<void(uint32_t*)>& f);
inline void ForEachId(const std::function<void(const uint32_t*)>& f) const;
// Runs the given function |f| on all "in" operand ids.
inline void ForEachInId(const std::function<void(uint32_t*)>& f);
inline void ForEachInId(const std::function<void(const uint32_t*)>& f) const;
// Runs the given function |f| on all "in" operand ids. If |f| returns false,
// iteration is terminated and this function returns false.
inline bool WhileEachInId(const std::function<bool(uint32_t*)>& f);
inline bool WhileEachInId(
const std::function<bool(const uint32_t*)>& f) const;
// Runs the given function |f| on all "in" operands.
inline void ForEachInOperand(const std::function<void(uint32_t*)>& f);
inline void ForEachInOperand(
const std::function<void(const uint32_t*)>& f) const;
// Runs the given function |f| on all "in" operands. If |f| returns false,
// iteration is terminated and this function return false.
inline bool WhileEachInOperand(const std::function<bool(uint32_t*)>& f);
inline bool WhileEachInOperand(
const std::function<bool(const uint32_t*)>& f) const;
// Returns true if it's an OpBranchConditional instruction
// with branch weights.
bool HasBranchWeights() const;
// Returns true if any operands can be labels
inline bool HasLabels() const;
// Pushes the binary segments for this instruction into the back of *|binary|.
void ToBinaryWithoutAttachedDebugInsts(std::vector<uint32_t>* binary) const;
// Replaces the operands to the instruction with |new_operands|. The caller
// is responsible for building a complete and valid list of operands for
// this instruction.
void ReplaceOperands(const OperandList& new_operands);
// Returns true if the instruction annotates an id with a decoration.
inline bool IsDecoration() const;
// Returns true if the instruction is known to be a load from read-only
// memory.
bool IsReadOnlyLoad() const;
// Returns the instruction that gives the base address of an address
// calculation. The instruction must be a load, as defined by |IsLoad|,
// store, copy, or access chain instruction. In logical addressing mode, will
// return an OpVariable or OpFunctionParameter instruction. For relaxed
// logical addressing, it would also return a load of a pointer to an opaque
// object. For physical addressing mode, could return other types of
// instructions.
Instruction* GetBaseAddress() const;
// Returns true if the instruction loads from memory or samples an image, and
// stores the result into an id. It considers only core instructions.
// Memory-to-memory instructions are not considered loads.
inline bool IsLoad() const;
// Returns true if the instruction generates a pointer that is definitely
// read-only. This is determined by analysing the pointer type's storage
// class and decorations that target the pointer's id. It does not analyse
// other instructions that the pointer may be derived from. Thus if 'true' is
// returned, the pointer is definitely read-only, while if 'false' is returned
// it is possible that the pointer may actually be read-only if it is derived
// from another pointer that is decorated as read-only.
bool IsReadOnlyPointer() const;
// The following functions check for the various descriptor types defined in
// the Vulkan specification section 13.1.
// Returns true if the instruction defines a pointer type that points to a
// storage image.
bool IsVulkanStorageImage() const;
// Returns true if the instruction defines a pointer type that points to a
// sampled image.
bool IsVulkanSampledImage() const;
// Returns true if the instruction defines a pointer type that points to a
// storage texel buffer.
bool IsVulkanStorageTexelBuffer() const;
// Returns true if the instruction defines a pointer type that points to a
// storage buffer.
bool IsVulkanStorageBuffer() const;
// Returns true if the instruction defines a variable in StorageBuffer or
// Uniform storage class with a pointer type that points to a storage buffer.
bool IsVulkanStorageBufferVariable() const;
// Returns true if the instruction defines a pointer type that points to a
// uniform buffer.
bool IsVulkanUniformBuffer() const;
// Returns true if the instruction is an atom operation that uses original
// value.
inline bool IsAtomicWithLoad() const;
// Returns true if the instruction is an atom operation.
inline bool IsAtomicOp() const;
// Returns true if this instruction is a branch or switch instruction (either
// conditional or not).
bool IsBranch() const { return spvOpcodeIsBranch(opcode()); }
// Returns true if this instruction causes the function to finish execution
// and return to its caller
bool IsReturn() const { return spvOpcodeIsReturn(opcode()); }
// Returns true if this instruction exits this function or aborts execution.
bool IsReturnOrAbort() const { return spvOpcodeIsReturnOrAbort(opcode()); }
// Returns true if this instruction is a basic block terminator.
bool IsBlockTerminator() const {
return spvOpcodeIsBlockTerminator(opcode());
}
// Returns true if |this| is an instruction that define an opaque type. Since
// runtime array have similar characteristics they are included as opaque
// types.
bool IsOpaqueType() const;
// Returns true if |this| is an instruction which could be folded into a
// constant value.
bool IsFoldable() const;
// Returns true if |this| is an instruction which could be folded into a
// constant value by |FoldScalar|.
bool IsFoldableByFoldScalar() const;
// Returns true if we are allowed to fold or otherwise manipulate the
// instruction that defines |id| in the given context. This includes not
// handling NaN values.
bool IsFloatingPointFoldingAllowed() const;
inline bool operator==(const Instruction&) const;
inline bool operator!=(const Instruction&) const;
inline bool operator<(const Instruction&) const;
// Takes ownership of the instruction owned by |i| and inserts it immediately
// before |this|. Returns the inserted instruction.
Instruction* InsertBefore(std::unique_ptr<Instruction>&& i);
// Takes ownership of the instructions in |list| and inserts them in order
// immediately before |this|. Returns the first inserted instruction.
// Assumes the list is non-empty.
Instruction* InsertBefore(std::vector<std::unique_ptr<Instruction>>&& list);
using utils::IntrusiveNodeBase<Instruction>::InsertBefore;
// Returns true if |this| is an instruction defining a constant, but not a
// Spec constant.
inline bool IsConstant() const;
// Returns true if |this| is an instruction with an opcode safe to move
bool IsOpcodeCodeMotionSafe() const;
// Pretty-prints |inst|.
//
// Provides the disassembly of a specific instruction. Utilizes |inst|'s
// context to provide the correct interpretation of types, constants, etc.
//
// |options| are the disassembly options. SPV_BINARY_TO_TEXT_OPTION_NO_HEADER
// is always added to |options|.
std::string PrettyPrint(uint32_t options = 0u) const;
// Returns true if the result can be a vector and the result of each component
// depends on the corresponding component of any vector inputs.
bool IsScalarizable() const;
// Return true if the only effect of this instructions is the result.
bool IsOpcodeSafeToDelete() const;
// Returns true if it is valid to use the result of |inst| as the base
// pointer for a load or store. In this case, valid is defined by the relaxed
// logical addressing rules when using logical addressing. Normal validation
// rules for physical addressing.
bool IsValidBasePointer() const;
// Returns debug opcode of an OpenCL.100.DebugInfo instruction. If
// it is not an OpenCL.100.DebugInfo instruction, just returns
// OpenCLDebugInfo100InstructionsMax.
OpenCLDebugInfo100Instructions GetOpenCL100DebugOpcode() const;
// Returns debug opcode of an NonSemantic.Shader.DebugInfo.100 instruction. If
// it is not an NonSemantic.Shader.DebugInfo.100 instruction, just return
// NonSemanticShaderDebugInfo100InstructionsMax.
NonSemanticShaderDebugInfo100Instructions GetShader100DebugOpcode() const;
// Returns debug opcode of an OpenCL.100.DebugInfo or
// NonSemantic.Shader.DebugInfo.100 instruction. Since these overlap, we
// return the OpenCLDebugInfo code
CommonDebugInfoInstructions GetCommonDebugOpcode() const;
// Returns true if it is an OpenCL.DebugInfo.100 instruction.
bool IsOpenCL100DebugInstr() const {
return GetOpenCL100DebugOpcode() != OpenCLDebugInfo100InstructionsMax;
}
// Returns true if it is an NonSemantic.Shader.DebugInfo.100 instruction.
bool IsShader100DebugInstr() const {
return GetShader100DebugOpcode() !=
NonSemanticShaderDebugInfo100InstructionsMax;
}
bool IsCommonDebugInstr() const {
return GetCommonDebugOpcode() != CommonDebugInfoInstructionsMax;
}
// Returns true if this instructions a non-semantic instruction.
bool IsNonSemanticInstruction() const;
// Dump this instruction on stderr. Useful when running interactive
// debuggers.
void Dump() const;
private:
// Returns the total count of result type id and result id.
uint32_t TypeResultIdCount() const {
if (has_type_id_ && has_result_id_) return 2;
if (has_type_id_ || has_result_id_) return 1;
return 0;
}
// Returns true if the instruction generates a read-only pointer, with the
// same caveats documented in the comment for IsReadOnlyPointer. The first
// version assumes the module is a shader module. The second assumes a
// kernel.
bool IsReadOnlyPointerShaders() const;
bool IsReadOnlyPointerKernel() const;
// Returns true if the result of |inst| can be used as the base image for an
// instruction that samples a image, reads an image, or writes to an image.
bool IsValidBaseImage() const;
IRContext* context_; // IR Context
spv::Op opcode_; // Opcode
bool has_type_id_; // True if the instruction has a type id
bool has_result_id_; // True if the instruction has a result id
uint32_t unique_id_; // Unique instruction id
// All logical operands, including result type id and result id.
OperandList operands_;
// Op[No]Line or Debug[No]Line instructions preceding this instruction. Note
// that for Instructions representing Op[No]Line or Debug[No]Line themselves,
// this field should be empty.
std::vector<Instruction> dbg_line_insts_;
// DebugScope that wraps this instruction.
DebugScope dbg_scope_;
friend InstructionList;
};
// Pretty-prints |inst| to |str| and returns |str|.
//
// Provides the disassembly of a specific instruction. Utilizes |inst|'s context
// to provide the correct interpretation of types, constants, etc.
//
// Disassembly uses raw ids (not pretty printed names).
std::ostream& operator<<(std::ostream& str, const Instruction& inst);
inline bool Instruction::operator==(const Instruction& other) const {
return unique_id() == other.unique_id();
}
inline bool Instruction::operator!=(const Instruction& other) const {
return !(*this == other);
}
inline bool Instruction::operator<(const Instruction& other) const {
return unique_id() < other.unique_id();
}
inline Operand& Instruction::GetOperand(uint32_t index) {
assert(index < operands_.size() && "operand index out of bound");
return operands_[index];
}
inline const Operand& Instruction::GetOperand(uint32_t index) const {
assert(index < operands_.size() && "operand index out of bound");
return operands_[index];
}
inline void Instruction::AddOperand(Operand&& operand) {
operands_.push_back(std::move(operand));
}
inline void Instruction::SetInOperand(uint32_t index,
Operand::OperandData&& data) {
SetOperand(index + TypeResultIdCount(), std::move(data));
}
inline void Instruction::SetOperand(uint32_t index,
Operand::OperandData&& data) {
assert(index < operands_.size() && "operand index out of bound");
assert(index >= TypeResultIdCount() && "operand is not a in-operand");
operands_[index].words = std::move(data);
}
inline void Instruction::SetInOperands(OperandList&& new_operands) {
// Remove the old in operands.
operands_.erase(operands_.begin() + TypeResultIdCount(), operands_.end());
// Add the new in operands.
operands_.insert(operands_.end(), new_operands.begin(), new_operands.end());
}
inline void Instruction::SetResultId(uint32_t res_id) {
// TODO(dsinclair): Allow setting a result id if there wasn't one
// previously. Need to make room in the operands_ array to place the result,
// and update the has_result_id_ flag.
assert(has_result_id_);
// TODO(dsinclair): Allow removing the result id. This needs to make sure,
// if there was a result id previously to remove it from the operands_ array
// and reset the has_result_id_ flag.
assert(res_id != 0);
auto ridx = has_type_id_ ? 1 : 0;
operands_[ridx].words = {res_id};
}
inline void Instruction::SetDebugScope(const DebugScope& scope) {
dbg_scope_ = scope;
for (auto& i : dbg_line_insts_) {
i.dbg_scope_ = scope;
}
}
inline void Instruction::SetResultType(uint32_t ty_id) {
// TODO(dsinclair): Allow setting a type id if there wasn't one
// previously. Need to make room in the operands_ array to place the result,
// and update the has_type_id_ flag.
assert(has_type_id_);
// TODO(dsinclair): Allow removing the type id. This needs to make sure,
// if there was a type id previously to remove it from the operands_ array
// and reset the has_type_id_ flag.
assert(ty_id != 0);
operands_.front().words = {ty_id};
}
inline bool Instruction::IsNop() const {
return opcode_ == spv::Op::OpNop && !has_type_id_ && !has_result_id_ &&
operands_.empty();
}
inline void Instruction::ToNop() {
opcode_ = spv::Op::OpNop;
has_type_id_ = false;
has_result_id_ = false;
operands_.clear();
}
inline bool Instruction::WhileEachInst(
const std::function<bool(Instruction*)>& f, bool run_on_debug_line_insts) {
if (run_on_debug_line_insts) {
for (auto& dbg_line : dbg_line_insts_) {
if (!f(&dbg_line)) return false;
}
}
return f(this);
}
inline bool Instruction::WhileEachInst(
const std::function<bool(const Instruction*)>& f,
bool run_on_debug_line_insts) const {
if (run_on_debug_line_insts) {
for (auto& dbg_line : dbg_line_insts_) {
if (!f(&dbg_line)) return false;
}
}
return f(this);
}
inline void Instruction::ForEachInst(const std::function<void(Instruction*)>& f,
bool run_on_debug_line_insts) {
WhileEachInst(
[&f](Instruction* inst) {
f(inst);
return true;
},
run_on_debug_line_insts);
}
inline void Instruction::ForEachInst(
const std::function<void(const Instruction*)>& f,
bool run_on_debug_line_insts) const {
WhileEachInst(
[&f](const Instruction* inst) {
f(inst);
return true;
},
run_on_debug_line_insts);
}
inline void Instruction::ForEachId(const std::function<void(uint32_t*)>& f) {
for (auto& operand : operands_)
if (spvIsIdType(operand.type)) f(&operand.words[0]);
}
inline void Instruction::ForEachId(
const std::function<void(const uint32_t*)>& f) const {
for (const auto& operand : operands_)
if (spvIsIdType(operand.type)) f(&operand.words[0]);
}
inline bool Instruction::WhileEachInId(
const std::function<bool(uint32_t*)>& f) {
for (auto& operand : operands_) {
if (spvIsInIdType(operand.type) && !f(&operand.words[0])) {
return false;
}
}
return true;
}
inline bool Instruction::WhileEachInId(
const std::function<bool(const uint32_t*)>& f) const {
for (const auto& operand : operands_) {
if (spvIsInIdType(operand.type) && !f(&operand.words[0])) {
return false;
}
}
return true;
}
inline void Instruction::ForEachInId(const std::function<void(uint32_t*)>& f) {
WhileEachInId([&f](uint32_t* id) {
f(id);
return true;
});
}
inline void Instruction::ForEachInId(
const std::function<void(const uint32_t*)>& f) const {
WhileEachInId([&f](const uint32_t* id) {
f(id);
return true;
});
}
inline bool Instruction::WhileEachInOperand(
const std::function<bool(uint32_t*)>& f) {
for (auto& operand : operands_) {
switch (operand.type) {
case SPV_OPERAND_TYPE_RESULT_ID:
case SPV_OPERAND_TYPE_TYPE_ID:
break;
default:
if (!f(&operand.words[0])) return false;
break;
}
}
return true;
}
inline bool Instruction::WhileEachInOperand(
const std::function<bool(const uint32_t*)>& f) const {
for (const auto& operand : operands_) {
switch (operand.type) {
case SPV_OPERAND_TYPE_RESULT_ID:
case SPV_OPERAND_TYPE_TYPE_ID:
break;
default:
if (!f(&operand.words[0])) return false;
break;
}
}
return true;
}
inline void Instruction::ForEachInOperand(
const std::function<void(uint32_t*)>& f) {
WhileEachInOperand([&f](uint32_t* operand) {
f(operand);
return true;
});
}
inline void Instruction::ForEachInOperand(
const std::function<void(const uint32_t*)>& f) const {
WhileEachInOperand([&f](const uint32_t* operand) {
f(operand);
return true;
});
}
inline bool Instruction::HasLabels() const {
switch (opcode_) {
case spv::Op::OpSelectionMerge:
case spv::Op::OpBranch:
case spv::Op::OpLoopMerge:
case spv::Op::OpBranchConditional:
case spv::Op::OpSwitch:
case spv::Op::OpPhi:
return true;
break;
default:
break;
}
return false;
}
bool Instruction::IsDecoration() const {
return spvOpcodeIsDecoration(opcode());
}
bool Instruction::IsLoad() const { return spvOpcodeIsLoad(opcode()); }
bool Instruction::IsAtomicWithLoad() const {
return spvOpcodeIsAtomicWithLoad(opcode());
}
bool Instruction::IsAtomicOp() const { return spvOpcodeIsAtomicOp(opcode()); }
bool Instruction::IsConstant() const {
return IsCompileTimeConstantInst(opcode());
}
} // namespace opt
} // namespace spvtools
#endif // SOURCE_OPT_INSTRUCTION_H_