mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-10-19 03:20:14 +00:00
bb7802b18c
This is the first step in replacing the std::vector of Instruction pointers to using and intrusive linked list. To this end, we created the InstructionList class. It inherites from the IntrusiveList class, but add the extra concept of ownership. An InstructionList owns the instruction that are in it. This is to be consistent with the current ownership rules where the vector owns the instruction that are in it. The other larger change is that the inst_ member of the BasicBlock class was changed to using the InstructionList class. Added test for the InsertBefore functions, and making sure that the InstructionList destructor will delete the elements that it contains. I've also add extra comments to explain ownership a little better.
115 lines
3.9 KiB
C++
115 lines
3.9 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.
|
|
|
|
#include "instruction.h"
|
|
|
|
#include <initializer_list>
|
|
|
|
#include "reflect.h"
|
|
|
|
namespace spvtools {
|
|
namespace ir {
|
|
|
|
Instruction::Instruction(const spv_parsed_instruction_t& inst,
|
|
std::vector<Instruction>&& dbg_line)
|
|
: opcode_(static_cast<SpvOp>(inst.opcode)),
|
|
type_id_(inst.type_id),
|
|
result_id_(inst.result_id),
|
|
dbg_line_insts_(std::move(dbg_line)) {
|
|
assert((!IsDebugLineInst(opcode_) || dbg_line.empty()) &&
|
|
"Op(No)Line attaching to Op(No)Line found");
|
|
for (uint32_t i = 0; i < inst.num_operands; ++i) {
|
|
const auto& current_payload = inst.operands[i];
|
|
std::vector<uint32_t> words(
|
|
inst.words + current_payload.offset,
|
|
inst.words + current_payload.offset + current_payload.num_words);
|
|
operands_.emplace_back(current_payload.type, std::move(words));
|
|
}
|
|
}
|
|
|
|
Instruction::Instruction(SpvOp op, uint32_t ty_id, uint32_t res_id,
|
|
const std::vector<Operand>& in_operands)
|
|
: utils::IntrusiveNodeBase<Instruction>(),
|
|
opcode_(op),
|
|
type_id_(ty_id),
|
|
result_id_(res_id),
|
|
operands_() {
|
|
if (type_id_ != 0) {
|
|
operands_.emplace_back(spv_operand_type_t::SPV_OPERAND_TYPE_TYPE_ID,
|
|
std::initializer_list<uint32_t>{type_id_});
|
|
}
|
|
if (result_id_ != 0) {
|
|
operands_.emplace_back(spv_operand_type_t::SPV_OPERAND_TYPE_RESULT_ID,
|
|
std::initializer_list<uint32_t>{result_id_});
|
|
}
|
|
operands_.insert(operands_.end(), in_operands.begin(), in_operands.end());
|
|
}
|
|
|
|
Instruction::Instruction(Instruction&& that)
|
|
: utils::IntrusiveNodeBase<Instruction>(),
|
|
opcode_(that.opcode_),
|
|
type_id_(that.type_id_),
|
|
result_id_(that.result_id_),
|
|
operands_(std::move(that.operands_)),
|
|
dbg_line_insts_(std::move(that.dbg_line_insts_)) {}
|
|
|
|
Instruction& Instruction::operator=(Instruction&& that) {
|
|
opcode_ = that.opcode_;
|
|
type_id_ = that.type_id_;
|
|
result_id_ = that.result_id_;
|
|
operands_ = std::move(that.operands_);
|
|
dbg_line_insts_ = std::move(that.dbg_line_insts_);
|
|
return *this;
|
|
}
|
|
|
|
Instruction* Instruction::Clone() const {
|
|
Instruction* clone = new Instruction();
|
|
clone->opcode_ = opcode_;
|
|
clone->type_id_ = type_id_;
|
|
clone->result_id_ = result_id_;
|
|
clone->operands_ = operands_;
|
|
clone->dbg_line_insts_ = dbg_line_insts_;
|
|
return clone;
|
|
}
|
|
|
|
uint32_t Instruction::GetSingleWordOperand(uint32_t index) const {
|
|
const auto& words = GetOperand(index).words;
|
|
assert(words.size() == 1 && "expected the operand only taking one word");
|
|
return words.front();
|
|
}
|
|
|
|
uint32_t Instruction::NumInOperandWords() const {
|
|
uint32_t size = 0;
|
|
for (uint32_t i = TypeResultIdCount(); i < operands_.size(); ++i)
|
|
size += static_cast<uint32_t>(operands_[i].words.size());
|
|
return size;
|
|
}
|
|
|
|
void Instruction::ToBinaryWithoutAttachedDebugInsts(
|
|
std::vector<uint32_t>* binary) const {
|
|
const uint32_t num_words = 1 + NumOperandWords();
|
|
binary->push_back((num_words << 16) | static_cast<uint16_t>(opcode_));
|
|
for (const auto& operand : operands_)
|
|
binary->insert(binary->end(), operand.words.begin(), operand.words.end());
|
|
}
|
|
|
|
void Instruction::ReplaceOperands(const std::vector<Operand>& new_operands) {
|
|
operands_.clear();
|
|
operands_.insert(operands_.begin(), new_operands.begin(), new_operands.end());
|
|
operands_.shrink_to_fit();
|
|
}
|
|
|
|
} // namespace ir
|
|
} // namespace spvtools
|