mirror of
https://gitee.com/openharmony/third_party_spirv-tools
synced 2024-11-27 01:21:25 +00:00
645 lines
24 KiB
C++
645 lines
24 KiB
C++
// Copyright (c) 2017 Pierre Moreau
|
|
//
|
|
// 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 "source/opt/decoration_manager.h"
|
|
|
|
#include <algorithm>
|
|
#include <memory>
|
|
#include <set>
|
|
#include <stack>
|
|
#include <utility>
|
|
|
|
#include "source/opt/ir_context.h"
|
|
|
|
namespace spvtools {
|
|
namespace opt {
|
|
namespace analysis {
|
|
namespace {
|
|
using InstructionVector = std::vector<const spvtools::opt::Instruction*>;
|
|
using DecorationSet = std::set<std::u32string>;
|
|
|
|
// Returns true if |a| is a subet of |b|.
|
|
bool IsSubset(const DecorationSet& a, const DecorationSet& b) {
|
|
auto it1 = a.begin();
|
|
auto it2 = b.begin();
|
|
|
|
while (it1 != a.end()) {
|
|
if (it2 == b.end() || *it1 < *it2) {
|
|
// |*it1| is in |a|, but not in |b|.
|
|
return false;
|
|
}
|
|
if (*it1 == *it2) {
|
|
// Found the element move to the next one.
|
|
it1++;
|
|
it2++;
|
|
} else /* *it1 > *it2 */ {
|
|
// Did not find |*it1| yet, check the next element in |b|.
|
|
it2++;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
} // namespace
|
|
|
|
bool DecorationManager::RemoveDecorationsFrom(
|
|
uint32_t id, std::function<bool(const Instruction&)> pred) {
|
|
bool was_modified = false;
|
|
const auto ids_iter = id_to_decoration_insts_.find(id);
|
|
if (ids_iter == id_to_decoration_insts_.end()) {
|
|
return was_modified;
|
|
}
|
|
|
|
TargetData& decorations_info = ids_iter->second;
|
|
auto context = module_->context();
|
|
std::vector<Instruction*> insts_to_kill;
|
|
const bool is_group = !decorations_info.decorate_insts.empty();
|
|
|
|
// Schedule all direct decorations for removal if instructed as such by
|
|
// |pred|.
|
|
for (Instruction* inst : decorations_info.direct_decorations)
|
|
if (pred(*inst)) insts_to_kill.push_back(inst);
|
|
|
|
// For all groups being directly applied to |id|, remove |id| (and the
|
|
// literal if |inst| is an OpGroupMemberDecorate) from the instruction
|
|
// applying the group.
|
|
std::unordered_set<const Instruction*> indirect_decorations_to_remove;
|
|
for (Instruction* inst : decorations_info.indirect_decorations) {
|
|
assert(inst->opcode() == spv::Op::OpGroupDecorate ||
|
|
inst->opcode() == spv::Op::OpGroupMemberDecorate);
|
|
|
|
std::vector<Instruction*> group_decorations_to_keep;
|
|
const uint32_t group_id = inst->GetSingleWordInOperand(0u);
|
|
const auto group_iter = id_to_decoration_insts_.find(group_id);
|
|
assert(group_iter != id_to_decoration_insts_.end() &&
|
|
"Unknown decoration group");
|
|
const auto& group_decorations = group_iter->second.direct_decorations;
|
|
for (Instruction* decoration : group_decorations) {
|
|
if (!pred(*decoration)) group_decorations_to_keep.push_back(decoration);
|
|
}
|
|
|
|
// If all decorations should be kept, then we can keep |id| part of the
|
|
// group. However, if the group itself has no decorations, we should remove
|
|
// the id from the group. This is needed to make |KillNameAndDecorate| work
|
|
// correctly when a decoration group has no decorations.
|
|
if (group_decorations_to_keep.size() == group_decorations.size() &&
|
|
group_decorations.size() != 0) {
|
|
continue;
|
|
}
|
|
|
|
// Otherwise, remove |id| from the targets of |group_id|
|
|
const uint32_t stride =
|
|
inst->opcode() == spv::Op::OpGroupDecorate ? 1u : 2u;
|
|
for (uint32_t i = 1u; i < inst->NumInOperands();) {
|
|
if (inst->GetSingleWordInOperand(i) != id) {
|
|
i += stride;
|
|
continue;
|
|
}
|
|
|
|
const uint32_t last_operand_index = inst->NumInOperands() - stride;
|
|
if (i < last_operand_index)
|
|
inst->GetInOperand(i) = inst->GetInOperand(last_operand_index);
|
|
// Remove the associated literal, if it exists.
|
|
if (stride == 2u) {
|
|
if (i < last_operand_index)
|
|
inst->GetInOperand(i + 1u) =
|
|
inst->GetInOperand(last_operand_index + 1u);
|
|
inst->RemoveInOperand(last_operand_index + 1u);
|
|
}
|
|
inst->RemoveInOperand(last_operand_index);
|
|
was_modified = true;
|
|
}
|
|
|
|
// If the instruction has no targets left, remove the instruction
|
|
// altogether.
|
|
if (inst->NumInOperands() == 1u) {
|
|
indirect_decorations_to_remove.emplace(inst);
|
|
insts_to_kill.push_back(inst);
|
|
} else if (was_modified) {
|
|
context->ForgetUses(inst);
|
|
indirect_decorations_to_remove.emplace(inst);
|
|
context->AnalyzeUses(inst);
|
|
}
|
|
|
|
// If only some of the decorations should be kept, clone them and apply
|
|
// them directly to |id|.
|
|
if (!group_decorations_to_keep.empty()) {
|
|
for (Instruction* decoration : group_decorations_to_keep) {
|
|
// simply clone decoration and change |group_id| to |id|
|
|
std::unique_ptr<Instruction> new_inst(
|
|
decoration->Clone(module_->context()));
|
|
new_inst->SetInOperand(0, {id});
|
|
module_->AddAnnotationInst(std::move(new_inst));
|
|
auto decoration_iter = --module_->annotation_end();
|
|
context->AnalyzeUses(&*decoration_iter);
|
|
}
|
|
}
|
|
}
|
|
|
|
auto& indirect_decorations = decorations_info.indirect_decorations;
|
|
indirect_decorations.erase(
|
|
std::remove_if(
|
|
indirect_decorations.begin(), indirect_decorations.end(),
|
|
[&indirect_decorations_to_remove](const Instruction* inst) {
|
|
return indirect_decorations_to_remove.count(inst);
|
|
}),
|
|
indirect_decorations.end());
|
|
|
|
was_modified |= !insts_to_kill.empty();
|
|
for (Instruction* inst : insts_to_kill) context->KillInst(inst);
|
|
insts_to_kill.clear();
|
|
|
|
// Schedule all instructions applying the group for removal if this group no
|
|
// longer applies decorations, either directly or indirectly.
|
|
if (is_group && decorations_info.direct_decorations.empty() &&
|
|
decorations_info.indirect_decorations.empty()) {
|
|
for (Instruction* inst : decorations_info.decorate_insts)
|
|
insts_to_kill.push_back(inst);
|
|
}
|
|
was_modified |= !insts_to_kill.empty();
|
|
for (Instruction* inst : insts_to_kill) context->KillInst(inst);
|
|
|
|
if (decorations_info.direct_decorations.empty() &&
|
|
decorations_info.indirect_decorations.empty() &&
|
|
decorations_info.decorate_insts.empty()) {
|
|
id_to_decoration_insts_.erase(ids_iter);
|
|
}
|
|
return was_modified;
|
|
}
|
|
|
|
std::vector<Instruction*> DecorationManager::GetDecorationsFor(
|
|
uint32_t id, bool include_linkage) {
|
|
return InternalGetDecorationsFor<Instruction*>(id, include_linkage);
|
|
}
|
|
|
|
std::vector<const Instruction*> DecorationManager::GetDecorationsFor(
|
|
uint32_t id, bool include_linkage) const {
|
|
return const_cast<DecorationManager*>(this)
|
|
->InternalGetDecorationsFor<const Instruction*>(id, include_linkage);
|
|
}
|
|
|
|
bool DecorationManager::HaveTheSameDecorations(uint32_t id1,
|
|
uint32_t id2) const {
|
|
const InstructionVector decorations_for1 = GetDecorationsFor(id1, false);
|
|
const InstructionVector decorations_for2 = GetDecorationsFor(id2, false);
|
|
|
|
// This function splits the decoration instructions into different sets,
|
|
// based on their opcode; only OpDecorate, OpDecorateId,
|
|
// OpDecorateStringGOOGLE, and OpMemberDecorate are considered, the other
|
|
// opcodes are ignored.
|
|
const auto fillDecorationSets =
|
|
[](const InstructionVector& decoration_list, DecorationSet* decorate_set,
|
|
DecorationSet* decorate_id_set, DecorationSet* decorate_string_set,
|
|
DecorationSet* member_decorate_set) {
|
|
for (const Instruction* inst : decoration_list) {
|
|
std::u32string decoration_payload;
|
|
// Ignore the opcode and the target as we do not want them to be
|
|
// compared.
|
|
for (uint32_t i = 1u; i < inst->NumInOperands(); ++i) {
|
|
for (uint32_t word : inst->GetInOperand(i).words) {
|
|
decoration_payload.push_back(word);
|
|
}
|
|
}
|
|
|
|
switch (inst->opcode()) {
|
|
case spv::Op::OpDecorate:
|
|
decorate_set->emplace(std::move(decoration_payload));
|
|
break;
|
|
case spv::Op::OpMemberDecorate:
|
|
member_decorate_set->emplace(std::move(decoration_payload));
|
|
break;
|
|
case spv::Op::OpDecorateId:
|
|
decorate_id_set->emplace(std::move(decoration_payload));
|
|
break;
|
|
case spv::Op::OpDecorateStringGOOGLE:
|
|
decorate_string_set->emplace(std::move(decoration_payload));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
DecorationSet decorate_set_for1;
|
|
DecorationSet decorate_id_set_for1;
|
|
DecorationSet decorate_string_set_for1;
|
|
DecorationSet member_decorate_set_for1;
|
|
fillDecorationSets(decorations_for1, &decorate_set_for1,
|
|
&decorate_id_set_for1, &decorate_string_set_for1,
|
|
&member_decorate_set_for1);
|
|
|
|
DecorationSet decorate_set_for2;
|
|
DecorationSet decorate_id_set_for2;
|
|
DecorationSet decorate_string_set_for2;
|
|
DecorationSet member_decorate_set_for2;
|
|
fillDecorationSets(decorations_for2, &decorate_set_for2,
|
|
&decorate_id_set_for2, &decorate_string_set_for2,
|
|
&member_decorate_set_for2);
|
|
|
|
const bool result = decorate_set_for1 == decorate_set_for2 &&
|
|
decorate_id_set_for1 == decorate_id_set_for2 &&
|
|
member_decorate_set_for1 == member_decorate_set_for2 &&
|
|
// Compare string sets last in case the strings are long.
|
|
decorate_string_set_for1 == decorate_string_set_for2;
|
|
return result;
|
|
}
|
|
|
|
bool DecorationManager::HaveSubsetOfDecorations(uint32_t id1,
|
|
uint32_t id2) const {
|
|
const InstructionVector decorations_for1 = GetDecorationsFor(id1, false);
|
|
const InstructionVector decorations_for2 = GetDecorationsFor(id2, false);
|
|
|
|
// This function splits the decoration instructions into different sets,
|
|
// based on their opcode; only OpDecorate, OpDecorateId,
|
|
// OpDecorateStringGOOGLE, and OpMemberDecorate are considered, the other
|
|
// opcodes are ignored.
|
|
const auto fillDecorationSets =
|
|
[](const InstructionVector& decoration_list, DecorationSet* decorate_set,
|
|
DecorationSet* decorate_id_set, DecorationSet* decorate_string_set,
|
|
DecorationSet* member_decorate_set) {
|
|
for (const Instruction* inst : decoration_list) {
|
|
std::u32string decoration_payload;
|
|
// Ignore the opcode and the target as we do not want them to be
|
|
// compared.
|
|
for (uint32_t i = 1u; i < inst->NumInOperands(); ++i) {
|
|
for (uint32_t word : inst->GetInOperand(i).words) {
|
|
decoration_payload.push_back(word);
|
|
}
|
|
}
|
|
|
|
switch (inst->opcode()) {
|
|
case spv::Op::OpDecorate:
|
|
decorate_set->emplace(std::move(decoration_payload));
|
|
break;
|
|
case spv::Op::OpMemberDecorate:
|
|
member_decorate_set->emplace(std::move(decoration_payload));
|
|
break;
|
|
case spv::Op::OpDecorateId:
|
|
decorate_id_set->emplace(std::move(decoration_payload));
|
|
break;
|
|
case spv::Op::OpDecorateStringGOOGLE:
|
|
decorate_string_set->emplace(std::move(decoration_payload));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
DecorationSet decorate_set_for1;
|
|
DecorationSet decorate_id_set_for1;
|
|
DecorationSet decorate_string_set_for1;
|
|
DecorationSet member_decorate_set_for1;
|
|
fillDecorationSets(decorations_for1, &decorate_set_for1,
|
|
&decorate_id_set_for1, &decorate_string_set_for1,
|
|
&member_decorate_set_for1);
|
|
|
|
DecorationSet decorate_set_for2;
|
|
DecorationSet decorate_id_set_for2;
|
|
DecorationSet decorate_string_set_for2;
|
|
DecorationSet member_decorate_set_for2;
|
|
fillDecorationSets(decorations_for2, &decorate_set_for2,
|
|
&decorate_id_set_for2, &decorate_string_set_for2,
|
|
&member_decorate_set_for2);
|
|
|
|
const bool result =
|
|
IsSubset(decorate_set_for1, decorate_set_for2) &&
|
|
IsSubset(decorate_id_set_for1, decorate_id_set_for2) &&
|
|
IsSubset(member_decorate_set_for1, member_decorate_set_for2) &&
|
|
// Compare string sets last in case the strings are long.
|
|
IsSubset(decorate_string_set_for1, decorate_string_set_for2);
|
|
return result;
|
|
}
|
|
|
|
// TODO(pierremoreau): If OpDecorateId is referencing an OpConstant, one could
|
|
// check that the constants are the same rather than just
|
|
// looking at the constant ID.
|
|
bool DecorationManager::AreDecorationsTheSame(const Instruction* inst1,
|
|
const Instruction* inst2,
|
|
bool ignore_target) const {
|
|
switch (inst1->opcode()) {
|
|
case spv::Op::OpDecorate:
|
|
case spv::Op::OpMemberDecorate:
|
|
case spv::Op::OpDecorateId:
|
|
case spv::Op::OpDecorateStringGOOGLE:
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
if (inst1->opcode() != inst2->opcode() ||
|
|
inst1->NumInOperands() != inst2->NumInOperands())
|
|
return false;
|
|
|
|
for (uint32_t i = ignore_target ? 1u : 0u; i < inst1->NumInOperands(); ++i)
|
|
if (inst1->GetInOperand(i) != inst2->GetInOperand(i)) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void DecorationManager::AnalyzeDecorations() {
|
|
if (!module_) return;
|
|
|
|
// For each group and instruction, collect all their decoration instructions.
|
|
for (Instruction& inst : module_->annotations()) {
|
|
AddDecoration(&inst);
|
|
}
|
|
}
|
|
|
|
void DecorationManager::AddDecoration(Instruction* inst) {
|
|
switch (inst->opcode()) {
|
|
case spv::Op::OpDecorate:
|
|
case spv::Op::OpDecorateId:
|
|
case spv::Op::OpDecorateStringGOOGLE:
|
|
case spv::Op::OpMemberDecorate: {
|
|
const auto target_id = inst->GetSingleWordInOperand(0u);
|
|
id_to_decoration_insts_[target_id].direct_decorations.push_back(inst);
|
|
break;
|
|
}
|
|
case spv::Op::OpGroupDecorate:
|
|
case spv::Op::OpGroupMemberDecorate: {
|
|
const uint32_t start =
|
|
inst->opcode() == spv::Op::OpGroupDecorate ? 1u : 2u;
|
|
const uint32_t stride = start;
|
|
for (uint32_t i = start; i < inst->NumInOperands(); i += stride) {
|
|
const auto target_id = inst->GetSingleWordInOperand(i);
|
|
TargetData& target_data = id_to_decoration_insts_[target_id];
|
|
target_data.indirect_decorations.push_back(inst);
|
|
}
|
|
const auto target_id = inst->GetSingleWordInOperand(0u);
|
|
id_to_decoration_insts_[target_id].decorate_insts.push_back(inst);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void DecorationManager::AddDecoration(spv::Op opcode,
|
|
std::vector<Operand> opnds) {
|
|
IRContext* ctx = module_->context();
|
|
std::unique_ptr<Instruction> newDecoOp(
|
|
new Instruction(ctx, opcode, 0, 0, opnds));
|
|
ctx->AddAnnotationInst(std::move(newDecoOp));
|
|
}
|
|
|
|
void DecorationManager::AddDecoration(uint32_t inst_id, uint32_t decoration) {
|
|
AddDecoration(
|
|
spv::Op::OpDecorate,
|
|
{{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {inst_id}},
|
|
{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {decoration}}});
|
|
}
|
|
|
|
void DecorationManager::AddDecorationVal(uint32_t inst_id, uint32_t decoration,
|
|
uint32_t decoration_value) {
|
|
AddDecoration(
|
|
spv::Op::OpDecorate,
|
|
{{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {inst_id}},
|
|
{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {decoration}},
|
|
{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER,
|
|
{decoration_value}}});
|
|
}
|
|
|
|
void DecorationManager::AddMemberDecoration(uint32_t inst_id, uint32_t member,
|
|
uint32_t decoration,
|
|
uint32_t decoration_value) {
|
|
AddDecoration(
|
|
spv::Op::OpMemberDecorate,
|
|
{{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {inst_id}},
|
|
{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {member}},
|
|
{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {decoration}},
|
|
{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER,
|
|
{decoration_value}}});
|
|
}
|
|
|
|
template <typename T>
|
|
std::vector<T> DecorationManager::InternalGetDecorationsFor(
|
|
uint32_t id, bool include_linkage) {
|
|
std::vector<T> decorations;
|
|
|
|
const auto ids_iter = id_to_decoration_insts_.find(id);
|
|
// |id| has no decorations
|
|
if (ids_iter == id_to_decoration_insts_.end()) return decorations;
|
|
|
|
const TargetData& target_data = ids_iter->second;
|
|
|
|
const auto process_direct_decorations =
|
|
[include_linkage,
|
|
&decorations](const std::vector<Instruction*>& direct_decorations) {
|
|
for (Instruction* inst : direct_decorations) {
|
|
const bool is_linkage =
|
|
inst->opcode() == spv::Op::OpDecorate &&
|
|
spv::Decoration(inst->GetSingleWordInOperand(1u)) ==
|
|
spv::Decoration::LinkageAttributes;
|
|
if (include_linkage || !is_linkage) decorations.push_back(inst);
|
|
}
|
|
};
|
|
|
|
// Process |id|'s decorations.
|
|
process_direct_decorations(ids_iter->second.direct_decorations);
|
|
|
|
// Process the decorations of all groups applied to |id|.
|
|
for (const Instruction* inst : target_data.indirect_decorations) {
|
|
const uint32_t group_id = inst->GetSingleWordInOperand(0u);
|
|
const auto group_iter = id_to_decoration_insts_.find(group_id);
|
|
assert(group_iter != id_to_decoration_insts_.end() && "Unknown group ID");
|
|
process_direct_decorations(group_iter->second.direct_decorations);
|
|
}
|
|
|
|
return decorations;
|
|
}
|
|
|
|
bool DecorationManager::WhileEachDecoration(
|
|
uint32_t id, uint32_t decoration,
|
|
std::function<bool(const Instruction&)> f) const {
|
|
for (const Instruction* inst : GetDecorationsFor(id, true)) {
|
|
switch (inst->opcode()) {
|
|
case spv::Op::OpMemberDecorate:
|
|
if (inst->GetSingleWordInOperand(2) == decoration) {
|
|
if (!f(*inst)) return false;
|
|
}
|
|
break;
|
|
case spv::Op::OpDecorate:
|
|
case spv::Op::OpDecorateId:
|
|
case spv::Op::OpDecorateStringGOOGLE:
|
|
if (inst->GetSingleWordInOperand(1) == decoration) {
|
|
if (!f(*inst)) return false;
|
|
}
|
|
break;
|
|
default:
|
|
assert(false && "Unexpected decoration instruction");
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void DecorationManager::ForEachDecoration(
|
|
uint32_t id, uint32_t decoration,
|
|
std::function<void(const Instruction&)> f) const {
|
|
WhileEachDecoration(id, decoration, [&f](const Instruction& inst) {
|
|
f(inst);
|
|
return true;
|
|
});
|
|
}
|
|
|
|
bool DecorationManager::HasDecoration(uint32_t id,
|
|
spv::Decoration decoration) const {
|
|
return HasDecoration(id, static_cast<uint32_t>(decoration));
|
|
}
|
|
|
|
bool DecorationManager::HasDecoration(uint32_t id, uint32_t decoration) const {
|
|
bool has_decoration = false;
|
|
ForEachDecoration(id, decoration, [&has_decoration](const Instruction&) {
|
|
has_decoration = true;
|
|
});
|
|
return has_decoration;
|
|
}
|
|
|
|
bool DecorationManager::FindDecoration(
|
|
uint32_t id, uint32_t decoration,
|
|
std::function<bool(const Instruction&)> f) {
|
|
return !WhileEachDecoration(
|
|
id, decoration, [&f](const Instruction& inst) { return !f(inst); });
|
|
}
|
|
|
|
void DecorationManager::CloneDecorations(uint32_t from, uint32_t to) {
|
|
const auto decoration_list = id_to_decoration_insts_.find(from);
|
|
if (decoration_list == id_to_decoration_insts_.end()) return;
|
|
auto context = module_->context();
|
|
for (Instruction* inst : decoration_list->second.direct_decorations) {
|
|
// simply clone decoration and change |target-id| to |to|
|
|
std::unique_ptr<Instruction> new_inst(inst->Clone(module_->context()));
|
|
new_inst->SetInOperand(0, {to});
|
|
module_->AddAnnotationInst(std::move(new_inst));
|
|
auto decoration_iter = --module_->annotation_end();
|
|
context->AnalyzeUses(&*decoration_iter);
|
|
}
|
|
// We need to copy the list of instructions as ForgetUses and AnalyzeUses are
|
|
// going to modify it.
|
|
std::vector<Instruction*> indirect_decorations =
|
|
decoration_list->second.indirect_decorations;
|
|
for (Instruction* inst : indirect_decorations) {
|
|
switch (inst->opcode()) {
|
|
case spv::Op::OpGroupDecorate:
|
|
context->ForgetUses(inst);
|
|
// add |to| to list of decorated id's
|
|
inst->AddOperand(
|
|
Operand(spv_operand_type_t::SPV_OPERAND_TYPE_ID, {to}));
|
|
context->AnalyzeUses(inst);
|
|
break;
|
|
case spv::Op::OpGroupMemberDecorate: {
|
|
context->ForgetUses(inst);
|
|
// for each (id == from), add (to, literal) as operands
|
|
const uint32_t num_operands = inst->NumOperands();
|
|
for (uint32_t i = 1; i < num_operands; i += 2) {
|
|
Operand op = inst->GetOperand(i);
|
|
if (op.words[0] == from) { // add new pair of operands: (to, literal)
|
|
inst->AddOperand(
|
|
Operand(spv_operand_type_t::SPV_OPERAND_TYPE_ID, {to}));
|
|
op = inst->GetOperand(i + 1);
|
|
inst->AddOperand(std::move(op));
|
|
}
|
|
}
|
|
context->AnalyzeUses(inst);
|
|
break;
|
|
}
|
|
default:
|
|
assert(false && "Unexpected decoration instruction");
|
|
}
|
|
}
|
|
}
|
|
|
|
void DecorationManager::CloneDecorations(
|
|
uint32_t from, uint32_t to,
|
|
const std::vector<spv::Decoration>& decorations_to_copy) {
|
|
const auto decoration_list = id_to_decoration_insts_.find(from);
|
|
if (decoration_list == id_to_decoration_insts_.end()) return;
|
|
auto context = module_->context();
|
|
for (Instruction* inst : decoration_list->second.direct_decorations) {
|
|
if (std::find(decorations_to_copy.begin(), decorations_to_copy.end(),
|
|
spv::Decoration(inst->GetSingleWordInOperand(1))) ==
|
|
decorations_to_copy.end()) {
|
|
continue;
|
|
}
|
|
|
|
// Clone decoration and change |target-id| to |to|.
|
|
std::unique_ptr<Instruction> new_inst(inst->Clone(module_->context()));
|
|
new_inst->SetInOperand(0, {to});
|
|
module_->AddAnnotationInst(std::move(new_inst));
|
|
auto decoration_iter = --module_->annotation_end();
|
|
context->AnalyzeUses(&*decoration_iter);
|
|
}
|
|
|
|
// We need to copy the list of instructions as ForgetUses and AnalyzeUses are
|
|
// going to modify it.
|
|
std::vector<Instruction*> indirect_decorations =
|
|
decoration_list->second.indirect_decorations;
|
|
for (Instruction* inst : indirect_decorations) {
|
|
switch (inst->opcode()) {
|
|
case spv::Op::OpGroupDecorate:
|
|
CloneDecorations(inst->GetSingleWordInOperand(0), to,
|
|
decorations_to_copy);
|
|
break;
|
|
case spv::Op::OpGroupMemberDecorate: {
|
|
assert(false && "The source id is not suppose to be a type.");
|
|
break;
|
|
}
|
|
default:
|
|
assert(false && "Unexpected decoration instruction");
|
|
}
|
|
}
|
|
}
|
|
|
|
void DecorationManager::RemoveDecoration(Instruction* inst) {
|
|
const auto remove_from_container = [inst](std::vector<Instruction*>& v) {
|
|
v.erase(std::remove(v.begin(), v.end(), inst), v.end());
|
|
};
|
|
|
|
switch (inst->opcode()) {
|
|
case spv::Op::OpDecorate:
|
|
case spv::Op::OpDecorateId:
|
|
case spv::Op::OpDecorateStringGOOGLE:
|
|
case spv::Op::OpMemberDecorate: {
|
|
const auto target_id = inst->GetSingleWordInOperand(0u);
|
|
auto const iter = id_to_decoration_insts_.find(target_id);
|
|
if (iter == id_to_decoration_insts_.end()) return;
|
|
remove_from_container(iter->second.direct_decorations);
|
|
} break;
|
|
case spv::Op::OpGroupDecorate:
|
|
case spv::Op::OpGroupMemberDecorate: {
|
|
const uint32_t stride =
|
|
inst->opcode() == spv::Op::OpGroupDecorate ? 1u : 2u;
|
|
for (uint32_t i = 1u; i < inst->NumInOperands(); i += stride) {
|
|
const auto target_id = inst->GetSingleWordInOperand(i);
|
|
auto const iter = id_to_decoration_insts_.find(target_id);
|
|
if (iter == id_to_decoration_insts_.end()) continue;
|
|
remove_from_container(iter->second.indirect_decorations);
|
|
}
|
|
const auto group_id = inst->GetSingleWordInOperand(0u);
|
|
auto const iter = id_to_decoration_insts_.find(group_id);
|
|
if (iter == id_to_decoration_insts_.end()) return;
|
|
remove_from_container(iter->second.decorate_insts);
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool operator==(const DecorationManager& lhs, const DecorationManager& rhs) {
|
|
return lhs.id_to_decoration_insts_ == rhs.id_to_decoration_insts_;
|
|
}
|
|
|
|
} // namespace analysis
|
|
} // namespace opt
|
|
} // namespace spvtools
|