AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-30 23:10:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
9215c1b7df
SPIRV-Tools/source/opt/decoration_manager.cpp

619 lines
23 KiB
C++
Raw Normal View History

Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
// 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.
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include "source/opt/decoration_manager.h"
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
#include <algorithm>
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include <memory>
Opt: Make DecorationManager::HaveTheSameDecorations symmetric Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1112 Also: Add SpvOpDecorateId to IsAnnotationInst()
2017-12-24 10:15:14 +00:00
#include <set>
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
#include <stack>
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include <utility>
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include "source/opt/ir_context.h"
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
Handle decorations better in some optimizations (#2716) There are a couple spots where we are not looking at decorations when we should. 1. Value numbering is suppose to assign a different value number to ids if they have different decorations. However that is not being done for OpCopyObject and OpPhi. 1. Instruction simplification is propagating OpCopyObject instruction without checking for decorations. It should only do that if no decorations are being lost. Add a new function to the decoration manager to check if the decorations of one id are a subset of the decorations of another. Fixes #2715.
2019-07-10 15:37:16 +00:00
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
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
namespace spvtools {
namespace opt {
namespace analysis {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
void DecorationManager::RemoveDecorationsFrom(
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
uint32_t id, std::function<bool(const Instruction&)> pred) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
const auto ids_iter = id_to_decoration_insts_.find(id);
Handle decoration groups with no decorations. (#1921) In DecorationManager::RemoveDecorationsFrom, we do not remove the id from a decoration group if the group has no decorations. This causes problems because KillNamesAndDecorates is suppose to remove all references to the id, but in this case, there is still a reference. This is fixed by adding a special case. Also, there is the possibility of a double free because RemoveDecorationsFrom will delete the instructions defining |id| when |id| is a decoration group. Later, KillInst would later write to memory that has been deleted when trying to turn it into a Nop. To fix this, we will only remove the decorations that use |id| and not its definition in RemoveDecorationsFrom.
2018-09-28 18:16:04 +00:00
if (ids_iter == id_to_decoration_insts_.end()) {
return;
}
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
TargetData& decorations_info = ids_iter->second;
auto context = module_->context();
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::vector<Instruction*> insts_to_kill;
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
const bool is_group = !decorations_info.decorate_insts.empty();
// Schedule all direct decorations for removal if instructed as such by
// |pred|.
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* inst : decorations_info.direct_decorations)
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
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.
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::unordered_set<const Instruction*> indirect_decorations_to_remove;
for (Instruction* inst : decorations_info.indirect_decorations) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
assert(inst->opcode() == SpvOpGroupDecorate ||
inst->opcode() == SpvOpGroupMemberDecorate);
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::vector<Instruction*> group_decorations_to_keep;
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
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;
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* decoration : group_decorations) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
if (!pred(*decoration)) group_decorations_to_keep.push_back(decoration);
}
Handle decoration groups with no decorations. (#1921) In DecorationManager::RemoveDecorationsFrom, we do not remove the id from a decoration group if the group has no decorations. This causes problems because KillNamesAndDecorates is suppose to remove all references to the id, but in this case, there is still a reference. This is fixed by adding a special case. Also, there is the possibility of a double free because RemoveDecorationsFrom will delete the instructions defining |id| when |id| is a decoration group. Later, KillInst would later write to memory that has been deleted when trying to turn it into a Nop. To fix this, we will only remove the decorations that use |id| and not its definition in RemoveDecorationsFrom.
2018-09-28 18:16:04 +00:00
// 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;
}
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
// Otherwise, remove |id| from the targets of |group_id|
const uint32_t stride = inst->opcode() == SpvOpGroupDecorate ? 1u : 2u;
bool was_modified = false;
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()) {
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* decoration : group_decorations_to_keep) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
// simply clone decoration and change |group_id| to |id|
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::unique_ptr<Instruction> new_inst(
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
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(),
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
[&indirect_decorations_to_remove](const Instruction* inst) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
return indirect_decorations_to_remove.count(inst);
}),
indirect_decorations.end());
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* inst : insts_to_kill) context->KillInst(inst);
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
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()) {
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* inst : decorations_info.decorate_insts)
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
insts_to_kill.push_back(inst);
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* inst : insts_to_kill) context->KillInst(inst);
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
if (decorations_info.direct_decorations.empty() &&
decorations_info.indirect_decorations.empty() &&
decorations_info.decorate_insts.empty()) {
id_to_decoration_insts_.erase(ids_iter);
}
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::vector<Instruction*> DecorationManager::GetDecorationsFor(
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
uint32_t id, bool include_linkage) {
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
return InternalGetDecorationsFor<Instruction*>(id, include_linkage);
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::vector<const Instruction*> DecorationManager::GetDecorationsFor(
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
uint32_t id, bool include_linkage) const {
Add pass to remove dead variables at the module level. There does not seem to be any pass that remove global variables. I think we could use one. This pass will look specifically for global variables that are not referenced and are not exported. Any decoration associated with the variable will also be removed. However, this could cause types or constants to become unreferenced. They will not be removed. Another pass will have to be called to remove those.
2017-10-20 16:17:41 +00:00
return const_cast<DecorationManager*>(this)
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
->InternalGetDecorationsFor<const Instruction*>(id, include_linkage);
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
}
bool DecorationManager::HaveTheSameDecorations(uint32_t id1,
uint32_t id2) const {
Handle decorations better in some optimizations (#2716) There are a couple spots where we are not looking at decorations when we should. 1. Value numbering is suppose to assign a different value number to ids if they have different decorations. However that is not being done for OpCopyObject and OpPhi. 1. Instruction simplification is propagating OpCopyObject instruction without checking for decorations. It should only do that if no decorations are being lost. Add a new function to the decoration manager to check if the decorations of one id are a subset of the decorations of another. Fixes #2715.
2019-07-10 15:37:16 +00:00
const InstructionVector decorations_for1 = GetDecorationsFor(id1, false);
const InstructionVector decorations_for2 = GetDecorationsFor(id2, false);
Opt: Make DecorationManager::HaveTheSameDecorations symmetric Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1112 Also: Add SpvOpDecorateId to IsAnnotationInst()
2017-12-24 10:15:14 +00:00
// This function splits the decoration instructions into different sets,
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
// based on their opcode; only OpDecorate, OpDecorateId,
// OpDecorateStringGOOGLE, and OpMemberDecorate are considered, the other
// opcodes are ignored.
Opt: Make DecorationManager::HaveTheSameDecorations symmetric Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1112 Also: Add SpvOpDecorateId to IsAnnotationInst()
2017-12-24 10:15:14 +00:00
const auto fillDecorationSets =
Handle decorations better in some optimizations (#2716) There are a couple spots where we are not looking at decorations when we should. 1. Value numbering is suppose to assign a different value number to ids if they have different decorations. However that is not being done for OpCopyObject and OpPhi. 1. Instruction simplification is propagating OpCopyObject instruction without checking for decorations. It should only do that if no decorations are being lost. Add a new function to the decoration manager to check if the decorations of one id are a subset of the decorations of another. Fixes #2715.
2019-07-10 15:37:16 +00:00
[](const InstructionVector& decoration_list, DecorationSet* decorate_set,
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
DecorationSet* decorate_id_set, DecorationSet* decorate_string_set,
DecorationSet* member_decorate_set) {
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (const Instruction* inst : decoration_list) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
std::u32string decoration_payload;
Opt: Make DecorationManager::HaveTheSameDecorations symmetric Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1112 Also: Add SpvOpDecorateId to IsAnnotationInst()
2017-12-24 10:15:14 +00:00
// Ignore the opcode and the target as we do not want them to be
// compared.
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
for (uint32_t i = 1u; i < inst->NumInOperands(); ++i) {
for (uint32_t word : inst->GetInOperand(i).words) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
decoration_payload.push_back(word);
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
}
}
Opt: Make DecorationManager::HaveTheSameDecorations symmetric Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1112 Also: Add SpvOpDecorateId to IsAnnotationInst()
2017-12-24 10:15:14 +00:00
switch (inst->opcode()) {
case SpvOpDecorate:
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
decorate_set->emplace(std::move(decoration_payload));
Opt: Make DecorationManager::HaveTheSameDecorations symmetric Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1112 Also: Add SpvOpDecorateId to IsAnnotationInst()
2017-12-24 10:15:14 +00:00
break;
case SpvOpMemberDecorate:
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
member_decorate_set->emplace(std::move(decoration_payload));
Opt: Make DecorationManager::HaveTheSameDecorations symmetric Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1112 Also: Add SpvOpDecorateId to IsAnnotationInst()
2017-12-24 10:15:14 +00:00
break;
case SpvOpDecorateId:
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
decorate_id_set->emplace(std::move(decoration_payload));
Opt: Make DecorationManager::HaveTheSameDecorations symmetric Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1112 Also: Add SpvOpDecorateId to IsAnnotationInst()
2017-12-24 10:15:14 +00:00
break;
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
case SpvOpDecorateStringGOOGLE:
decorate_string_set->emplace(std::move(decoration_payload));
break;
Opt: Make DecorationManager::HaveTheSameDecorations symmetric Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1112 Also: Add SpvOpDecorateId to IsAnnotationInst()
2017-12-24 10:15:14 +00:00
default:
break;
}
}
};
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
DecorationSet decorate_set_for1;
DecorationSet decorate_id_set_for1;
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
DecorationSet decorate_string_set_for1;
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
DecorationSet member_decorate_set_for1;
fillDecorationSets(decorations_for1, &decorate_set_for1,
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
&decorate_id_set_for1, &decorate_string_set_for1,
&member_decorate_set_for1);
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
DecorationSet decorate_set_for2;
DecorationSet decorate_id_set_for2;
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
DecorationSet decorate_string_set_for2;
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
DecorationSet member_decorate_set_for2;
fillDecorationSets(decorations_for2, &decorate_set_for2,
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
&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;
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
}
Handle decorations better in some optimizations (#2716) There are a couple spots where we are not looking at decorations when we should. 1. Value numbering is suppose to assign a different value number to ids if they have different decorations. However that is not being done for OpCopyObject and OpPhi. 1. Instruction simplification is propagating OpCopyObject instruction without checking for decorations. It should only do that if no decorations are being lost. Add a new function to the decoration manager to check if the decorations of one id are a subset of the decorations of another. Fixes #2715.
2019-07-10 15:37:16 +00:00
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 SpvOpDecorate:
decorate_set->emplace(std::move(decoration_payload));
break;
case SpvOpMemberDecorate:
member_decorate_set->emplace(std::move(decoration_payload));
break;
case SpvOpDecorateId:
decorate_id_set->emplace(std::move(decoration_payload));
break;
case SpvOpDecorateStringGOOGLE:
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;
}
Opt: Fix implementation and comment of AreDecorationsTheSame Target should not be ignored when comparing decorations in RemoveDuplicates Opt: Remove unused code in RemoveDuplicateDecorations
2017-11-29 23:29:34 +00:00
// 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.
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
bool DecorationManager::AreDecorationsTheSame(const Instruction* inst1,
const Instruction* inst2,
Opt: Fix implementation and comment of AreDecorationsTheSame Target should not be ignored when comparing decorations in RemoveDuplicates Opt: Remove unused code in RemoveDuplicateDecorations
2017-11-29 23:29:34 +00:00
bool ignore_target) const {
switch (inst1->opcode()) {
case SpvOpDecorate:
case SpvOpMemberDecorate:
case SpvOpDecorateId:
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
case SpvOpDecorateStringGOOGLE:
Opt: Fix implementation and comment of AreDecorationsTheSame Target should not be ignored when comparing decorations in RemoveDuplicates Opt: Remove unused code in RemoveDuplicateDecorations
2017-11-29 23:29:34 +00:00
break;
default:
return false;
}
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
Opt: Fix implementation and comment of AreDecorationsTheSame Target should not be ignored when comparing decorations in RemoveDuplicates Opt: Remove unused code in RemoveDuplicateDecorations
2017-11-29 23:29:34 +00:00
if (inst1->opcode() != inst2->opcode() ||
inst1->NumInOperands() != inst2->NumInOperands())
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
return false;
Opt: Fix implementation and comment of AreDecorationsTheSame Target should not be ignored when comparing decorations in RemoveDuplicates Opt: Remove unused code in RemoveDuplicateDecorations
2017-11-29 23:29:34 +00:00
for (uint32_t i = ignore_target ? 1u : 0u; i < inst1->NumInOperands(); ++i)
if (inst1->GetInOperand(i) != inst2->GetInOperand(i)) return false;
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
return true;
}
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
void DecorationManager::AnalyzeDecorations() {
if (!module_) return;
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
// For each group and instruction, collect all their decoration instructions.
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction& inst : module_->annotations()) {
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
AddDecoration(&inst);
}
}
Add base and core bindless validation instrumentation classes (#2014) * Add base and core bindless validation instrumentation classes * Fix formatting. * Few more formatting fixes * Fix build failure * More build fixes * Need to call non-const functions in order. Specifically, these are functions which call TakeNextId(). These need to be called in a specific order to guarantee that tests which do exact compares will work across all platforms. c++ pretty much does not guarantee order of evaluation of operands, so any such functions need to be called separately in individual statements to guarantee order. * More ordering. * And more ordering. * And more formatting. * Attempt to fix NDK build * Another attempt to address NDK build problem. * One more attempt at NDK build failure * Add instrument.hpp to BUILD.gn * Some name improvement in instrument.hpp * Change all types in instrument.hpp to int. * Improve documentation in instrument.hpp * Format fixes * Comment clean up in instrument.hpp * imageInst -> image_inst * Fix GetLabel() issue.
2018-11-08 18:54:54 +00:00
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
void DecorationManager::AddDecoration(Instruction* inst) {
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
switch (inst->opcode()) {
case SpvOpDecorate:
case SpvOpDecorateId:
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
case SpvOpDecorateStringGOOGLE:
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
case SpvOpMemberDecorate: {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
const auto target_id = inst->GetSingleWordInOperand(0u);
id_to_decoration_insts_[target_id].direct_decorations.push_back(inst);
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
break;
}
case SpvOpGroupDecorate:
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
case SpvOpGroupMemberDecorate: {
const uint32_t start = inst->opcode() == SpvOpGroupDecorate ? 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);
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
}
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
const auto target_id = inst->GetSingleWordInOperand(0u);
id_to_decoration_insts_[target_id].decorate_insts.push_back(inst);
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
break;
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
}
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
default:
break;
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
}
}
Add base and core bindless validation instrumentation classes (#2014) * Add base and core bindless validation instrumentation classes * Fix formatting. * Few more formatting fixes * Fix build failure * More build fixes * Need to call non-const functions in order. Specifically, these are functions which call TakeNextId(). These need to be called in a specific order to guarantee that tests which do exact compares will work across all platforms. c++ pretty much does not guarantee order of evaluation of operands, so any such functions need to be called separately in individual statements to guarantee order. * More ordering. * And more ordering. * And more formatting. * Attempt to fix NDK build * Another attempt to address NDK build problem. * One more attempt at NDK build failure * Add instrument.hpp to BUILD.gn * Some name improvement in instrument.hpp * Change all types in instrument.hpp to int. * Improve documentation in instrument.hpp * Format fixes * Comment clean up in instrument.hpp * imageInst -> image_inst * Fix GetLabel() issue.
2018-11-08 18:54:54 +00:00
void DecorationManager::AddDecoration(SpvOp 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(
SpvOpDecorate,
{{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(
SpvOpDecorate,
{{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(
SpvOpMemberDecorate,
{{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}}});
}
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
template <typename T>
Add pass to remove dead variables at the module level. There does not seem to be any pass that remove global variables. I think we could use one. This pass will look specifically for global variables that are not referenced and are not exported. Any decoration associated with the variable will also be removed. However, this could cause types or constants to become unreferenced. They will not be removed. Another pass will have to be called to remove those.
2017-10-20 16:17:41 +00:00
std::vector<T> DecorationManager::InternalGetDecorationsFor(
uint32_t id, bool include_linkage) {
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
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;
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
const TargetData& target_data = ids_iter->second;
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
const auto process_direct_decorations =
[include_linkage,
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
&decorations](const std::vector<Instruction*>& direct_decorations) {
for (Instruction* inst : direct_decorations) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
const bool is_linkage = inst->opcode() == SpvOpDecorate &&
inst->GetSingleWordInOperand(1u) ==
SpvDecorationLinkageAttributes;
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|.
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (const Instruction* inst : target_data.indirect_decorations) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
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);
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
}
return decorations;
}
Adding early exit versions of several ForEach* methods * Looked through code for instances where code would benefit from early exit * Added a corresponding WhileEach* method and updated the code
2018-01-12 20:05:53 +00:00
bool DecorationManager::WhileEachDecoration(
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
uint32_t id, uint32_t decoration,
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::function<bool(const Instruction&)> f) {
for (const Instruction* inst : GetDecorationsFor(id, true)) {
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
switch (inst->opcode()) {
case SpvOpMemberDecorate:
if (inst->GetSingleWordInOperand(2) == decoration) {
Adding early exit versions of several ForEach* methods * Looked through code for instances where code would benefit from early exit * Added a corresponding WhileEach* method and updated the code
2018-01-12 20:05:53 +00:00
if (!f(*inst)) return false;
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
}
break;
case SpvOpDecorate:
case SpvOpDecorateId:
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
case SpvOpDecorateStringGOOGLE:
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
if (inst->GetSingleWordInOperand(1) == decoration) {
Adding early exit versions of several ForEach* methods * Looked through code for instances where code would benefit from early exit * Added a corresponding WhileEach* method and updated the code
2018-01-12 20:05:53 +00:00
if (!f(*inst)) return false;
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
}
break;
default:
assert(false && "Unexpected decoration instruction");
}
}
Adding early exit versions of several ForEach* methods * Looked through code for instances where code would benefit from early exit * Added a corresponding WhileEach* method and updated the code
2018-01-12 20:05:53 +00:00
return true;
}
void DecorationManager::ForEachDecoration(
uint32_t id, uint32_t decoration,
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::function<void(const Instruction&)> f) {
WhileEachDecoration(id, decoration, [&f](const Instruction& inst) {
Adding early exit versions of several ForEach* methods * Looked through code for instances where code would benefit from early exit * Added a corresponding WhileEach* method and updated the code
2018-01-12 20:05:53 +00:00
f(inst);
return true;
});
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
}
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
void DecorationManager::CloneDecorations(uint32_t from, uint32_t to) {
const auto decoration_list = id_to_decoration_insts_.find(from);
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
if (decoration_list == id_to_decoration_insts_.end()) return;
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
auto context = module_->context();
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* inst : decoration_list->second.direct_decorations) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
// simply clone decoration and change |target-id| to |to|
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::unique_ptr<Instruction> new_inst(inst->Clone(module_->context()));
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
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.
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::vector<Instruction*> indirect_decorations =
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
decoration_list->second.indirect_decorations;
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* inst : indirect_decorations) {
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
switch (inst->opcode()) {
case SpvOpGroupDecorate:
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
context->ForgetUses(inst);
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
// add |to| to list of decorated id's
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
inst->AddOperand(
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
Operand(spv_operand_type_t::SPV_OPERAND_TYPE_ID, {to}));
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
context->AnalyzeUses(inst);
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
break;
case SpvOpGroupMemberDecorate: {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
context->ForgetUses(inst);
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
// 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) {
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
Operand op = inst->GetOperand(i);
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
if (op.words[0] == from) { // add new pair of operands: (to, literal)
inst->AddOperand(
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
Operand(spv_operand_type_t::SPV_OPERAND_TYPE_ID, {to}));
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
op = inst->GetOperand(i + 1);
inst->AddOperand(std::move(op));
Add pass to remove dead variables at the module level. There does not seem to be any pass that remove global variables. I think we could use one. This pass will look specifically for global variables that are not referenced and are not exported. Any decoration associated with the variable will also be removed. However, this could cause types or constants to become unreferenced. They will not be removed. Another pass will have to be called to remove those.
2017-10-20 16:17:41 +00:00
}
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
}
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
context->AnalyzeUses(inst);
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
break;
Add pass to remove dead variables at the module level. There does not seem to be any pass that remove global variables. I think we could use one. This pass will look specifically for global variables that are not referenced and are not exported. Any decoration associated with the variable will also be removed. However, this could cause types or constants to become unreferenced. They will not be removed. Another pass will have to be called to remove those.
2017-10-20 16:17:41 +00:00
}
Fix decorations of inlined functions. Fixes issue #728. Currently the inliner is not generating decorations for inlined code which corresponds to function code which has decorations. An example of decorations that are relevant: RelaxedPrecision, NoContraction. The solution is to replicate the decoration during inlining.
2017-10-24 16:28:18 +00:00
default:
assert(false && "Unexpected decoration instruction");
Add pass to remove dead variables at the module level. There does not seem to be any pass that remove global variables. I think we could use one. This pass will look specifically for global variables that are not referenced and are not exported. Any decoration associated with the variable will also be removed. However, this could cause types or constants to become unreferenced. They will not be removed. Another pass will have to be called to remove those.
2017-10-20 16:17:41 +00:00
}
}
}
Copy decorations when creating new ids. (#1843) * Copy decorations when creating new ids. When creating a new value based on an old value, we need to copy the decorations to the new id. This change does this in 3 places: 1) The variable holding the return value of the function generated by merge return should get decorations from the function. 2) The results of the OpPhi instructions should get decorations from the variable they are replacing in the ssa writer. 3) In local access chain convert the intermediate struct (result of OpCompositeInsert) generated for the store replacement should get its decorations from the variable being stored to. Fixes #1787.
2018-08-24 15:55:39 +00:00
void DecorationManager::CloneDecorations(
uint32_t from, uint32_t to,
const std::vector<SpvDecoration>& 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(),
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 SpvOpGroupDecorate:
CloneDecorations(inst->GetSingleWordInOperand(0), to,
decorations_to_copy);
break;
case SpvOpGroupMemberDecorate: {
assert(false && "The source id is not suppose to be a type.");
break;
}
default:
assert(false && "Unexpected decoration instruction");
}
}
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
void DecorationManager::RemoveDecoration(Instruction* inst) {
const auto remove_from_container = [inst](std::vector<Instruction*>& v) {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
v.erase(std::remove(v.begin(), v.end(), inst), v.end());
};
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
switch (inst->opcode()) {
case SpvOpDecorate:
case SpvOpDecorateId:
Teach DecorationManager about OpDecorateStringGOOGLE Also add more decoration manager test coverage for OpDecorateId. Fixes #1396
2018-03-13 17:52:53 +00:00
case SpvOpDecorateStringGOOGLE:
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
case SpvOpMemberDecorate: {
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
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);
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
} break;
case SpvOpGroupDecorate:
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
case SpvOpGroupMemberDecorate: {
const uint32_t stride = inst->opcode() == SpvOpGroupDecorate ? 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);
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
}
Reimplement the DecorationManager This reimplementation fixes several issues when removing decorations associated to an ID (partially addresses #1174 and gives tools for fixing #898), as well as making it easier to remove groups; a few additional tests have been added. DecorationManager::RemoveDecoration() will still not delete dead decorations it created, but I do not think it is its job either; given the following input ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %2 Restrict %2 = OpDecorationGroup OpGroupDecorate %2 %1 %3 OpDecorate %4 Invariant %4 = OpDecorationGroup OpGroupDecorate %4 %2 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` which of the following two outputs would you expect RemoveDecoration(2) to produce: ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` or ``` OpCapability Shader OpCapability Linkage OpMemoryModel Logical GLSL450 OpDecorate %4 Invariant %4 = OpDecorationGroup %uint = OpTypeInt 32 0 %1 = OpVariable %uint Uniform %3 = OpVariable %uint Uniform ``` Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/924 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1174
2018-02-20 18:19:57 +00:00
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;
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
default:
break;
}
}
Invalidate the decoration manager at the start of ADCE. (#2189) * Invalidate the decoration manager at the start of ADCE. If the decoration manager is kept live the the contex will try to keep it up to date. ADCE deals with group decorations by changing the operands in |OpGroupDecorate| instructions directly without informing the decoration manager. This puts it in an invalid state, which will cause an error when the context tries to update it. To Avoid this problem, we will invalidate the decoration manager upfront. At the same time, the decoration manager is now considered when checking the consistency of the decoration manager.
2018-12-10 18:24:33 +00:00
bool operator==(const DecorationManager& lhs, const DecorationManager& rhs) {
return lhs.id_to_decoration_insts_ == rhs.id_to_decoration_insts_;
}
Implement Linker (module combiner) Add extra iterators for ir::Module's sections Add extra getters to ir::Function Add a const version of BasicBlock::GetLabelInst() Use the max of all inputs' version as version Split debug in debug1 and debug2 - Debug1 instructions have to be placed before debug2 instructions. Error out if different addressing or memory models are found Exit early if no binaries were given Error out if entry points are redeclared Implement copy ctors for Function and BasicBlock - Visual Studio ends up generating copy constructors that call deleted functions while compiling the linker code, while GCC and clang do not. So explicitly write those functions to avoid Visual Studio messing up. Move removing duplicate capabilities to its own pass Add functions running on all IDs present in an instruction Remove duplicate SpvOpExtInstImport Give default options value for link functions Remove linkage capability if not making a library Check types before allowing to link Detect if two types/variables/functions have different decorations Remove decorations of imported variables/functions and their types Add a DecorationManager Add a method for removing all decorations of id Add methods for removing operands from instructions Error out if one of the modules has a non-zero schema Update README.md to talk about the linker Do not freak out if an imported built-in variable has no export
2017-07-13 00:16:51 +00:00
} // namespace analysis
} // namespace opt
} // namespace spvtools
Reference in New Issue Copy Permalink