Sync with NDK master.
diff --git a/CHANGES b/CHANGES
index 0e76412..653e6df 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,7 +1,28 @@
Revision history for SPIRV-Tools
-v2016.2-dev 2016-07-19
- - Start v2016.2
+v2016.3-dev 2016-08-05
+ - Start v2016.3
+ - Add target environment enums for OpenCL 2.1, OpenCL 2.2,
+ OpenGL 4.0, OpenGL 4.1, OpenGL 4.2, OpenGL 4.3, OpenGL 4.5.
+
+v2016.2 2016-08-05
+ - Validator is incomplete
+ - Checks ID use block is dominated by definition block
+ - Add optimization passes (in API and spirv-opt command)
+ - Strip debug info instructions
+ - Freeze spec constant to their default values
+ - Allow INotEqual as operation for OpSpecConstantOp
+ - Fixes bugs:
+ #270: validator: crash when continue construct is unreachable
+ #279: validator: infinite loop when analyzing some degenerate control
+ flow graphs
+ #286: validator: don't incorrectly generate def-use error for
+ (variable,parent) parameters to OpPhi
+ #290: disassembler: never generate bare % for an identifier
+ #295: validator: def-use dominance check should ignore unreachable uses
+ #276: validator: allow unreachable continue constructs
+ #297: validator: allow an unreachable block to branch to a reachable
+ merge block
v2016.1 2016-07-19
- Fix https://github.com/KhronosGroup/SPIRV-Tools/issues/261
diff --git a/CMakeLists.txt b/CMakeLists.txt
index bdb9f3b..bb9fe7d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -116,8 +116,8 @@
# But it still depends on MSVCRT.dll.
if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
if (${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
- set_target_properties(${TARGET} PROPERTIES LINK_FLAGS
- -static -static-libgcc -static-libstdc++)
+ set_target_properties(${TARGET} PROPERTIES
+ LINK_FLAGS -static -static-libgcc -static-libstdc++)
endif()
endif()
endfunction()
@@ -138,8 +138,13 @@
# Defaults to OFF if the user didn't set it.
option(SPIRV_SKIP_EXECUTABLES
- "Skip building the executable and tests along with the library"
- ${SPIRV_SKIP_EXECUTABLES})
+ "Skip building the executable and tests along with the library"
+ ${SPIRV_SKIP_EXECUTABLES})
+option(SPIRV_SKIP_TESTS
+ "Skip building tests along with the library" ${SPIRV_SKIP_TESTS})
+if ("${SPIRV_SKIP_EXECUTABLES}")
+ set(SPIRV_SKIP_TESTS ON)
+endif()
add_subdirectory(external)
diff --git a/include/spirv-tools/libspirv.h b/include/spirv-tools/libspirv.h
index a3a1647..dc11c2a 100644
--- a/include/spirv-tools/libspirv.h
+++ b/include/spirv-tools/libspirv.h
@@ -352,6 +352,14 @@
SPV_ENV_UNIVERSAL_1_0, // SPIR-V 1.0 latest revision, no other restrictions.
SPV_ENV_VULKAN_1_0, // Vulkan 1.0 latest revision.
SPV_ENV_UNIVERSAL_1_1, // SPIR-V 1.1 latest revision, no other restrictions.
+ SPV_ENV_OPENCL_2_1, // OpenCL 2.1 latest revision.
+ SPV_ENV_OPENCL_2_2, // OpenCL 2.2 latest revision.
+ SPV_ENV_OPENGL_4_0, // OpenGL 4.0 plus GL_ARB_gl_spirv, latest revisions.
+ SPV_ENV_OPENGL_4_1, // OpenGL 4.1 plus GL_ARB_gl_spirv, latest revisions.
+ SPV_ENV_OPENGL_4_2, // OpenGL 4.2 plus GL_ARB_gl_spirv, latest revisions.
+ SPV_ENV_OPENGL_4_3, // OpenGL 4.3 plus GL_ARB_gl_spirv, latest revisions.
+ // There is no variant for OpenGL 4.4.
+ SPV_ENV_OPENGL_4_5, // OpenGL 4.5 plus GL_ARB_gl_spirv, latest revisions.
} spv_target_env;
// Returns a string describing the given SPIR-V target environment.
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index de227d6..316645e 100644
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -103,11 +103,11 @@
PROPERTIES OBJECT_DEPENDS "${EXTINST_CPP_DEPENDS}")
set(SPIRV_TOOLS_BUILD_VERSION_INC
- ${spirv-tools_BINARY_DIR}/build-version.inc)
+ ${spirv-tools_BINARY_DIR}/build-version.inc)
set(SPIRV_TOOLS_BUILD_VERSION_INC_GENERATOR
- ${spirv-tools_SOURCE_DIR}/utils/update_build_version.py)
+ ${spirv-tools_SOURCE_DIR}/utils/update_build_version.py)
set(SPIRV_TOOLS_CHANGES_FILE
- ${spirv-tools_SOURCE_DIR}/CHANGES)
+ ${spirv-tools_SOURCE_DIR}/CHANGES)
add_custom_command(OUTPUT ${SPIRV_TOOLS_BUILD_VERSION_INC}
COMMAND ${PYTHON_EXECUTABLE}
${SPIRV_TOOLS_BUILD_VERSION_INC_GENERATOR}
@@ -167,10 +167,10 @@
${CMAKE_CURRENT_SOURCE_DIR}/validate_id.cpp
${CMAKE_CURRENT_SOURCE_DIR}/validate_instruction.cpp
${CMAKE_CURRENT_SOURCE_DIR}/validate_layout.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/validate_ssa.cpp
${CMAKE_CURRENT_SOURCE_DIR}/val/BasicBlock.cpp
${CMAKE_CURRENT_SOURCE_DIR}/val/Construct.cpp
${CMAKE_CURRENT_SOURCE_DIR}/val/Function.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/val/Id.cpp
${CMAKE_CURRENT_SOURCE_DIR}/val/ValidationState.cpp)
# The software_version.cpp file includes build-version.inc.
diff --git a/source/assembly_grammar.cpp b/source/assembly_grammar.cpp
index b85aa03..11f9bc3 100644
--- a/source/assembly_grammar.cpp
+++ b/source/assembly_grammar.cpp
@@ -150,6 +150,7 @@
CASE(Select),
// Comparison
CASE(IEqual),
+ CASE(INotEqual),
CASE(ULessThan),
CASE(SLessThan),
CASE(UGreaterThan),
@@ -165,8 +166,8 @@
CASE(InBoundsPtrAccessChain),
};
-// The 58 is determined by counting the opcodes listed in the spec.
-static_assert(58 == sizeof(kOpSpecConstantOpcodes)/sizeof(kOpSpecConstantOpcodes[0]),
+// The 59 is determined by counting the opcodes listed in the spec.
+static_assert(59 == sizeof(kOpSpecConstantOpcodes)/sizeof(kOpSpecConstantOpcodes[0]),
"OpSpecConstantOp opcode table is incomplete");
#undef CASE
// clang-format on
diff --git a/source/binary.h b/source/binary.h
index 923a834..0d9ef28 100644
--- a/source/binary.h
+++ b/source/binary.h
@@ -28,7 +28,8 @@
#define LIBSPIRV_BINARY_H_
#include "spirv-tools/libspirv.h"
-#include "table.h"
+#include "spirv/1.1/spirv.h"
+#include "spirv_definition.h"
// Functions
diff --git a/source/ext_inst.cpp b/source/ext_inst.cpp
index e92c99c..0851fcf 100644
--- a/source/ext_inst.cpp
+++ b/source/ext_inst.cpp
@@ -62,6 +62,13 @@
case SPV_ENV_UNIVERSAL_1_0:
case SPV_ENV_VULKAN_1_0:
case SPV_ENV_UNIVERSAL_1_1:
+ case SPV_ENV_OPENCL_2_1:
+ case SPV_ENV_OPENCL_2_2:
+ case SPV_ENV_OPENGL_4_0:
+ case SPV_ENV_OPENGL_4_1:
+ case SPV_ENV_OPENGL_4_2:
+ case SPV_ENV_OPENGL_4_3:
+ case SPV_ENV_OPENGL_4_5:
*pExtInstTable = &table_1_0;
return SPV_SUCCESS;
default:
diff --git a/source/instruction.h b/source/instruction.h
index 37b35b2..f203dd0 100644
--- a/source/instruction.h
+++ b/source/instruction.h
@@ -30,10 +30,9 @@
#include <cstdint>
#include <vector>
+#include "spirv-tools/libspirv.h"
#include "spirv/1.1/spirv.h"
-#include "table.h"
-
// Describes an instruction.
struct spv_instruction_t {
// Normally, both opcode and extInstType contain valid data.
diff --git a/source/name_mapper.cpp b/source/name_mapper.cpp
index f2c03ca..0dac99a 100644
--- a/source/name_mapper.cpp
+++ b/source/name_mapper.cpp
@@ -76,7 +76,8 @@
}
std::string FriendlyNameMapper::Sanitize(const std::string& suggested_name) {
- // Just replace invalid characters by '_'.
+ if (suggested_name.empty()) return "_";
+ // Otherwise, replace invalid characters by '_'.
std::string result;
std::string valid =
"abcdefghijklmnopqrstuvwxyz"
diff --git a/source/opcode.cpp b/source/opcode.cpp
index 22a0df6..2e6c7da 100644
--- a/source/opcode.cpp
+++ b/source/opcode.cpp
@@ -101,9 +101,16 @@
switch (env) {
case SPV_ENV_UNIVERSAL_1_0:
case SPV_ENV_VULKAN_1_0:
+ case SPV_ENV_OPENCL_2_1:
+ case SPV_ENV_OPENGL_4_0:
+ case SPV_ENV_OPENGL_4_1:
+ case SPV_ENV_OPENGL_4_2:
+ case SPV_ENV_OPENGL_4_3:
+ case SPV_ENV_OPENGL_4_5:
*pInstTable = &table_1_0;
return SPV_SUCCESS;
case SPV_ENV_UNIVERSAL_1_1:
+ case SPV_ENV_OPENCL_2_2:
*pInstTable = &table_1_1;
return SPV_SUCCESS;
}
diff --git a/source/operand.cpp b/source/operand.cpp
index a909380..b6dacc5 100644
--- a/source/operand.cpp
+++ b/source/operand.cpp
@@ -53,9 +53,16 @@
switch (env) {
case SPV_ENV_UNIVERSAL_1_0:
case SPV_ENV_VULKAN_1_0:
+ case SPV_ENV_OPENCL_2_1:
+ case SPV_ENV_OPENGL_4_0:
+ case SPV_ENV_OPENGL_4_1:
+ case SPV_ENV_OPENGL_4_2:
+ case SPV_ENV_OPENGL_4_3:
+ case SPV_ENV_OPENGL_4_5:
*pOperandTable = &table_1_0;
return SPV_SUCCESS;
case SPV_ENV_UNIVERSAL_1_1:
+ case SPV_ENV_OPENCL_2_2:
*pOperandTable = &table_1_1;
return SPV_SUCCESS;
}
diff --git a/source/opt/CMakeLists.txt b/source/opt/CMakeLists.txt
index 24a201d..b4e23e4 100644
--- a/source/opt/CMakeLists.txt
+++ b/source/opt/CMakeLists.txt
@@ -1,5 +1,6 @@
add_library(SPIRV-Tools-opt
basic_block.h
+ def_use_manager.h
function.h
instruction.h
ir_loader.h
@@ -9,6 +10,7 @@
passes.h
pass_manager.h
+ def_use_manager.cpp
function.cpp
instruction.cpp
ir_loader.cpp
diff --git a/source/opt/def_use_manager.cpp b/source/opt/def_use_manager.cpp
new file mode 100644
index 0000000..4775421
--- /dev/null
+++ b/source/opt/def_use_manager.cpp
@@ -0,0 +1,121 @@
+// Copyright (c) 2016 Google Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+// https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#include "def_use_manager.h"
+
+#include <cassert>
+#include <functional>
+
+#include "instruction.h"
+#include "module.h"
+
+namespace spvtools {
+namespace opt {
+namespace analysis {
+
+void DefUseManager::AnalyzeDefUse(ir::Module* module) {
+ module->ForEachInst(std::bind(&DefUseManager::AnalyzeInstDefUse, this,
+ std::placeholders::_1));
+}
+
+ir::Instruction* DefUseManager::GetDef(uint32_t id) {
+ if (id_to_def_.count(id) == 0) return nullptr;
+ return id_to_def_.at(id);
+}
+
+UseList* DefUseManager::GetUses(uint32_t id) {
+ if (id_to_uses_.count(id) == 0) return nullptr;
+ return &id_to_uses_.at(id);
+}
+
+bool DefUseManager::KillDef(uint32_t id) {
+ if (id_to_def_.count(id) == 0) return false;
+
+ // Go through all ids usd by this instruction, remove this instruction's uses
+ // of them.
+ for (const auto use_id : result_id_to_used_ids_[id]) {
+ if (id_to_uses_.count(use_id) == 0) continue;
+ auto& uses = id_to_uses_[use_id];
+ for (auto it = uses.begin(); it != uses.end();) {
+ if (it->inst->result_id() == id) {
+ it = uses.erase(it);
+ } else {
+ ++it;
+ }
+ }
+ if (uses.empty()) id_to_uses_.erase(use_id);
+ }
+ result_id_to_used_ids_.erase(id);
+
+ id_to_uses_.erase(id); // Remove all uses of this id.
+ // This must happen at the last since we use information inside the instuction
+ // in the above.
+ id_to_def_[id]->ToNop();
+ id_to_def_.erase(id);
+ return true;
+}
+
+bool DefUseManager::ReplaceAllUsesWith(uint32_t before, uint32_t after) {
+ if (before == after) return false;
+ if (id_to_uses_.count(before) == 0) return false;
+
+ for (auto it = id_to_uses_[before].cbegin(); it != id_to_uses_[before].cend();
+ ++it) {
+ // Make the modification in the instruction.
+ it->inst->SetOperand(it->operand_index, {after});
+ // Register the use of |after| id into id_to_uses_.
+ // TODO(antiagainst): de-duplication.
+ id_to_uses_[after].push_back({it->inst, it->operand_index});
+ }
+ id_to_uses_.erase(before);
+ return true;
+}
+
+void DefUseManager::AnalyzeInstDefUse(ir::Instruction* inst) {
+ const uint32_t def_id = inst->result_id();
+ if (def_id != 0) id_to_def_[def_id] = inst;
+
+ for (uint32_t i = 0; i < inst->NumOperands(); ++i) {
+ switch (inst->GetOperand(i).type) {
+ // For any id type but result id type
+ case SPV_OPERAND_TYPE_ID:
+ case SPV_OPERAND_TYPE_TYPE_ID:
+ case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID:
+ case SPV_OPERAND_TYPE_SCOPE_ID: {
+ uint32_t use_id = inst->GetSingleWordOperand(i);
+ // use_id is used by the instruction generating def_id.
+ id_to_uses_[use_id].push_back({inst, i});
+ if (def_id != 0) result_id_to_used_ids_[def_id].push_back(use_id);
+ } break;
+ default:
+ break;
+ }
+ }
+}
+
+} // namespace analysis
+} // namespace opt
+} // namespace spvtools
diff --git a/source/opt/def_use_manager.h b/source/opt/def_use_manager.h
new file mode 100644
index 0000000..d7745d7
--- /dev/null
+++ b/source/opt/def_use_manager.h
@@ -0,0 +1,108 @@
+// Copyright (c) 2016 Google Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+// https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#ifndef LIBSPIRV_OPT_DEF_USE_MANAGER_H_
+#define LIBSPIRV_OPT_DEF_USE_MANAGER_H_
+
+#include <list>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "instruction.h"
+#include "module.h"
+
+namespace spvtools {
+namespace opt {
+namespace analysis {
+
+// Class for representing a use of id. Note that result:
+// * Type id is a use.
+// * Ids referenced in OpSectionMerge & OpLoopMerge are considered as use.
+// * Ids referenced in OpPhi's in operands are considered as use.
+struct Use {
+ ir::Instruction* inst; // Instruction using the id.
+ uint32_t operand_index; // logical operand index of the id use. This can be
+ // the index of result type id.
+};
+
+using UseList = std::list<Use>;
+
+// A class for analyzing and managing defs and uses in an ir::Module.
+class DefUseManager {
+ public:
+ using IdToDefMap = std::unordered_map<uint32_t, ir::Instruction*>;
+ using IdToUsesMap = std::unordered_map<uint32_t, UseList>;
+
+ // Analyzes the defs and uses in the given |module| and populates data
+ // structures in this class.
+ // TODO(antiagainst): This method should not modify the given module. Create
+ // const overload for ForEachInst().
+ void AnalyzeDefUse(ir::Module* module);
+
+ // Returns the def instruction for the given |id|. If there is no instruction
+ // defining |id|, returns nullptr.
+ ir::Instruction* GetDef(uint32_t id);
+ // Returns the use instructions for the given |id|. If there is no uses of
+ // |id|, returns nullptr.
+ UseList* GetUses(uint32_t id);
+
+ // Returns the map from ids to their def instructions.
+ const IdToDefMap& id_to_defs() const { return id_to_def_; }
+ // Returns the map from ids to their uses in instructions.
+ const IdToUsesMap& id_to_uses() const { return id_to_uses_; }
+
+ // Turns the instruction defining the given |id| into a Nop. Returns true on
+ // success, false if the given |id| is not defined at all. This method also
+ // erases both the uses of |id| and the |id|-generating instruction's use
+ // information kept in this manager, but not the operands in the original
+ // instructions.
+ bool KillDef(uint32_t id);
+ // Replaces all uses of |before| id with |after| id. Returns true if any
+ // replacement happens. This method does not kill the definition of the
+ // |before| id. If |after| is the same as |before|, does nothing and returns
+ // false.
+ bool ReplaceAllUsesWith(uint32_t before, uint32_t after);
+
+ private:
+ using ResultIdToUsedIdsMap =
+ std::unordered_map<uint32_t, std::vector<uint32_t>>;
+
+ // Analyzes the defs and uses in the given |inst|.
+ void AnalyzeInstDefUse(ir::Instruction* inst);
+
+ IdToDefMap id_to_def_; // Mapping from ids to their definitions
+ IdToUsesMap id_to_uses_; // Mapping from ids to their uses
+ // Mapping from result ids to the ids used in the instructions generating the
+ // result ids.
+ ResultIdToUsedIdsMap result_id_to_used_ids_;
+};
+
+} // namespace analysis
+} // namespace opt
+} // namespace spvtools
+
+#endif // LIBSPIRV_OPT_DEF_USE_MANAGER_H_
diff --git a/source/opt/instruction.h b/source/opt/instruction.h
index 0bbcd6e..18447ca 100644
--- a/source/opt/instruction.h
+++ b/source/opt/instruction.h
@@ -85,7 +85,18 @@
Instruction(const spv_parsed_instruction_t& inst,
std::vector<Instruction>&& dbg_line = {});
+ Instruction(const Instruction&) = default;
+ Instruction& operator=(const Instruction&) = default;
+
+ Instruction(Instruction&&) = default;
+ Instruction& operator=(Instruction&&) = default;
+
SpvOp opcode() const { return opcode_; }
+ // Sets the opcode of this instruction to a specific opcode. Note this may
+ // invalidate the instruction.
+ // TODO(qining): Remove this function when instruction building and insertion
+ // is well implemented.
+ void SetOpcode(SpvOp op) { opcode_ = op; }
uint32_t type_id() const { return type_id_; }
uint32_t result_id() const { return result_id_; }
// Returns the vector of line-related debug instructions attached to this
diff --git a/source/opt/libspirv.cpp b/source/opt/libspirv.cpp
index fe1b2b5..c076762 100644
--- a/source/opt/libspirv.cpp
+++ b/source/opt/libspirv.cpp
@@ -68,13 +68,12 @@
}
spv_result_t SpvTools::Disassemble(const std::vector<uint32_t>& binary,
- std::string* text) {
+ std::string* text, uint32_t options) {
spv_text spvtext = nullptr;
spv_diagnostic diagnostic = nullptr;
spv_result_t status = spvBinaryToText(context_, binary.data(), binary.size(),
- SPV_BINARY_TO_TEXT_OPTION_NO_HEADER,
- &spvtext, &diagnostic);
+ options, &spvtext, &diagnostic);
if (status == SPV_SUCCESS) {
text->assign(spvtext->str, spvtext->str + spvtext->length);
}
diff --git a/source/opt/libspirv.hpp b/source/opt/libspirv.hpp
index 667276f..e039c17 100644
--- a/source/opt/libspirv.hpp
+++ b/source/opt/libspirv.hpp
@@ -54,10 +54,14 @@
// Returns SPV_SUCCESS on successful assembling.
spv_result_t Assemble(const std::string& text, std::vector<uint32_t>* binary);
- // Disassembles the given SPIR-V |binary| and returns the assembly. Returns
- // SPV_SUCCESS on successful disassembling.
- spv_result_t Disassemble(const std::vector<uint32_t>& binary,
- std::string* text);
+ // Disassembles the given SPIR-V |binary| with the given options and returns
+ // the assembly. By default the options are set to generate assembly with
+ // friendly variable names and no SPIR-V assembly header. Returns SPV_SUCCESS
+ // on successful disassembling.
+ spv_result_t Disassemble(
+ const std::vector<uint32_t>& binary, std::string* text,
+ uint32_t options = SPV_BINARY_TO_TEXT_OPTION_NO_HEADER |
+ SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES);
// Builds and returns a Module from the given SPIR-V |binary|.
std::unique_ptr<ir::Module> BuildModule(const std::vector<uint32_t>& binary);
diff --git a/source/opt/module.cpp b/source/opt/module.cpp
index c6bab3a..85d1f0e 100644
--- a/source/opt/module.cpp
+++ b/source/opt/module.cpp
@@ -43,7 +43,7 @@
for (auto& i : capabilities_) f(&i);
for (auto& i : extensions_) f(&i);
for (auto& i : ext_inst_imports_) f(&i);
- f(&memory_model_);
+ if (memory_model_) f(memory_model_.get());
for (auto& i : entry_points_) f(&i);
for (auto& i : execution_modes_) f(&i);
for (auto& i : debugs_) f(&i);
@@ -64,7 +64,7 @@
for (const auto& c : capabilities_) c.ToBinary(binary, skip_nop);
for (const auto& e : extensions_) e.ToBinary(binary, skip_nop);
for (const auto& e : ext_inst_imports_) e.ToBinary(binary, skip_nop);
- memory_model_.ToBinary(binary, skip_nop);
+ if (memory_model_) memory_model_->ToBinary(binary, skip_nop);
for (const auto& e : entry_points_) e.ToBinary(binary, skip_nop);
for (const auto& e : execution_modes_) e.ToBinary(binary, skip_nop);
for (const auto& d : debugs_) d.ToBinary(binary, skip_nop);
diff --git a/source/opt/module.h b/source/opt/module.h
index f4bfbbc..df02dbd 100644
--- a/source/opt/module.h
+++ b/source/opt/module.h
@@ -28,6 +28,7 @@
#define LIBSPIRV_OPT_MODULE_H_
#include <functional>
+#include <memory>
#include <utility>
#include <vector>
@@ -63,8 +64,10 @@
void AddExtInstImport(Instruction&& e) {
ext_inst_imports_.push_back(std::move(e));
}
- // Appends a memory model instruction to this module.
- void SetMemoryModel(Instruction&& m) { memory_model_ = std::move(m); }
+ // Adds a memory model instruction to this module.
+ void SetMemoryModel(Instruction&& m) {
+ memory_model_.reset(new Instruction(std::move(m)));
+ }
// Appends an entry point instruction to this module.
void AddEntryPoint(Instruction&& e) { entry_points_.push_back(std::move(e)); }
// Appends an execution mode instruction to this module.
@@ -113,7 +116,8 @@
std::vector<Instruction> capabilities_;
std::vector<Instruction> extensions_;
std::vector<Instruction> ext_inst_imports_;
- Instruction memory_model_; // A module only has one memory model instruction.
+ std::unique_ptr<Instruction>
+ memory_model_; // A module only has one memory model instruction.
std::vector<Instruction> entry_points_;
std::vector<Instruction> execution_modes_;
std::vector<Instruction> debugs_;
diff --git a/source/opt/passes.cpp b/source/opt/passes.cpp
index 3749c53..65ab769 100644
--- a/source/opt/passes.cpp
+++ b/source/opt/passes.cpp
@@ -41,5 +41,35 @@
return modified;
}
+bool FreezeSpecConstantValuePass::Process(ir::Module* module) {
+ bool modified = false;
+ module->ForEachInst([&modified](ir::Instruction* inst) {
+ switch (inst->opcode()) {
+ case SpvOp::SpvOpSpecConstant:
+ inst->SetOpcode(SpvOp::SpvOpConstant);
+ modified = true;
+ break;
+ case SpvOp::SpvOpSpecConstantTrue:
+ inst->SetOpcode(SpvOp::SpvOpConstantTrue);
+ modified = true;
+ break;
+ case SpvOp::SpvOpSpecConstantFalse:
+ inst->SetOpcode(SpvOp::SpvOpConstantFalse);
+ modified = true;
+ break;
+ case SpvOp::SpvOpDecorate:
+ if (inst->GetSingleWordInOperand(1) ==
+ SpvDecoration::SpvDecorationSpecId) {
+ inst->ToNop();
+ modified = true;
+ }
+ break;
+ default:
+ break;
+ }
+ });
+ return modified;
+}
+
} // namespace opt
} // namespace spvtools
diff --git a/source/opt/passes.h b/source/opt/passes.h
index cb07e0b..23873a8 100644
--- a/source/opt/passes.h
+++ b/source/opt/passes.h
@@ -46,7 +46,7 @@
// A null pass that does nothing.
class NullPass : public Pass {
- const char* name() const override { return "Null"; }
+ const char* name() const override { return "null"; }
bool Process(ir::Module*) override { return false; }
};
@@ -54,10 +54,24 @@
// Section 3.32.2 of the SPIR-V spec).
class StripDebugInfoPass : public Pass {
public:
- const char* name() const override { return "StripDebugInfo"; }
+ const char* name() const override { return "strip-debug"; }
bool Process(ir::Module* module) override;
};
+// The transformation pass that specializes the value of spec constants to
+// their default values. This pass only processes the spec constants that have
+// Spec ID decorations (defined by OpSpecConstant, OpSpecConstantTrue and
+// OpSpecConstantFalse instructions) and replaces them with their front-end
+// version counterparts (OpConstant, OpConstantTrue and OpConstantFalse). The
+// corresponding Spec ID annotation instructions will also be removed. This
+// pass does not fold the newly added front-end constants and does not process
+// other spec constants defined by OpSpecConstantComposite or OpSpecConstantOp.
+class FreezeSpecConstantValuePass : public Pass {
+ public:
+ const char* name() const override { return "freeze-spec-const"; }
+ bool Process(ir::Module*) override;
+};
+
} // namespace opt
} // namespace spvtools
diff --git a/source/spirv_definition.h b/source/spirv_definition.h
index 59f8509..9cd3f36 100644
--- a/source/spirv_definition.h
+++ b/source/spirv_definition.h
@@ -29,7 +29,7 @@
#include <cstdint>
-#include "spirv-tools/libspirv.h"
+#include "spirv/1.1/spirv.h"
#define spvIsInBitfield(value, bitfield) ((value) == ((value)&bitfield))
diff --git a/source/spirv_target_env.cpp b/source/spirv_target_env.cpp
index 116d6b5..e95ce9e 100644
--- a/source/spirv_target_env.cpp
+++ b/source/spirv_target_env.cpp
@@ -38,8 +38,20 @@
return "SPIR-V 1.0 (under Vulkan 1.0 semantics)";
case SPV_ENV_UNIVERSAL_1_1:
return "SPIR-V 1.1";
- default:
- break;
+ case SPV_ENV_OPENCL_2_1:
+ return "SPIR-V 1.0 (under OpenCL 2.1 semantics)";
+ case SPV_ENV_OPENCL_2_2:
+ return "SPIR-V 1.1 (under OpenCL 2.2 semantics)";
+ case SPV_ENV_OPENGL_4_0:
+ return "SPIR-V 1.0 (under OpenCL 4.0 semantics)";
+ case SPV_ENV_OPENGL_4_1:
+ return "SPIR-V 1.0 (under OpenCL 4.1 semantics)";
+ case SPV_ENV_OPENGL_4_2:
+ return "SPIR-V 1.0 (under OpenCL 4.2 semantics)";
+ case SPV_ENV_OPENGL_4_3:
+ return "SPIR-V 1.0 (under OpenCL 4.3 semantics)";
+ case SPV_ENV_OPENGL_4_5:
+ return "SPIR-V 1.0 (under OpenCL 4.5 semantics)";
}
assert(0 && "Unhandled SPIR-V target environment");
return "";
@@ -49,26 +61,55 @@
switch (env) {
case SPV_ENV_UNIVERSAL_1_0:
case SPV_ENV_VULKAN_1_0:
+ case SPV_ENV_OPENCL_2_1:
+ case SPV_ENV_OPENGL_4_0:
+ case SPV_ENV_OPENGL_4_1:
+ case SPV_ENV_OPENGL_4_2:
+ case SPV_ENV_OPENGL_4_3:
+ case SPV_ENV_OPENGL_4_5:
return SPV_SPIRV_VERSION_WORD(1, 0);
case SPV_ENV_UNIVERSAL_1_1:
+ case SPV_ENV_OPENCL_2_2:
return SPV_SPIRV_VERSION_WORD(1, 1);
- default:
- break;
}
assert(0 && "Unhandled SPIR-V target environment");
return SPV_SPIRV_VERSION_WORD(0, 0);
}
bool spvParseTargetEnv(const char* s, spv_target_env* env) {
- if (!strncmp(s, "vulkan1.0", strlen("vulkan1.0"))) {
+ auto match = [s](const char* b) {
+ return s && (0 == strncmp(s, b, strlen(b)));
+ };
+ if (match("vulkan1.0")) {
if (env) *env = SPV_ENV_VULKAN_1_0;
return true;
- } else if (!strncmp(s, "spv1.0", strlen("spv1.0"))) {
+ } else if (match("spv1.0")) {
if (env) *env = SPV_ENV_UNIVERSAL_1_0;
return true;
- } else if (!strncmp(s, "spv1.1", strlen("spv1.1"))) {
+ } else if (match("spv1.1")) {
if (env) *env = SPV_ENV_UNIVERSAL_1_1;
return true;
+ } else if (match("opencl2.1")) {
+ if (env) *env = SPV_ENV_OPENCL_2_1;
+ return true;
+ } else if (match("opencl2.2")) {
+ if (env) *env = SPV_ENV_OPENCL_2_2;
+ return true;
+ } else if (match("opengl4.0")) {
+ if (env) *env = SPV_ENV_OPENGL_4_0;
+ return true;
+ } else if (match("opengl4.1")) {
+ if (env) *env = SPV_ENV_OPENGL_4_1;
+ return true;
+ } else if (match("opengl4.2")) {
+ if (env) *env = SPV_ENV_OPENGL_4_2;
+ return true;
+ } else if (match("opengl4.3")) {
+ if (env) *env = SPV_ENV_OPENGL_4_3;
+ return true;
+ } else if (match("opengl4.5")) {
+ if (env) *env = SPV_ENV_OPENGL_4_5;
+ return true;
} else {
if (env) *env = SPV_ENV_UNIVERSAL_1_0;
return false;
diff --git a/source/table.cpp b/source/table.cpp
index 3b142a2..2312ceb 100644
--- a/source/table.cpp
+++ b/source/table.cpp
@@ -33,6 +33,13 @@
case SPV_ENV_UNIVERSAL_1_0:
case SPV_ENV_VULKAN_1_0:
case SPV_ENV_UNIVERSAL_1_1:
+ case SPV_ENV_OPENCL_2_1:
+ case SPV_ENV_OPENCL_2_2:
+ case SPV_ENV_OPENGL_4_0:
+ case SPV_ENV_OPENGL_4_1:
+ case SPV_ENV_OPENGL_4_2:
+ case SPV_ENV_OPENGL_4_3:
+ case SPV_ENV_OPENGL_4_5:
break;
default:
return nullptr;
diff --git a/source/val/BasicBlock.cpp b/source/val/BasicBlock.cpp
index eb54f2a..3e95618 100644
--- a/source/val/BasicBlock.cpp
+++ b/source/val/BasicBlock.cpp
@@ -26,6 +26,7 @@
#include "BasicBlock.h"
+#include <algorithm>
#include <utility>
#include <vector>
@@ -76,12 +77,16 @@
return;
}
-void BasicBlock::SetSuccessorsUnsafe(std::vector<BasicBlock*>&& others) {
- successors_ = std::move(others);
+bool BasicBlock::dominates(const BasicBlock& other) const {
+ return (this == &other) ||
+ !(other.dom_end() ==
+ std::find(other.dom_begin(), other.dom_end(), this));
}
-void BasicBlock::SetPredecessorsUnsafe(std::vector<BasicBlock*>&& others) {
- predecessors_ = std::move(others);
+bool BasicBlock::postdominates(const BasicBlock& other) const {
+ return (this == &other) ||
+ !(other.pdom_end() ==
+ std::find(other.pdom_begin(), other.pdom_end(), this));
}
BasicBlock::DominatorIterator::DominatorIterator() : current_(nullptr) {}
diff --git a/source/val/BasicBlock.h b/source/val/BasicBlock.h
index 9be655c..21b0e39 100644
--- a/source/val/BasicBlock.h
+++ b/source/val/BasicBlock.h
@@ -121,20 +121,20 @@
/// Adds @p next BasicBlocks as successors of this BasicBlock
void RegisterSuccessors(const std::vector<BasicBlock*>& next = {});
- /// Set the successors to this block, without updating other internal state,
- /// and without updating the other blocks.
- void SetSuccessorsUnsafe(std::vector<BasicBlock*>&& others);
-
- /// Set the predecessors to this block, without updating other internal state,
- /// and without updating the other blocks.
- void SetPredecessorsUnsafe(std::vector<BasicBlock*>&& others);
-
/// Returns true if the id of the BasicBlock matches
bool operator==(const BasicBlock& other) const { return other.id_ == id_; }
/// Returns true if the id of the BasicBlock matches
bool operator==(const uint32_t& other_id) const { return other_id == id_; }
+ /// Returns true if this block dominates the other block.
+ /// Assumes dominators have been computed.
+ bool dominates(const BasicBlock& other) const;
+
+ /// Returns true if this block postdominates the other block.
+ /// Assumes dominators have been computed.
+ bool postdominates(const BasicBlock& other) const;
+
/// @brief A BasicBlock dominator iterator class
///
/// This iterator will iterate over the (post)dominators of the block
diff --git a/source/val/Function.cpp b/source/val/Function.cpp
index d13915e..0240d68 100644
--- a/source/val/Function.cpp
+++ b/source/val/Function.cpp
@@ -29,42 +29,79 @@
#include <cassert>
#include <algorithm>
+#include <unordered_set>
+#include <unordered_map>
#include <utility>
#include "val/BasicBlock.h"
#include "val/Construct.h"
-#include "val/ValidationState.h"
+#include "validate.h"
using std::ignore;
using std::list;
using std::make_pair;
using std::pair;
-using std::string;
using std::tie;
using std::vector;
-namespace libspirv {
namespace {
-void printDot(const BasicBlock& other, const ValidationState_t& module) {
- string block_string;
- if (other.successors()->empty()) {
- block_string += "end ";
- } else {
- for (auto block : *other.successors()) {
- block_string += module.getIdOrName(block->id()) + " ";
+using libspirv::BasicBlock;
+
+// Computes a minimal set of root nodes required to traverse, in the forward
+// direction, the CFG represented by the given vector of blocks, and successor
+// and predecessor functions. When considering adding two nodes, each having
+// predecessors, favour using the one that appears earlier on the input blocks
+// list.
+std::vector<BasicBlock*> TraversalRoots(const std::vector<BasicBlock*>& blocks,
+ libspirv::get_blocks_func succ_func,
+ libspirv::get_blocks_func pred_func) {
+ // The set of nodes which have been visited from any of the roots so far.
+ std::unordered_set<const BasicBlock*> visited;
+
+ auto mark_visited = [&visited](const BasicBlock* b) { visited.insert(b); };
+ auto ignore_block = [](const BasicBlock*) {};
+ auto ignore_blocks = [](const BasicBlock*, const BasicBlock*) {};
+
+ auto traverse_from_root = [&mark_visited, &succ_func, &ignore_block,
+ &ignore_blocks](const BasicBlock* entry) {
+ DepthFirstTraversal(entry, succ_func, mark_visited, ignore_block,
+ ignore_blocks);
+ };
+
+ std::vector<BasicBlock*> result;
+
+ // First collect nodes without predecessors.
+ for (auto block : blocks) {
+ if (pred_func(block)->empty()) {
+ assert(visited.count(block) == 0 && "Malformed graph!");
+ result.push_back(block);
+ traverse_from_root(block);
}
}
- printf("%10s -> {%s\b}\n", module.getIdOrName(other.id()).c_str(),
- block_string.c_str());
+
+ // Now collect other stranded nodes. These must be in unreachable cycles.
+ for (auto block : blocks) {
+ if (visited.count(block) == 0) {
+ result.push_back(block);
+ traverse_from_root(block);
+ }
+ }
+
+ return result;
}
-} /// namespace
+
+} // anonymous namespace
+
+namespace libspirv {
+
+// Universal Limit of ResultID + 1
+static const uint32_t kInvalidId = 0x400000;
Function::Function(uint32_t function_id, uint32_t result_type_id,
SpvFunctionControlMask function_control,
- uint32_t function_type_id, ValidationState_t& module)
- : module_(module),
- id_(function_id),
+ uint32_t function_type_id)
+ : id_(function_id),
function_type_id_(function_type_id),
result_type_id_(result_type_id),
function_control_(function_control),
@@ -74,8 +111,6 @@
current_block_(nullptr),
pseudo_entry_block_(0),
pseudo_exit_block_(kInvalidId),
- pseudo_entry_blocks_({&pseudo_entry_block_}),
- pseudo_exit_blocks_({&pseudo_exit_block_}),
cfg_constructs_(),
variable_ids_(),
parameter_ids_() {}
@@ -86,9 +121,6 @@
spv_result_t Function::RegisterFunctionParameter(uint32_t parameter_id,
uint32_t type_id) {
- assert(module_.in_function_body() == true &&
- "RegisterFunctionParameter can only be called when parsing the binary "
- "outside of another function");
assert(current_block_ == nullptr &&
"RegisterFunctionParameter can only be called when parsing the binary "
"ouside of a block");
@@ -104,18 +136,17 @@
RegisterBlock(merge_id, false);
RegisterBlock(continue_id, false);
BasicBlock& merge_block = blocks_.at(merge_id);
- BasicBlock& continue_block = blocks_.at(continue_id);
+ BasicBlock& continue_target_block = blocks_.at(continue_id);
assert(current_block_ &&
"RegisterLoopMerge must be called when called within a block");
current_block_->set_type(kBlockTypeLoop);
merge_block.set_type(kBlockTypeMerge);
- continue_block.set_type(kBlockTypeContinue);
- cfg_constructs_.emplace_back(ConstructType::kLoop, current_block_,
- &merge_block);
- Construct& loop_construct = cfg_constructs_.back();
- cfg_constructs_.emplace_back(ConstructType::kContinue, &continue_block);
- Construct& continue_construct = cfg_constructs_.back();
+ continue_target_block.set_type(kBlockTypeContinue);
+ Construct& loop_construct =
+ AddConstruct({ConstructType::kLoop, current_block_, &merge_block});
+ Construct& continue_construct =
+ AddConstruct({ConstructType::kContinue, &continue_target_block});
continue_construct.set_corresponding_constructs({&loop_construct});
loop_construct.set_corresponding_constructs({&continue_construct});
@@ -128,30 +159,11 @@
current_block_->set_type(kBlockTypeHeader);
merge_block.set_type(kBlockTypeMerge);
- cfg_constructs_.emplace_back(ConstructType::kSelection, current_block(),
- &merge_block);
+ AddConstruct({ConstructType::kSelection, current_block(), &merge_block});
+
return SPV_SUCCESS;
}
-void Function::PrintDotGraph() const {
- if (first_block()) {
- string func_name(module_.getIdOrName(id_));
- printf("digraph %s {\n", func_name.c_str());
- PrintBlocks();
- printf("}\n");
- }
-}
-
-void Function::PrintBlocks() const {
- if (first_block()) {
- printf("%10s -> %s\n", module_.getIdOrName(id_).c_str(),
- module_.getIdOrName(first_block()->id()).c_str());
- for (const auto& block : blocks_) {
- printDot(block.second, module_);
- }
- }
-}
-
spv_result_t Function::RegisterSetFunctionDeclType(FunctionDecl type) {
assert(declaration_type_ == FunctionDecl::kFunctionDeclUnknown);
declaration_type_ = type;
@@ -159,12 +171,6 @@
}
spv_result_t Function::RegisterBlock(uint32_t block_id, bool is_definition) {
- assert(module_.in_function_body() == true &&
- "RegisterBlocks can only be called when parsing a binary inside of a "
- "function");
- assert(module_.current_layout_section() !=
- ModuleLayoutSection::kLayoutFunctionDeclarations &&
- "RegisterBlocks cannot be called within a function declaration");
assert(
declaration_type_ == FunctionDecl::kFunctionDeclDefinition &&
"RegisterBlocks can only be called after declaration_type_ is defined");
@@ -191,13 +197,9 @@
void Function::RegisterBlockEnd(vector<uint32_t> next_list,
SpvOp branch_instruction) {
- assert(module_.in_function_body() == true &&
- "RegisterBlockEnd can only be called when parsing a binary in a "
- "function");
assert(
current_block_ &&
"RegisterBlockEnd can only be called when parsing a binary in a block");
-
vector<BasicBlock*> next_blocks;
next_blocks.reserve(next_list.size());
@@ -212,6 +214,22 @@
next_blocks.push_back(&inserted_block->second);
}
+ if (current_block_->is_type(kBlockTypeLoop)) {
+ // For each loop header, record the set of its successors, and include
+ // its continue target if the continue target is not the loop header
+ // itself.
+ std::vector<BasicBlock*>& next_blocks_plus_continue_target =
+ loop_header_successors_plus_continue_target_map_[current_block_];
+ next_blocks_plus_continue_target = next_blocks;
+ auto continue_target = FindConstructForEntryBlock(current_block_)
+ .corresponding_constructs()
+ .back()
+ ->entry_block();
+ if (continue_target != current_block_) {
+ next_blocks_plus_continue_target.push_back(continue_target);
+ }
+ }
+
current_block_->RegisterBranchInstruction(branch_instruction);
current_block_->RegisterSuccessors(next_blocks);
current_block_ = nullptr;
@@ -222,16 +240,7 @@
if (!end_has_been_registered_) {
end_has_been_registered_ = true;
- // Compute the successors of the pseudo-entry block, and
- // the predecessors of the pseudo exit block.
- vector<BasicBlock*> sources;
- vector<BasicBlock*> sinks;
- for (const auto b : ordered_blocks_) {
- if (b->predecessors()->empty()) sources.push_back(b);
- if (b->successors()->empty()) sinks.push_back(b);
- }
- pseudo_entry_block_.SetSuccessorsUnsafe(std::move(sources));
- pseudo_exit_block_.SetPredecessorsUnsafe(std::move(sinks));
+ ComputeAugmentedCFG();
}
}
@@ -249,16 +258,6 @@
const BasicBlock* Function::current_block() const { return current_block_; }
BasicBlock* Function::current_block() { return current_block_; }
-BasicBlock* Function::pseudo_entry_block() { return &pseudo_entry_block_; }
-const BasicBlock* Function::pseudo_entry_block() const {
- return &pseudo_entry_block_;
-}
-
-BasicBlock* Function::pseudo_exit_block() { return &pseudo_exit_block_; }
-const BasicBlock* Function::pseudo_exit_block() const {
- return &pseudo_exit_block_;
-}
-
const list<Construct>& Function::constructs() const { return cfg_constructs_; }
list<Construct>& Function::constructs() { return cfg_constructs_; }
@@ -299,4 +298,89 @@
tie(out, defined) = const_cast<const Function*>(this)->GetBlock(block_id);
return make_pair(const_cast<BasicBlock*>(out), defined);
}
+
+Function::GetBlocksFunction Function::AugmentedCFGSuccessorsFunction() const {
+ return [this](const BasicBlock* block) {
+ auto where = augmented_successors_map_.find(block);
+ return where == augmented_successors_map_.end() ? block->successors()
+ : &(*where).second;
+ };
+}
+
+Function::GetBlocksFunction
+Function::AugmentedCFGSuccessorsFunctionIncludingHeaderToContinueEdge() const {
+ return [this](const BasicBlock* block) {
+ auto where = loop_header_successors_plus_continue_target_map_.find(block);
+ return where == loop_header_successors_plus_continue_target_map_.end()
+ ? AugmentedCFGSuccessorsFunction()(block)
+ : &(*where).second;
+ };
+}
+
+Function::GetBlocksFunction Function::AugmentedCFGPredecessorsFunction() const {
+ return [this](const BasicBlock* block) {
+ auto where = augmented_predecessors_map_.find(block);
+ return where == augmented_predecessors_map_.end() ? block->predecessors()
+ : &(*where).second;
+ };
+}
+
+void Function::ComputeAugmentedCFG() {
+ // Compute the successors of the pseudo-entry block, and
+ // the predecessors of the pseudo exit block.
+ auto succ_func = [](const BasicBlock* b) { return b->successors(); };
+ auto pred_func = [](const BasicBlock* b) { return b->predecessors(); };
+ auto sources = TraversalRoots(ordered_blocks_, succ_func, pred_func);
+
+ // For the predecessor traversals, reverse the order of blocks. This
+ // will affect the post-dominance calculation as follows:
+ // - Suppose you have blocks A and B, with A appearing before B in
+ // the list of blocks.
+ // - Also, A branches only to B, and B branches only to A.
+ // - We want to compute A as dominating B, and B as post-dominating B.
+ // By using reversed blocks for predecessor traversal roots discovery,
+ // we'll add an edge from B to the pseudo-exit node, rather than from A.
+ // All this is needed to correctly process the dominance/post-dominance
+ // constraint when A is a loop header that points to itself as its
+ // own continue target, and B is the latch block for the loop.
+ std::vector<BasicBlock*> reversed_blocks(ordered_blocks_.rbegin(),
+ ordered_blocks_.rend());
+ auto sinks = TraversalRoots(reversed_blocks, pred_func, succ_func);
+
+ // Wire up the pseudo entry block.
+ augmented_successors_map_[&pseudo_entry_block_] = sources;
+ for (auto block : sources) {
+ auto& augmented_preds = augmented_predecessors_map_[block];
+ const auto& preds = *block->predecessors();
+ augmented_preds.reserve(1 + preds.size());
+ augmented_preds.push_back(&pseudo_entry_block_);
+ augmented_preds.insert(augmented_preds.end(), preds.begin(), preds.end());
+ }
+
+ // Wire up the pseudo exit block.
+ augmented_predecessors_map_[&pseudo_exit_block_] = sinks;
+ for (auto block : sinks) {
+ auto& augmented_succ = augmented_successors_map_[block];
+ const auto& succ = *block->successors();
+ augmented_succ.reserve(1 + succ.size());
+ augmented_succ.push_back(&pseudo_exit_block_);
+ augmented_succ.insert(augmented_succ.end(), succ.begin(), succ.end());
+ }
+};
+
+Construct& Function::AddConstruct(const Construct& new_construct) {
+ cfg_constructs_.push_back(new_construct);
+ auto& result = cfg_constructs_.back();
+ entry_block_to_construct_[new_construct.entry_block()] = &result;
+ return result;
+}
+
+Construct& Function::FindConstructForEntryBlock(const BasicBlock* entry_block) {
+ auto where = entry_block_to_construct_.find(entry_block);
+ assert(where != entry_block_to_construct_.end());
+ auto construct_ptr = (*where).second;
+ assert(construct_ptr);
+ return *construct_ptr;
+}
+
} /// namespace libspirv
diff --git a/source/val/Function.h b/source/val/Function.h
index a8175e9..1fbe113 100644
--- a/source/val/Function.h
+++ b/source/val/Function.h
@@ -28,6 +28,7 @@
#define LIBSPIRV_VAL_FUNCTION_H_
#include <list>
+#include <functional>
#include <unordered_map>
#include <unordered_set>
#include <vector>
@@ -35,6 +36,7 @@
#include "spirv-tools/libspirv.h"
#include "spirv/1.1/spirv.h"
#include "val/BasicBlock.h"
+#include "val/Construct.h"
namespace libspirv {
@@ -44,17 +46,13 @@
kFunctionDeclDefinition /// < Function definition
};
-class Construct;
-class ValidationState_t;
-
/// This class manages all function declaration and definitions in a module. It
/// handles the state and id information while parsing a function in the SPIR-V
/// binary.
class Function {
public:
Function(uint32_t id, uint32_t result_type_id,
- SpvFunctionControlMask function_control, uint32_t function_type_id,
- ValidationState_t& module);
+ SpvFunctionControlMask function_control, uint32_t function_type_id);
/// Registers a function parameter in the current function
/// @return Returns SPV_SUCCESS if the call was successful
@@ -152,31 +150,41 @@
/// Returns the block that is currently being parsed in the binary
const BasicBlock* current_block() const;
- /// Returns the pseudo exit block
- BasicBlock* pseudo_entry_block();
+ // For dominance calculations, we want to analyze all the
+ // blocks in the function, even in degenerate control flow cases
+ // including unreachable blocks. We therefore make an "augmented CFG"
+ // which is the same as the ordinary CFG but adds:
+ // - A pseudo-entry node.
+ // - A pseudo-exit node.
+ // - A minimal set of edges so that a forward traversal from the
+ // pseudo-entry node will visit all nodes.
+ // - A minimal set of edges so that a backward traversal from the
+ // pseudo-exit node will visit all nodes.
+ // In particular, the pseudo-entry node is the unique source of the
+ // augmented CFG, and the psueo-exit node is the unique sink of the
+ // augmented CFG.
/// Returns the pseudo exit block
- const BasicBlock* pseudo_entry_block() const;
+ BasicBlock* pseudo_entry_block() { return &pseudo_entry_block_; }
/// Returns the pseudo exit block
- BasicBlock* pseudo_exit_block();
+ const BasicBlock* pseudo_entry_block() const { return &pseudo_entry_block_; }
/// Returns the pseudo exit block
- const BasicBlock* pseudo_exit_block() const;
+ BasicBlock* pseudo_exit_block() { return &pseudo_exit_block_; }
- /// Returns a vector with just the pseudo entry block.
- /// This serves as the predecessors of each source node in the CFG when
- /// computing dominators.
- const std::vector<BasicBlock*>* pseudo_entry_blocks() const {
- return &pseudo_entry_blocks_;
- }
+ /// Returns the pseudo exit block
+ const BasicBlock* pseudo_exit_block() const { return &pseudo_exit_block_; }
- /// Returns a vector with just the pseudo exit block.
- /// This serves as the successors of each sink node in the CFG when computing
- /// dominators.
- const std::vector<BasicBlock*>* pseudo_exit_blocks() const {
- return &pseudo_exit_blocks_;
- }
+ using GetBlocksFunction =
+ std::function<const std::vector<BasicBlock*>*(const BasicBlock*)>;
+ /// Returns the block successors function for the augmented CFG.
+ GetBlocksFunction AugmentedCFGSuccessorsFunction() const;
+ /// Like AugmentedCFGSuccessorsFunction, but also includes a forward edge from
+ /// a loop header block to its continue target, if they are different blocks.
+ GetBlocksFunction AugmentedCFGSuccessorsFunctionIncludingHeaderToContinueEdge() const;
+ /// Returns the block predecessors function for the augmented CFG.
+ GetBlocksFunction AugmentedCFGPredecessorsFunction() const;
/// Prints a GraphViz digraph of the CFG of the current funciton
void PrintDotGraph() const;
@@ -185,8 +193,17 @@
void PrintBlocks() const;
private:
- /// Parent module
- ValidationState_t& module_;
+ // Computes the representation of the augmented CFG.
+ // Populates augmented_successors_map_ and augmented_predecessors_map_.
+ void ComputeAugmentedCFG();
+
+ // Adds a copy of the given Construct, and tracks it by its entry block.
+ // Returns a reference to the stored construct.
+ Construct& AddConstruct(const Construct& new_construct);
+
+ // Returns a reference to the construct corresponding to the given entry
+ // block.
+ Construct& FindConstructForEntryBlock(const BasicBlock* entry_block);
/// The result id of the OpLabel that defined this block
uint32_t id_;
@@ -218,28 +235,49 @@
/// The block that is currently being parsed
BasicBlock* current_block_;
- /// A pseudo entry block that, for the purposes of dominance analysis,
- /// is considered the predecessor to any ordinary block without predecessors.
- /// After the function end has been registered, its successor list consists
- /// of all ordinary blocks without predecessors. It has no predecessors.
- /// It does not appear in the predecessor or successor list of any
- /// ordinary block.
+ /// A pseudo entry node used in dominance analysis.
+ /// After the function end has been registered, the successor list of the
+ /// pseudo entry node is the minimal set of nodes such that all nodes in the
+ /// CFG can be reached by following successor lists. That is, the successors
+ /// will be:
+ /// - Any basic block without predecessors. This includes the entry
+ /// block to the function.
+ /// - A single node from each otherwise unreachable cycle in the CFG, if
+ /// such cycles exist.
+ /// The pseudo entry node does not appear in the predecessor or successor
+ /// list of any ordinary block.
+ /// It has no predecessors.
/// It has Id 0.
BasicBlock pseudo_entry_block_;
- /// A pseudo exit block that, for the purposes of dominance analysis,
- /// is considered the successor to any ordinary block without successors.
- /// After the function end has been registered, its predecessor list consists
- /// of all ordinary blocks without successors. It has no successors.
- /// It does not appear in the predecessor or successor list of any
- /// ordinary block.
+ /// A pseudo exit block used in dominance analysis.
+ /// After the function end has been registered, the predecessor list of the
+ /// pseudo exit node is the minimal set of nodes such that all nodes in the
+ /// CFG can be reached by following predecessor lists. That is, the
+ /// predecessors will be:
+ /// - Any basic block without successors. This includes any basic block
+ /// ending with an OpReturn, OpReturnValue or similar instructions.
+ /// - A single node from each otherwise unreachable cycle in the CFG, if
+ /// such cycles exist.
+ /// The pseudo exit node does not appear in the predecessor or successor
+ /// list of any ordinary block.
+ /// It has no successors.
BasicBlock pseudo_exit_block_;
- // A vector containing pseudo_entry_block_.
- const std::vector<BasicBlock*> pseudo_entry_blocks_;
+ // Maps a block to its successors in the augmented CFG, if that set is
+ // different from its successors in the ordinary CFG.
+ std::unordered_map<const BasicBlock*, std::vector<BasicBlock*>>
+ augmented_successors_map_;
+ // Maps a block to its predecessors in the augmented CFG, if that set is
+ // different from its predecessors in the ordinary CFG.
+ std::unordered_map<const BasicBlock*, std::vector<BasicBlock*>>
+ augmented_predecessors_map_;
- // A vector containing pseudo_exit_block_.
- const std::vector<BasicBlock*> pseudo_exit_blocks_;
+ // Maps a structured loop header to its CFG successors and also its
+ // continue target if that continue target is not the loop header
+ // itself. This might have duplicates.
+ std::unordered_map<const BasicBlock*, std::vector<BasicBlock*>>
+ loop_header_successors_plus_continue_target_map_;
/// The constructs that are available in this function
std::list<Construct> cfg_constructs_;
@@ -249,6 +287,9 @@
/// The function parameter ids of the functions
std::vector<uint32_t> parameter_ids_;
+
+ /// Maps a construct's entry block to the construct.
+ std::unordered_map<const BasicBlock*, Construct*> entry_block_to_construct_;
};
} /// namespace libspirv
diff --git a/source/val/Id.cpp b/source/val/Id.cpp
new file mode 100644
index 0000000..2a0e01a
--- /dev/null
+++ b/source/val/Id.cpp
@@ -0,0 +1,62 @@
+// Copyright (c) 2015-2016 The Khronos Group Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+// https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#include "val/Id.h"
+
+namespace libspirv {
+#define OPERATOR(OP) \
+ bool operator OP(const Id& lhs, const Id& rhs) { \
+ return lhs.id_ OP rhs.id_; \
+ } \
+ bool operator OP(const Id& lhs, uint32_t rhs) { return lhs.id_ OP rhs; }
+
+OPERATOR(<)
+OPERATOR(==)
+#undef OPERATOR
+
+Id::Id(const uint32_t result_id)
+ : id_(result_id),
+ type_id_(0),
+ opcode_(SpvOpNop),
+ defining_function_(nullptr),
+ defining_block_(nullptr),
+ uses_(),
+ words_(0) {}
+
+Id::Id(const spv_parsed_instruction_t* inst, Function* function,
+ BasicBlock* block)
+ : id_(inst->result_id),
+ type_id_(inst->type_id),
+ opcode_(static_cast<SpvOp>(inst->opcode)),
+ defining_function_(function),
+ defining_block_(block),
+ uses_(),
+ words_(inst->words, inst->words + inst->num_words) {}
+
+void Id::RegisterUse(const BasicBlock* block) {
+ if (block) { uses_.insert(block); }
+}
+} // namespace libspirv
diff --git a/source/val/Id.h b/source/val/Id.h
new file mode 100644
index 0000000..c6e36cc
--- /dev/null
+++ b/source/val/Id.h
@@ -0,0 +1,135 @@
+// Copyright (c) 2015-2016 The Khronos Group Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+// https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#ifndef LIBSPIRV_VAL_ID_H_
+#define LIBSPIRV_VAL_ID_H_
+
+#include <cstdint>
+
+#include <functional>
+#include <set>
+
+#include "spirv-tools/libspirv.h"
+#include "val/Function.h"
+
+namespace libspirv {
+
+class BasicBlock;
+
+/// Represents a definition of any ID
+///
+/// This class represents the a definition of an Id in a module. This object can
+/// be formed as a complete, or incomplete Id. A complete Id allows you to
+/// reference all of the properties of this class and forms a fully defined
+/// object in the module. The incomplete Id is defined only by its integer value
+/// in a module and can only be used to search in a data structure.
+class Id {
+ public:
+ /// This constructor creates an incomplete Id. This constructor can be used to
+ /// create Id that are used to find other Ids
+ explicit Id(const uint32_t result_id = 0);
+
+ /// This constructor creates a complete Id.
+ explicit Id(const spv_parsed_instruction_t* inst,
+ Function* function = nullptr, BasicBlock* block = nullptr);
+
+ /// Registers a use of the Id
+ void RegisterUse(const BasicBlock* block = nullptr);
+
+ /// returns the id of the Id
+ operator uint32_t() const { return id_; }
+
+ uint32_t id() const { return id_; }
+ uint32_t type_id() const { return type_id_; }
+ SpvOp opcode() const { return opcode_; }
+
+ /// returns the Function where the id was defined. nullptr if it was defined
+ /// outside of a Function
+ const Function* defining_function() const { return defining_function_; }
+
+ /// returns the BasicBlock where the id was defined. nullptr if it was defined
+ /// outside of a BasicBlock
+ const BasicBlock* defining_block() const { return defining_block_; }
+
+ /// Returns the set of blocks where this Id was used
+ const std::set<const BasicBlock*>& uses() const { return uses_; }
+
+ /// The words used to define the Id
+ const std::vector<uint32_t>& words() const { return words_; }
+
+ private:
+ /// The integer that identifies the Id
+ uint32_t id_;
+
+ /// The type of the Id
+ uint32_t type_id_;
+
+ /// The opcode used to define the Id
+ SpvOp opcode_;
+
+ /// The function in which the Id was defined
+ Function* defining_function_;
+
+ /// The block in which the Id was defined
+ BasicBlock* defining_block_;
+
+ /// The blocks in which the Id was used
+ std::set<const BasicBlock*> uses_;
+
+ /// The words of the instuction that defined the Id
+ std::vector<uint32_t> words_;
+
+#define OPERATOR(OP) \
+ friend bool operator OP(const Id& lhs, const Id& rhs); \
+ friend bool operator OP(const Id& lhs, uint32_t rhs)
+ OPERATOR(<);
+ OPERATOR(==);
+#undef OPERATOR
+};
+
+#define OPERATOR(OP) \
+ bool operator OP(const Id& lhs, const Id& rhs); \
+ bool operator OP(const Id& lhs, uint32_t rhs)
+
+OPERATOR(<);
+OPERATOR(==);
+#undef OPERATOR
+
+} // namespace libspirv
+
+// custom specialization of std::hash for Id
+namespace std {
+template <>
+struct hash<libspirv::Id> {
+ typedef libspirv::Id argument_type;
+ typedef std::size_t result_type;
+ result_type operator()(const argument_type& id) const {
+ return hash<uint32_t>()(id);
+ }
+};
+} /// namespace std
+
+#endif // LIBSPIRV_VAL_ID_H_
diff --git a/source/val/ValidationState.cpp b/source/val/ValidationState.cpp
index 217b488..eba0d7f 100644
--- a/source/val/ValidationState.cpp
+++ b/source/val/ValidationState.cpp
@@ -33,7 +33,10 @@
#include "val/Function.h"
using std::list;
+using std::make_pair;
+using std::pair;
using std::string;
+using std::unordered_map;
using std::vector;
namespace libspirv {
@@ -248,7 +251,18 @@
}
bool ValidationState_t::IsDefinedId(uint32_t id) const {
- return usedefs_.FindDef(id).first;
+ return all_definitions_.find(Id{id}) != end(all_definitions_);
+}
+
+const Id* ValidationState_t::FindDef(uint32_t id) const {
+ if (all_definitions_.count(Id{id}) == 0) {
+ return nullptr;
+ } else {
+ /// We are in a const function, so we cannot use defs.operator[]().
+ /// Luckily we know the key exists, so defs_.at() won't throw an
+ /// exception.
+ return &all_definitions_.at(id);
+ }
}
// Increments the instruction count. Used for diagnostic
@@ -327,9 +341,7 @@
memory_model_ = mm;
}
-SpvMemoryModel ValidationState_t::memory_model() const {
- return memory_model_;
-}
+SpvMemoryModel ValidationState_t::memory_model() const { return memory_model_; }
spv_result_t ValidationState_t::RegisterFunction(
uint32_t id, uint32_t ret_type_id, SpvFunctionControlMask function_control,
@@ -339,7 +351,7 @@
"of another function");
in_function_ = true;
module_functions_.emplace_back(id, ret_type_id, function_control,
- function_type_id, *this);
+ function_type_id);
// TODO(umar): validate function type and type_id
@@ -358,4 +370,26 @@
return SPV_SUCCESS;
}
+void ValidationState_t::AddId(const spv_parsed_instruction_t& inst) {
+ if (in_function_body()) {
+ if (in_block()) {
+ all_definitions_[inst.result_id] =
+ Id{&inst, ¤t_function(), current_function().current_block()};
+ } else {
+ all_definitions_[inst.result_id] = Id{&inst, ¤t_function()};
+ }
+ } else {
+ all_definitions_[inst.result_id] = Id{&inst};
+ }
+}
+
+void ValidationState_t::RegisterUseId(uint32_t used_id) {
+ auto used = all_definitions_.find(used_id);
+ if (used != end(all_definitions_)) {
+ if (in_function_body())
+ used->second.RegisterUse(current_function().current_block());
+ else
+ used->second.RegisterUse(nullptr);
+ }
+}
} /// namespace libspirv
diff --git a/source/val/ValidationState.h b/source/val/ValidationState.h
index af5e54c..6a43c90 100644
--- a/source/val/ValidationState.h
+++ b/source/val/ValidationState.h
@@ -39,24 +39,11 @@
#include "spirv-tools/libspirv.h"
#include "spirv/1.1/spirv.h"
#include "spirv_definition.h"
+#include "val/Function.h"
+#include "val/Id.h"
namespace libspirv {
-// Universal Limit of ResultID + 1
-static const uint32_t kInvalidId = 0x400000;
-
-// Info about a result ID.
-typedef struct spv_id_info_t {
- /// Id value.
- uint32_t id;
- /// Type id, or 0 if no type.
- uint32_t type_id;
- /// Opcode of the instruction defining the id.
- SpvOp opcode;
- /// Binary words of the instruction defining the id.
- std::vector<uint32_t> words;
-} spv_id_info_t;
-
/// This enum represents the sections of a SPIRV module. See section 2.4
/// of the SPIRV spec for additional details of the order. The enumerant values
/// are in the same order as the vector returned by GetModuleOrder
@@ -75,8 +62,6 @@
kLayoutFunctionDefinitions /// < Section 2.4 #11
};
-class Function;
-
/// This class manages the state of the SPIR-V validation as it is being parsed.
class ValidationState_t {
public:
@@ -138,41 +123,6 @@
/// instruction
bool in_block() const;
- /// Keeps track of ID definitions and uses.
- class UseDefTracker {
- public:
- void AddDef(const spv_id_info_t& def) { defs_[def.id] = def; }
-
- void AddUse(uint32_t id) { uses_.insert(id); }
-
- /// Finds id's def, if it exists. If found, returns <true, def>. Otherwise,
- /// returns <false, something>.
- std::pair<bool, spv_id_info_t> FindDef(uint32_t id) const {
- if (defs_.count(id) == 0) {
- return std::make_pair(false, spv_id_info_t{});
- } else {
- /// We are in a const function, so we cannot use defs.operator[]().
- /// Luckily we know the key exists, so defs_.at() won't throw an
- /// exception.
- return std::make_pair(true, defs_.at(id));
- }
- }
-
- /// Returns uses of IDs lacking defs.
- std::unordered_set<uint32_t> FindUsesWithoutDefs() const {
- auto diff = uses_;
- for (const auto d : defs_) diff.erase(d.first);
- return diff;
- }
-
- private:
- std::unordered_set<uint32_t> uses_;
- std::unordered_map<uint32_t, spv_id_info_t> defs_;
- };
-
- UseDefTracker& usedefs() { return usedefs_; }
- const UseDefTracker& usedefs() const { return usedefs_; }
-
/// Returns a list of entry point function ids
std::vector<uint32_t>& entry_points() { return entry_points_; }
const std::vector<uint32_t>& entry_points() const { return entry_points_; }
@@ -210,7 +160,23 @@
AssemblyGrammar& grammar() { return grammar_; }
+ /// Adds an id to the module
+ void AddId(const spv_parsed_instruction_t& inst);
+
+ /// Register Id use
+ void RegisterUseId(uint32_t used_id);
+
+ /// Finds id's def, if it exists. If found, returns the definition otherwise
+ /// nullptr
+ const Id* FindDef(uint32_t id) const;
+
+ const std::unordered_map<uint32_t, Id>& all_definitions() const {
+ return all_definitions_;
+ }
+
private:
+ ValidationState_t(const ValidationState_t&);
+
spv_diagnostic* diagnostic_;
/// Tracks the number of instructions evaluated by the validator
int instruction_counter_;
@@ -231,8 +197,7 @@
spv_capability_mask_t
module_capabilities_; /// Module's declared capabilities.
- /// Definitions and uses of all the IDs in the module.
- UseDefTracker usedefs_;
+ std::unordered_map<uint32_t, Id> all_definitions_;
/// IDs that are entry points, ie, arguments to OpEntryPoint.
std::vector<uint32_t> entry_points_;
diff --git a/source/validate.cpp b/source/validate.cpp
index 6e10a8a..836bea1 100644
--- a/source/validate.cpp
+++ b/source/validate.cpp
@@ -59,7 +59,7 @@
using libspirv::CfgPass;
using libspirv::InstructionPass;
using libspirv::ModuleLayoutPass;
-using libspirv::SsaPass;
+using libspirv::IdPass;
using libspirv::ValidationState_t;
spv_result_t spvValidateIDs(
@@ -67,15 +67,11 @@
const spv_opcode_table opcodeTable, const spv_operand_table operandTable,
const spv_ext_inst_table extInstTable, const ValidationState_t& state,
spv_position position, spv_diagnostic* pDiagnostic) {
- auto undefd = state.usedefs().FindUsesWithoutDefs();
- for (auto id : undefd) {
- DIAGNOSTIC << "Undefined ID: " << id;
- }
position->index = SPV_INDEX_INSTRUCTION;
spvCheckReturn(spvValidateInstructionIDs(pInsts, count, opcodeTable,
operandTable, extInstTable, state,
position, pDiagnostic));
- return undefd.empty() ? SPV_SUCCESS : SPV_ERROR_INVALID_ID;
+ return SPV_SUCCESS;
}
namespace {
@@ -127,18 +123,6 @@
}
}
-// Collects use-def info about an instruction's IDs.
-void ProcessIds(ValidationState_t& _, const spv_parsed_instruction_t& inst) {
- if (inst.result_id) {
- _.usedefs().AddDef(
- {inst.result_id, inst.type_id, static_cast<SpvOp>(inst.opcode),
- std::vector<uint32_t>(inst.words, inst.words + inst.num_words)});
- }
- for (auto op = inst.operands; op != inst.operands + inst.num_operands; ++op) {
- if (spvIsIdType(op->type)) _.usedefs().AddUse(inst.words[op->offset]);
- }
-}
-
spv_result_t ProcessInstruction(void* user_data,
const spv_parsed_instruction_t* inst) {
ValidationState_t& _ = *(reinterpret_cast<ValidationState_t*>(user_data));
@@ -148,15 +132,53 @@
DebugInstructionPass(_, inst);
// TODO(umar): Perform data rules pass
- ProcessIds(_, *inst);
+ spvCheckReturn(IdPass(_, inst));
spvCheckReturn(ModuleLayoutPass(_, inst));
spvCheckReturn(CfgPass(_, inst));
- spvCheckReturn(SsaPass(_, inst));
spvCheckReturn(InstructionPass(_, inst));
return SPV_SUCCESS;
}
+void printDot(const ValidationState_t& _, const libspirv::BasicBlock& other) {
+ string block_string;
+ if (other.successors()->empty()) {
+ block_string += "end ";
+ } else {
+ for (auto block : *other.successors()) {
+ block_string += _.getIdOrName(block->id()) + " ";
+ }
+ }
+ printf("%10s -> {%s\b}\n", _.getIdOrName(other.id()).c_str(),
+ block_string.c_str());
+}
+
+void PrintBlocks(ValidationState_t& _, libspirv::Function func) {
+ assert(func.first_block());
+
+ printf("%10s -> %s\n", _.getIdOrName(func.id()).c_str(),
+ _.getIdOrName(func.first_block()->id()).c_str());
+ for (const auto& block : func.ordered_blocks()) {
+ printDot(_, *block);
+ }
+}
+
+#ifdef __clang__
+#define UNUSED(func) [[gnu::unused]] func
+#elif defined(__GNUC__)
+#define UNUSED(func) func __attribute__((unused)); func
+#elif defined(_MSC_VER)
+#define UNUSED(func) func
+#endif
+
+UNUSED(void PrintDotGraph(ValidationState_t& _, libspirv::Function func)) {
+ if (func.first_block()) {
+ string func_name(_.getIdOrName(func.id()));
+ printf("digraph %s {\n", func_name.c_str());
+ PrintBlocks(_, func);
+ printf("}\n");
+ }
+}
} // anonymous namespace
spv_result_t spvValidate(const spv_const_context context,
@@ -196,7 +218,7 @@
vector<uint32_t> ids = vstate.UnresolvedForwardIds();
transform(begin(ids), end(ids), ostream_iterator<string>(ss, " "),
- bind(&ValidationState_t::getIdName, vstate, _1));
+ bind(&ValidationState_t::getIdName, std::ref(vstate), _1));
auto id_str = ss.str();
return vstate.diag(SPV_ERROR_INVALID_ID)
@@ -207,6 +229,7 @@
// CFG checks are performed after the binary has been parsed
// and the CFGPass has collected information about the control flow
spvCheckReturn(PerformCfgChecks(vstate));
+ spvCheckReturn(CheckIdDefinitionDominateUse(vstate));
// NOTE: Copy each instruction for easier processing
std::vector<spv_instruction_t> instructions;
diff --git a/source/validate.h b/source/validate.h
index 35ec9a6..c6ffac0 100644
--- a/source/validate.h
+++ b/source/validate.h
@@ -27,37 +27,49 @@
#ifndef LIBSPIRV_VALIDATE_H_
#define LIBSPIRV_VALIDATE_H_
-#include <algorithm>
-#include <array>
#include <functional>
-#include <list>
-#include <map>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
#include <utility>
#include <vector>
-#include "assembly_grammar.h"
-#include "binary.h"
-#include "diagnostic.h"
#include "instruction.h"
#include "spirv-tools/libspirv.h"
-#include "spirv_definition.h"
#include "table.h"
-#include "val/BasicBlock.h"
-
-// Structures
namespace libspirv {
class ValidationState_t;
+class BasicBlock;
/// A function that returns a vector of BasicBlocks given a BasicBlock. Used to
/// get the successor and predecessor nodes of a CFG block
using get_blocks_func =
std::function<const std::vector<BasicBlock*>*(const BasicBlock*)>;
+/// @brief Depth first traversal starting from the \p entry BasicBlock
+///
+/// This function performs a depth first traversal from the \p entry
+/// BasicBlock and calls the pre/postorder functions when it needs to process
+/// the node in pre order, post order. It also calls the backedge function
+/// when a back edge is encountered.
+///
+/// @param[in] entry The root BasicBlock of a CFG
+/// @param[in] successor_func A function which will return a pointer to the
+/// successor nodes
+/// @param[in] preorder A function that will be called for every block in a
+/// CFG following preorder traversal semantics
+/// @param[in] postorder A function that will be called for every block in a
+/// CFG following postorder traversal semantics
+/// @param[in] backedge A function that will be called when a backedge is
+/// encountered during a traversal
+/// NOTE: The @p successor_func and predecessor_func each return a pointer to a
+/// collection such that iterators to that collection remain valid for the
+/// lifetime of the algorithm.
+void DepthFirstTraversal(
+ const BasicBlock* entry, get_blocks_func successor_func,
+ std::function<void(const BasicBlock*)> preorder,
+ std::function<void(const BasicBlock*)> postorder,
+ std::function<void(const BasicBlock*, const BasicBlock*)> backedge);
+
/// @brief Calculates dominator edges for a set of blocks
///
/// Computes dominators using the algorithm of Cooper, Harvey, and Kennedy
@@ -89,6 +101,18 @@
/// @return SPV_SUCCESS if no errors are found. SPV_ERROR_INVALID_CFG otherwise
spv_result_t PerformCfgChecks(ValidationState_t& _);
+/// @brief This function checks all ID definitions dominate their use in the
+/// CFG.
+///
+/// This function will iterate over all ID definitions that are defined in the
+/// functions of a module and make sure that the definitions appear in a
+/// block that dominates their use.
+///
+/// @param[in] _ the validation state of the module
+///
+/// @return SPV_SUCCESS if no errors are found. SPV_ERROR_INVALID_ID otherwise
+spv_result_t CheckIdDefinitionDominateUse(const ValidationState_t& _);
+
/// @brief Updates the immediate dominator for each of the block edges
///
/// Updates the immediate dominator of the blocks for each of the edges
@@ -115,9 +139,8 @@
spv_result_t CfgPass(ValidationState_t& _,
const spv_parsed_instruction_t* inst);
-/// Performs SSA validation of a module
-spv_result_t SsaPass(ValidationState_t& _,
- const spv_parsed_instruction_t* inst);
+/// Performs Id and SSA validation of a module
+spv_result_t IdPass(ValidationState_t& _, const spv_parsed_instruction_t* inst);
/// Performs instruction validation.
spv_result_t InstructionPass(ValidationState_t& _,
diff --git a/source/validate_cfg.cpp b/source/validate_cfg.cpp
index a95f2cd..6342a91 100644
--- a/source/validate_cfg.cpp
+++ b/source/validate_cfg.cpp
@@ -30,8 +30,9 @@
#include <algorithm>
#include <functional>
-#include <set>
+#include <map>
#include <string>
+#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
@@ -47,12 +48,14 @@
using std::get;
using std::ignore;
using std::make_pair;
+using std::make_tuple;
using std::numeric_limits;
using std::pair;
using std::set;
using std::string;
using std::tie;
using std::transform;
+using std::tuple;
using std::unordered_map;
using std::unordered_set;
using std::vector;
@@ -86,26 +89,8 @@
return false;
}
-/// @brief Depth first traversal starting from the \p entry BasicBlock
-///
-/// This function performs a depth first traversal from the \p entry
-/// BasicBlock and calls the pre/postorder functions when it needs to process
-/// the node in pre order, post order. It also calls the backedge function
-/// when a back edge is encountered.
-///
-/// @param[in] entry The root BasicBlock of a CFG
-/// @param[in] successor_func A function which will return a pointer to the
-/// successor nodes
-/// @param[in] preorder A function that will be called for every block in a
-/// CFG following preorder traversal semantics
-/// @param[in] postorder A function that will be called for every block in a
-/// CFG following postorder traversal semantics
-/// @param[in] backedge A function that will be called when a backedge is
-/// encountered during a traversal
-/// NOTE: The @p successor_func and predecessor_func each return a pointer to a
-/// collection such that iterators to that collection remain valid for the
-/// lifetime
-/// of the algorithm
+} // namespace
+
void DepthFirstTraversal(const BasicBlock* entry,
get_blocks_func successor_func,
function<void(cbb_ptr)> preorder,
@@ -143,8 +128,6 @@
}
}
-} // namespace
-
vector<pair<BasicBlock*, BasicBlock*>> CalculateDominators(
const vector<cbb_ptr>& postorder, get_blocks_func predecessor_func) {
struct block_detail {
@@ -164,10 +147,12 @@
changed = false;
for (auto b = postorder.rbegin() + 1; b != postorder.rend(); ++b) {
const vector<BasicBlock*>& predecessors = *predecessor_func(*b);
- // first processed/reachable predecessor
+ // Find the first processed/reachable predecessor that is reachable
+ // in the forward traversal.
auto res = find_if(begin(predecessors), end(predecessors),
[&idoms, undefined_dom](BasicBlock* pred) {
- return idoms[pred].dominator != undefined_dom;
+ return idoms.count(pred) &&
+ idoms[pred].dominator != undefined_dom;
});
if (res == end(predecessors)) continue;
const BasicBlock* idom = *res;
@@ -176,6 +161,10 @@
// all other predecessors
for (const auto* p : predecessors) {
if (idom == p) continue;
+ // Only consider nodes reachable in the forward traversal.
+ // Otherwise the intersection doesn't make sense and will never
+ // terminate.
+ if (!idoms.count(p)) continue;
if (idoms[p].dominator != undefined_dom) {
size_t finger1 = idoms[p].postorder_index;
size_t finger2 = idom_idx;
@@ -248,7 +237,6 @@
uint32_t back_edge_block_id;
uint32_t loop_header_block_id;
tie(back_edge_block_id, loop_header_block_id) = edge;
-
auto is_this_header = [=](Construct& c) {
return c.type() == ConstructType::kLoop &&
c.entry_block()->id() == loop_header_block_id;
@@ -268,22 +256,10 @@
}
}
-/// Constructs an error message for construct validation errors
-string ConstructErrorString(const Construct& construct,
- const string& header_string,
- const string& exit_string,
- bool post_dominate = false) {
- string construct_name;
- string header_name;
- string exit_name;
- string dominate_text;
- if (post_dominate) {
- dominate_text = "is not post dominated by";
- } else {
- dominate_text = "does not dominate";
- }
+tuple<string, string, string> ConstructNames(ConstructType type) {
+ string construct_name, header_name, exit_name;
- switch (construct.type()) {
+ switch (type) {
case ConstructType::kSelection:
construct_name = "selection";
header_name = "selection header";
@@ -301,12 +277,31 @@
break;
case ConstructType::kCase:
construct_name = "case";
- header_name = "case block";
- exit_name = "exit block"; // TODO(umar): there has to be a better name
+ header_name = "case entry block";
+ exit_name = "case exit block";
break;
default:
assert(1 == 0 && "Not defined type");
}
+
+ return make_tuple(construct_name, header_name, exit_name);
+}
+
+/// Constructs an error message for construct validation errors
+string ConstructErrorString(const Construct& construct,
+ const string& header_string,
+ const string& exit_string,
+ bool post_dominate = false) {
+ string construct_name, header_name, exit_name, dominate_text;
+ if (post_dominate) {
+ dominate_text = "is not post dominated by";
+ } else {
+ dominate_text = "does not dominate";
+ }
+
+ tie(construct_name, header_name, exit_name) =
+ ConstructNames(construct.type());
+
// TODO(umar): Add header block for continue constructs to error message
return "The " + construct_name + " construct with the " + header_name + " " +
header_string + " " + dominate_text + " the " + exit_name + " " +
@@ -318,7 +313,9 @@
const vector<pair<uint32_t, uint32_t>>& back_edges) {
/// Check all backedges target only loop headers and have exactly one
/// back-edge branching to it
- set<uint32_t> loop_headers;
+
+ // Map a loop header to blocks with back-edges to the loop header.
+ std::map<uint32_t, std::unordered_set<uint32_t>> loop_latch_blocks;
for (auto back_edge : back_edges) {
uint32_t back_edge_block;
uint32_t header_block;
@@ -329,14 +326,20 @@
<< _.getIdName(header_block)
<< ") can only be formed between a block and a loop header.";
}
- bool success;
- tie(ignore, success) = loop_headers.insert(header_block);
- if (!success) {
- // TODO(umar): List the back-edge blocks that are branching to loop
- // header
+ loop_latch_blocks[header_block].insert(back_edge_block);
+ }
+
+ // Check the loop headers have exactly one back-edge branching to it
+ for (BasicBlock* loop_header : function.ordered_blocks()) {
+ if (!loop_header->reachable()) continue;
+ if (!loop_header->is_type(kBlockTypeLoop)) continue;
+ auto loop_header_id = loop_header->id();
+ auto num_latch_blocks = loop_latch_blocks[loop_header_id].size();
+ if (num_latch_blocks != 1) {
return _.diag(SPV_ERROR_INVALID_CFG)
- << "Loop header " << _.getIdName(header_block)
- << " targeted by multiple back-edges";
+ << "Loop header " << _.getIdName(loop_header_id)
+ << " is targeted by " << num_latch_blocks
+ << " back-edge blocks but the standard requires exactly one";
}
}
@@ -345,15 +348,27 @@
auto header = construct.entry_block();
auto merge = construct.exit_block();
- // if the merge block is reachable then it's dominated by the header
- if (merge->reachable() &&
+ if (header->reachable() && !merge) {
+ string construct_name, header_name, exit_name;
+ tie(construct_name, header_name, exit_name) =
+ ConstructNames(construct.type());
+ return _.diag(SPV_ERROR_INTERNAL)
+ << "Construct " + construct_name + " with " + header_name + " " +
+ _.getIdName(header->id()) + " does not have a " +
+ exit_name + ". This may be a bug in the validator.";
+ }
+
+ // If the merge block is reachable then it's dominated by the header.
+ if (merge && merge->reachable() &&
find(merge->dom_begin(), merge->dom_end(), header) ==
merge->dom_end()) {
return _.diag(SPV_ERROR_INVALID_CFG)
<< ConstructErrorString(construct, _.getIdName(header->id()),
_.getIdName(merge->id()));
}
- if (construct.type() == ConstructType::kContinue) {
+ // Check post-dominance for continue constructs. But dominance and
+ // post-dominance only make sense when the construct is reachable.
+ if (header->reachable() && construct.type() == ConstructType::kContinue) {
if (find(header->pdom_begin(), header->pdom_end(), merge) ==
merge->pdom_end()) {
return _.diag(SPV_ERROR_INVALID_CFG)
@@ -389,70 +404,49 @@
<< _.getIdName(function.id());
}
- // Prepare for dominance calculations. We want to analyze all the
- // blocks in the function, even in degenerate control flow cases
- // including unreachable blocks. For this calculation, we create an
- // agumented CFG by adding a pseudo-entry node that is considered the
- // predecessor of each source in the original CFG, and a pseudo-exit
- // node that is considered the successor to each sink in the original
- // CFG. The augmented CFG is guaranteed to have a single source node
- // (i.e. not having predecessors) and a single exit node (i.e. not
- // having successors). However, there might be isolated strongly
- // connected components that are not reachable by following successors
- // from the pseudo entry node, and not reachable by following
- // predecessors from the pseudo exit node.
-
- auto* pseudo_entry = function.pseudo_entry_block();
- auto* pseudo_exit = function.pseudo_exit_block();
- // We need vectors to use as the predecessors (in the augmented CFG)
- // for the source nodes of the original CFG. It must have a stable
- // address for the duration of the calculation.
- auto* pseudo_entry_vec = function.pseudo_entry_blocks();
- // Similarly, we need a vector to be used as the successors (in the
- // augmented CFG) for sinks in the original CFG.
- auto* pseudo_exit_vec = function.pseudo_exit_blocks();
- // Returns the predecessors of a block in the augmented CFG.
- auto augmented_predecessor_fn = [pseudo_entry, pseudo_entry_vec](
- const BasicBlock* block) {
- auto predecessors = block->predecessors();
- return (block != pseudo_entry && predecessors->empty()) ? pseudo_entry_vec
- : predecessors;
- };
- // Returns the successors of a block in the augmented CFG.
- auto augmented_successor_fn = [pseudo_exit,
- pseudo_exit_vec](const BasicBlock* block) {
- auto successors = block->successors();
- return (block != pseudo_exit && successors->empty()) ? pseudo_exit_vec
- : successors;
- };
-
// Set each block's immediate dominator and immediate postdominator,
// and find all back-edges.
+ //
+ // We want to analyze all the blocks in the function, even in degenerate
+ // control flow cases including unreachable blocks. So use the augmented
+ // CFG to ensure we cover all the blocks.
vector<const BasicBlock*> postorder;
vector<const BasicBlock*> postdom_postorder;
vector<pair<uint32_t, uint32_t>> back_edges;
+ auto ignore_block = [](cbb_ptr) {};
+ auto ignore_edge = [](cbb_ptr, cbb_ptr) {};
if (!function.ordered_blocks().empty()) {
/// calculate dominators
- DepthFirstTraversal(pseudo_entry, augmented_successor_fn, [](cbb_ptr) {},
+ DepthFirstTraversal(function.first_block(),
+ function.AugmentedCFGSuccessorsFunction(),
+ ignore_block,
[&](cbb_ptr b) { postorder.push_back(b); },
- [&](cbb_ptr from, cbb_ptr to) {
- back_edges.emplace_back(from->id(), to->id());
- });
- auto edges =
- libspirv::CalculateDominators(postorder, augmented_predecessor_fn);
+ ignore_edge);
+ auto edges = libspirv::CalculateDominators(
+ postorder, function.AugmentedCFGPredecessorsFunction());
for (auto edge : edges) {
edge.first->SetImmediateDominator(edge.second);
}
/// calculate post dominators
- DepthFirstTraversal(pseudo_exit, augmented_predecessor_fn, [](cbb_ptr) {},
+ DepthFirstTraversal(function.pseudo_exit_block(),
+ function.AugmentedCFGPredecessorsFunction(),
+ ignore_block,
[&](cbb_ptr b) { postdom_postorder.push_back(b); },
- [&](cbb_ptr, cbb_ptr) {});
+ ignore_edge);
auto postdom_edges = libspirv::CalculateDominators(
- postdom_postorder, augmented_successor_fn);
+ postdom_postorder, function.AugmentedCFGSuccessorsFunction());
for (auto edge : postdom_edges) {
edge.first->SetImmediatePostDominator(edge.second);
}
+ /// calculate back edges.
+ DepthFirstTraversal(
+ function.pseudo_entry_block(),
+ function
+ .AugmentedCFGSuccessorsFunctionIncludingHeaderToContinueEdge(),
+ ignore_block, ignore_block, [&](cbb_ptr from, cbb_ptr to) {
+ back_edges.emplace_back(from->id(), to->id());
+ });
}
UpdateContinueConstructExitBlocks(function, back_edges);
@@ -462,7 +456,7 @@
if (blocks.empty() == false) {
for (auto block = begin(blocks) + 1; block != end(blocks); ++block) {
if (auto idom = (*block)->immediate_dominator()) {
- if (idom != pseudo_entry &&
+ if (idom != function.pseudo_entry_block() &&
block == std::find(begin(blocks), block, idom)) {
return _.diag(SPV_ERROR_INVALID_CFG)
<< "Block " << _.getIdName((*block)->id())
diff --git a/source/validate_id.cpp b/source/validate_id.cpp
index e98b339..b94e861 100644
--- a/source/validate_id.cpp
+++ b/source/validate_id.cpp
@@ -28,6 +28,7 @@
#include <cassert>
+#include <algorithm>
#include <iostream>
#include <unordered_map>
#include <vector>
@@ -43,7 +44,9 @@
action; \
}
-using UseDefTracker = libspirv::ValidationState_t::UseDefTracker;
+using libspirv::ValidationState_t;
+using std::function;
+using std::ignore;
namespace {
@@ -55,7 +58,7 @@
const spv_instruction_t* pInsts, const uint64_t instCountArg,
const SpvMemoryModel memoryModelArg,
const SpvAddressingModel addressingModelArg,
- const UseDefTracker& usedefs,
+ const ValidationState_t& module,
const std::vector<uint32_t>& entry_points, spv_position positionArg,
spv_diagnostic* pDiagnosticArg)
: opcodeTable(opcodeTableArg),
@@ -67,7 +70,7 @@
addressingModel(addressingModelArg),
position(positionArg),
pDiagnostic(pDiagnosticArg),
- usedefs_(usedefs),
+ module_(module),
entry_points_(entry_points) {}
bool isValid(const spv_instruction_t* inst);
@@ -85,7 +88,7 @@
const SpvAddressingModel addressingModel;
spv_position position;
spv_diagnostic* pDiagnostic;
- UseDefTracker usedefs_;
+ const ValidationState_t& module_;
std::vector<uint32_t> entry_points_;
};
@@ -106,20 +109,20 @@
bool idUsage::isValid<SpvOpMemberName>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto typeIndex = 1;
- auto type = usedefs_.FindDef(inst->words[typeIndex]);
- if (!type.first || SpvOpTypeStruct != type.second.opcode) {
+ auto type = module_.FindDef(inst->words[typeIndex]);
+ if (!type || SpvOpTypeStruct != type->opcode()) {
DIAG(typeIndex) << "OpMemberName Type <id> '" << inst->words[typeIndex]
<< "' is not a struct type.";
return false;
}
auto memberIndex = 2;
auto member = inst->words[memberIndex];
- auto memberCount = (uint32_t)(type.second.words.size() - 2);
+ auto memberCount = (uint32_t)(type->words().size() - 2);
spvCheck(memberCount <= member, DIAG(memberIndex)
<< "OpMemberName Member <id> '"
<< inst->words[memberIndex]
<< "' index is larger than Type <id> '"
- << type.second.id << "'s member count.";
+ << type->id() << "'s member count.";
return false);
return true;
}
@@ -128,8 +131,8 @@
bool idUsage::isValid<SpvOpLine>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto fileIndex = 1;
- auto file = usedefs_.FindDef(inst->words[fileIndex]);
- if (!file.first || SpvOpString != file.second.opcode) {
+ auto file = module_.FindDef(inst->words[fileIndex]);
+ if (!file || SpvOpString != file->opcode()) {
DIAG(fileIndex) << "OpLine Target <id> '" << inst->words[fileIndex]
<< "' is not an OpString.";
return false;
@@ -141,8 +144,8 @@
bool idUsage::isValid<SpvOpMemberDecorate>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto structTypeIndex = 1;
- auto structType = usedefs_.FindDef(inst->words[structTypeIndex]);
- if (!structType.first || SpvOpTypeStruct != structType.second.opcode) {
+ auto structType = module_.FindDef(inst->words[structTypeIndex]);
+ if (!structType || SpvOpTypeStruct != structType->opcode()) {
DIAG(structTypeIndex) << "OpMemberDecorate Structure type <id> '"
<< inst->words[structTypeIndex]
<< "' is not a struct type.";
@@ -150,7 +153,7 @@
}
auto memberIndex = 2;
auto member = inst->words[memberIndex];
- auto memberCount = static_cast<uint32_t>(structType.second.words.size() - 2);
+ auto memberCount = static_cast<uint32_t>(structType->words().size() - 2);
spvCheck(memberCount < member, DIAG(memberIndex)
<< "OpMemberDecorate Structure type <id> '"
<< inst->words[memberIndex]
@@ -163,9 +166,8 @@
bool idUsage::isValid<SpvOpGroupDecorate>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto decorationGroupIndex = 1;
- auto decorationGroup = usedefs_.FindDef(inst->words[decorationGroupIndex]);
- if (!decorationGroup.first ||
- SpvOpDecorationGroup != decorationGroup.second.opcode) {
+ auto decorationGroup = module_.FindDef(inst->words[decorationGroupIndex]);
+ if (!decorationGroup || SpvOpDecorationGroup != decorationGroup->opcode()) {
DIAG(decorationGroupIndex) << "OpGroupDecorate Decoration group <id> '"
<< inst->words[decorationGroupIndex]
<< "' is not a decoration group.";
@@ -190,8 +192,8 @@
bool idUsage::isValid<SpvOpEntryPoint>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto entryPointIndex = 2;
- auto entryPoint = usedefs_.FindDef(inst->words[entryPointIndex]);
- if (!entryPoint.first || SpvOpFunction != entryPoint.second.opcode) {
+ auto entryPoint = module_.FindDef(inst->words[entryPointIndex]);
+ if (!entryPoint || SpvOpFunction != entryPoint->opcode()) {
DIAG(entryPointIndex) << "OpEntryPoint Entry Point <id> '"
<< inst->words[entryPointIndex]
<< "' is not a function.";
@@ -202,16 +204,16 @@
if (executionModel != SpvExecutionModelKernel) {
// TODO: Check the entry point signature is void main(void), may be subject
// to change
- auto entryPointType = usedefs_.FindDef(entryPoint.second.words[4]);
- if (!entryPointType.first || 3 != entryPointType.second.words.size()) {
+ auto entryPointType = module_.FindDef(entryPoint->words()[4]);
+ if (!entryPointType || 3 != entryPointType->words().size()) {
DIAG(entryPointIndex) << "OpEntryPoint Entry Point <id> '"
<< inst->words[entryPointIndex]
<< "'s function parameter count is not zero.";
return false;
}
}
- auto returnType = usedefs_.FindDef(entryPoint.second.type_id);
- if (!returnType.first || SpvOpTypeVoid != returnType.second.opcode) {
+ auto returnType = module_.FindDef(entryPoint->type_id());
+ if (!returnType || SpvOpTypeVoid != returnType->opcode()) {
DIAG(entryPointIndex) << "OpEntryPoint Entry Point <id> '"
<< inst->words[entryPointIndex]
<< "'s function return type is not void.";
@@ -241,9 +243,8 @@
bool idUsage::isValid<SpvOpTypeVector>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto componentIndex = 2;
- auto componentType = usedefs_.FindDef(inst->words[componentIndex]);
- if (!componentType.first ||
- !spvOpcodeIsScalarType(componentType.second.opcode)) {
+ auto componentType = module_.FindDef(inst->words[componentIndex]);
+ if (!componentType || !spvOpcodeIsScalarType(componentType->opcode())) {
DIAG(componentIndex) << "OpTypeVector Component Type <id> '"
<< inst->words[componentIndex]
<< "' is not a scalar type.";
@@ -256,8 +257,8 @@
bool idUsage::isValid<SpvOpTypeMatrix>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto columnTypeIndex = 2;
- auto columnType = usedefs_.FindDef(inst->words[columnTypeIndex]);
- if (!columnType.first || SpvOpTypeVector != columnType.second.opcode) {
+ auto columnType = module_.FindDef(inst->words[columnTypeIndex]);
+ if (!columnType || SpvOpTypeVector != columnType->opcode()) {
DIAG(columnTypeIndex) << "OpTypeMatrix Column Type <id> '"
<< inst->words[columnTypeIndex]
<< "' is not a vector.";
@@ -297,36 +298,35 @@
bool idUsage::isValid<SpvOpTypeArray>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto elementTypeIndex = 2;
- auto elementType = usedefs_.FindDef(inst->words[elementTypeIndex]);
- if (!elementType.first ||
- !spvOpcodeGeneratesType(elementType.second.opcode)) {
+ auto elementType = module_.FindDef(inst->words[elementTypeIndex]);
+ if (!elementType || !spvOpcodeGeneratesType(elementType->opcode())) {
DIAG(elementTypeIndex) << "OpTypeArray Element Type <id> '"
<< inst->words[elementTypeIndex]
<< "' is not a type.";
return false;
}
auto lengthIndex = 3;
- auto length = usedefs_.FindDef(inst->words[lengthIndex]);
- if (!length.first || !spvOpcodeIsConstant(length.second.opcode)) {
+ auto length = module_.FindDef(inst->words[lengthIndex]);
+ if (!length || !spvOpcodeIsConstant(length->opcode())) {
DIAG(lengthIndex) << "OpTypeArray Length <id> '" << inst->words[lengthIndex]
<< "' is not a scalar constant type.";
return false;
}
// NOTE: Check the initialiser value of the constant
- auto constInst = length.second.words;
+ auto constInst = length->words();
auto constResultTypeIndex = 1;
- auto constResultType = usedefs_.FindDef(constInst[constResultTypeIndex]);
- if (!constResultType.first || SpvOpTypeInt != constResultType.second.opcode) {
+ auto constResultType = module_.FindDef(constInst[constResultTypeIndex]);
+ if (!constResultType || SpvOpTypeInt != constResultType->opcode()) {
DIAG(lengthIndex) << "OpTypeArray Length <id> '" << inst->words[lengthIndex]
<< "' is not a constant integer type.";
return false;
}
- switch (length.second.opcode) {
+ switch (length->opcode()) {
case SpvOpSpecConstant:
case SpvOpConstant:
- if (aboveZero(length.second.words, constResultType.second.words)) break;
+ if (aboveZero(length->words(), constResultType->words())) break;
// Else fall through!
case SpvOpConstantNull: {
DIAG(lengthIndex) << "OpTypeArray Length <id> '"
@@ -347,9 +347,8 @@
bool idUsage::isValid<SpvOpTypeRuntimeArray>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto elementTypeIndex = 2;
- auto elementType = usedefs_.FindDef(inst->words[elementTypeIndex]);
- if (!elementType.first ||
- !spvOpcodeGeneratesType(elementType.second.opcode)) {
+ auto elementType = module_.FindDef(inst->words[elementTypeIndex]);
+ if (!elementType || !spvOpcodeGeneratesType(elementType->opcode())) {
DIAG(elementTypeIndex) << "OpTypeRuntimeArray Element Type <id> '"
<< inst->words[elementTypeIndex]
<< "' is not a type.";
@@ -363,9 +362,8 @@
const spv_opcode_desc) {
for (size_t memberTypeIndex = 2; memberTypeIndex < inst->words.size();
++memberTypeIndex) {
- auto memberType = usedefs_.FindDef(inst->words[memberTypeIndex]);
- if (!memberType.first ||
- !spvOpcodeGeneratesType(memberType.second.opcode)) {
+ auto memberType = module_.FindDef(inst->words[memberTypeIndex]);
+ if (!memberType || !spvOpcodeGeneratesType(memberType->opcode())) {
DIAG(memberTypeIndex) << "OpTypeStruct Member Type <id> '"
<< inst->words[memberTypeIndex]
<< "' is not a type.";
@@ -379,8 +377,8 @@
bool idUsage::isValid<SpvOpTypePointer>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto typeIndex = 3;
- auto type = usedefs_.FindDef(inst->words[typeIndex]);
- if (!type.first || !spvOpcodeGeneratesType(type.second.opcode)) {
+ auto type = module_.FindDef(inst->words[typeIndex]);
+ if (!type || !spvOpcodeGeneratesType(type->opcode())) {
DIAG(typeIndex) << "OpTypePointer Type <id> '" << inst->words[typeIndex]
<< "' is not a type.";
return false;
@@ -392,16 +390,16 @@
bool idUsage::isValid<SpvOpTypeFunction>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto returnTypeIndex = 2;
- auto returnType = usedefs_.FindDef(inst->words[returnTypeIndex]);
- if (!returnType.first || !spvOpcodeGeneratesType(returnType.second.opcode)) {
+ auto returnType = module_.FindDef(inst->words[returnTypeIndex]);
+ if (!returnType || !spvOpcodeGeneratesType(returnType->opcode())) {
DIAG(returnTypeIndex) << "OpTypeFunction Return Type <id> '"
<< inst->words[returnTypeIndex] << "' is not a type.";
return false;
}
for (size_t paramTypeIndex = 3; paramTypeIndex < inst->words.size();
++paramTypeIndex) {
- auto paramType = usedefs_.FindDef(inst->words[paramTypeIndex]);
- if (!paramType.first || !spvOpcodeGeneratesType(paramType.second.opcode)) {
+ auto paramType = module_.FindDef(inst->words[paramTypeIndex]);
+ if (!paramType || !spvOpcodeGeneratesType(paramType->opcode())) {
DIAG(paramTypeIndex) << "OpTypeFunction Parameter Type <id> '"
<< inst->words[paramTypeIndex] << "' is not a type.";
return false;
@@ -421,8 +419,8 @@
bool idUsage::isValid<SpvOpConstantTrue>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first || SpvOpTypeBool != resultType.second.opcode) {
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType || SpvOpTypeBool != resultType->opcode()) {
DIAG(resultTypeIndex) << "OpConstantTrue Result Type <id> '"
<< inst->words[resultTypeIndex]
<< "' is not a boolean type.";
@@ -435,8 +433,8 @@
bool idUsage::isValid<SpvOpConstantFalse>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first || SpvOpTypeBool != resultType.second.opcode) {
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType || SpvOpTypeBool != resultType->opcode()) {
DIAG(resultTypeIndex) << "OpConstantFalse Result Type <id> '"
<< inst->words[resultTypeIndex]
<< "' is not a boolean type.";
@@ -449,8 +447,8 @@
bool idUsage::isValid<SpvOpConstantComposite>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first || !spvOpcodeIsComposite(resultType.second.opcode)) {
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType || !spvOpcodeIsComposite(resultType->opcode())) {
DIAG(resultTypeIndex) << "OpConstantComposite Result Type <id> '"
<< inst->words[resultTypeIndex]
<< "' is not a composite type.";
@@ -458,163 +456,155 @@
}
auto constituentCount = inst->words.size() - 3;
- switch (resultType.second.opcode) {
+ switch (resultType->opcode()) {
case SpvOpTypeVector: {
- auto componentCount = resultType.second.words[3];
+ auto componentCount = resultType->words()[3];
spvCheck(
componentCount != constituentCount,
// TODO: Output ID's on diagnostic
DIAG(inst->words.size() - 1)
<< "OpConstantComposite Constituent <id> count does not match "
"Result Type <id> '"
- << resultType.second.id << "'s vector component count.";
+ << resultType->id() << "'s vector component count.";
return false);
- auto componentType = usedefs_.FindDef(resultType.second.words[2]);
- assert(componentType.first);
+ auto componentType = module_.FindDef(resultType->words()[2]);
+ assert(componentType);
for (size_t constituentIndex = 3; constituentIndex < inst->words.size();
constituentIndex++) {
- auto constituent = usedefs_.FindDef(inst->words[constituentIndex]);
- if (!constituent.first ||
- !spvOpcodeIsConstant(constituent.second.opcode)) {
+ auto constituent = module_.FindDef(inst->words[constituentIndex]);
+ if (!constituent || !spvOpcodeIsConstant(constituent->opcode())) {
DIAG(constituentIndex) << "OpConstantComposite Constituent <id> '"
<< inst->words[constituentIndex]
<< "' is not a constant.";
return false;
}
- auto constituentResultType =
- usedefs_.FindDef(constituent.second.type_id);
- if (!constituentResultType.first ||
- componentType.second.opcode !=
- constituentResultType.second.opcode) {
+ auto constituentResultType = module_.FindDef(constituent->type_id());
+ if (!constituentResultType ||
+ componentType->opcode() != constituentResultType->opcode()) {
DIAG(constituentIndex) << "OpConstantComposite Constituent <id> '"
<< inst->words[constituentIndex]
<< "'s type does not match Result Type <id> '"
- << resultType.second.id
+ << resultType->id()
<< "'s vector element type.";
return false;
}
}
} break;
case SpvOpTypeMatrix: {
- auto columnCount = resultType.second.words[3];
+ auto columnCount = resultType->words()[3];
spvCheck(
columnCount != constituentCount,
// TODO: Output ID's on diagnostic
DIAG(inst->words.size() - 1)
<< "OpConstantComposite Constituent <id> count does not match "
"Result Type <id> '"
- << resultType.second.id << "'s matrix column count.";
+ << resultType->id() << "'s matrix column count.";
return false);
- auto columnType = usedefs_.FindDef(resultType.second.words[2]);
- assert(columnType.first);
- auto componentCount = columnType.second.words[3];
- auto componentType = usedefs_.FindDef(columnType.second.words[2]);
- assert(componentType.first);
+ auto columnType = module_.FindDef(resultType->words()[2]);
+ assert(columnType);
+ auto componentCount = columnType->words()[3];
+ auto componentType = module_.FindDef(columnType->words()[2]);
+ assert(componentType);
for (size_t constituentIndex = 3; constituentIndex < inst->words.size();
constituentIndex++) {
- auto constituent = usedefs_.FindDef(inst->words[constituentIndex]);
- if (!constituent.first ||
- SpvOpConstantComposite != constituent.second.opcode) {
+ auto constituent = module_.FindDef(inst->words[constituentIndex]);
+ if (!constituent || SpvOpConstantComposite != constituent->opcode()) {
DIAG(constituentIndex) << "OpConstantComposite Constituent <id> '"
<< inst->words[constituentIndex]
<< "' is not a constant composite.";
return false;
}
- auto vector = usedefs_.FindDef(constituent.second.type_id);
- assert(vector.first);
- spvCheck(columnType.second.opcode != vector.second.opcode,
+ auto vector = module_.FindDef(constituent->type_id());
+ assert(vector);
+ spvCheck(columnType->opcode() != vector->opcode(),
DIAG(constituentIndex)
<< "OpConstantComposite Constituent <id> '"
<< inst->words[constituentIndex]
<< "' type does not match Result Type <id> '"
- << resultType.second.id << "'s matrix column type.";
+ << resultType->id() << "'s matrix column type.";
return false);
- auto vectorComponentType = usedefs_.FindDef(vector.second.words[2]);
- assert(vectorComponentType.first);
- spvCheck(componentType.second.id != vectorComponentType.second.id,
+ auto vectorComponentType = module_.FindDef(vector->words()[2]);
+ assert(vectorComponentType);
+ spvCheck(componentType->id() != vectorComponentType->id(),
DIAG(constituentIndex)
<< "OpConstantComposite Constituent <id> '"
<< inst->words[constituentIndex]
<< "' component type does not match Result Type <id> '"
- << resultType.second.id
- << "'s matrix column component type.";
+ << resultType->id() << "'s matrix column component type.";
return false);
spvCheck(
- componentCount != vector.second.words[3],
+ componentCount != vector->words()[3],
DIAG(constituentIndex)
<< "OpConstantComposite Constituent <id> '"
<< inst->words[constituentIndex]
<< "' vector component count does not match Result Type <id> '"
- << resultType.second.id << "'s vector component count.";
+ << resultType->id() << "'s vector component count.";
return false);
}
} break;
case SpvOpTypeArray: {
- auto elementType = usedefs_.FindDef(resultType.second.words[2]);
- assert(elementType.first);
- auto length = usedefs_.FindDef(resultType.second.words[3]);
- assert(length.first);
- spvCheck(length.second.words[3] != constituentCount,
+ auto elementType = module_.FindDef(resultType->words()[2]);
+ assert(elementType);
+ auto length = module_.FindDef(resultType->words()[3]);
+ assert(length);
+ spvCheck(length->words()[3] != constituentCount,
DIAG(inst->words.size() - 1)
<< "OpConstantComposite Constituent count does not match "
"Result Type <id> '"
- << resultType.second.id << "'s array length.";
+ << resultType->id() << "'s array length.";
return false);
for (size_t constituentIndex = 3; constituentIndex < inst->words.size();
constituentIndex++) {
- auto constituent = usedefs_.FindDef(inst->words[constituentIndex]);
- if (!constituent.first ||
- !spvOpcodeIsConstant(constituent.second.opcode)) {
+ auto constituent = module_.FindDef(inst->words[constituentIndex]);
+ if (!constituent || !spvOpcodeIsConstant(constituent->opcode())) {
DIAG(constituentIndex) << "OpConstantComposite Constituent <id> '"
<< inst->words[constituentIndex]
<< "' is not a constant.";
return false;
}
- auto constituentType = usedefs_.FindDef(constituent.second.type_id);
- assert(constituentType.first);
- spvCheck(elementType.second.id != constituentType.second.id,
+ auto constituentType = module_.FindDef(constituent->type_id());
+ assert(constituentType);
+ spvCheck(elementType->id() != constituentType->id(),
DIAG(constituentIndex)
<< "OpConstantComposite Constituent <id> '"
<< inst->words[constituentIndex]
<< "'s type does not match Result Type <id> '"
- << resultType.second.id << "'s array element type.";
+ << resultType->id() << "'s array element type.";
return false);
}
} break;
case SpvOpTypeStruct: {
- auto memberCount = resultType.second.words.size() - 2;
+ auto memberCount = resultType->words().size() - 2;
spvCheck(memberCount != constituentCount,
DIAG(resultTypeIndex)
<< "OpConstantComposite Constituent <id> '"
<< inst->words[resultTypeIndex]
<< "' count does not match Result Type <id> '"
- << resultType.second.id << "'s struct member count.";
+ << resultType->id() << "'s struct member count.";
return false);
for (uint32_t constituentIndex = 3, memberIndex = 2;
constituentIndex < inst->words.size();
constituentIndex++, memberIndex++) {
- auto constituent = usedefs_.FindDef(inst->words[constituentIndex]);
- if (!constituent.first ||
- !spvOpcodeIsConstant(constituent.second.opcode)) {
+ auto constituent = module_.FindDef(inst->words[constituentIndex]);
+ if (!constituent || !spvOpcodeIsConstant(constituent->opcode())) {
DIAG(constituentIndex) << "OpConstantComposite Constituent <id> '"
<< inst->words[constituentIndex]
<< "' is not a constant.";
return false;
}
- auto constituentType = usedefs_.FindDef(constituent.second.type_id);
- assert(constituentType.first);
+ auto constituentType = module_.FindDef(constituent->type_id());
+ assert(constituentType);
- auto memberType =
- usedefs_.FindDef(resultType.second.words[memberIndex]);
- assert(memberType.first);
- spvCheck(memberType.second.id != constituentType.second.id,
+ auto memberType = module_.FindDef(resultType->words()[memberIndex]);
+ assert(memberType);
+ spvCheck(memberType->id() != constituentType->id(),
DIAG(constituentIndex)
<< "OpConstantComposite Constituent <id> '"
<< inst->words[constituentIndex]
<< "' type does not match the Result Type <id> '"
- << resultType.second.id << "'s member type.";
+ << resultType->id() << "'s member type.";
return false);
}
} break;
@@ -627,8 +617,8 @@
bool idUsage::isValid<SpvOpConstantSampler>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first || SpvOpTypeSampler != resultType.second.opcode) {
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType || SpvOpTypeSampler != resultType->opcode()) {
DIAG(resultTypeIndex) << "OpConstantSampler Result Type <id> '"
<< inst->words[resultTypeIndex]
<< "' is not a sampler type.";
@@ -638,10 +628,10 @@
}
// True if instruction defines a type that can have a null value, as defined by
-// the SPIR-V spec. Tracks composite-type components through usedefs to check
+// the SPIR-V spec. Tracks composite-type components through module to check
// nullability transitively.
bool IsTypeNullable(const std::vector<uint32_t>& instruction,
- const UseDefTracker& usedefs) {
+ const ValidationState_t& module) {
uint16_t opcode;
uint16_t word_count;
spvOpcodeSplit(instruction[0], &word_count, &opcode);
@@ -658,15 +648,14 @@
case SpvOpTypeArray:
case SpvOpTypeMatrix:
case SpvOpTypeVector: {
- auto base_type = usedefs.FindDef(instruction[2]);
- return base_type.first && IsTypeNullable(base_type.second.words, usedefs);
+ auto base_type = module.FindDef(instruction[2]);
+ return base_type && IsTypeNullable(base_type->words(), module);
}
case SpvOpTypeStruct: {
for (size_t elementIndex = 2; elementIndex < instruction.size();
++elementIndex) {
- auto element = usedefs.FindDef(instruction[elementIndex]);
- if (!element.first || !IsTypeNullable(element.second.words, usedefs))
- return false;
+ auto element = module.FindDef(instruction[elementIndex]);
+ if (!element || !IsTypeNullable(element->words(), module)) return false;
}
return true;
}
@@ -679,8 +668,8 @@
bool idUsage::isValid<SpvOpConstantNull>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first || !IsTypeNullable(resultType.second.words, usedefs_)) {
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType || !IsTypeNullable(resultType->words(), module_)) {
DIAG(resultTypeIndex) << "OpConstantNull Result Type <id> '"
<< inst->words[resultTypeIndex]
<< "' cannot have a null value.";
@@ -693,8 +682,8 @@
bool idUsage::isValid<SpvOpSpecConstantTrue>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first || SpvOpTypeBool != resultType.second.opcode) {
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType || SpvOpTypeBool != resultType->opcode()) {
DIAG(resultTypeIndex) << "OpSpecConstantTrue Result Type <id> '"
<< inst->words[resultTypeIndex]
<< "' is not a boolean type.";
@@ -707,8 +696,8 @@
bool idUsage::isValid<SpvOpSpecConstantFalse>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first || SpvOpTypeBool != resultType.second.opcode) {
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType || SpvOpTypeBool != resultType->opcode()) {
DIAG(resultTypeIndex) << "OpSpecConstantFalse Result Type <id> '"
<< inst->words[resultTypeIndex]
<< "' is not a boolean type.";
@@ -732,8 +721,8 @@
bool idUsage::isValid<SpvOpVariable>(const spv_instruction_t* inst,
const spv_opcode_desc opcodeEntry) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first || SpvOpTypePointer != resultType.second.opcode) {
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType || SpvOpTypePointer != resultType->opcode()) {
DIAG(resultTypeIndex) << "OpVariable Result Type <id> '"
<< inst->words[resultTypeIndex]
<< "' is not a pointer type.";
@@ -741,8 +730,8 @@
}
if (opcodeEntry->numTypes < inst->words.size()) {
auto initialiserIndex = 4;
- auto initialiser = usedefs_.FindDef(inst->words[initialiserIndex]);
- if (!initialiser.first || !spvOpcodeIsConstant(initialiser.second.opcode)) {
+ auto initialiser = module_.FindDef(inst->words[initialiserIndex]);
+ if (!initialiser || !spvOpcodeIsConstant(initialiser->opcode())) {
DIAG(initialiserIndex) << "OpVariable Initializer <id> '"
<< inst->words[initialiserIndex]
<< "' is not a constant.";
@@ -756,34 +745,32 @@
bool idUsage::isValid<SpvOpLoad>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- spvCheck(!resultType.first, DIAG(resultTypeIndex)
- << "OpLoad Result Type <id> '"
- << inst->words[resultTypeIndex]
- << "' is not defind.";
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ spvCheck(!resultType, DIAG(resultTypeIndex) << "OpLoad Result Type <id> '"
+ << inst->words[resultTypeIndex]
+ << "' is not defind.";
return false);
auto pointerIndex = 3;
- auto pointer = usedefs_.FindDef(inst->words[pointerIndex]);
- if (!pointer.first ||
- (addressingModel == SpvAddressingModelLogical &&
- !spvOpcodeReturnsLogicalPointer(pointer.second.opcode))) {
+ auto pointer = module_.FindDef(inst->words[pointerIndex]);
+ if (!pointer || (addressingModel == SpvAddressingModelLogical &&
+ !spvOpcodeReturnsLogicalPointer(pointer->opcode()))) {
DIAG(pointerIndex) << "OpLoad Pointer <id> '" << inst->words[pointerIndex]
<< "' is not a pointer.";
return false;
}
- auto pointerType = usedefs_.FindDef(pointer.second.type_id);
- if (!pointerType.first || pointerType.second.opcode != SpvOpTypePointer) {
+ auto pointerType = module_.FindDef(pointer->type_id());
+ if (!pointerType || pointerType->opcode() != SpvOpTypePointer) {
DIAG(pointerIndex) << "OpLoad type for pointer <id> '"
<< inst->words[pointerIndex]
<< "' is not a pointer type.";
return false;
}
- auto pointeeType = usedefs_.FindDef(pointerType.second.words[3]);
- if (!pointeeType.first || resultType.second.id != pointeeType.second.id) {
+ auto pointeeType = module_.FindDef(pointerType->words()[3]);
+ if (!pointeeType || resultType->id() != pointeeType->id()) {
DIAG(resultTypeIndex) << "OpLoad Result Type <id> '"
<< inst->words[resultTypeIndex]
- << "' does not match Pointer <id> '"
- << pointer.second.id << "'s type.";
+ << "' does not match Pointer <id> '" << pointer->id()
+ << "'s type.";
return false;
}
return true;
@@ -793,47 +780,46 @@
bool idUsage::isValid<SpvOpStore>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto pointerIndex = 1;
- auto pointer = usedefs_.FindDef(inst->words[pointerIndex]);
- if (!pointer.first ||
- (addressingModel == SpvAddressingModelLogical &&
- !spvOpcodeReturnsLogicalPointer(pointer.second.opcode))) {
+ auto pointer = module_.FindDef(inst->words[pointerIndex]);
+ if (!pointer || (addressingModel == SpvAddressingModelLogical &&
+ !spvOpcodeReturnsLogicalPointer(pointer->opcode()))) {
DIAG(pointerIndex) << "OpStore Pointer <id> '" << inst->words[pointerIndex]
<< "' is not a pointer.";
return false;
}
- auto pointerType = usedefs_.FindDef(pointer.second.type_id);
- if (!pointer.first || pointerType.second.opcode != SpvOpTypePointer) {
+ auto pointerType = module_.FindDef(pointer->type_id());
+ if (!pointer || pointerType->opcode() != SpvOpTypePointer) {
DIAG(pointerIndex) << "OpStore type for pointer <id> '"
<< inst->words[pointerIndex]
<< "' is not a pointer type.";
return false;
}
- auto type = usedefs_.FindDef(pointerType.second.words[3]);
- assert(type.first);
- spvCheck(SpvOpTypeVoid == type.second.opcode, DIAG(pointerIndex)
- << "OpStore Pointer <id> '"
- << inst->words[pointerIndex]
- << "'s type is void.";
+ auto type = module_.FindDef(pointerType->words()[3]);
+ assert(type);
+ spvCheck(SpvOpTypeVoid == type->opcode(), DIAG(pointerIndex)
+ << "OpStore Pointer <id> '"
+ << inst->words[pointerIndex]
+ << "'s type is void.";
return false);
auto objectIndex = 2;
- auto object = usedefs_.FindDef(inst->words[objectIndex]);
- if (!object.first || !object.second.type_id) {
+ auto object = module_.FindDef(inst->words[objectIndex]);
+ if (!object || !object->type_id()) {
DIAG(objectIndex) << "OpStore Object <id> '" << inst->words[objectIndex]
<< "' is not an object.";
return false;
}
- auto objectType = usedefs_.FindDef(object.second.type_id);
- assert(objectType.first);
- spvCheck(SpvOpTypeVoid == objectType.second.opcode,
+ auto objectType = module_.FindDef(object->type_id());
+ assert(objectType);
+ spvCheck(SpvOpTypeVoid == objectType->opcode(),
DIAG(objectIndex) << "OpStore Object <id> '"
<< inst->words[objectIndex] << "'s type is void.";
return false);
- spvCheck(type.second.id != objectType.second.id,
+ spvCheck(type->id() != objectType->id(),
DIAG(pointerIndex)
<< "OpStore Pointer <id> '" << inst->words[pointerIndex]
- << "'s type does not match Object <id> '" << objectType.second.id
+ << "'s type does not match Object <id> '" << objectType->id()
<< "'s type.";
return false);
return true;
@@ -843,23 +829,23 @@
bool idUsage::isValid<SpvOpCopyMemory>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto targetIndex = 1;
- auto target = usedefs_.FindDef(inst->words[targetIndex]);
- if (!target.first) return false;
+ auto target = module_.FindDef(inst->words[targetIndex]);
+ if (!target) return false;
auto sourceIndex = 2;
- auto source = usedefs_.FindDef(inst->words[sourceIndex]);
- if (!source.first) return false;
- auto targetPointerType = usedefs_.FindDef(target.second.type_id);
- assert(targetPointerType.first);
- auto targetType = usedefs_.FindDef(targetPointerType.second.words[3]);
- assert(targetType.first);
- auto sourcePointerType = usedefs_.FindDef(source.second.type_id);
- assert(sourcePointerType.first);
- auto sourceType = usedefs_.FindDef(sourcePointerType.second.words[3]);
- assert(sourceType.first);
- spvCheck(targetType.second.id != sourceType.second.id,
+ auto source = module_.FindDef(inst->words[sourceIndex]);
+ if (!source) return false;
+ auto targetPointerType = module_.FindDef(target->type_id());
+ assert(targetPointerType);
+ auto targetType = module_.FindDef(targetPointerType->words()[3]);
+ assert(targetType);
+ auto sourcePointerType = module_.FindDef(source->type_id());
+ assert(sourcePointerType);
+ auto sourceType = module_.FindDef(sourcePointerType->words()[3]);
+ assert(sourceType);
+ spvCheck(targetType->id() != sourceType->id(),
DIAG(sourceIndex)
<< "OpCopyMemory Target <id> '" << inst->words[sourceIndex]
- << "'s type does not match Source <id> '" << sourceType.second.id
+ << "'s type does not match Source <id> '" << sourceType->id()
<< "'s type.";
return false);
return true;
@@ -869,47 +855,45 @@
bool idUsage::isValid<SpvOpCopyMemorySized>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto targetIndex = 1;
- auto target = usedefs_.FindDef(inst->words[targetIndex]);
- if (!target.first) return false;
+ auto target = module_.FindDef(inst->words[targetIndex]);
+ if (!target) return false;
auto sourceIndex = 2;
- auto source = usedefs_.FindDef(inst->words[sourceIndex]);
- if (!source.first) return false;
+ auto source = module_.FindDef(inst->words[sourceIndex]);
+ if (!source) return false;
auto sizeIndex = 3;
- auto size = usedefs_.FindDef(inst->words[sizeIndex]);
- if (!size.first) return false;
- auto targetPointerType = usedefs_.FindDef(target.second.type_id);
- spvCheck(!targetPointerType.first ||
- SpvOpTypePointer != targetPointerType.second.opcode,
- DIAG(targetIndex) << "OpCopyMemorySized Target <id> '"
- << inst->words[targetIndex]
- << "' is not a pointer.";
- return false);
- auto sourcePointerType = usedefs_.FindDef(source.second.type_id);
- spvCheck(!sourcePointerType.first ||
- SpvOpTypePointer != sourcePointerType.second.opcode,
- DIAG(sourceIndex) << "OpCopyMemorySized Source <id> '"
- << inst->words[sourceIndex]
- << "' is not a pointer.";
- return false);
- switch (size.second.opcode) {
+ auto size = module_.FindDef(inst->words[sizeIndex]);
+ if (!size) return false;
+ auto targetPointerType = module_.FindDef(target->type_id());
+ spvCheck(
+ !targetPointerType || SpvOpTypePointer != targetPointerType->opcode(),
+ DIAG(targetIndex) << "OpCopyMemorySized Target <id> '"
+ << inst->words[targetIndex] << "' is not a pointer.";
+ return false);
+ auto sourcePointerType = module_.FindDef(source->type_id());
+ spvCheck(
+ !sourcePointerType || SpvOpTypePointer != sourcePointerType->opcode(),
+ DIAG(sourceIndex) << "OpCopyMemorySized Source <id> '"
+ << inst->words[sourceIndex] << "' is not a pointer.";
+ return false);
+ switch (size->opcode()) {
// TODO: The following opcode's are assumed to be valid, refer to the
// following bug https://cvs.khronos.org/bugzilla/show_bug.cgi?id=13871 for
// clarification
case SpvOpConstant:
case SpvOpSpecConstant: {
- auto sizeType = usedefs_.FindDef(size.second.type_id);
- assert(sizeType.first);
- spvCheck(SpvOpTypeInt != sizeType.second.opcode,
+ auto sizeType = module_.FindDef(size->type_id());
+ assert(sizeType);
+ spvCheck(SpvOpTypeInt != sizeType->opcode(),
DIAG(sizeIndex) << "OpCopyMemorySized Size <id> '"
<< inst->words[sizeIndex]
<< "'s type is not an integer type.";
return false);
} break;
case SpvOpVariable: {
- auto pointerType = usedefs_.FindDef(size.second.type_id);
- assert(pointerType.first);
- auto sizeType = usedefs_.FindDef(pointerType.second.type_id);
- spvCheck(!sizeType.first || SpvOpTypeInt != sizeType.second.opcode,
+ auto pointerType = module_.FindDef(size->type_id());
+ assert(pointerType);
+ auto sizeType = module_.FindDef(pointerType->type_id());
+ spvCheck(!sizeType || SpvOpTypeInt != sizeType->opcode(),
DIAG(sizeIndex) << "OpCopyMemorySized Size <id> '"
<< inst->words[sizeIndex]
<< "'s variable type is not an integer type.";
@@ -960,23 +944,23 @@
bool idUsage::isValid<SpvOpFunction>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first) return false;
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType) return false;
auto functionTypeIndex = 4;
- auto functionType = usedefs_.FindDef(inst->words[functionTypeIndex]);
- if (!functionType.first || SpvOpTypeFunction != functionType.second.opcode) {
+ auto functionType = module_.FindDef(inst->words[functionTypeIndex]);
+ if (!functionType || SpvOpTypeFunction != functionType->opcode()) {
DIAG(functionTypeIndex) << "OpFunction Function Type <id> '"
<< inst->words[functionTypeIndex]
<< "' is not a function type.";
return false;
}
- auto returnType = usedefs_.FindDef(functionType.second.words[2]);
- assert(returnType.first);
- spvCheck(returnType.second.id != resultType.second.id,
+ auto returnType = module_.FindDef(functionType->words()[2]);
+ assert(returnType);
+ spvCheck(returnType->id() != resultType->id(),
DIAG(resultTypeIndex) << "OpFunction Result Type <id> '"
<< inst->words[resultTypeIndex]
<< "' does not match the Function Type <id> '"
- << resultType.second.id << "'s return type.";
+ << resultType->id() << "'s return type.";
return false);
return true;
}
@@ -985,8 +969,8 @@
bool idUsage::isValid<SpvOpFunctionParameter>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first) return false;
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType) return false;
// NOTE: Find OpFunction & ensure OpFunctionParameter is not out of place.
size_t paramIndex = 0;
assert(firstInst < inst && "Invalid instruction pointer");
@@ -997,17 +981,17 @@
paramIndex++;
}
}
- auto functionType = usedefs_.FindDef(inst->words[4]);
- assert(functionType.first);
- if (paramIndex >= functionType.second.words.size() - 3) {
+ auto functionType = module_.FindDef(inst->words[4]);
+ assert(functionType);
+ if (paramIndex >= functionType->words().size() - 3) {
DIAG(0) << "Too many OpFunctionParameters for " << inst->words[2]
- << ": expected " << functionType.second.words.size() - 3
+ << ": expected " << functionType->words().size() - 3
<< " based on the function's type";
return false;
}
- auto paramType = usedefs_.FindDef(functionType.second.words[paramIndex + 3]);
- assert(paramType.first);
- spvCheck(resultType.second.id != paramType.second.id,
+ auto paramType = module_.FindDef(functionType->words()[paramIndex + 3]);
+ assert(paramType);
+ spvCheck(resultType->id() != paramType->id(),
DIAG(resultTypeIndex)
<< "OpFunctionParameter Result Type <id> '"
<< inst->words[resultTypeIndex]
@@ -1021,27 +1005,27 @@
bool idUsage::isValid<SpvOpFunctionCall>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto resultTypeIndex = 1;
- auto resultType = usedefs_.FindDef(inst->words[resultTypeIndex]);
- if (!resultType.first) return false;
+ auto resultType = module_.FindDef(inst->words[resultTypeIndex]);
+ if (!resultType) return false;
auto functionIndex = 3;
- auto function = usedefs_.FindDef(inst->words[functionIndex]);
- if (!function.first || SpvOpFunction != function.second.opcode) {
+ auto function = module_.FindDef(inst->words[functionIndex]);
+ if (!function || SpvOpFunction != function->opcode()) {
DIAG(functionIndex) << "OpFunctionCall Function <id> '"
<< inst->words[functionIndex] << "' is not a function.";
return false;
}
- auto returnType = usedefs_.FindDef(function.second.type_id);
- assert(returnType.first);
- spvCheck(returnType.second.id != resultType.second.id,
+ auto returnType = module_.FindDef(function->type_id());
+ assert(returnType);
+ spvCheck(returnType->id() != resultType->id(),
DIAG(resultTypeIndex) << "OpFunctionCall Result Type <id> '"
<< inst->words[resultTypeIndex]
<< "'s type does not match Function <id> '"
- << returnType.second.id << "'s return type.";
+ << returnType->id() << "'s return type.";
return false);
- auto functionType = usedefs_.FindDef(function.second.words[4]);
- assert(functionType.first);
+ auto functionType = module_.FindDef(function->words()[4]);
+ assert(functionType);
auto functionCallArgCount = inst->words.size() - 4;
- auto functionParamCount = functionType.second.words.size() - 3;
+ auto functionParamCount = functionType->words().size() - 3;
spvCheck(
functionParamCount != functionCallArgCount,
DIAG(inst->words.size() - 1)
@@ -1050,19 +1034,17 @@
return false);
for (size_t argumentIndex = 4, paramIndex = 3;
argumentIndex < inst->words.size(); argumentIndex++, paramIndex++) {
- auto argument = usedefs_.FindDef(inst->words[argumentIndex]);
- if (!argument.first) return false;
- auto argumentType = usedefs_.FindDef(argument.second.type_id);
- assert(argumentType.first);
- auto parameterType =
- usedefs_.FindDef(functionType.second.words[paramIndex]);
- assert(parameterType.first);
- spvCheck(argumentType.second.id != parameterType.second.id,
+ auto argument = module_.FindDef(inst->words[argumentIndex]);
+ if (!argument) return false;
+ auto argumentType = module_.FindDef(argument->type_id());
+ assert(argumentType);
+ auto parameterType = module_.FindDef(functionType->words()[paramIndex]);
+ assert(parameterType);
+ spvCheck(argumentType->id() != parameterType->id(),
DIAG(argumentIndex) << "OpFunctionCall Argument <id> '"
<< inst->words[argumentIndex]
<< "'s type does not match Function <id> '"
- << parameterType.second.id
- << "'s parameter type.";
+ << parameterType->id() << "'s parameter type.";
return false);
}
return true;
@@ -1698,22 +1680,22 @@
bool idUsage::isValid<SpvOpReturnValue>(const spv_instruction_t* inst,
const spv_opcode_desc) {
auto valueIndex = 1;
- auto value = usedefs_.FindDef(inst->words[valueIndex]);
- if (!value.first || !value.second.type_id) {
+ auto value = module_.FindDef(inst->words[valueIndex]);
+ if (!value || !value->type_id()) {
DIAG(valueIndex) << "OpReturnValue Value <id> '" << inst->words[valueIndex]
<< "' does not represent a value.";
return false;
}
- auto valueType = usedefs_.FindDef(value.second.type_id);
- if (!valueType.first || SpvOpTypeVoid == valueType.second.opcode) {
- DIAG(valueIndex) << "OpReturnValue value's type <id> '"
- << value.second.type_id << "' is missing or void.";
+ auto valueType = module_.FindDef(value->type_id());
+ if (!valueType || SpvOpTypeVoid == valueType->opcode()) {
+ DIAG(valueIndex) << "OpReturnValue value's type <id> '" << value->type_id()
+ << "' is missing or void.";
return false;
}
if (addressingModel == SpvAddressingModelLogical &&
- SpvOpTypePointer == valueType.second.opcode) {
+ SpvOpTypePointer == valueType->opcode()) {
DIAG(valueIndex)
- << "OpReturnValue value's type <id> '" << value.second.type_id
+ << "OpReturnValue value's type <id> '" << value->type_id()
<< "' is a pointer, which is invalid in the Logical addressing model.";
return false;
}
@@ -1726,8 +1708,8 @@
spvCheck(SpvOpFunction != function->opcode,
DIAG(valueIndex) << "OpReturnValue is not in a basic block.";
return false);
- auto returnType = usedefs_.FindDef(function->words[1]);
- spvCheck(!returnType.first || returnType.second.id != valueType.second.id,
+ auto returnType = module_.FindDef(function->words[1]);
+ spvCheck(!returnType || returnType->id() != valueType->id(),
DIAG(valueIndex)
<< "OpReturnValue Value <id> '" << inst->words[valueIndex]
<< "'s type does not match OpFunction's return type.";
@@ -2338,8 +2320,176 @@
#undef TODO
#undef CASE
}
+// This function takes the opcode of an instruction and returns
+// a function object that will return true if the index
+// of the operand can be forwarad declared. This function will
+// used in the SSA validation stage of the pipeline
+function<bool(unsigned)> getCanBeForwardDeclaredFunction(SpvOp opcode) {
+ function<bool(unsigned index)> out;
+ switch (opcode) {
+ case SpvOpExecutionMode:
+ case SpvOpEntryPoint:
+ case SpvOpName:
+ case SpvOpMemberName:
+ case SpvOpSelectionMerge:
+ case SpvOpDecorate:
+ case SpvOpMemberDecorate:
+ case SpvOpBranch:
+ case SpvOpLoopMerge:
+ out = [](unsigned) { return true; };
+ break;
+ case SpvOpGroupDecorate:
+ case SpvOpGroupMemberDecorate:
+ case SpvOpBranchConditional:
+ case SpvOpSwitch:
+ out = [](unsigned index) { return index != 0; };
+ break;
+
+ case SpvOpFunctionCall:
+ out = [](unsigned index) { return index == 2; };
+ break;
+
+ case SpvOpPhi:
+ out = [](unsigned index) { return index > 1; };
+ break;
+
+ case SpvOpEnqueueKernel:
+ out = [](unsigned index) { return index == 8; };
+ break;
+
+ case SpvOpGetKernelNDrangeSubGroupCount:
+ case SpvOpGetKernelNDrangeMaxSubGroupSize:
+ out = [](unsigned index) { return index == 3; };
+ break;
+
+ case SpvOpGetKernelWorkGroupSize:
+ case SpvOpGetKernelPreferredWorkGroupSizeMultiple:
+ out = [](unsigned index) { return index == 2; };
+ break;
+
+ default:
+ out = [](unsigned) { return false; };
+ break;
+ }
+ return out;
+}
} // anonymous namespace
+namespace libspirv {
+
+/// This function checks all ID definitions dominate their use in the CFG.
+///
+/// This function will iterate over all ID definitions that are defined in the
+/// functions of a module and make sure that the definitions appear in a
+/// block that dominates their use.
+///
+/// NOTE: This function does NOT check module scoped functions which are
+/// checked during the initial binary parse in the IdPass below
+spv_result_t CheckIdDefinitionDominateUse(const ValidationState_t& _) {
+ for (const auto& definition : _.all_definitions()) {
+ // Check only those blocks defined in a function
+ if (const Function* func = definition.second.defining_function()) {
+ if (const BasicBlock* block = definition.second.defining_block()) {
+ // If the Id is defined within a block then make sure all references to
+ // that Id appear in a blocks that are dominated by the defining block
+ for (auto use : definition.second.uses()) {
+ if (!use->reachable()) continue;
+ if (use->dom_end() == find(use->dom_begin(), use->dom_end(), block)) {
+ return _.diag(SPV_ERROR_INVALID_ID)
+ << "ID " << _.getIdName(definition.first)
+ << " defined in block " << _.getIdName(block->id())
+ << " does not dominate its use in block "
+ << _.getIdName(use->id());
+ }
+ }
+ } else {
+ // If the Ids defined within a function but not in a block(i.e. function
+ // parameters, block ids), then make sure all references to that Id
+ // appear within the same function
+ bool found = false;
+ for (auto use : definition.second.uses()) {
+ tie(ignore, found) = func->GetBlock(use->id());
+ if (!found) {
+ return _.diag(SPV_ERROR_INVALID_ID)
+ << "ID " << _.getIdName(definition.first)
+ << " used in block " << _.getIdName(use->id())
+ << " is used outside of it's defining function "
+ << _.getIdName(func->id());
+ }
+ }
+ }
+ }
+ // NOTE: Ids defined outside of functions must appear before they are used
+ // This check is being performed in the IdPass function
+ }
+ // TODO(dneto): We don't track check of IDs by phi nodes. We should check
+ // that for each (variable, predecessor) pair in an OpPhi, that the variable
+ // is defined in a block that dominates that predecessor block.
+ return SPV_SUCCESS;
+}
+
+// Performs SSA validation on the IDs of an instruction. The
+// can_have_forward_declared_ids functor should return true if the
+// instruction operand's ID can be forward referenced.
+spv_result_t IdPass(ValidationState_t& _,
+ const spv_parsed_instruction_t* inst) {
+ auto can_have_forward_declared_ids =
+ getCanBeForwardDeclaredFunction(static_cast<SpvOp>(inst->opcode));
+
+ for (unsigned i = 0; i < inst->num_operands; i++) {
+ const spv_parsed_operand_t& operand = inst->operands[i];
+ const spv_operand_type_t& type = operand.type;
+ const uint32_t* operand_ptr = inst->words + operand.offset;
+
+ auto ret = SPV_ERROR_INTERNAL;
+ switch (type) {
+ case SPV_OPERAND_TYPE_RESULT_ID:
+ // NOTE: Multiple Id definitions are being checked by the binary parser
+ // NOTE: result Id is added *after* all of the other Ids have been
+ // checked to avoid premature use in the same instruction
+ _.RemoveIfForwardDeclared(*operand_ptr);
+ ret = SPV_SUCCESS;
+ break;
+ case SPV_OPERAND_TYPE_ID:
+ case SPV_OPERAND_TYPE_TYPE_ID:
+ case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID:
+ case SPV_OPERAND_TYPE_SCOPE_ID:
+ if (_.IsDefinedId(*operand_ptr)) {
+ if (inst->opcode == SpvOpPhi && i > 1) {
+ // For now, ignore uses of IDs as arguments to OpPhi, since
+ // the job of an OpPhi is to allow a block to use an ID from a
+ // block that doesn't dominate the use.
+ // We only track usage by a particular block, rather than
+ // which instruction and operand number is using the value, so
+ // we have to just bluntly avod tracking the use here.
+ // Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/286
+ } else {
+ _.RegisterUseId(*operand_ptr);
+ }
+ ret = SPV_SUCCESS;
+ } else if (can_have_forward_declared_ids(i)) {
+ ret = _.ForwardDeclareId(*operand_ptr);
+ } else {
+ ret = _.diag(SPV_ERROR_INVALID_ID) << "ID "
+ << _.getIdName(*operand_ptr)
+ << " has not been defined";
+ }
+ break;
+ default:
+ ret = SPV_SUCCESS;
+ break;
+ }
+ if (SPV_SUCCESS != ret) {
+ return ret;
+ }
+ }
+ if (inst->result_id) {
+ _.AddId(*inst);
+ }
+ return SPV_SUCCESS;
+}
+} // namespace libspirv
+
spv_result_t spvValidateInstructionIDs(const spv_instruction_t* pInsts,
const uint64_t instCount,
const spv_opcode_table opcodeTable,
@@ -2349,8 +2499,8 @@
spv_position position,
spv_diagnostic* pDiag) {
idUsage idUsage(opcodeTable, operandTable, extInstTable, pInsts, instCount,
- state.memory_model(), state.addressing_model(),
- state.usedefs(), state.entry_points(), position, pDiag);
+ state.memory_model(), state.addressing_model(), state,
+ state.entry_points(), position, pDiag);
for (uint64_t instIndex = 0; instIndex < instCount; ++instIndex) {
spvCheck(!idUsage.isValid(&pInsts[instIndex]), return SPV_ERROR_INVALID_ID);
position->index += pInsts[instIndex].words.size();
diff --git a/source/validate_ssa.cpp b/source/validate_ssa.cpp
deleted file mode 100644
index 914d5ca..0000000
--- a/source/validate_ssa.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright (c) 2015-2016 The Khronos Group Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and/or associated documentation files (the
-// "Materials"), to deal in the Materials without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Materials, and to
-// permit persons to whom the Materials are furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Materials.
-//
-// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
-// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
-// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
-// https://www.khronos.org/registry/
-//
-// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-
-#include "validate.h"
-
-#include <functional>
-
-#include "opcode.h"
-#include "val/ValidationState.h"
-
-using std::function;
-using libspirv::ValidationState_t;
-
-namespace {
-// This function takes the opcode of an instruction and returns
-// a function object that will return true if the index
-// of the operand can be forwarad declared. This function will
-// used in the SSA validation stage of the pipeline
-function<bool(unsigned)> getCanBeForwardDeclaredFunction(SpvOp opcode) {
- function<bool(unsigned index)> out;
- switch (opcode) {
- case SpvOpExecutionMode:
- case SpvOpEntryPoint:
- case SpvOpName:
- case SpvOpMemberName:
- case SpvOpSelectionMerge:
- case SpvOpDecorate:
- case SpvOpMemberDecorate:
- case SpvOpBranch:
- case SpvOpLoopMerge:
- out = [](unsigned) { return true; };
- break;
- case SpvOpGroupDecorate:
- case SpvOpGroupMemberDecorate:
- case SpvOpBranchConditional:
- case SpvOpSwitch:
- out = [](unsigned index) { return index != 0; };
- break;
-
- case SpvOpFunctionCall:
- out = [](unsigned index) { return index == 2; };
- break;
-
- case SpvOpPhi:
- out = [](unsigned index) { return index > 1; };
- break;
-
- case SpvOpEnqueueKernel:
- out = [](unsigned index) { return index == 8; };
- break;
-
- case SpvOpGetKernelNDrangeSubGroupCount:
- case SpvOpGetKernelNDrangeMaxSubGroupSize:
- out = [](unsigned index) { return index == 3; };
- break;
-
- case SpvOpGetKernelWorkGroupSize:
- case SpvOpGetKernelPreferredWorkGroupSizeMultiple:
- out = [](unsigned index) { return index == 2; };
- break;
-
- default:
- out = [](unsigned) { return false; };
- break;
- }
- return out;
-}
-} // namespace
-
-namespace libspirv {
-
-// Performs SSA validation on the IDs of an instruction. The
-// can_have_forward_declared_ids functor should return true if the
-// instruction operand's ID can be forward referenced.
-//
-// TODO(umar): Use dominators to correctly validate SSA. For example, the result
-// id from a 'then' block cannot dominate its usage in the 'else' block. This
-// is not yet performed by this function.
-spv_result_t SsaPass(ValidationState_t& _,
- const spv_parsed_instruction_t* inst) {
- auto can_have_forward_declared_ids =
- getCanBeForwardDeclaredFunction(static_cast<SpvOp>(inst->opcode));
-
- for (unsigned i = 0; i < inst->num_operands; i++) {
- const spv_parsed_operand_t& operand = inst->operands[i];
- const spv_operand_type_t& type = operand.type;
- const uint32_t* operand_ptr = inst->words + operand.offset;
-
- auto ret = SPV_ERROR_INTERNAL;
- switch (type) {
- case SPV_OPERAND_TYPE_RESULT_ID:
- _.RemoveIfForwardDeclared(*operand_ptr);
- ret = SPV_SUCCESS;
- break;
- case SPV_OPERAND_TYPE_ID:
- case SPV_OPERAND_TYPE_TYPE_ID:
- case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID:
- case SPV_OPERAND_TYPE_SCOPE_ID:
- if (_.IsDefinedId(*operand_ptr)) {
- ret = SPV_SUCCESS;
- } else if (can_have_forward_declared_ids(i)) {
- ret = _.ForwardDeclareId(*operand_ptr);
- } else {
- ret = _.diag(SPV_ERROR_INVALID_ID) << "ID "
- << _.getIdName(*operand_ptr)
- << " has not been defined";
- }
- break;
- default:
- ret = SPV_SUCCESS;
- break;
- }
- if (SPV_SUCCESS != ret) {
- return ret;
- }
- }
- return SPV_SUCCESS;
-}
-} // namespace libspirv
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 971e5ac..1ac7a6b 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -30,118 +30,122 @@
# SRCS src_file.h src_file.cpp
# LIBS lib1 lib2
# )
-function(add_spvtools_unittest)
- set(one_value_args TARGET)
- set(multi_value_args SRCS LIBS)
- cmake_parse_arguments(
- ARG "" "${one_value_args}" "${multi_value_args}" ${ARGN})
- add_executable(${ARG_TARGET} ${ARG_SRCS})
- spvtools_default_compile_options(${ARG_TARGET})
- if(${COMPILER_IS_LIKE_GNU})
- target_compile_options(${ARG_TARGET} PRIVATE -Wno-undef)
- endif()
- if(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
- # Disable C4503 "decorated name length exceeded" warning,
- # triggered by some heavily templated types.
- # We don't care much about that in test code.
- # Important to do since we have warnings-as-errors.
- target_compile_options(${ARG_TARGET} PRIVATE /wd4503)
- endif()
- target_include_directories(${ARG_TARGET} PRIVATE
- ${spirv-tools_SOURCE_DIR}
- ${spirv-tools_SOURCE_DIR}/include
- ${SPIRV_HEADER_INCLUDE_DIR}
- ${gtest_SOURCE_DIR}/include
- ${gmock_SOURCE_DIR}/include
- )
- target_link_libraries(${ARG_TARGET} PRIVATE ${ARG_LIBS})
- target_link_libraries(${ARG_TARGET} PRIVATE gmock_main)
- add_test(NAME spirv-tools-${ARG_TARGET} COMMAND ${ARG_TARGET})
-endfunction()
-if (NOT ${SPIRV_SKIP_EXECUTABLES})
- if (TARGET gmock)
+if (NOT "${SPIRV_SKIP_TESTS}")
+ if (TARGET gmock_main)
message(STATUS "Found Google Mock, building tests.")
-
- set(TEST_SOURCES
- ${CMAKE_CURRENT_SOURCE_DIR}/TestFixture.h
- ${CMAKE_CURRENT_SOURCE_DIR}/UnitSPIRV.h
-
- ${CMAKE_CURRENT_SOURCE_DIR}/AssemblyContext.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/AssemblyFormat.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/BinaryDestroy.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/BinaryEndianness.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/BinaryHeaderGet.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/BinaryParse.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/BinaryToText.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/BinaryToText.Literal.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/Comment.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/DiagnosticDestroy.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/DiagnosticPrint.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/DiagnosticStream.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/ExtInstGLSLstd450.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/ExtInst.OpenCL.std.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/FixWord.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/GeneratorMagicNumber.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/HexFloat.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/ImmediateInt.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/LibspirvMacros.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/NamedId.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/NameMapper.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/OpcodeMake.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/OpcodeRequiresCapabilities.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/OpcodeSplit.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/OpcodeTableGet.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/OperandCapabilities.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/Operand.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/OperandPattern.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/SoftwareVersion.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextAdvance.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextDestroy.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextLiteral.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextStartsNewInst.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Annotation.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Barrier.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Constant.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.ControlFlow.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Debug.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.DeviceSideEnqueue.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Extension.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Function.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Group.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Image.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Literal.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Memory.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Miscellaneous.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.ModeSetting.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.PipeStorage.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.TypeDeclaration.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.SubgroupDispatch.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/TextWordGet.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/UnitSPIRV.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/ValidateFixtures.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/Validate.Capability.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/Validate.CFG.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/Validate.Layout.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/Validate.Storage.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/Validate.SSA.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/ValidateID.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/ValidationState.cpp
- )
- add_spvtools_unittest(
- TARGET UnitSPIRV
- SRCS ${TEST_SOURCES}
- LIBS ${SPIRV_TOOLS})
-
- add_spvtools_unittest(
- TARGET cpp_interface
- SRCS cpp_interface.cpp
- LIBS SPIRV-Tools-opt ${SPIRV_TOOLS})
-
- add_subdirectory(opt)
else()
message(STATUS "Did not find googletest, tests will not be built."
"To enable tests place googletest in '<spirv-dir>/external/googletest'.")
endif()
endif()
+
+function(add_spvtools_unittest)
+ if (NOT "${SPIRV_SKIP_TESTS}" AND TARGET gmock_main)
+ set(one_value_args TARGET)
+ set(multi_value_args SRCS LIBS)
+ cmake_parse_arguments(
+ ARG "" "${one_value_args}" "${multi_value_args}" ${ARGN})
+ add_executable(${ARG_TARGET} ${ARG_SRCS})
+ spvtools_default_compile_options(${ARG_TARGET})
+ if(${COMPILER_IS_LIKE_GNU})
+ target_compile_options(${ARG_TARGET} PRIVATE -Wno-undef)
+ endif()
+ if(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
+ # Disable C4503 "decorated name length exceeded" warning,
+ # triggered by some heavily templated types.
+ # We don't care much about that in test code.
+ # Important to do since we have warnings-as-errors.
+ target_compile_options(${ARG_TARGET} PRIVATE /wd4503)
+ endif()
+ target_include_directories(${ARG_TARGET} PRIVATE
+ ${spirv-tools_SOURCE_DIR}
+ ${spirv-tools_SOURCE_DIR}/include
+ ${SPIRV_HEADER_INCLUDE_DIR}
+ ${gtest_SOURCE_DIR}/include
+ ${gmock_SOURCE_DIR}/include
+ )
+ target_link_libraries(${ARG_TARGET} PRIVATE ${ARG_LIBS})
+ target_link_libraries(${ARG_TARGET} PRIVATE gmock_main)
+ add_test(NAME spirv-tools-${ARG_TARGET} COMMAND ${ARG_TARGET})
+ endif()
+endfunction()
+
+set(TEST_SOURCES
+ ${CMAKE_CURRENT_SOURCE_DIR}/TestFixture.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/UnitSPIRV.h
+
+ ${CMAKE_CURRENT_SOURCE_DIR}/AssemblyContext.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/AssemblyFormat.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/BinaryDestroy.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/BinaryEndianness.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/BinaryHeaderGet.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/BinaryParse.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/BinaryToText.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/BinaryToText.Literal.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/Comment.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/DiagnosticDestroy.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/DiagnosticPrint.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/DiagnosticStream.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/ExtInstGLSLstd450.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/ExtInst.OpenCL.std.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/FixWord.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/GeneratorMagicNumber.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/HexFloat.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/ImmediateInt.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/LibspirvMacros.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/NamedId.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/NameMapper.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/OpcodeMake.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/OpcodeRequiresCapabilities.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/OpcodeSplit.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/OpcodeTableGet.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/OperandCapabilities.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/Operand.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/OperandPattern.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/SoftwareVersion.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TargetEnv.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextAdvance.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextDestroy.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextLiteral.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextStartsNewInst.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Annotation.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Barrier.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Constant.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.ControlFlow.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Debug.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.DeviceSideEnqueue.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Extension.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Function.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Group.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Image.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Literal.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Memory.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.Miscellaneous.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.ModeSetting.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.PipeStorage.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.TypeDeclaration.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextToBinary.SubgroupDispatch.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/TextWordGet.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/UnitSPIRV.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/ValidateFixtures.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/Validate.Capability.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/Validate.CFG.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/Validate.Layout.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/Validate.Storage.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/Validate.SSA.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/ValidateID.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/ValidationState.cpp
+)
+add_spvtools_unittest(
+ TARGET UnitSPIRV
+ SRCS ${TEST_SOURCES}
+ LIBS ${SPIRV_TOOLS})
+
+add_spvtools_unittest(
+ TARGET cpp_interface
+ SRCS cpp_interface.cpp
+ LIBS SPIRV-Tools-opt ${SPIRV_TOOLS})
+
+add_subdirectory(opt)
diff --git a/test/NameMapper.cpp b/test/NameMapper.cpp
index e3332cf..fdb709b 100644
--- a/test/NameMapper.cpp
+++ b/test/NameMapper.cpp
@@ -134,6 +134,13 @@
{"OpName %1 \"abcdefg\"", 1, "abcdefg"},
{"OpName %1 \"Hello world!\"", 1, "Hello_world_"},
{"OpName %1 \"0123456789\"", 1, "0123456789"},
+ {"OpName %1 \"_\"", 1, "_"},
+ // An empty string is not valid for SPIR-V assembly IDs.
+ {"OpName %1 \"\"", 1, "_"},
+ // Test uniqueness when presented with things mapping to "_"
+ {"OpName %1 \"\" OpName %2 \"\"", 1, "_"},
+ {"OpName %1 \"\" OpName %2 \"\"", 2, "__0"},
+ {"OpName %1 \"\" OpName %2 \"\" OpName %3 \"_\"", 3, "__1"},
// Test uniqueness of names that are forced to be
// numbers.
{"OpName %1 \"2\" OpName %2 \"2\"", 1, "2"},
diff --git a/test/OpcodeTableGet.cpp b/test/OpcodeTableGet.cpp
index b9fe3c1..5e220b6 100644
--- a/test/OpcodeTableGet.cpp
+++ b/test/OpcodeTableGet.cpp
@@ -30,24 +30,21 @@
namespace {
-using GetTargetTest = ::testing::TestWithParam<spv_target_env>;
+using GetTargetOpcodeTableGetTest = ::testing::TestWithParam<spv_target_env>;
using ::testing::ValuesIn;
-using std::vector;
-TEST_P(GetTargetTest, SanityCheck) {
+TEST_P(GetTargetOpcodeTableGetTest, SanityCheck) {
spv_opcode_table table;
ASSERT_EQ(SPV_SUCCESS, spvOpcodeTableGet(&table, GetParam()));
ASSERT_NE(0u, table->count);
ASSERT_NE(nullptr, table->entries);
}
-TEST_P(GetTargetTest, InvalidPointerTable) {
+TEST_P(GetTargetOpcodeTableGetTest, InvalidPointerTable) {
ASSERT_EQ(SPV_ERROR_INVALID_POINTER, spvOpcodeTableGet(nullptr, GetParam()));
}
-INSTANTIATE_TEST_CASE_P(OpcodeTableGet, GetTargetTest,
- ValuesIn(vector<spv_target_env>{SPV_ENV_UNIVERSAL_1_0,
- SPV_ENV_UNIVERSAL_1_1,
- SPV_ENV_VULKAN_1_0}), );
+INSTANTIATE_TEST_CASE_P(OpcodeTableGet, GetTargetOpcodeTableGetTest,
+ ValuesIn(spvtest::AllTargetEnvironments()));
} // anonymous namespace
diff --git a/test/TargetEnv.cpp b/test/TargetEnv.cpp
new file mode 100644
index 0000000..235e6d7
--- /dev/null
+++ b/test/TargetEnv.cpp
@@ -0,0 +1,100 @@
+// Copyright (c) 2016 Google Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+// https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#include <gmock/gmock.h>
+
+#include "UnitSPIRV.h"
+
+#include "source/spirv_target_env.h"
+
+namespace {
+
+using ::testing::AnyOf;
+using ::testing::Eq;
+using ::testing::ValuesIn;
+using ::testing::StartsWith;
+
+using TargetEnvTest = ::testing::TestWithParam<spv_target_env>;
+TEST_P(TargetEnvTest, CreateContext) {
+ spv_target_env env = GetParam();
+ spv_context context = spvContextCreate(env);
+ ASSERT_NE(nullptr, context);
+ spvContextDestroy(context); // Avoid leaking
+}
+
+TEST_P(TargetEnvTest, ValidDescription) {
+ const char* description = spvTargetEnvDescription(GetParam());
+ ASSERT_NE(nullptr, description);
+ ASSERT_THAT(description, StartsWith("SPIR-V "));
+}
+
+TEST_P(TargetEnvTest, ValidSpirvVersion) {
+ auto spirv_version = spvVersionForTargetEnv(GetParam());
+ ASSERT_THAT(spirv_version, AnyOf(0x10000, 0x10100));
+}
+
+INSTANTIATE_TEST_CASE_P(AllTargetEnvs, TargetEnvTest,
+ ValuesIn(spvtest::AllTargetEnvironments()));
+
+TEST(GetContextTest, InvalidTargetEnvProducesNull) {
+ spv_context context = spvContextCreate((spv_target_env)10);
+ EXPECT_EQ(context, nullptr);
+}
+
+// A test case for parsing an environment string.
+struct ParseCase {
+ const char* input;
+ bool success; // Expect to successfully parse?
+ spv_target_env env; // The parsed environment, if successful.
+};
+
+using TargetParseTest = ::testing::TestWithParam<ParseCase>;
+
+TEST_P(TargetParseTest, InvalidTargetEnvProducesNull) {
+ spv_target_env env;
+ bool parsed = spvParseTargetEnv(GetParam().input, &env);
+ EXPECT_THAT(parsed, Eq(GetParam().success));
+ EXPECT_THAT(env, Eq(GetParam().env));
+}
+
+INSTANTIATE_TEST_CASE_P(TargetParsing, TargetParseTest,
+ ValuesIn(std::vector<ParseCase>{
+ {"spv1.0", true, SPV_ENV_UNIVERSAL_1_0},
+ {"spv1.1", true, SPV_ENV_UNIVERSAL_1_1},
+ {"vulkan1.0", true, SPV_ENV_VULKAN_1_0},
+ {"opencl2.1", true, SPV_ENV_OPENCL_2_1},
+ {"opencl2.2", true, SPV_ENV_OPENCL_2_2},
+ {"opengl4.0", true, SPV_ENV_OPENGL_4_0},
+ {"opengl4.1", true, SPV_ENV_OPENGL_4_1},
+ {"opengl4.2", true, SPV_ENV_OPENGL_4_2},
+ {"opengl4.3", true, SPV_ENV_OPENGL_4_3},
+ {"opengl4.5", true, SPV_ENV_OPENGL_4_5},
+ {nullptr, false, SPV_ENV_UNIVERSAL_1_0},
+ {"", false, SPV_ENV_UNIVERSAL_1_0},
+ {"abc", false, SPV_ENV_UNIVERSAL_1_0},
+ }));
+
+} // anonymous namespace
diff --git a/test/UnitSPIRV.h b/test/UnitSPIRV.h
index 93bf791..5456672 100644
--- a/test/UnitSPIRV.h
+++ b/test/UnitSPIRV.h
@@ -216,5 +216,13 @@
return result;
}
+// Returns a vector of all valid target environment enums.
+inline std::vector<spv_target_env> AllTargetEnvironments() {
+ return {SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_OPENCL_2_1,
+ SPV_ENV_OPENCL_2_2, SPV_ENV_VULKAN_1_0, SPV_ENV_OPENGL_4_0,
+ SPV_ENV_OPENGL_4_1, SPV_ENV_OPENGL_4_2, SPV_ENV_OPENGL_4_3,
+ SPV_ENV_OPENGL_4_5};
+}
+
} // namespace spvtest
#endif // LIBSPIRV_TEST_UNITSPIRV_H_
diff --git a/test/Validate.CFG.cpp b/test/Validate.CFG.cpp
index 4027946..6a1920e 100644
--- a/test/Validate.CFG.cpp
+++ b/test/Validate.CFG.cpp
@@ -91,8 +91,13 @@
: label_(label), body_(), type_(type), successors_() {}
/// Sets the instructions which will appear in the body of the block
- Block& setBody(std::string body) {
- body_ = body;
+ Block& SetBody(std::string body) {
+ body_ = body;
+ return *this;
+ }
+
+ Block& AppendBody(std::string body) {
+ body_ += body;
return *this;
}
@@ -189,6 +194,87 @@
::testing::Values(SpvCapabilityShader,
SpvCapabilityKernel));
+TEST_P(ValidateCFG, LoopReachableFromEntryButNeverLeadingToReturn) {
+ // In this case, the loop is reachable from a node without a predecessor,
+ // but never reaches a node with a return.
+ //
+ // This motivates the need for the pseudo-exit node to have a node
+ // from a cycle in its predecessors list. Otherwise the validator's
+ // post-dominance calculation will go into an infinite loop.
+ //
+ // For more motivation, see
+ // https://github.com/KhronosGroup/SPIRV-Tools/issues/279
+ string str = R"(
+ OpCapability Shader
+ OpMemoryModel Logical GLSL450
+
+ OpName %entry "entry"
+ OpName %loop "loop"
+ OpName %exit "exit"
+
+%voidt = OpTypeVoid
+%funct = OpTypeFunction %voidt
+
+%main = OpFunction %voidt None %funct
+%entry = OpLabel
+ OpBranch %loop
+%loop = OpLabel
+ OpLoopMerge %exit %loop None
+ OpBranch %loop
+%exit = OpLabel
+ OpReturn
+ OpFunctionEnd
+ )";
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << str;
+}
+
+TEST_P(ValidateCFG, LoopUnreachableFromEntryButLeadingToReturn) {
+ // In this case, the loop is not reachable from a node without a
+ // predecessor, but eventually reaches a node with a return.
+ //
+ // This motivates the need for the pseudo-entry node to have a node
+ // from a cycle in its successors list. Otherwise the validator's
+ // dominance calculation will go into an infinite loop.
+ //
+ // For more motivation, see
+ // https://github.com/KhronosGroup/SPIRV-Tools/issues/279
+ // Before that fix, we'd have an infinite loop when calculating
+ // post-dominators.
+ string str = R"(
+ OpCapability Shader
+ OpMemoryModel Logical GLSL450
+
+ OpName %entry "entry"
+ OpName %loop "loop"
+ OpName %cont "cont"
+ OpName %exit "exit"
+
+%voidt = OpTypeVoid
+%funct = OpTypeFunction %voidt
+%boolt = OpTypeBool
+%false = OpConstantFalse %boolt
+
+%main = OpFunction %voidt None %funct
+%entry = OpLabel
+ OpReturn
+
+%loop = OpLabel
+ OpLoopMerge %exit %cont None
+ OpBranch %cont
+
+%cont = OpLabel
+ OpBranchConditional %false %loop %exit
+
+%exit = OpLabel
+ OpReturn
+ OpFunctionEnd
+ )";
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << str
+ << getDiagnosticString();
+}
+
TEST_P(ValidateCFG, Simple) {
bool is_shader = GetParam() == SpvCapabilityShader;
Block entry("entry");
@@ -196,9 +282,9 @@
Block cont("cont");
Block merge("merge", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
if (is_shader) {
- loop.setBody("OpLoopMerge %merge %cont None\n");
+ loop.SetBody("OpLoopMerge %merge %cont None\n");
}
string str = header(GetParam()) + nameOps("loop", "entry", "cont", "merge",
@@ -220,7 +306,7 @@
Block cont("cont");
Block exit("exit", SpvOpReturn);
- entry.setBody("%var = OpVariable %ptrt Function\n");
+ entry.SetBody("%var = OpVariable %ptrt Function\n");
string str = header(GetParam()) + nameOps(make_pair("func", "Main")) +
types_consts() + " %func = OpFunction %voidt None %funct\n";
@@ -239,7 +325,7 @@
Block exit("exit", SpvOpReturn);
// This operation should only be performed in the entry block
- cont.setBody("%var = OpVariable %ptrt Function\n");
+ cont.SetBody("%var = OpVariable %ptrt Function\n");
string str = header(GetParam()) + nameOps(make_pair("func", "Main")) +
types_consts() + " %func = OpFunction %voidt None %funct\n";
@@ -257,6 +343,29 @@
"Variables can only be defined in the first block of a function"));
}
+TEST_P(ValidateCFG, BlockSelfLoopIsOk) {
+ bool is_shader = GetParam() == SpvCapabilityShader;
+ Block entry("entry");
+ Block loop("loop", SpvOpBranchConditional);
+ Block merge("merge", SpvOpReturn);
+
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) loop.SetBody("OpLoopMerge %merge %loop None\n");
+
+ string str = header(GetParam()) +
+ nameOps("loop", "merge", make_pair("func", "Main")) +
+ types_consts() + "%func = OpFunction %voidt None %funct\n";
+
+ str += entry >> loop;
+ // loop branches to itself, but does not trigger an error.
+ str += loop >> vector<Block>({merge, loop});
+ str += merge;
+ str += "OpFunctionEnd\n";
+
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString();
+}
+
TEST_P(ValidateCFG, BlockAppearsBeforeDominatorBad) {
bool is_shader = GetParam() == SpvCapabilityShader;
Block entry("entry");
@@ -264,8 +373,8 @@
Block branch("branch", SpvOpBranchConditional);
Block merge("merge", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) branch.setBody("OpSelectionMerge %merge None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) branch.SetBody("OpSelectionMerge %merge None\n");
string str = header(GetParam()) +
nameOps("cont", "branch", make_pair("func", "Main")) +
@@ -291,11 +400,11 @@
Block selection("selection", SpvOpBranchConditional);
Block merge("merge", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) loop.setBody(" OpLoopMerge %merge %loop None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) loop.SetBody(" OpLoopMerge %merge %loop None\n");
// cannot share the same merge
- if (is_shader) selection.setBody("OpSelectionMerge %merge None\n");
+ if (is_shader) selection.SetBody("OpSelectionMerge %merge None\n");
string str = header(GetParam()) +
nameOps("merge", make_pair("func", "Main")) + types_consts() +
@@ -325,11 +434,11 @@
Block selection("selection", SpvOpBranchConditional);
Block merge("merge", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) selection.setBody(" OpSelectionMerge %merge None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) selection.SetBody(" OpSelectionMerge %merge None\n");
// cannot share the same merge
- if (is_shader) loop.setBody(" OpLoopMerge %merge %loop None\n");
+ if (is_shader) loop.SetBody(" OpLoopMerge %merge %loop None\n");
string str = header(GetParam()) +
nameOps("merge", make_pair("func", "Main")) + types_consts() +
@@ -377,8 +486,8 @@
Block bad("bad", SpvOpBranchConditional);
Block exit("exit", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- bad.setBody(" OpLoopMerge %entry %exit None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ bad.SetBody(" OpLoopMerge %entry %exit None\n");
string str = header(GetParam()) +
nameOps("entry", "bad", make_pair("func", "Main")) +
@@ -403,8 +512,8 @@
Block merge("merge");
Block end("end", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- bad.setBody("OpLoopMerge %merge %cont None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ bad.SetBody("OpLoopMerge %merge %cont None\n");
string str = header(GetParam()) +
nameOps("entry", "bad", make_pair("func", "Main")) +
@@ -433,8 +542,8 @@
Block merge("merge");
Block end("end", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- bad.setBody("OpSelectionMerge %merge None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ bad.SetBody("OpSelectionMerge %merge None\n");
string str = header(GetParam()) +
nameOps("entry", "bad", make_pair("func", "Main")) +
@@ -462,8 +571,8 @@
Block middle("middle", SpvOpBranchConditional);
Block end("end", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- middle.setBody("OpSelectionMerge %end None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ middle.SetBody("OpSelectionMerge %end None\n");
Block entry2("entry2");
Block middle2("middle2");
@@ -499,9 +608,9 @@
Block f("f");
Block merge("merge", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
+ head.SetBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) head.setBody("OpSelectionMerge %merge None\n");
+ if (is_shader) head.AppendBody("OpSelectionMerge %merge None\n");
string str = header(GetParam()) +
nameOps("head", "merge", make_pair("func", "Main")) +
@@ -514,7 +623,6 @@
str += "OpFunctionEnd\n";
CompileSuccessfully(str);
-
if (is_shader) {
ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions());
EXPECT_THAT(
@@ -535,8 +643,8 @@
Block f("f", SpvOpReturn);
Block merge("merge", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) branch.setBody("OpSelectionMerge %merge None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) branch.AppendBody("OpSelectionMerge %merge None\n");
string str = header(GetParam()) +
nameOps("branch", "merge", make_pair("func", "Main")) +
@@ -561,8 +669,8 @@
Block f("f", SpvOpReturn);
Block merge("merge", SpvOpUnreachable);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) branch.setBody("OpSelectionMerge %merge None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) branch.AppendBody("OpSelectionMerge %merge None\n");
string str = header(GetParam()) +
nameOps("branch", "merge", make_pair("func", "Main")) +
@@ -606,8 +714,8 @@
Block merge("merge");
Block exit("exit", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) unreachable.setBody("OpSelectionMerge %merge None\n");
+ unreachable.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) unreachable.AppendBody("OpSelectionMerge %merge None\n");
string str = header(GetParam()) +
nameOps("unreachable", "exit", make_pair("func", "Main")) +
types_consts() + "%func = OpFunction %voidt None %funct\n";
@@ -638,8 +746,8 @@
Block loop("loop", SpvOpBranchConditional);
Block exit("exit", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) loop.setBody("OpLoopMerge %exit %loop None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) loop.AppendBody("OpLoopMerge %exit %loop None\n");
string str = header(GetParam()) + string(types_consts()) +
"%func = OpFunction %voidt None %funct\n";
@@ -664,10 +772,10 @@
Block loop1_merge("loop1_merge");
Block exit("exit", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
if (is_shader) {
- loop1.setBody("OpLoopMerge %loop1_merge %loop2 None\n");
- loop2.setBody("OpLoopMerge %loop2_merge %loop2 None\n");
+ loop1.SetBody("OpLoopMerge %loop1_merge %loop2 None\n");
+ loop2.SetBody("OpLoopMerge %loop2_merge %loop2 None\n");
}
string str = header(GetParam()) + nameOps("loop2", "loop2_merge") +
@@ -694,11 +802,11 @@
vector<Block> merge_blocks;
Block inner("inner");
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
if_blocks.emplace_back("if0", SpvOpBranchConditional);
- if (is_shader) if_blocks[0].setBody("OpSelectionMerge %if_merge0 None\n");
+ if (is_shader) if_blocks[0].SetBody("OpSelectionMerge %if_merge0 None\n");
merge_blocks.emplace_back("if_merge0", SpvOpReturn);
for (int i = 1; i < N; i++) {
@@ -706,7 +814,7 @@
ss << i;
if_blocks.emplace_back("if" + ss.str(), SpvOpBranchConditional);
if (is_shader)
- if_blocks[i].setBody("OpSelectionMerge %if_merge" + ss.str() + " None\n");
+ if_blocks[i].SetBody("OpSelectionMerge %if_merge" + ss.str() + " None\n");
merge_blocks.emplace_back("if_merge" + ss.str(), SpvOpBranch);
}
string str = header(GetParam()) + string(types_consts()) +
@@ -737,10 +845,10 @@
Block be_block("be_block");
Block exit("exit", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
if (is_shader) {
- loop1.setBody("OpLoopMerge %exit %loop2_merge None\n");
- loop2.setBody("OpLoopMerge %loop2_merge %loop2 None\n");
+ loop1.SetBody("OpLoopMerge %exit %loop2_merge None\n");
+ loop2.SetBody("OpLoopMerge %loop2_merge %loop2 None\n");
}
string str = header(GetParam()) +
@@ -775,8 +883,8 @@
Block f("f");
Block exit("exit", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) split.setBody("OpSelectionMerge %exit None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) split.SetBody("OpSelectionMerge %exit None\n");
string str = header(GetParam()) + nameOps("split", "f") + types_consts() +
"%func = OpFunction %voidt None %funct\n";
@@ -806,8 +914,8 @@
Block split("split", SpvOpBranchConditional);
Block exit("exit", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) split.setBody("OpSelectionMerge %exit None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) split.SetBody("OpSelectionMerge %exit None\n");
string str = header(GetParam()) + nameOps("split") + types_consts() +
"%func = OpFunction %voidt None %funct\n";
@@ -829,22 +937,24 @@
}
}
-TEST_P(ValidateCFG, MultipleBackEdgesToLoopHeaderBad) {
+TEST_P(ValidateCFG, MultipleBackEdgeBlocksToLoopHeaderBad) {
bool is_shader = GetParam() == SpvCapabilityShader;
Block entry("entry");
Block loop("loop", SpvOpBranchConditional);
- Block cont("cont", SpvOpBranchConditional);
+ Block back0("back0");
+ Block back1("back1");
Block merge("merge", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) loop.setBody("OpLoopMerge %merge %loop None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) loop.SetBody("OpLoopMerge %merge %back0 None\n");
- string str = header(GetParam()) + nameOps("cont", "loop") + types_consts() +
- "%func = OpFunction %voidt None %funct\n";
+ string str = header(GetParam()) + nameOps("loop", "back0", "back1") +
+ types_consts() + "%func = OpFunction %voidt None %funct\n";
str += entry >> loop;
- str += loop >> vector<Block>({cont, merge});
- str += cont >> vector<Block>({loop, loop});
+ str += loop >> vector<Block>({back0, back1});
+ str += back0 >> loop;
+ str += back1 >> loop;
str += merge;
str += "OpFunctionEnd";
@@ -853,7 +963,9 @@
ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
MatchesRegex(
- "Loop header .\\[loop\\] targeted by multiple back-edges"));
+ "Loop header .\\[loop\\] is targeted by 2 back-edge blocks "
+ "but the standard requires exactly one"))
+ << str;
} else {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
@@ -868,8 +980,8 @@
Block merge("merge", SpvOpReturn);
Block exit("exit", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) loop.setBody("OpLoopMerge %merge %cheader None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) loop.SetBody("OpLoopMerge %merge %cheader None\n");
string str = header(GetParam()) + nameOps("cheader", "be_block") +
types_consts() + "%func = OpFunction %voidt None %funct\n";
@@ -901,8 +1013,8 @@
Block cont("cont", SpvOpBranchConditional);
Block merge("merge", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) loop.setBody("OpLoopMerge %merge %loop None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) loop.SetBody("OpLoopMerge %merge %loop None\n");
string str = header(GetParam()) + nameOps("cont", "loop") + types_consts() +
"%func = OpFunction %voidt None %funct\n";
@@ -919,7 +1031,7 @@
EXPECT_THAT(getDiagnosticString(),
MatchesRegex("The continue construct with the continue target "
".\\[loop\\] is not post dominated by the "
- "back-edge block .\\[cont\\]"));
+ "back-edge block .\\[cont\\]")) << str;
} else {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
@@ -933,8 +1045,8 @@
Block merge("merge");
Block exit("exit", SpvOpReturn);
- entry.setBody("%cond = OpSLessThan %intt %one %two\n");
- if (is_shader) loop.setBody("OpLoopMerge %merge %loop None\n");
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) loop.SetBody("OpLoopMerge %merge %loop None\n");
string str = header(GetParam()) + nameOps("cont", "loop") + types_consts() +
"%func = OpFunction %voidt None %funct\n";
@@ -987,11 +1099,11 @@
%main = OpFunction %void None %voidf
)";
- entry.setBody(
- "%idval = OpLoad %uvec3 %id\n"
- "%x = OpCompositeExtract %u32 %idval 0\n"
- "%selector = OpUMod %u32 %x %three\n"
- "OpSelectionMerge %phi None\n");
+ entry.SetBody(
+ "%idval = OpLoad %uvec3 %id\n"
+ "%x = OpCompositeExtract %u32 %idval 0\n"
+ "%selector = OpUMod %u32 %x %three\n"
+ "OpSelectionMerge %phi None\n");
str += entry >> vector<Block>({def, case0, case1, case2});
str += case1 >> phi;
str += def;
@@ -1001,7 +1113,198 @@
str += "OpFunctionEnd";
CompileSuccessfully(str);
- ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
+ EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
+}
+
+TEST_F(ValidateCFG, LoopWithZeroBackEdgesBad) {
+ string str = R"(
+ OpCapability Shader
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %main "main"
+ OpName %loop "loop"
+%voidt = OpTypeVoid
+%funct = OpTypeFunction %voidt
+%main = OpFunction %voidt None %funct
+%loop = OpLabel
+ OpLoopMerge %exit %exit None
+ OpBranch %exit
+%exit = OpLabel
+ OpReturn
+ OpFunctionEnd
+)";
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions());
+ EXPECT_THAT(
+ getDiagnosticString(),
+ MatchesRegex("Loop header .\\[loop\\] is targeted by "
+ "0 back-edge blocks but the standard requires exactly "
+ "one"));
+}
+
+TEST_F(ValidateCFG, LoopWithBackEdgeFromUnreachableContinueConstructGood) {
+ string str = R"(
+ OpCapability Shader
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %main "main"
+ OpName %loop "loop"
+%voidt = OpTypeVoid
+%funct = OpTypeFunction %voidt
+%floatt = OpTypeFloat 32
+%boolt = OpTypeBool
+%one = OpConstant %floatt 1
+%two = OpConstant %floatt 2
+%main = OpFunction %voidt None %funct
+%entry = OpLabel
+ OpBranch %loop
+%loop = OpLabel
+ OpLoopMerge %exit %cont None
+ OpBranch %16
+%16 = OpLabel
+%cond = OpFOrdLessThan %boolt %one %two
+ OpBranchConditional %cond %body %exit
+%body = OpLabel
+ OpReturn
+%cont = OpLabel ; Reachable only from OpLoopMerge ContinueTarget parameter
+ OpBranch %loop ; Should be considered a back-edge
+%exit = OpLabel
+ OpReturn
+ OpFunctionEnd
+)";
+
+ CompileSuccessfully(str);
+ EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString();
+}
+
+TEST_P(ValidateCFG,
+ NestedConstructWithUnreachableMergeBlockBranchingToOuterMergeBlock) {
+ // Test for https://github.com/KhronosGroup/SPIRV-Tools/issues/297
+ // The nested construct has an unreachable merge block. In the
+ // augmented CFG that merge block
+ // we still determine that the
+ bool is_shader = GetParam() == SpvCapabilityShader;
+ Block entry("entry", SpvOpBranchConditional);
+ Block inner_head("inner_head", SpvOpBranchConditional);
+ Block inner_true("inner_true", SpvOpReturn);
+ Block inner_false("inner_false", SpvOpReturn);
+ Block inner_merge("inner_merge");
+ Block exit("exit", SpvOpReturn);
+
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) {
+ entry.AppendBody("OpSelectionMerge %exit None\n");
+ inner_head.SetBody("OpSelectionMerge %inner_merge None\n");
+ }
+
+ string str = header(GetParam()) + nameOps("entry", "inner_merge", "exit") +
+ types_consts() + "%func = OpFunction %voidt None %funct\n";
+
+ str += entry >> vector<Block>({inner_head, exit});
+ str += inner_head >> vector<Block>({inner_true, inner_false});
+ str += inner_true;
+ str += inner_false;
+ str += inner_merge >> exit;
+ str += exit;
+ str += "OpFunctionEnd";
+
+ CompileSuccessfully(str);
+ EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString();
+}
+
+TEST_P(ValidateCFG, ContinueTargetCanBeMergeBlockForNestedStructureGood) {
+ // This example is valid. It shows that the validator can't just add
+ // an edge from the loop head to the continue target. If that edge
+ // is added, then the "if_merge" block is both the continue target
+ // for the loop and also the merge block for the nested selection, but
+ // then it wouldn't be dominated by "if_head", the header block for the
+ // nested selection.
+ bool is_shader = GetParam() == SpvCapabilityShader;
+ Block entry("entry");
+ Block loop("loop");
+ Block if_head("if_head", SpvOpBranchConditional);
+ Block if_true("if_true");
+ Block if_merge("if_merge", SpvOpBranchConditional);
+ Block merge("merge", SpvOpReturn);
+
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) {
+ loop.SetBody("OpLoopMerge %merge %if_merge None\n");
+ if_head.SetBody("OpSelectionMerge %if_merge None\n");
+ }
+
+ string str = header(GetParam()) + nameOps("entry", "loop", "if_head",
+ "if_true", "if_merge", "merge") +
+ types_consts() + "%func = OpFunction %voidt None %funct\n";
+
+ str += entry >> loop;
+ str += loop >> if_head;
+ str += if_head >> vector<Block>({if_true, if_merge});
+ str += if_true >> if_merge;
+ str += if_merge >> vector<Block>({loop, merge});
+ str += merge;
+ str += "OpFunctionEnd";
+
+ CompileSuccessfully(str);
+ EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString();
+}
+
+TEST_P(ValidateCFG, SingleLatchBlockMultipleBranchesToLoopHeader) {
+ // This test case ensures we allow both branches of a loop latch block
+ // to go back to the loop header. It still counts as a single back edge.
+ bool is_shader = GetParam() == SpvCapabilityShader;
+ Block entry("entry");
+ Block loop("loop", SpvOpBranchConditional);
+ Block latch("latch", SpvOpBranchConditional);
+ Block merge("merge", SpvOpReturn);
+
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) {
+ loop.SetBody("OpLoopMerge %merge %latch None\n");
+ }
+
+ string str = header(GetParam()) + nameOps("entry", "loop", "latch", "merge") +
+ types_consts() + "%func = OpFunction %voidt None %funct\n";
+
+ str += entry >> loop;
+ str += loop >> vector<Block>({latch, merge});
+ str += latch >> vector<Block>({loop, loop}); // This is the key
+ str += merge;
+ str += "OpFunctionEnd";
+
+ CompileSuccessfully(str);
+ EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << str
+ << getDiagnosticString();
+}
+
+TEST_P(ValidateCFG, SingleLatchBlockHeaderContinueTargetIsItselfGood) {
+ // This test case ensures we don't count a Continue Target from a loop
+ // header to itself as a self-loop when computing back edges.
+ // Also, it detects that there is an edge from %latch to the pseudo-exit
+ // node, rather than from %loop. In particular, it detects that we
+ // have used the *reverse* textual order of blocks when computing
+ // predecessor traversal roots.
+ bool is_shader = GetParam() == SpvCapabilityShader;
+ Block entry("entry");
+ Block loop("loop");
+ Block latch("latch");
+ Block merge("merge", SpvOpReturn);
+
+ entry.SetBody("%cond = OpSLessThan %intt %one %two\n");
+ if (is_shader) {
+ loop.SetBody("OpLoopMerge %merge %loop None\n");
+ }
+
+ string str = header(GetParam()) + nameOps("entry", "loop", "latch", "merge") +
+ types_consts() + "%func = OpFunction %voidt None %funct\n";
+
+ str += entry >> loop;
+ str += loop >> latch;
+ str += latch >> loop;
+ str += merge;
+ str += "OpFunctionEnd";
+
+ CompileSuccessfully(str);
+ EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << str
+ << getDiagnosticString();
}
/// TODO(umar): Switch instructions
diff --git a/test/Validate.SSA.cpp b/test/Validate.SSA.cpp
index 09f0533..5e2267b 100644
--- a/test/Validate.SSA.cpp
+++ b/test/Validate.SSA.cpp
@@ -35,15 +35,16 @@
#include <utility>
using ::testing::HasSubstr;
+using ::testing::MatchesRegex;
using std::string;
using std::pair;
using std::stringstream;
namespace {
-using Validate = spvtest::ValidateBase<pair<string, bool>>;
+using ValidateSSA = spvtest::ValidateBase<pair<string, bool>>;
-TEST_F(Validate, Default) {
+TEST_F(ValidateSSA, Default) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -60,7 +61,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, IdUndefinedBad) {
+TEST_F(ValidateSSA, IdUndefinedBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -77,7 +78,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_F(Validate, IdRedefinedBad) {
+TEST_F(ValidateSSA, IdRedefinedBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -93,7 +94,7 @@
ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
}
-TEST_F(Validate, DominateUsageBad) {
+TEST_F(ValidateSSA, DominateUsageBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -106,7 +107,50 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("not_dominant"));
}
-TEST_F(Validate, ForwardNameGood) {
+TEST_F(ValidateSSA, DominateUsageWithinBlockBad) {
+ char str[] = R"(
+ OpCapability Shader
+ OpMemoryModel Logical GLSL450
+ OpName %bad "bad"
+%voidt = OpTypeVoid
+%funct = OpTypeFunction %voidt
+%uintt = OpTypeInt 32 0
+%one = OpConstant %uintt 1
+%func = OpFunction %voidt None %funct
+%entry = OpLabel
+%sum = OpIAdd %uintt %one %bad
+%bad = OpCopyObject %uintt %sum
+ OpReturn
+ OpFunctionEnd
+)";
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
+ EXPECT_THAT(getDiagnosticString(),
+ MatchesRegex("ID .\\[bad\\] has not been defined"));
+}
+
+TEST_F(ValidateSSA, DominateUsageSameInstructionBad) {
+ char str[] = R"(
+ OpCapability Shader
+ OpMemoryModel Logical GLSL450
+ OpName %sum "sum"
+%voidt = OpTypeVoid
+%funct = OpTypeFunction %voidt
+%uintt = OpTypeInt 32 0
+%one = OpConstant %uintt 1
+%func = OpFunction %voidt None %funct
+%entry = OpLabel
+%sum = OpIAdd %uintt %one %sum
+ OpReturn
+ OpFunctionEnd
+)";
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
+ EXPECT_THAT(getDiagnosticString(),
+ MatchesRegex("ID .\\[sum\\] has not been defined"));
+}
+
+TEST_F(ValidateSSA, ForwardNameGood) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -122,7 +166,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, ForwardNameMissingTargetBad) {
+TEST_F(ValidateSSA, ForwardNameMissingTargetBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -133,7 +177,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("main"));
}
-TEST_F(Validate, ForwardMemberNameGood) {
+TEST_F(ValidateSSA, ForwardMemberNameGood) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -147,7 +191,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, ForwardMemberNameMissingTargetBad) {
+TEST_F(ValidateSSA, ForwardMemberNameMissingTargetBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -162,7 +206,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("size"));
}
-TEST_F(Validate, ForwardDecorateGood) {
+TEST_F(ValidateSSA, ForwardDecorateGood) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -175,7 +219,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, ForwardDecorateInvalidIDBad) {
+TEST_F(ValidateSSA, ForwardDecorateInvalidIDBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -196,7 +240,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_F(Validate, ForwardMemberDecorateGood) {
+TEST_F(ValidateSSA, ForwardMemberDecorateGood) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -210,7 +254,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, ForwardMemberDecorateInvalidIdBad) {
+TEST_F(ValidateSSA, ForwardMemberDecorateInvalidIdBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -226,7 +270,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_F(Validate, ForwardGroupDecorateGood) {
+TEST_F(ValidateSSA, ForwardGroupDecorateGood) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -243,7 +287,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, ForwardGroupDecorateMissingGroupBad) {
+TEST_F(ValidateSSA, ForwardGroupDecorateMissingGroupBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -262,7 +306,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_F(Validate, ForwardGroupDecorateMissingTargetBad) {
+TEST_F(ValidateSSA, ForwardGroupDecorateMissingTargetBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -281,7 +325,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_F(Validate, ForwardGroupDecorateDecorationGroupDominateBad) {
+TEST_F(ValidateSSA, ForwardGroupDecorateDecorationGroupDominateBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -300,7 +344,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("group"));
}
-TEST_F(Validate, ForwardDecorateInvalidIdBad) {
+TEST_F(ValidateSSA, ForwardDecorateInvalidIdBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -321,7 +365,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_F(Validate, FunctionCallGood) {
+TEST_F(ValidateSSA, FunctionCallGood) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -348,7 +392,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, ForwardFunctionCallGood) {
+TEST_F(ValidateSSA, ForwardFunctionCallGood) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -375,7 +419,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, ForwardBranchConditionalGood) {
+TEST_F(ValidateSSA, ForwardBranchConditionalGood) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -401,7 +445,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, ForwardBranchConditionalWithWeightsGood) {
+TEST_F(ValidateSSA, ForwardBranchConditionalWithWeightsGood) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -427,7 +471,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, ForwardBranchConditionalNonDominantConditionBad) {
+TEST_F(ValidateSSA, ForwardBranchConditionalNonDominantConditionBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -456,7 +500,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("conditional"));
}
-TEST_F(Validate, ForwardBranchConditionalMissingTargetBad) {
+TEST_F(ValidateSSA, ForwardBranchConditionalMissingTargetBad) {
char str[] = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
@@ -497,6 +541,11 @@
%intt = OpTypeInt 32 1
%uintt = OpTypeInt 32 0
%vfunct = OpTypeFunction %voidt
+%intptrt = OpTypePointer UniformConstant %intt
+%zero = OpConstant %intt 0
+%one = OpConstant %intt 1
+%ten = OpConstant %intt 10
+%false = OpConstantFalse %boolt
)";
const string kKernelTypesAndConstants = R"(
@@ -507,7 +556,6 @@
%ndt = OpTypeStruct %intt %arr3t %arr3t %arr3t
%eventt = OpTypeEvent
-%intptrt = OpTypePointer UniformConstant %int8t
%offset = OpConstant %intt 0
%local = OpConstant %intt 1
@@ -541,7 +589,7 @@
OpFunctionEnd
)";
-TEST_F(Validate, EnqueueKernelGood) {
+TEST_F(ValidateSSA, EnqueueKernelGood) {
string str = kHeader + kBasicTypes + kKernelTypesAndConstants +
kKernelDefinition + R"(
%main = OpFunction %voidt None %vfunct
@@ -558,7 +606,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, ForwardEnqueueKernelGood) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelGood) {
string str = kHeader + kBasicTypes + kKernelTypesAndConstants + R"(
%main = OpFunction %voidt None %vfunct
%mainl = OpLabel
@@ -575,7 +623,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, EnqueueMissingFunctionBad) {
+TEST_F(ValidateSSA, EnqueueMissingFunctionBad) {
string str = kHeader + "OpName %kfunc \"kfunc\"" + kBasicTypes +
kKernelTypesAndConstants + R"(
%main = OpFunction %voidt None %vfunct
@@ -610,7 +658,7 @@
return out;
}
-TEST_F(Validate, ForwardEnqueueKernelMissingParameter1Bad) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelMissingParameter1Bad) {
string str = forwardKernelNonDominantParameterBaseCode("missing") + R"(
%err = OpEnqueueKernel %missing %dqueue %flags %ndval
%nevent %event %revent %kfunc %firstp
@@ -623,7 +671,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_F(Validate, ForwardEnqueueKernelNonDominantParameter2Bad) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter2Bad) {
string str = forwardKernelNonDominantParameterBaseCode("dqueue2") + R"(
%err = OpEnqueueKernel %uintt %dqueue2 %flags %ndval
%nevent %event %revent %kfunc
@@ -637,7 +685,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("dqueue2"));
}
-TEST_F(Validate, ForwardEnqueueKernelNonDominantParameter3Bad) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter3Bad) {
string str = forwardKernelNonDominantParameterBaseCode("ndval2") + R"(
%err = OpEnqueueKernel %uintt %dqueue %flags %ndval2
%nevent %event %revent %kfunc %firstp
@@ -651,7 +699,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("ndval2"));
}
-TEST_F(Validate, ForwardEnqueueKernelNonDominantParameter4Bad) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter4Bad) {
string str = forwardKernelNonDominantParameterBaseCode("nevent2") + R"(
%err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent2
%event %revent %kfunc %firstp %psize
@@ -665,7 +713,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("nevent2"));
}
-TEST_F(Validate, ForwardEnqueueKernelNonDominantParameter5Bad) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter5Bad) {
string str = forwardKernelNonDominantParameterBaseCode("event2") + R"(
%err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent
%event2 %revent %kfunc %firstp %psize
@@ -679,7 +727,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("event2"));
}
-TEST_F(Validate, ForwardEnqueueKernelNonDominantParameter6Bad) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter6Bad) {
string str = forwardKernelNonDominantParameterBaseCode("revent2") + R"(
%err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent
%event %revent2 %kfunc %firstp %psize
@@ -693,7 +741,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("revent2"));
}
-TEST_F(Validate, ForwardEnqueueKernelNonDominantParameter8Bad) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter8Bad) {
string str = forwardKernelNonDominantParameterBaseCode("firstp2") + R"(
%err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent
%event %revent %kfunc %firstp2 %psize
@@ -707,7 +755,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("firstp2"));
}
-TEST_F(Validate, ForwardEnqueueKernelNonDominantParameter9Bad) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter9Bad) {
string str = forwardKernelNonDominantParameterBaseCode("psize2") + R"(
%err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent
%event %revent %kfunc %firstp %psize2
@@ -721,7 +769,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("psize2"));
}
-TEST_F(Validate, ForwardEnqueueKernelNonDominantParameter10Bad) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter10Bad) {
string str = forwardKernelNonDominantParameterBaseCode("palign2") + R"(
%err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent
%event %revent %kfunc %firstp %psize
@@ -735,7 +783,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("palign2"));
}
-TEST_F(Validate, ForwardEnqueueKernelNonDominantParameter11Bad) {
+TEST_F(ValidateSSA, ForwardEnqueueKernelNonDominantParameter11Bad) {
string str = forwardKernelNonDominantParameterBaseCode("lsize2") + R"(
%err = OpEnqueueKernel %uintt %dqueue %flags %ndval %nevent
%event %revent %kfunc %firstp %psize
@@ -758,14 +806,14 @@
{"OpGetKernelWorkGroupSize", kNoNDrange},
{"OpGetKernelPreferredWorkGroupSizeMultiple", kNoNDrange}};
-INSTANTIATE_TEST_CASE_P(KernelArgs, Validate, ::testing::ValuesIn(cases),);
+INSTANTIATE_TEST_CASE_P(KernelArgs, ValidateSSA, ::testing::ValuesIn(cases), );
static const string return_instructions = R"(
OpReturn
OpFunctionEnd
)";
-TEST_P(Validate, GetKernelGood) {
+TEST_P(ValidateSSA, GetKernelGood) {
string instruction = GetParam().first;
bool with_ndrange = GetParam().second;
string ndrange_param = with_ndrange ? " %ndval " : " ";
@@ -781,7 +829,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_P(Validate, ForwardGetKernelGood) {
+TEST_P(ValidateSSA, ForwardGetKernelGood) {
string instruction = GetParam().first;
bool with_ndrange = GetParam().second;
string ndrange_param = with_ndrange ? " %ndval " : " ";
@@ -801,7 +849,7 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_P(Validate, ForwardGetKernelMissingDefinitionBad) {
+TEST_P(ValidateSSA, ForwardGetKernelMissingDefinitionBad) {
string instruction = GetParam().first;
bool with_ndrange = GetParam().second;
string ndrange_param = with_ndrange ? " %ndval " : " ";
@@ -818,7 +866,7 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_P(Validate, ForwardGetKernelNDrangeSubGroupCountMissingParameter1Bad) {
+TEST_P(ValidateSSA, ForwardGetKernelNDrangeSubGroupCountMissingParameter1Bad) {
string instruction = GetParam().first;
bool with_ndrange = GetParam().second;
string ndrange_param = with_ndrange ? " %ndval " : " ";
@@ -835,7 +883,8 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_P(Validate, ForwardGetKernelNDrangeSubGroupCountNonDominantParameter2Bad) {
+TEST_P(ValidateSSA,
+ ForwardGetKernelNDrangeSubGroupCountNonDominantParameter2Bad) {
string instruction = GetParam().first;
bool with_ndrange = GetParam().second;
string ndrange_param = with_ndrange ? " %ndval2 " : " ";
@@ -855,7 +904,8 @@
}
}
-TEST_P(Validate, ForwardGetKernelNDrangeSubGroupCountNonDominantParameter4Bad) {
+TEST_P(ValidateSSA,
+ ForwardGetKernelNDrangeSubGroupCountNonDominantParameter4Bad) {
string instruction = GetParam().first;
bool with_ndrange = GetParam().second;
string ndrange_param = with_ndrange ? " %ndval " : " ";
@@ -873,7 +923,8 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("firstp2"));
}
-TEST_P(Validate, ForwardGetKernelNDrangeSubGroupCountNonDominantParameter5Bad) {
+TEST_P(ValidateSSA,
+ ForwardGetKernelNDrangeSubGroupCountNonDominantParameter5Bad) {
string instruction = GetParam().first;
bool with_ndrange = GetParam().second;
string ndrange_param = with_ndrange ? " %ndval " : " ";
@@ -891,7 +942,8 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("psize2"));
}
-TEST_P(Validate, ForwardGetKernelNDrangeSubGroupCountNonDominantParameter6Bad) {
+TEST_P(ValidateSSA,
+ ForwardGetKernelNDrangeSubGroupCountNonDominantParameter6Bad) {
string instruction = GetParam().first;
bool with_ndrange = GetParam().second;
string ndrange_param = with_ndrange ? " %ndval " : " ";
@@ -911,12 +963,9 @@
}
}
-TEST_F(Validate, PhiGood) {
+TEST_F(ValidateSSA, PhiGood) {
string str = kHeader + kBasicTypes +
R"(
-%zero = OpConstant %intt 0
-%one = OpConstant %intt 1
-%ten = OpConstant %intt 10
%func = OpFunction %voidt None %vfunct
%preheader = OpLabel
%init = OpCopyObject %intt %zero
@@ -937,12 +986,9 @@
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-TEST_F(Validate, PhiMissingTypeBad) {
+TEST_F(ValidateSSA, PhiMissingTypeBad) {
string str = kHeader + "OpName %missing \"missing\"" + kBasicTypes +
R"(
-%zero = OpConstant %intt 0
-%one = OpConstant %intt 1
-%ten = OpConstant %intt 10
%func = OpFunction %voidt None %vfunct
%preheader = OpLabel
%init = OpCopyObject %intt %zero
@@ -964,12 +1010,9 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_F(Validate, PhiMissingIdBad) {
+TEST_F(ValidateSSA, PhiMissingIdBad) {
string str = kHeader + "OpName %missing \"missing\"" + kBasicTypes +
R"(
-%zero = OpConstant %intt 0
-%one = OpConstant %intt 1
-%ten = OpConstant %intt 10
%func = OpFunction %voidt None %vfunct
%preheader = OpLabel
%init = OpCopyObject %intt %zero
@@ -991,12 +1034,9 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-TEST_F(Validate, PhiMissingLabelBad) {
+TEST_F(ValidateSSA, PhiMissingLabelBad) {
string str = kHeader + "OpName %missing \"missing\"" + kBasicTypes +
R"(
-%zero = OpConstant %intt 0
-%one = OpConstant %intt 1
-%ten = OpConstant %intt 10
%func = OpFunction %voidt None %vfunct
%preheader = OpLabel
%init = OpCopyObject %intt %zero
@@ -1018,5 +1058,247 @@
EXPECT_THAT(getDiagnosticString(), HasSubstr("missing"));
}
-// TODO(umar): OpGroupMemberDecorate
+TEST_F(ValidateSSA, IdDominatesItsUseGood) {
+ string str = kHeader + kBasicTypes +
+ R"(
+%func = OpFunction %voidt None %vfunct
+%entry = OpLabel
+%cond = OpSLessThan %intt %one %ten
+%eleven = OpIAdd %intt %one %ten
+ OpSelectionMerge %merge None
+ OpBranchConditional %cond %t %f
+%t = OpLabel
+%twelve = OpIAdd %intt %eleven %one
+ OpBranch %merge
+%f = OpLabel
+%twentytwo = OpIAdd %intt %eleven %ten
+ OpBranch %merge
+%merge = OpLabel
+ OpReturn
+ OpFunctionEnd
+)";
+
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
+
+TEST_F(ValidateSSA, IdDoesNotDominateItsUseBad) {
+ string str = kHeader +
+ "OpName %eleven \"eleven\"\n"
+ "OpName %true_block \"true_block\"\n"
+ "OpName %false_block \"false_block\"" +
+ kBasicTypes +
+ R"(
+%func = OpFunction %voidt None %vfunct
+%entry = OpLabel
+%cond = OpSLessThan %intt %one %ten
+ OpSelectionMerge %merge None
+ OpBranchConditional %cond %true_block %false_block
+%true_block = OpLabel
+%eleven = OpIAdd %intt %one %ten
+%twelve = OpIAdd %intt %eleven %one
+ OpBranch %merge
+%false_block = OpLabel
+%twentytwo = OpIAdd %intt %eleven %ten
+ OpBranch %merge
+%merge = OpLabel
+ OpReturn
+ OpFunctionEnd
+)";
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
+ EXPECT_THAT(
+ getDiagnosticString(),
+ MatchesRegex("ID .\\[eleven\\] defined in block .\\[true_block\\] does "
+ "not dominate its use in block .\\[false_block\\]"));
+}
+
+TEST_F(ValidateSSA, PhiUseDoesntDominateDefinitionGood) {
+ string str = kHeader + kBasicTypes +
+ R"(
+%func = OpFunction %voidt None %vfunct
+%entry = OpLabel
+%var_one = OpVariable %intptrt Function %one
+%one_val = OpLoad %intt %var_one
+ OpBranch %loop
+%loop = OpLabel
+%i = OpPhi %intt %one_val %entry %inew %cont
+%cond = OpSLessThan %intt %one %ten
+ OpLoopMerge %merge %cont None
+ OpBranchConditional %cond %body %merge
+%body = OpLabel
+ OpBranch %cont
+%cont = OpLabel
+%inew = OpIAdd %intt %i %one
+ OpBranch %loop
+%merge = OpLabel
+ OpReturn
+ OpFunctionEnd
+)";
+
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
+}
+
+TEST_F(ValidateSSA, PhiUseDoesntDominateUseOfPhiOperandUsedBeforeDefinitionBad) {
+ string str = kHeader
+ + "OpName %inew \"inew\""
+ + kBasicTypes +
+ R"(
+%func = OpFunction %voidt None %vfunct
+%entry = OpLabel
+%var_one = OpVariable %intptrt Function %one
+%one_val = OpLoad %intt %var_one
+ OpBranch %loop
+%loop = OpLabel
+%i = OpPhi %intt %one_val %entry %inew %cont
+%bad = OpIAdd %intt %inew %one
+%cond = OpSLessThan %intt %one %ten
+ OpLoopMerge %merge %cont None
+ OpBranchConditional %cond %body %merge
+%body = OpLabel
+ OpBranch %cont
+%cont = OpLabel
+%inew = OpIAdd %intt %i %one
+ OpBranch %loop
+%merge = OpLabel
+ OpReturn
+ OpFunctionEnd
+)";
+
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
+ EXPECT_THAT(
+ getDiagnosticString(),
+ MatchesRegex("ID .\\[inew\\] has not been defined"));
+}
+
+TEST_F(ValidateSSA, PhiUseMayComeFromNonDominatingBlockGood) {
+ string str = kHeader
+ + "OpName %if_true \"if_true\"\n"
+ + "OpName %exit \"exit\"\n"
+ + "OpName %copy \"copy\"\n"
+ + kBasicTypes +
+ R"(
+%func = OpFunction %voidt None %vfunct
+%entry = OpLabel
+ OpBranchConditional %false %if_true %exit
+
+%if_true = OpLabel
+%copy = OpCopyObject %boolt %false
+ OpBranch %exit
+
+; The use of %copy here is ok, even though it was defined
+; in a block that does not dominate %exit. That's the point
+; of an OpPhi.
+%exit = OpLabel
+%value = OpPhi %boolt %false %entry %copy %if_true
+ OpReturn
+ OpFunctionEnd
+)";
+
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString();
+}
+
+TEST_F(ValidateSSA, DISABLED_PhiVariableDefMustComeFromBlockDominatingThePredecessorBad) {
+ string str = kHeader
+ + "OpName %if_true \"if_true\"\n"
+ + "OpName %if_false \"if_false\"\n"
+ + "OpName %exit \"exit\"\n"
+ + "OpName %true_copy \"true_copy\"\n"
+ + "OpName %false_copy \"false_copy\"\n"
+ + kBasicTypes +
+ R"(
+%func = OpFunction %voidt None %vfunct
+%entry = OpLabel
+ OpBranchConditional %false %if_true %if_false
+
+%if_true = OpLabel
+%true_copy = OpCopyObject %boolt %false
+ OpBranch %exit
+
+%if_false = OpLabel
+%false_copy = OpCopyObject %boolt %false
+ OpBranch %exit
+
+; The (variable,Id) pairs are swapped.
+%exit = OpLabel
+%value = OpPhi %boolt %true_copy %if_false %false_copy %if_true
+ OpReturn
+ OpFunctionEnd
+)";
+
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
+ // TODO(dneto): Check for a good error message
+}
+
+TEST_F(ValidateSSA, DominanceCheckIgnoresUsesInUnreachableBlocksDefInBlockGood) {
+ string str = kHeader
+ + kBasicTypes +
+ R"(
+%func = OpFunction %voidt None %vfunct
+%entry = OpLabel
+%def = OpCopyObject %boolt %false
+ OpReturn
+
+%unreach = OpLabel
+%use = OpCopyObject %boolt %def
+ OpReturn
+ OpFunctionEnd
+)";
+
+ CompileSuccessfully(str);
+ EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString();
+}
+
+TEST_F(ValidateSSA, DominanceCheckIgnoresUsesInUnreachableBlocksDefIsParamGood) {
+ string str = kHeader + kBasicTypes +
+ R"(
+%void_fn_int = OpTypeFunction %voidt %intt
+%func = OpFunction %voidt None %void_fn_int
+%int_param = OpFunctionParameter %intt
+%entry = OpLabel
+ OpReturn
+
+%unreach = OpLabel
+%use = OpCopyObject %intt %int_param
+ OpReturn
+ OpFunctionEnd
+)";
+
+ CompileSuccessfully(str);
+ EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString();
+}
+
+TEST_F(ValidateSSA, UseFunctionParameterFromOtherFunctionBad) {
+ string str = kHeader +
+ "OpName %first \"first\"\n"
+ "OpName %entry2 \"entry2\"\n"
+ "OpName %func \"func\"\n" +
+ kBasicTypes +
+ R"(
+%viifunct = OpTypeFunction %voidt %intt %intt
+%func = OpFunction %voidt None %viifunct
+%first = OpFunctionParameter %intt
+%second = OpFunctionParameter %intt
+ OpFunctionEnd
+%func2 = OpFunction %voidt None %viifunct
+%first2 = OpFunctionParameter %intt
+%second2 = OpFunctionParameter %intt
+%entry2 = OpLabel
+%baduse = OpIAdd %intt %first %first2
+ OpReturn
+ OpFunctionEnd
+)";
+
+ CompileSuccessfully(str);
+ ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
+ EXPECT_THAT(
+ getDiagnosticString(),
+ MatchesRegex("ID .\\[first\\] used in block .\\[entry2\\] is used "
+ "outside of it's defining function .\\[func\\]"));
+}
+// TODO(umar): OpGroupMemberDecorate
+} // namespace
diff --git a/test/opt/CMakeLists.txt b/test/opt/CMakeLists.txt
index f83b793..90bd472 100644
--- a/test/opt/CMakeLists.txt
+++ b/test/opt/CMakeLists.txt
@@ -39,7 +39,22 @@
LIBS SPIRV-Tools-opt ${SPIRV_TOOLS}
)
+add_spvtools_unittest(TARGET pass_freeze_spec_const
+ SRCS test_freeze_spec_const.cpp pass_utils.cpp
+ LIBS SPIRV-Tools-opt ${SPIRV_TOOLS}
+)
+
add_spvtools_unittest(TARGET pass_utils
SRCS test_utils.cpp pass_utils.cpp
LIBS SPIRV-Tools-opt ${SPIRV_TOOLS}
)
+
+add_spvtools_unittest(TARGET def_use
+ SRCS test_def_use.cpp pass_utils.cpp
+ LIBS SPIRV-Tools-opt ${SPIRV_TOOLS}
+)
+
+add_spvtools_unittest(TARGET assembly_builder
+ SRCS test_assembly_builder.cpp pass_utils.cpp
+ LIBS SPIRV-Tools-opt ${SPIRV_TOOLS}
+)
diff --git a/test/opt/assembly_builder.h b/test/opt/assembly_builder.h
new file mode 100644
index 0000000..855a546
--- /dev/null
+++ b/test/opt/assembly_builder.h
@@ -0,0 +1,250 @@
+// Copyright (c) 2016 Google Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+// https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#ifndef LIBSPIRV_TEST_OPT_ASSEMBLY_BUILDER
+#define LIBSPIRV_TEST_OPT_ASSEMBLY_BUILDER
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+namespace spvtools {
+
+// A simple SPIR-V assembly code builder for test uses. It builds an SPIR-V
+// assembly module from vectors of assembly strings. It allows users to add
+// instructions to the main function and the type-constants-globals section
+// directly. It relies on OpName instructions and friendly-name disassembling
+// to keep the ID names unchanged after assembling.
+//
+// An assembly module is divided into several sections, matching with the
+// SPIR-V Logical Layout:
+// Global Preamble:
+// OpCapability instructions;
+// OpExtension instructions and OpExtInstImport instructions;
+// OpMemoryModel instruction;
+// OpEntryPoint and OpExecutionMode instruction;
+// OpString, OpSourceExtension, OpSource and OpSourceContinued instructions.
+// Names:
+// OpName instructions.
+// Annotations:
+// OpDecorate, OpMemberDecorate, OpGroupDecorate, OpGroupMemberDecorate and
+// OpDecorationGroup.
+// Types, Constants and Global variables:
+// Types, constants and global variables declaration instructions.
+// Main Function:
+// Main function instructions.
+// Main Function Postamble:
+// The return and function end instructions.
+//
+// The assembly code is built by concatenating all the strings in the above
+// sections.
+//
+// Users define the contents in section <Type, Constants and Global Variables>
+// and <Main Function>. The <Names> section is to hold the names for IDs to
+// keep them unchanged before and after assembling. All defined IDs to be added
+// to this code builder will be assigned with a global name through OpName
+// instruction. The name is extracted from the definition instruction.
+// E.g. adding instruction: %var_a = OpConstant %int 2, will also add an
+// instruction: OpName %var_a, "var_a".
+//
+// Note that the name must not be used on more than one defined IDs and
+// friendly-name disassembling must be enabled so that OpName instructions will
+// be respected.
+class AssemblyBuilder {
+ // The base ID value for spec constants.
+ static const uint32_t SPEC_ID_BASE = 200;
+
+ public:
+ // Initalize a minimal SPIR-V assembly code as the template. The minimal
+ // module contains an empty main function and some predefined names for the
+ // main function.
+ AssemblyBuilder()
+ : spec_id_counter_(SPEC_ID_BASE),
+ global_preamble_({
+ // clang-format off
+ "OpCapability Shader",
+ "OpCapability Float64",
+ "%1 = OpExtInstImport \"GLSL.std.450\"",
+ "OpMemoryModel Logical GLSL450",
+ "OpEntryPoint Vertex %main \"main\"",
+ // clang-format on
+ }),
+ names_(),
+ annotations_(),
+ types_consts_globals_(),
+ main_func_(),
+ main_func_postamble_({
+ "OpReturn", "OpFunctionEnd",
+ }) {
+ AppendTypesConstantsGlobals({
+ "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void",
+ });
+ AppendInMain({
+ "%main = OpFunction %void None %main_func_type",
+ "%main_func_entry_block = OpLabel",
+ });
+ }
+
+ // Appends instructions to the types-constants-globals section and returns
+ // the reference of this assembly builder. IDs defined in the given code will
+ // be added to the Names section and then be registered with OpName
+ // instruction. Corresponding decoration instruction will be added for spec
+ // constants defined with opcode: 'OpSpecConstant'.
+ AssemblyBuilder& AppendTypesConstantsGlobals(
+ const std::vector<std::string>& vec_asm_code) {
+ AddNamesForResultIDsIn(vec_asm_code);
+ // Check spec constants defined with OpSpecConstant.
+ for (auto& inst_str : vec_asm_code) {
+ if (inst_str.find("= OpSpecConstant ") != std::string::npos ||
+ inst_str.find("= OpSpecConstantTrue ") != std::string::npos ||
+ inst_str.find("= OpSpecConstantFalse ") != std::string::npos) {
+ AddSpecIDFor(GetResultIDName(inst_str));
+ }
+ }
+ types_consts_globals_.insert(types_consts_globals_.end(),
+ vec_asm_code.begin(), vec_asm_code.end());
+ return *this;
+ }
+
+ // Appends instructions to the main function block, which is already labelled
+ // with "main_func_entry_block". Returns the reference of this assembly
+ // builder. IDs defined in the given code will be added to the Names section
+ // and then be registered with OpName instruction.
+ AssemblyBuilder& AppendInMain(const std::vector<std::string>& vec_asm_code) {
+ AddNamesForResultIDsIn(vec_asm_code);
+ main_func_.insert(main_func_.end(), vec_asm_code.begin(),
+ vec_asm_code.end());
+ return *this;
+ }
+
+ // Appends annotation instructions to the annotation section, and returns the
+ // reference of this assembly builder.
+ AssemblyBuilder& AppendAnnotations(
+ const std::vector<std::string>& vec_annotations) {
+ annotations_.insert(annotations_.end(), vec_annotations.begin(),
+ vec_annotations.end());
+ return *this;
+ }
+
+ // Get the SPIR-V assembly code as string.
+ std::string GetCode() const {
+ std::ostringstream ss;
+ for (const auto& line : global_preamble_) {
+ ss << line << std::endl;
+ }
+ for (const auto& line : names_) {
+ ss << line << std::endl;
+ }
+ for (const auto& line : annotations_) {
+ ss << line << std::endl;
+ }
+ for (const auto& line : types_consts_globals_) {
+ ss << line << std::endl;
+ }
+ for (const auto& line : main_func_) {
+ ss << line << std::endl;
+ }
+ for (const auto& line : main_func_postamble_) {
+ ss << line << std::endl;
+ }
+ return ss.str();
+ }
+
+ private:
+ // Adds a given name to the Name section with OpName. If the given name has
+ // been added before, does nothing.
+ void AddOpNameIfNotExist(const std::string& id_name) {
+ if (!used_names_.count(id_name)) {
+ std::stringstream opname_inst;
+ opname_inst << "OpName "
+ << "%" << id_name << " \"" << id_name << "\"";
+ names_.emplace_back(opname_inst.str());
+ used_names_.insert(id_name);
+ }
+ }
+
+ // Adds the names in a vector of assembly code strings to the Names section.
+ // If a '=' sign is found in an instruction, this instruction will be treated
+ // as an ID defining instruction. The ID name used in the instruction will be
+ // extracted and added to the Names section.
+ void AddNamesForResultIDsIn(const std::vector<std::string>& vec_asm_code) {
+ for (const auto& line : vec_asm_code) {
+ std::string name = GetResultIDName(line);
+ if (!name.empty()) {
+ AddOpNameIfNotExist(name);
+ }
+ }
+ }
+
+ // Adds an OpDecorate SpecId instruction for the given ID name.
+ void AddSpecIDFor(const std::string& id_name) {
+ std::stringstream decorate_inst;
+ decorate_inst << "OpDecorate "
+ << "%" << id_name << " SpecId " << spec_id_counter_;
+ spec_id_counter_ += 1;
+ annotations_.emplace_back(decorate_inst.str());
+ }
+
+ // Extracts the ID name from a SPIR-V assembly instruction string. If the
+ // instruction is an ID-defining instruction (has result ID), returns the
+ // name of the result ID in string. If the instruction does not have result
+ // ID, returns an empty string.
+ std::string GetResultIDName(const std::string inst_str) {
+ std::string name;
+ if (inst_str.find('=') != std::string::npos) {
+ size_t assign_sign = inst_str.find('=');
+ name = inst_str.substr(0, assign_sign);
+ name.erase(remove_if(name.begin(), name.end(),
+ [](char c) { return c == ' ' || c == '%'; }),
+ name.end());
+ }
+ return name;
+ }
+
+ uint32_t spec_id_counter_;
+ // The vector that contains common preambles shared across all test SPIR-V
+ // code.
+ std::vector<std::string> global_preamble_;
+ // The vector that contains OpName instructions.
+ std::vector<std::string> names_;
+ // The vector that contains annotation instructions.
+ std::vector<std::string> annotations_;
+ // The vector that contains the code to declare types, constants and global
+ // variables (aka. the Types-Constants-Globals section).
+ std::vector<std::string> types_consts_globals_;
+ // The vector that contains the code in main function's entry block.
+ std::vector<std::string> main_func_;
+ // The vector that contains the postamble of main function body.
+ std::vector<std::string> main_func_postamble_;
+ // All of the defined variable names.
+ std::unordered_set<std::string> used_names_;
+};
+
+} // namespace spvtools
+
+#endif // LIBSPIRV_TEST_OPT_ASSEMBLY_BUILDER
diff --git a/test/opt/pass_fixture.h b/test/opt/pass_fixture.h
index 0c3b2df..1247184 100644
--- a/test/opt/pass_fixture.h
+++ b/test/opt/pass_fixture.h
@@ -29,6 +29,7 @@
#include <memory>
#include <string>
+#include <tuple>
#include <vector>
#include <gtest/gtest.h>
@@ -52,26 +53,50 @@
PassTest()
: tools_(SPV_ENV_UNIVERSAL_1_1), manager_(new opt::PassManager()) {}
+ // Runs the given |pass| on the binary assembled from the |assembly|, and
+ // disassebles the optimized binary. Returns a tuple of disassembly string
+ // and the boolean value returned from pass Process() function.
+ std::tuple<std::string, bool> OptimizeAndDisassemble(
+ opt::Pass* pass, const std::string& original, bool skip_nop = false) {
+ std::unique_ptr<ir::Module> module = tools_.BuildModule(original);
+ EXPECT_NE(nullptr, module);
+ if (!module) {
+ return std::make_tuple(std::string(), false);
+ }
+
+ const bool modified = pass->Process(module.get());
+
+ std::vector<uint32_t> binary;
+ module->ToBinary(&binary, skip_nop);
+ std::string optimized;
+ EXPECT_EQ(SPV_SUCCESS, tools_.Disassemble(binary, &optimized));
+ return std::make_tuple(optimized, modified);
+ }
+
+ // Runs a single pass of class |PassT| on the binary assembled from the
+ // |assembly|, disassembles the optimized binary. Returns a tuple of
+ // disassembly string and the boolean value from the pass Process() function.
+ template <typename PassT>
+ std::tuple<std::string, bool> SinglePassRunAndDisassemble(
+ const std::string& assembly, bool skip_nop = false) {
+ auto pass = std::unique_ptr<PassT>(new PassT);
+ return OptimizeAndDisassemble(pass.get(), assembly, skip_nop);
+ }
+
// Runs a single pass of class |PassT| on the binary assembled from the
// |original| assembly, and checks whether the optimized binary can be
// disassembled to the |expected| assembly. This does *not* involve pass
// manager. Callers are suggested to use SCOPED_TRACE() for better messages.
template <typename PassT>
void SinglePassRunAndCheck(const std::string& original,
- const std::string& expected) {
- std::unique_ptr<ir::Module> module = tools_.BuildModule(original);
- ASSERT_NE(nullptr, module);
-
- const bool modified =
- std::unique_ptr<PassT>(new PassT)->Process(module.get());
+ const std::string& expected,
+ bool skip_nop = false) {
+ std::string optimized;
+ bool modified = false;
+ std::tie(optimized, modified) =
+ SinglePassRunAndDisassemble<PassT>(original, skip_nop);
// Check whether the pass returns the correct modification indication.
EXPECT_EQ(original != expected, modified);
-
- std::vector<uint32_t> binary;
- module->ToBinary(&binary, /* skip_nop = */ false);
-
- std::string optimized;
- EXPECT_EQ(SPV_SUCCESS, tools_.Disassemble(binary, &optimized));
EXPECT_EQ(expected, optimized);
}
diff --git a/test/opt/pass_utils.cpp b/test/opt/pass_utils.cpp
index a6f2374..68bc1a4 100644
--- a/test/opt/pass_utils.cpp
+++ b/test/opt/pass_utils.cpp
@@ -43,7 +43,27 @@
// clang-format on
};
-// Returns true if the given string contains any debug opcode substring.
+} // anonymous namespace
+
+namespace spvtools {
+
+bool FindAndReplace(std::string* process_str, const std::string find_str,
+ const std::string replace_str) {
+ if (process_str->empty() || find_str.empty()) {
+ return false;
+ }
+ bool replaced = false;
+ // Note this algorithm has quadratic time complexity. It is OK for test cases
+ // with short strings, but might not fit in other contexts.
+ for (size_t pos = process_str->find(find_str, 0); pos != std::string::npos;
+ pos = process_str->find(find_str, pos)) {
+ process_str->replace(pos, find_str.length(), replace_str);
+ pos += replace_str.length();
+ replaced = true;
+ }
+ return replaced;
+}
+
bool ContainsDebugOpcode(const char* inst) {
return std::any_of(std::begin(kDebugOpcodes), std::end(kDebugOpcodes),
[inst](const char* op) {
@@ -51,10 +71,6 @@
});
}
-} // anonymous namespace
-
-namespace spvtools {
-
std::string SelectiveJoin(const std::vector<const char*>& strings,
const std::function<bool(const char*)>& skip_dictator,
char delimiter) {
diff --git a/test/opt/pass_utils.h b/test/opt/pass_utils.h
index 6e047db..f504eb5 100644
--- a/test/opt/pass_utils.h
+++ b/test/opt/pass_utils.h
@@ -33,6 +33,18 @@
namespace spvtools {
+// In-place substring replacement. Finds the |find_str| in the |process_str|
+// and replaces the found substring with |replace_str|. Returns true if at
+// least one replacement is done successfully, returns false otherwise. The
+// replaced substring won't be processed again, which means: If the
+// |replace_str| has |find_str| as its substring, that newly replaced part of
+// |process_str| won't be processed again.
+bool FindAndReplace(std::string* process_str, const std::string find_str,
+ const std::string replace_str);
+
+// Returns true if the given string contains any debug opcode substring.
+bool ContainsDebugOpcode(const char* inst);
+
// Returns the concatenated string from a vector of |strings|, with postfixing
// each string with the given |delimiter|. if the |skip_dictator| returns true
// for an original string, that string will be omitted.
diff --git a/test/opt/test_assembly_builder.cpp b/test/opt/test_assembly_builder.cpp
new file mode 100644
index 0000000..7303047
--- /dev/null
+++ b/test/opt/test_assembly_builder.cpp
@@ -0,0 +1,256 @@
+// Copyright (c) 2016 Google Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+// https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#include "assembly_builder.h"
+
+#include "pass_fixture.h"
+#include "pass_utils.h"
+
+namespace {
+
+using namespace spvtools;
+using AssemblyBuilderTest = PassTest<::testing::Test>;
+
+TEST_F(AssemblyBuilderTest, MinimalShader) {
+ AssemblyBuilder builder;
+ std::vector<const char*> expected = {
+ // clang-format off
+ "OpCapability Shader",
+ "OpCapability Float64",
+ "%1 = OpExtInstImport \"GLSL.std.450\"",
+ "OpMemoryModel Logical GLSL450",
+ "OpEntryPoint Vertex %main \"main\"",
+ "OpName %void \"void\"",
+ "OpName %main_func_type \"main_func_type\"",
+ "OpName %main \"main\"",
+ "OpName %main_func_entry_block \"main_func_entry_block\"",
+ "%void = OpTypeVoid",
+ "%main_func_type = OpTypeFunction %void",
+ "%main = OpFunction %void None %main_func_type",
+"%main_func_entry_block = OpLabel",
+ "OpReturn",
+ "OpFunctionEnd",
+ // clang-format on
+ };
+
+ SinglePassRunAndCheck<opt::NullPass>(builder.GetCode(),
+ JoinAllInsts(expected));
+}
+
+TEST_F(AssemblyBuilderTest, ShaderWithConstants) {
+ AssemblyBuilder builder;
+ builder
+ .AppendTypesConstantsGlobals({
+ // clang-format off
+ "%bool = OpTypeBool",
+ "%_PF_bool = OpTypePointer Function %bool",
+ "%bt = OpConstantTrue %bool",
+ "%bf = OpConstantFalse %bool",
+ "%int = OpTypeInt 32 1",
+ "%_PF_int = OpTypePointer Function %int",
+ "%si = OpConstant %int 1",
+ "%uint = OpTypeInt 32 0",
+ "%_PF_uint = OpTypePointer Function %uint",
+ "%ui = OpConstant %uint 2",
+ "%float = OpTypeFloat 32",
+ "%_PF_float = OpTypePointer Function %float",
+ "%f = OpConstant %float 3.14",
+ "%double = OpTypeFloat 64",
+ "%_PF_double = OpTypePointer Function %double",
+ "%d = OpConstant %double 3.14159265358979",
+ // clang-format on
+ })
+ .AppendInMain({
+ // clang-format off
+ "%btv = OpVariable %_PF_bool Function",
+ "%bfv = OpVariable %_PF_bool Function",
+ "%iv = OpVariable %_PF_int Function",
+ "%uv = OpVariable %_PF_uint Function",
+ "%fv = OpVariable %_PF_float Function",
+ "%dv = OpVariable %_PF_double Function",
+ "OpStore %btv %bt",
+ "OpStore %bfv %bf",
+ "OpStore %iv %si",
+ "OpStore %uv %ui",
+ "OpStore %fv %f",
+ "OpStore %dv %d",
+ // clang-format on
+ });
+
+ std::vector<const char*> expected = {
+ // clang-format off
+ "OpCapability Shader",
+ "OpCapability Float64",
+ "%1 = OpExtInstImport \"GLSL.std.450\"",
+ "OpMemoryModel Logical GLSL450",
+ "OpEntryPoint Vertex %main \"main\"",
+ "OpName %void \"void\"",
+ "OpName %main_func_type \"main_func_type\"",
+ "OpName %main \"main\"",
+ "OpName %main_func_entry_block \"main_func_entry_block\"",
+ "OpName %bool \"bool\"",
+ "OpName %_PF_bool \"_PF_bool\"",
+ "OpName %bt \"bt\"",
+ "OpName %bf \"bf\"",
+ "OpName %int \"int\"",
+ "OpName %_PF_int \"_PF_int\"",
+ "OpName %si \"si\"",
+ "OpName %uint \"uint\"",
+ "OpName %_PF_uint \"_PF_uint\"",
+ "OpName %ui \"ui\"",
+ "OpName %float \"float\"",
+ "OpName %_PF_float \"_PF_float\"",
+ "OpName %f \"f\"",
+ "OpName %double \"double\"",
+ "OpName %_PF_double \"_PF_double\"",
+ "OpName %d \"d\"",
+ "OpName %btv \"btv\"",
+ "OpName %bfv \"bfv\"",
+ "OpName %iv \"iv\"",
+ "OpName %uv \"uv\"",
+ "OpName %fv \"fv\"",
+ "OpName %dv \"dv\"",
+ "%void = OpTypeVoid",
+"%main_func_type = OpTypeFunction %void",
+ "%bool = OpTypeBool",
+ "%_PF_bool = OpTypePointer Function %bool",
+ "%bt = OpConstantTrue %bool",
+ "%bf = OpConstantFalse %bool",
+ "%int = OpTypeInt 32 1",
+ "%_PF_int = OpTypePointer Function %int",
+ "%si = OpConstant %int 1",
+ "%uint = OpTypeInt 32 0",
+ "%_PF_uint = OpTypePointer Function %uint",
+ "%ui = OpConstant %uint 2",
+ "%float = OpTypeFloat 32",
+ "%_PF_float = OpTypePointer Function %float",
+ "%f = OpConstant %float 3.14",
+ "%double = OpTypeFloat 64",
+ "%_PF_double = OpTypePointer Function %double",
+ "%d = OpConstant %double 3.14159265358979",
+ "%main = OpFunction %void None %main_func_type",
+"%main_func_entry_block = OpLabel",
+ "%btv = OpVariable %_PF_bool Function",
+ "%bfv = OpVariable %_PF_bool Function",
+ "%iv = OpVariable %_PF_int Function",
+ "%uv = OpVariable %_PF_uint Function",
+ "%fv = OpVariable %_PF_float Function",
+ "%dv = OpVariable %_PF_double Function",
+ "OpStore %btv %bt",
+ "OpStore %bfv %bf",
+ "OpStore %iv %si",
+ "OpStore %uv %ui",
+ "OpStore %fv %f",
+ "OpStore %dv %d",
+ "OpReturn",
+ "OpFunctionEnd",
+ // clang-format on
+ };
+ SinglePassRunAndCheck<opt::NullPass>(builder.GetCode(),
+ JoinAllInsts(expected));
+}
+
+TEST_F(AssemblyBuilderTest, SpecConstants) {
+ AssemblyBuilder builder;
+ builder.AppendTypesConstantsGlobals({
+ "%bool = OpTypeBool", "%uint = OpTypeInt 32 0", "%int = OpTypeInt 32 1",
+ "%float = OpTypeFloat 32", "%double = OpTypeFloat 64",
+ "%v2int = OpTypeVector %int 2",
+
+ "%spec_true = OpSpecConstantTrue %bool",
+ "%spec_false = OpSpecConstantFalse %bool",
+ "%spec_uint = OpSpecConstant %uint 1",
+ "%spec_int = OpSpecConstant %int 1",
+ "%spec_float = OpSpecConstant %float 1.2",
+ "%spec_double = OpSpecConstant %double 1.23456789",
+
+ // Spec constants defined below should not have SpecID.
+ "%spec_add_op = OpSpecConstantOp %int IAdd %spec_int %spec_int",
+ "%spec_vec = OpSpecConstantComposite %v2int %spec_int %spec_int",
+ "%spec_vec_x = OpSpecConstantOp %int CompositeExtract %spec_vec 0",
+ });
+ std::vector<const char*> expected = {
+ // clang-format off
+ "OpCapability Shader",
+ "OpCapability Float64",
+ "%1 = OpExtInstImport \"GLSL.std.450\"",
+ "OpMemoryModel Logical GLSL450",
+ "OpEntryPoint Vertex %main \"main\"",
+ "OpName %void \"void\"",
+ "OpName %main_func_type \"main_func_type\"",
+ "OpName %main \"main\"",
+ "OpName %main_func_entry_block \"main_func_entry_block\"",
+ "OpName %bool \"bool\"",
+ "OpName %uint \"uint\"",
+ "OpName %int \"int\"",
+ "OpName %float \"float\"",
+ "OpName %double \"double\"",
+ "OpName %v2int \"v2int\"",
+ "OpName %spec_true \"spec_true\"",
+ "OpName %spec_false \"spec_false\"",
+ "OpName %spec_uint \"spec_uint\"",
+ "OpName %spec_int \"spec_int\"",
+ "OpName %spec_float \"spec_float\"",
+ "OpName %spec_double \"spec_double\"",
+ "OpName %spec_add_op \"spec_add_op\"",
+ "OpName %spec_vec \"spec_vec\"",
+ "OpName %spec_vec_x \"spec_vec_x\"",
+ "OpDecorate %spec_true SpecId 200",
+ "OpDecorate %spec_false SpecId 201",
+ "OpDecorate %spec_uint SpecId 202",
+ "OpDecorate %spec_int SpecId 203",
+ "OpDecorate %spec_float SpecId 204",
+ "OpDecorate %spec_double SpecId 205",
+ "%void = OpTypeVoid",
+ "%main_func_type = OpTypeFunction %void",
+ "%bool = OpTypeBool",
+ "%uint = OpTypeInt 32 0",
+ "%int = OpTypeInt 32 1",
+ "%float = OpTypeFloat 32",
+ "%double = OpTypeFloat 64",
+ "%v2int = OpTypeVector %int 2",
+ "%spec_true = OpSpecConstantTrue %bool",
+ "%spec_false = OpSpecConstantFalse %bool",
+ "%spec_uint = OpSpecConstant %uint 1",
+ "%spec_int = OpSpecConstant %int 1",
+ "%spec_float = OpSpecConstant %float 1.2",
+ "%spec_double = OpSpecConstant %double 1.23456789",
+ "%spec_add_op = OpSpecConstantOp %int IAdd %spec_int %spec_int",
+ "%spec_vec = OpSpecConstantComposite %v2int %spec_int %spec_int",
+ "%spec_vec_x = OpSpecConstantOp %int CompositeExtract %spec_vec 0",
+ "%main = OpFunction %void None %main_func_type",
+"%main_func_entry_block = OpLabel",
+ "OpReturn",
+ "OpFunctionEnd",
+
+ // clang-format on
+ };
+
+ SinglePassRunAndCheck<opt::NullPass>(builder.GetCode(),
+ JoinAllInsts(expected));
+}
+
+} // anonymous namespace
diff --git a/test/opt/test_def_use.cpp b/test/opt/test_def_use.cpp
new file mode 100644
index 0000000..9bcc114
--- /dev/null
+++ b/test/opt/test_def_use.cpp
@@ -0,0 +1,1158 @@
+// Copyright (c) 2016 Google Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+// https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#include <memory>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "opt/def_use_manager.h"
+#include "opt/libspirv.hpp"
+#include "pass_utils.h"
+
+namespace {
+
+using ::testing::ElementsAre;
+
+using namespace spvtools;
+using spvtools::opt::analysis::DefUseManager;
+
+// Disassembles the given |inst| and returns the disassembly.
+std::string DisassembleInst(ir::Instruction* inst) {
+ SpvTools tools(SPV_ENV_UNIVERSAL_1_1);
+
+ std::vector<uint32_t> binary;
+ // We need this to generate the necessary header in the binary.
+ tools.Assemble("", &binary);
+ inst->ToBinary(&binary, /* skip_nop = */ false);
+
+ std::string text;
+ // We'll need to check the underlying id numbers.
+ // So turn off friendly names for ids.
+ tools.Disassemble(binary, &text, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER);
+ while (!text.empty() && text.back() == '\n') text.pop_back();
+ return text;
+}
+
+// A struct for holding expected id defs and uses.
+struct InstDefUse {
+ using IdInstPair = std::pair<uint32_t, const char*>;
+ using IdInstsPair = std::pair<uint32_t, std::vector<const char*>>;
+
+ // Ids and their corresponding def instructions.
+ std::vector<IdInstPair> defs;
+ // Ids and their corresponding use instructions.
+ std::vector<IdInstsPair> uses;
+};
+
+// Checks that the |actual_defs| and |actual_uses| are in accord with
+// |expected_defs_uses|.
+void CheckDef(const InstDefUse& expected_defs_uses,
+ const DefUseManager::IdToDefMap& actual_defs) {
+ // Check defs.
+ ASSERT_EQ(expected_defs_uses.defs.size(), actual_defs.size());
+ for (uint32_t i = 0; i < expected_defs_uses.defs.size(); ++i) {
+ const auto id = expected_defs_uses.defs[i].first;
+ const auto expected_def = expected_defs_uses.defs[i].second;
+ ASSERT_EQ(1u, actual_defs.count(id)) << "expected to def id [" << id << "]";
+ EXPECT_EQ(expected_def, DisassembleInst(actual_defs.at(id)));
+ }
+}
+
+void CheckUse(const InstDefUse& expected_defs_uses,
+ const DefUseManager::IdToUsesMap& actual_uses) {
+ // Check uses.
+ ASSERT_EQ(expected_defs_uses.uses.size(), actual_uses.size());
+ for (uint32_t i = 0; i < expected_defs_uses.uses.size(); ++i) {
+ const auto id = expected_defs_uses.uses[i].first;
+ const auto& expected_uses = expected_defs_uses.uses[i].second;
+
+ ASSERT_EQ(1u, actual_uses.count(id)) << "expected to use id [" << id << "]";
+ const auto& uses = actual_uses.at(id);
+
+ ASSERT_EQ(expected_uses.size(), uses.size())
+ << "id [" << id << "] # uses: expected: " << expected_uses.size()
+ << " actual: " << uses.size();
+ auto it = uses.cbegin();
+ for (const auto expected_use : expected_uses) {
+ EXPECT_EQ(expected_use, DisassembleInst(it->inst))
+ << "id [" << id << "] use instruction mismatch";
+ ++it;
+ }
+ }
+}
+
+// The following test case mimics how LLVM handles induction variables.
+// But, yeah, it's not very readable. However, we only care about the id
+// defs and uses. So, no need to make sure this is valid OpPhi construct.
+const char kOpPhiTestFunction[] =
+ " %2 = OpFunction %1 None %3 "
+ " %4 = OpLabel "
+ " OpBranch %5 "
+
+ " %5 = OpLabel "
+ " %7 = OpPhi %6 %8 %4 %9 %5 "
+ "%11 = OpPhi %10 %12 %4 %13 %5 "
+ " %9 = OpIAdd %6 %7 %14 "
+ "%13 = OpFAdd %10 %11 %15 "
+ "%17 = OpSLessThan %16 %7 %18 "
+ " OpLoopMerge %19 %5 None "
+ " OpBranchConditional %17 %5 %19 "
+
+ "%19 = OpLabel "
+ " OpReturn "
+ " OpFunctionEnd";
+
+struct ParseDefUseCase {
+ const char* text;
+ InstDefUse du;
+};
+
+using ParseDefUseTest = ::testing::TestWithParam<ParseDefUseCase>;
+
+TEST_P(ParseDefUseTest, Case) {
+ const auto& tc = GetParam();
+
+ // Build module.
+ const std::vector<const char*> text = {tc.text};
+ std::unique_ptr<ir::Module> module =
+ SpvTools(SPV_ENV_UNIVERSAL_1_1).BuildModule(JoinAllInsts(text));
+ ASSERT_NE(nullptr, module);
+
+ // Analyze def and use.
+ opt::analysis::DefUseManager manager;
+ manager.AnalyzeDefUse(module.get());
+
+ CheckDef(tc.du, manager.id_to_defs());
+ CheckUse(tc.du, manager.id_to_uses());
+}
+
+// clang-format off
+INSTANTIATE_TEST_CASE_P(
+ TestCase, ParseDefUseTest,
+ ::testing::ValuesIn(std::vector<ParseDefUseCase>{
+ {"", {{}, {}}}, // no instruction
+ {"OpMemoryModel Logical GLSL450", {{}, {}}}, // no def and use
+ { // single def, no use
+ "%1 = OpString \"wow\"",
+ {
+ {{1, "%1 = OpString \"wow\""}}, // defs
+ {} // uses
+ }
+ },
+ { // multiple def, no use
+ "%1 = OpString \"hello\" "
+ "%2 = OpString \"world\" "
+ "%3 = OpTypeVoid",
+ {
+ { // defs
+ {1, "%1 = OpString \"hello\""},
+ {2, "%2 = OpString \"world\""},
+ {3, "%3 = OpTypeVoid"},
+ },
+ {} // uses
+ }
+ },
+ { // single use, no def
+ "OpTypeForwardPointer %1 Input",
+ {
+ {}, // defs
+ { // uses
+ {1, {"OpTypeForwardPointer %1 Input"}},
+ }
+ }
+ },
+ { // multiple use, no def
+ "OpEntryPoint Fragment %1 \"main\" "
+ "OpTypeForwardPointer %2 Input "
+ "OpTypeForwardPointer %3 Output",
+ {
+ {}, // defs
+ { // uses
+ {1, {"OpEntryPoint Fragment %1 \"main\""}},
+ {2, {"OpTypeForwardPointer %2 Input"}},
+ {3, {"OpTypeForwardPointer %3 Output"}},
+ }
+ }
+ },
+ { // multiple def, multiple use
+ "%1 = OpTypeBool "
+ "%2 = OpTypeVector %1 3 "
+ "%3 = OpTypeMatrix %2 3",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpTypeVector %1 3"},
+ {3, "%3 = OpTypeMatrix %2 3"},
+ },
+ { // uses
+ {1, {"%2 = OpTypeVector %1 3"}},
+ {2, {"%3 = OpTypeMatrix %2 3"}},
+ }
+ }
+ },
+ { // multiple use of the same id
+ "%1 = OpTypeBool "
+ "%2 = OpTypeVector %1 2 "
+ "%3 = OpTypeVector %1 3 "
+ "%4 = OpTypeVector %1 4",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpTypeVector %1 2"},
+ {3, "%3 = OpTypeVector %1 3"},
+ {4, "%4 = OpTypeVector %1 4"},
+ },
+ { // uses
+ {1,
+ {
+ "%2 = OpTypeVector %1 2",
+ "%3 = OpTypeVector %1 3",
+ "%4 = OpTypeVector %1 4",
+ }
+ },
+ }
+ }
+ },
+ { // labels
+ "%2 = OpFunction %1 None %3 "
+
+ "%4 = OpLabel "
+ "OpBranchConditional %5 %6 %7 "
+
+ "%6 = OpLabel "
+ "OpBranch %7 "
+
+ "%7 = OpLabel "
+ "OpReturn "
+
+ "OpFunctionEnd",
+ {
+ { // defs
+ {2, "%2 = OpFunction %1 None %3"},
+ {4, "%4 = OpLabel"},
+ {6, "%6 = OpLabel"},
+ {7, "%7 = OpLabel"},
+ },
+ { // uses
+ {1, {"%2 = OpFunction %1 None %3"}},
+ {3, {"%2 = OpFunction %1 None %3"}},
+ {5, {"OpBranchConditional %5 %6 %7"}},
+ {6, {"OpBranchConditional %5 %6 %7"}},
+ {7,
+ {
+ "OpBranchConditional %5 %6 %7",
+ "OpBranch %7",
+ }
+ },
+ }
+ }
+ },
+ { // cross function
+ "%1 = OpTypeBool "
+
+ "%2 = OpFunction %1 None %3 "
+
+ "%4 = OpLabel "
+ "%5 = OpVariable %1 Function "
+ "%6 = OpFunctionCall %1 %2 %5 "
+ "OpReturnValue %6 "
+
+ "OpFunctionEnd",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpFunction %1 None %3"},
+ {4, "%4 = OpLabel"},
+ {5, "%5 = OpVariable %1 Function"},
+ {6, "%6 = OpFunctionCall %1 %2 %5"},
+ },
+ { // uses
+ {1,
+ {
+ "%2 = OpFunction %1 None %3",
+ "%5 = OpVariable %1 Function",
+ "%6 = OpFunctionCall %1 %2 %5",
+ }
+ },
+ {2, {"%6 = OpFunctionCall %1 %2 %5"}},
+ {5, {"%6 = OpFunctionCall %1 %2 %5"}},
+ {3, {"%2 = OpFunction %1 None %3"}},
+ {6, {"OpReturnValue %6"}},
+ }
+ }
+ },
+ { // selection merge and loop merge
+ "%2 = OpFunction %1 None %3 "
+
+ "%4 = OpLabel "
+ "OpLoopMerge %5 %4 None "
+ "OpBranch %6 "
+
+ "%5 = OpLabel "
+ "OpReturn "
+
+ "%6 = OpLabel "
+ "OpSelectionMerge %7 None "
+ "OpBranchConditional %8 %9 %7 "
+
+ "%7 = OpLabel "
+ "OpReturn "
+
+ "%9 = OpLabel "
+ "OpReturn "
+
+ "OpFunctionEnd",
+ {
+ { // defs
+ {2, "%2 = OpFunction %1 None %3"},
+ {4, "%4 = OpLabel"},
+ {5, "%5 = OpLabel"},
+ {6, "%6 = OpLabel"},
+ {7, "%7 = OpLabel"},
+ {9, "%9 = OpLabel"},
+ },
+ { // uses
+ {1, {"%2 = OpFunction %1 None %3"}},
+ {3, {"%2 = OpFunction %1 None %3"}},
+ {4, {"OpLoopMerge %5 %4 None"}},
+ {5, {"OpLoopMerge %5 %4 None"}},
+ {6, {"OpBranch %6"}},
+ {7,
+ {
+ "OpSelectionMerge %7 None",
+ "OpBranchConditional %8 %9 %7",
+ }
+ },
+ {8, {"OpBranchConditional %8 %9 %7"}},
+ {9, {"OpBranchConditional %8 %9 %7"}},
+ }
+ }
+ },
+ { // Forward reference
+ "OpDecorate %1 Block "
+ "OpTypeForwardPointer %2 Input "
+ "%3 = OpTypeInt 32 0 "
+ "%1 = OpTypeStruct %3 "
+ "%2 = OpTypePointer Input %3",
+ {
+ { // defs
+ {1, "%1 = OpTypeStruct %3"},
+ {2, "%2 = OpTypePointer Input %3"},
+ {3, "%3 = OpTypeInt 32 0"},
+ },
+ { // uses
+ {1, {"OpDecorate %1 Block"}},
+ {2, {"OpTypeForwardPointer %2 Input"}},
+ {3,
+ {
+ "%1 = OpTypeStruct %3",
+ "%2 = OpTypePointer Input %3",
+ }
+ }
+ },
+ },
+ },
+ { // OpPhi
+ kOpPhiTestFunction,
+ {
+ { // defs
+ {2, "%2 = OpFunction %1 None %3"},
+ {4, "%4 = OpLabel"},
+ {5, "%5 = OpLabel"},
+ {7, "%7 = OpPhi %6 %8 %4 %9 %5"},
+ {9, "%9 = OpIAdd %6 %7 %14"},
+ {11, "%11 = OpPhi %10 %12 %4 %13 %5"},
+ {13, "%13 = OpFAdd %10 %11 %15"},
+ {17, "%17 = OpSLessThan %16 %7 %18"},
+ {19, "%19 = OpLabel"},
+ },
+ { // uses
+ {1, {"%2 = OpFunction %1 None %3"}},
+ {3, {"%2 = OpFunction %1 None %3"}},
+ {4,
+ {
+ "%7 = OpPhi %6 %8 %4 %9 %5",
+ "%11 = OpPhi %10 %12 %4 %13 %5",
+ }
+ },
+ {5,
+ {
+ "OpBranch %5",
+ "%7 = OpPhi %6 %8 %4 %9 %5",
+ "%11 = OpPhi %10 %12 %4 %13 %5",
+ "OpLoopMerge %19 %5 None",
+ "OpBranchConditional %17 %5 %19",
+ }
+ },
+ {6,
+ {
+ "%7 = OpPhi %6 %8 %4 %9 %5",
+ "%9 = OpIAdd %6 %7 %14",
+ }
+ },
+ {7,
+ {
+ "%9 = OpIAdd %6 %7 %14",
+ "%17 = OpSLessThan %16 %7 %18",
+ }
+ },
+ {8, {"%7 = OpPhi %6 %8 %4 %9 %5"}},
+ {9, {"%7 = OpPhi %6 %8 %4 %9 %5"}},
+ {10,
+ {
+ "%11 = OpPhi %10 %12 %4 %13 %5",
+ "%13 = OpFAdd %10 %11 %15",
+ }
+ },
+ {11, {"%13 = OpFAdd %10 %11 %15"}},
+ {12, {"%11 = OpPhi %10 %12 %4 %13 %5"}},
+ {13, {"%11 = OpPhi %10 %12 %4 %13 %5"}},
+ {14, {"%9 = OpIAdd %6 %7 %14"}},
+ {15, {"%13 = OpFAdd %10 %11 %15"}},
+ {16, {"%17 = OpSLessThan %16 %7 %18"}},
+ {17, {"OpBranchConditional %17 %5 %19"}},
+ {18, {"%17 = OpSLessThan %16 %7 %18"}},
+ {19,
+ {
+ "OpLoopMerge %19 %5 None",
+ "OpBranchConditional %17 %5 %19",
+ }
+ },
+ },
+ },
+ },
+ { // OpPhi defining and referencing the same id.
+ "%1 = OpTypeBool "
+ "%2 = OpConstantTrue %1 "
+
+ "%4 = OpFunction %3 None %5 "
+ "%6 = OpLabel "
+ " OpBranch %7 "
+ "%7 = OpLabel "
+ "%8 = OpPhi %1 %8 %7 %2 %6 " // both defines and uses %8
+ " OpBranch %7 "
+ " OpFunctionEnd",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpConstantTrue %1"},
+ {4, "%4 = OpFunction %3 None %5"},
+ {6, "%6 = OpLabel"},
+ {7, "%7 = OpLabel"},
+ {8, "%8 = OpPhi %1 %8 %7 %2 %6"},
+ },
+ { // uses
+ {1,
+ {
+ "%2 = OpConstantTrue %1",
+ "%8 = OpPhi %1 %8 %7 %2 %6",
+ }
+ },
+ {2, {"%8 = OpPhi %1 %8 %7 %2 %6"}},
+ {3, {"%4 = OpFunction %3 None %5"}},
+ {5, {"%4 = OpFunction %3 None %5"}},
+ {6, {"%8 = OpPhi %1 %8 %7 %2 %6"}},
+ {7,
+ {
+ "OpBranch %7",
+ "%8 = OpPhi %1 %8 %7 %2 %6",
+ "OpBranch %7",
+ }
+ },
+ {8, {"%8 = OpPhi %1 %8 %7 %2 %6"}},
+ },
+ },
+ },
+ })
+);
+// clang-format on
+
+struct ReplaceUseCase {
+ const char* before;
+ std::vector<std::pair<uint32_t, uint32_t>> candidates;
+ const char* after;
+ InstDefUse du;
+};
+
+using ReplaceUseTest = ::testing::TestWithParam<ReplaceUseCase>;
+
+// Disassembles the given |module| and returns the disassembly.
+std::string DisassembleModule(ir::Module* module) {
+ SpvTools tools(SPV_ENV_UNIVERSAL_1_1);
+
+ std::vector<uint32_t> binary;
+ module->ToBinary(&binary, /* skip_nop = */ false);
+
+ std::string text;
+ // We'll need to check the underlying id numbers.
+ // So turn off friendly names for ids.
+ tools.Disassemble(binary, &text, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER);
+ while (!text.empty() && text.back() == '\n') text.pop_back();
+ return text;
+}
+
+TEST_P(ReplaceUseTest, Case) {
+ const auto& tc = GetParam();
+
+ // Build module.
+ const std::vector<const char*> text = {tc.before};
+ std::unique_ptr<ir::Module> module =
+ SpvTools(SPV_ENV_UNIVERSAL_1_1).BuildModule(JoinAllInsts(text));
+ ASSERT_NE(nullptr, module);
+
+ // Analyze def and use.
+ opt::analysis::DefUseManager manager;
+ manager.AnalyzeDefUse(module.get());
+
+ // Do the substitution.
+ for (const auto& candiate : tc.candidates) {
+ manager.ReplaceAllUsesWith(candiate.first, candiate.second);
+ }
+
+ EXPECT_EQ(tc.after, DisassembleModule(module.get()));
+ CheckDef(tc.du, manager.id_to_defs());
+ CheckUse(tc.du, manager.id_to_uses());
+}
+
+// clang-format off
+INSTANTIATE_TEST_CASE_P(
+ TestCase, ReplaceUseTest,
+ ::testing::ValuesIn(std::vector<ReplaceUseCase>{
+ { // no use, no replace request
+ "", {}, "", {},
+ },
+ { // no use, some replace requests
+ "OpMemoryModel Logical GLSL450",
+ {{1, 2}, {3, 4}, {7, 8}, {7, 9}, {7, 10}, {2, 10}, {3, 10}},
+ "OpMemoryModel Logical GLSL450",
+ {},
+ },
+ { // replace one use
+ "%1 = OpTypeBool "
+ "%2 = OpTypeVector %1 3",
+ {{1, 3}},
+ "%1 = OpTypeBool\n"
+ "%2 = OpTypeVector %3 3",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpTypeVector %3 3"},
+ },
+ { // uses
+ {3, {"%2 = OpTypeVector %3 3"}},
+ },
+ },
+ },
+ { // replace and then replace back
+ "%1 = OpTypeBool "
+ "%2 = OpTypeVector %1 3",
+ {{1, 3}, {3, 1}},
+ "%1 = OpTypeBool\n"
+ "%2 = OpTypeVector %1 3",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpTypeVector %1 3"},
+ },
+ { // uses
+ {1, {"%2 = OpTypeVector %1 3"}},
+ },
+ },
+ },
+ { // replace with the same id
+ "%1 = OpTypeBool "
+ "%2 = OpTypeVector %1 3",
+ {{1, 1}, {2, 2}, {3, 3}},
+ "%1 = OpTypeBool\n"
+ "%2 = OpTypeVector %1 3",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpTypeVector %1 3"},
+ },
+ { // uses
+ {1, {"%2 = OpTypeVector %1 3"}},
+ },
+ },
+ },
+ { // replace in sequence
+ "%1 = OpTypeBool "
+ "%2 = OpTypeVector %1 3",
+ {{1, 3}, {3, 4}, {4, 5}, {5, 100}},
+ "%1 = OpTypeBool\n"
+ "%2 = OpTypeVector %100 3",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpTypeVector %100 3"},
+ },
+ { // uses
+ {100, {"%2 = OpTypeVector %100 3"}},
+ },
+ },
+ },
+ { // replace multiple uses
+ "%1 = OpTypeBool "
+ "%2 = OpTypeVector %1 2 "
+ "%3 = OpTypeVector %1 3 "
+ "%4 = OpTypeVector %1 4 "
+ "%5 = OpTypeMatrix %2 2 "
+ "%6 = OpTypeMatrix %3 3 "
+ "%7 = OpTypeMatrix %4 4",
+ {{1, 10}, {2, 20}, {4, 40}},
+ "%1 = OpTypeBool\n"
+ "%2 = OpTypeVector %10 2\n"
+ "%3 = OpTypeVector %10 3\n"
+ "%4 = OpTypeVector %10 4\n"
+ "%5 = OpTypeMatrix %20 2\n"
+ "%6 = OpTypeMatrix %3 3\n"
+ "%7 = OpTypeMatrix %40 4",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpTypeVector %10 2"},
+ {3, "%3 = OpTypeVector %10 3"},
+ {4, "%4 = OpTypeVector %10 4"},
+ {5, "%5 = OpTypeMatrix %20 2"},
+ {6, "%6 = OpTypeMatrix %3 3"},
+ {7, "%7 = OpTypeMatrix %40 4"},
+ },
+ { // uses
+ {10,
+ {
+ "%2 = OpTypeVector %10 2",
+ "%3 = OpTypeVector %10 3",
+ "%4 = OpTypeVector %10 4",
+ }
+ },
+ {20, {"%5 = OpTypeMatrix %20 2"}},
+ {3, {"%6 = OpTypeMatrix %3 3"}},
+ {40, {"%7 = OpTypeMatrix %40 4"}},
+ },
+ },
+ },
+ { // OpPhi.
+ kOpPhiTestFunction,
+ // replace one id used by OpPhi, replace one id generated by OpPhi
+ {{9, 9000}, {11, 9}},
+ "%2 = OpFunction %1 None %3\n"
+ "%4 = OpLabel\n"
+ "OpBranch %5\n"
+
+ "%5 = OpLabel\n"
+ "%7 = OpPhi %6 %8 %4 %9000 %5\n" // %9 -> %9000
+ "%11 = OpPhi %10 %12 %4 %13 %5\n"
+ "%9 = OpIAdd %6 %7 %14\n"
+ "%13 = OpFAdd %10 %9 %15\n" // %11 -> %9
+ "%17 = OpSLessThan %16 %7 %18\n"
+ "OpLoopMerge %19 %5 None\n"
+ "OpBranchConditional %17 %5 %19\n"
+
+ "%19 = OpLabel\n"
+ "OpReturn\n"
+ "OpFunctionEnd",
+ {
+ { // defs.
+ {2, "%2 = OpFunction %1 None %3"},
+ {4, "%4 = OpLabel"},
+ {5, "%5 = OpLabel"},
+ {7, "%7 = OpPhi %6 %8 %4 %9000 %5"},
+ {9, "%9 = OpIAdd %6 %7 %14"},
+ {11, "%11 = OpPhi %10 %12 %4 %13 %5"},
+ {13, "%13 = OpFAdd %10 %9 %15"},
+ {17, "%17 = OpSLessThan %16 %7 %18"},
+ {19, "%19 = OpLabel"},
+ },
+ { // uses
+ {1, {"%2 = OpFunction %1 None %3"}},
+ {3, {"%2 = OpFunction %1 None %3"}},
+ {4,
+ {
+ "%7 = OpPhi %6 %8 %4 %9000 %5",
+ "%11 = OpPhi %10 %12 %4 %13 %5",
+ }
+ },
+ {5,
+ {
+ "OpBranch %5",
+ "%7 = OpPhi %6 %8 %4 %9000 %5",
+ "%11 = OpPhi %10 %12 %4 %13 %5",
+ "OpLoopMerge %19 %5 None",
+ "OpBranchConditional %17 %5 %19",
+ }
+ },
+ {6,
+ {
+ "%7 = OpPhi %6 %8 %4 %9000 %5",
+ "%9 = OpIAdd %6 %7 %14",
+ }
+ },
+ {7,
+ {
+ "%9 = OpIAdd %6 %7 %14",
+ "%17 = OpSLessThan %16 %7 %18",
+ }
+ },
+ {8, {"%7 = OpPhi %6 %8 %4 %9000 %5"}},
+ {9, {"%13 = OpFAdd %10 %9 %15"}}, // uses of %9 changed from %7 to %13
+ {10,
+ {
+ "%11 = OpPhi %10 %12 %4 %13 %5",
+ "%13 = OpFAdd %10 %9 %15",
+ }
+ },
+ // no more uses of %11
+ {12, {"%11 = OpPhi %10 %12 %4 %13 %5"}},
+ {13, {"%11 = OpPhi %10 %12 %4 %13 %5"}},
+ {14, {"%9 = OpIAdd %6 %7 %14"}},
+ {15, {"%13 = OpFAdd %10 %9 %15"}},
+ {16, {"%17 = OpSLessThan %16 %7 %18"}},
+ {17, {"OpBranchConditional %17 %5 %19"}},
+ {18, {"%17 = OpSLessThan %16 %7 %18"}},
+ {19,
+ {
+ "OpLoopMerge %19 %5 None",
+ "OpBranchConditional %17 %5 %19",
+ }
+ },
+ // new uses of %9000
+ {9000, {"%7 = OpPhi %6 %8 %4 %9000 %5"}},
+ },
+ },
+ },
+ { // OpPhi defining and referencing the same id.
+ "%1 = OpTypeBool "
+ "%2 = OpConstantTrue %1 "
+
+ "%4 = OpFunction %3 None %5 "
+ "%6 = OpLabel "
+ " OpBranch %7 "
+ "%7 = OpLabel "
+ "%8 = OpPhi %1 %8 %7 %2 %6 " // both defines and uses %8
+ " OpBranch %7 "
+ " OpFunctionEnd",
+ {{8, 2}},
+ "%1 = OpTypeBool\n"
+ "%2 = OpConstantTrue %1\n"
+
+ "%4 = OpFunction %3 None %5\n"
+ "%6 = OpLabel\n"
+ "OpBranch %7\n"
+ "%7 = OpLabel\n"
+ "%8 = OpPhi %1 %2 %7 %2 %6\n" // use of %8 changed to %2
+ "OpBranch %7\n"
+ "OpFunctionEnd",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpConstantTrue %1"},
+ {4, "%4 = OpFunction %3 None %5"},
+ {6, "%6 = OpLabel"},
+ {7, "%7 = OpLabel"},
+ {8, "%8 = OpPhi %1 %2 %7 %2 %6"},
+ },
+ { // uses
+ {1,
+ {
+ "%2 = OpConstantTrue %1",
+ "%8 = OpPhi %1 %2 %7 %2 %6",
+ }
+ },
+ {2,
+ {
+ // TODO(antiagainst): address this.
+ // We have duplication here because we didn't check existence
+ // before inserting uses.
+ "%8 = OpPhi %1 %2 %7 %2 %6",
+ "%8 = OpPhi %1 %2 %7 %2 %6",
+ }
+ },
+ {3, {"%4 = OpFunction %3 None %5"}},
+ {5, {"%4 = OpFunction %3 None %5"}},
+ {6, {"%8 = OpPhi %1 %2 %7 %2 %6"}},
+ {7,
+ {
+ "OpBranch %7",
+ "%8 = OpPhi %1 %2 %7 %2 %6",
+ "OpBranch %7",
+ }
+ },
+ // {8, {"%8 = OpPhi %1 %8 %7 %2 %6"}},
+ },
+ },
+ },
+ })
+);
+// clang-format on
+
+struct KillDefCase {
+ const char* before;
+ std::vector<uint32_t> ids_to_kill;
+ const char* after;
+ InstDefUse du;
+};
+
+using KillDefTest = ::testing::TestWithParam<KillDefCase>;
+
+TEST_P(KillDefTest, Case) {
+ const auto& tc = GetParam();
+
+ // Build module.
+ const std::vector<const char*> text = {tc.before};
+ std::unique_ptr<ir::Module> module =
+ SpvTools(SPV_ENV_UNIVERSAL_1_1).BuildModule(JoinAllInsts(text));
+ ASSERT_NE(nullptr, module);
+
+ // Analyze def and use.
+ opt::analysis::DefUseManager manager;
+ manager.AnalyzeDefUse(module.get());
+
+ // Do the substitution.
+ for (const auto id : tc.ids_to_kill) manager.KillDef(id);
+
+ EXPECT_EQ(tc.after, DisassembleModule(module.get()));
+ CheckDef(tc.du, manager.id_to_defs());
+ CheckUse(tc.du, manager.id_to_uses());
+}
+
+// clang-format off
+INSTANTIATE_TEST_CASE_P(
+ TestCase, KillDefTest,
+ ::testing::ValuesIn(std::vector<KillDefCase>{
+ { // no def, no use, no kill
+ "", {}, "", {}
+ },
+ { // kill nothing
+ "%1 = OpTypeBool "
+ "%2 = OpTypeVector %1 2 "
+ "%3 = OpTypeVector %1 3 ",
+ {},
+ "%1 = OpTypeBool\n"
+ "%2 = OpTypeVector %1 2\n"
+ "%3 = OpTypeVector %1 3",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpTypeVector %1 2"},
+ {3, "%3 = OpTypeVector %1 3"},
+ },
+ { // uses
+ {1,
+ {
+ "%2 = OpTypeVector %1 2",
+ "%3 = OpTypeVector %1 3",
+ }
+ },
+ },
+ },
+ },
+ { // kill id used, kill id not used, kill id not defined
+ "%1 = OpTypeBool "
+ "%2 = OpTypeVector %1 2 "
+ "%3 = OpTypeVector %1 3 "
+ "%4 = OpTypeVector %1 4 "
+ "%5 = OpTypeMatrix %3 3 "
+ "%6 = OpTypeMatrix %2 3",
+ {1, 3, 5, 10}, // ids to kill
+ "OpNop\n"
+ "%2 = OpTypeVector %1 2\n"
+ "OpNop\n"
+ "%4 = OpTypeVector %1 4\n"
+ "OpNop\n"
+ "%6 = OpTypeMatrix %2 3",
+ {
+ { // defs
+ {2, "%2 = OpTypeVector %1 2"},
+ {4, "%4 = OpTypeVector %1 4"},
+ {6, "%6 = OpTypeMatrix %2 3"},
+ },
+ { // uses. %1 and %3 are both killed, so no uses
+ // recorded for them anymore.
+ {2, {"%6 = OpTypeMatrix %2 3"}},
+ }
+ },
+ },
+ { // OpPhi.
+ kOpPhiTestFunction,
+ {9, 11}, // kill one id used by OpPhi, kill one id generated by OpPhi
+ "%2 = OpFunction %1 None %3\n"
+ "%4 = OpLabel\n"
+ "OpBranch %5\n"
+
+ "%5 = OpLabel\n"
+ "%7 = OpPhi %6 %8 %4 %9 %5\n"
+ "OpNop\n"
+ "OpNop\n"
+ "%13 = OpFAdd %10 %11 %15\n"
+ "%17 = OpSLessThan %16 %7 %18\n"
+ "OpLoopMerge %19 %5 None\n"
+ "OpBranchConditional %17 %5 %19\n"
+
+ "%19 = OpLabel\n"
+ "OpReturn\n"
+ "OpFunctionEnd",
+ {
+ { // defs. %9 & %11 are killed.
+ {2, "%2 = OpFunction %1 None %3"},
+ {4, "%4 = OpLabel"},
+ {5, "%5 = OpLabel"},
+ {7, "%7 = OpPhi %6 %8 %4 %9 %5"},
+ {13, "%13 = OpFAdd %10 %11 %15"},
+ {17, "%17 = OpSLessThan %16 %7 %18"},
+ {19, "%19 = OpLabel"},
+ },
+ { // uses
+ {1, {"%2 = OpFunction %1 None %3"}},
+ {3, {"%2 = OpFunction %1 None %3"}},
+ {4,
+ {
+ "%7 = OpPhi %6 %8 %4 %9 %5",
+ // "%11 = OpPhi %10 %12 %4 %13 %5",
+ }
+ },
+ {5,
+ {
+ "OpBranch %5",
+ "%7 = OpPhi %6 %8 %4 %9 %5",
+ // "%11 = OpPhi %10 %12 %4 %13 %5",
+ "OpLoopMerge %19 %5 None",
+ "OpBranchConditional %17 %5 %19",
+ }
+ },
+ {6,
+ {
+ "%7 = OpPhi %6 %8 %4 %9 %5",
+ // "%9 = OpIAdd %6 %7 %14",
+ }
+ },
+ {7,
+ {
+ // "%9 = OpIAdd %6 %7 %14",
+ "%17 = OpSLessThan %16 %7 %18",
+ }
+ },
+ {8, {"%7 = OpPhi %6 %8 %4 %9 %5"}},
+ // {9, {"%7 = OpPhi %6 %8 %4 %9 %5"}},
+ {10,
+ {
+ // "%11 = OpPhi %10 %12 %4 %13 %5",
+ "%13 = OpFAdd %10 %11 %15",
+ }
+ },
+ // {11, {"%13 = OpFAdd %10 %11 %15"}},
+ // {12, {"%11 = OpPhi %10 %12 %4 %13 %5"}},
+ // {13, {"%11 = OpPhi %10 %12 %4 %13 %5"}},
+ // {14, {"%9 = OpIAdd %6 %7 %14"}},
+ {15, {"%13 = OpFAdd %10 %11 %15"}},
+ {16, {"%17 = OpSLessThan %16 %7 %18"}},
+ {17, {"OpBranchConditional %17 %5 %19"}},
+ {18, {"%17 = OpSLessThan %16 %7 %18"}},
+ {19,
+ {
+ "OpLoopMerge %19 %5 None",
+ "OpBranchConditional %17 %5 %19",
+ }
+ },
+ },
+ },
+ },
+ { // OpPhi defining and referencing the same id.
+ "%1 = OpTypeBool "
+ "%2 = OpConstantTrue %1 "
+
+ "%4 = OpFunction %3 None %5 "
+ "%6 = OpLabel "
+ " OpBranch %7 "
+ "%7 = OpLabel "
+ "%8 = OpPhi %1 %8 %7 %2 %6 " // both defines and uses %8
+ " OpBranch %7 "
+ " OpFunctionEnd",
+ {8},
+ "%1 = OpTypeBool\n"
+ "%2 = OpConstantTrue %1\n"
+
+ "%4 = OpFunction %3 None %5\n"
+ "%6 = OpLabel\n"
+ "OpBranch %7\n"
+ "%7 = OpLabel\n"
+ "OpNop\n"
+ "OpBranch %7\n"
+ "OpFunctionEnd",
+ {
+ { // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpConstantTrue %1"},
+ {4, "%4 = OpFunction %3 None %5"},
+ {6, "%6 = OpLabel"},
+ {7, "%7 = OpLabel"},
+ // {8, "%8 = OpPhi %1 %8 %7 %2 %6"},
+ },
+ { // uses
+ {1,
+ {
+ "%2 = OpConstantTrue %1",
+ // "%8 = OpPhi %1 %8 %7 %2 %6",
+ }
+ },
+ // {2, {"%8 = OpPhi %1 %8 %7 %2 %6"}},
+ {3, {"%4 = OpFunction %3 None %5"}},
+ {5, {"%4 = OpFunction %3 None %5"}},
+ // {6, {"%8 = OpPhi %1 %8 %7 %2 %6"}},
+ {7,
+ {
+ "OpBranch %7",
+ // "%8 = OpPhi %1 %8 %7 %2 %6",
+ "OpBranch %7",
+ }
+ },
+ // {8, {"%8 = OpPhi %1 %8 %7 %2 %6"}},
+ },
+ },
+ },
+ })
+);
+// clang-format on
+//
+TEST(DefUseTest, OpSwitch) {
+ // Because disassembler has basic type check for OpSwitch's selector, we
+ // cannot use the DisassembleInst() in the above. Thus, this special spotcheck
+ // test case.
+
+ const char original_text[] =
+ // int64 f(int64 v) {
+ // switch (v) {
+ // case 1: break;
+ // case -4294967296: break;
+ // case 9223372036854775807: break;
+ // default: break;
+ // }
+ // return v;
+ // }
+ " %1 = OpTypeInt 64 1 "
+ " %2 = OpFunction %1 None %3 " // %3 is int64(int64)*
+ " %4 = OpFunctionParameter %1 "
+ " %5 = OpLabel "
+ " %6 = OpLoad %1 %4 " // selector value
+ " OpSelectionMerge %7 None "
+ " OpSwitch %6 %8 "
+ " 1 %9 " // 1
+ " -4294967296 %10 " // -2^32
+ " 9223372036854775807 %11 " // 2^63-1
+ " %8 = OpLabel " // default
+ " OpBranch %7 "
+ " %9 = OpLabel "
+ " OpBranch %7 "
+ "%10 = OpLabel "
+ " OpBranch %7 "
+ "%11 = OpLabel "
+ " OpBranch %7 "
+ " %7 = OpLabel "
+ " OpReturnValue %6 "
+ " OpFunctionEnd";
+
+ std::unique_ptr<ir::Module> module =
+ SpvTools(SPV_ENV_UNIVERSAL_1_1).BuildModule(original_text);
+ ASSERT_NE(nullptr, module);
+
+ // Analyze def and use.
+ opt::analysis::DefUseManager manager;
+ manager.AnalyzeDefUse(module.get());
+
+ // Do a bunch replacements.
+ manager.ReplaceAllUsesWith(9, 900); // to unused id
+ manager.ReplaceAllUsesWith(10, 1000); // to unused id
+ manager.ReplaceAllUsesWith(11, 7); // to existing id
+
+ // clang-format off
+ const char modified_text[] =
+ "%1 = OpTypeInt 64 1\n"
+ "%2 = OpFunction %1 None %3\n" // %3 is int64(int64)*
+ "%4 = OpFunctionParameter %1\n"
+ "%5 = OpLabel\n"
+ "%6 = OpLoad %1 %4\n" // selector value
+ "OpSelectionMerge %7 None\n"
+ "OpSwitch %6 %8 1 %900 -4294967296 %1000 9223372036854775807 %7\n" // changed!
+ "%8 = OpLabel\n" // default
+ "OpBranch %7\n"
+ "%9 = OpLabel\n"
+ "OpBranch %7\n"
+ "%10 = OpLabel\n"
+ "OpBranch %7\n"
+ "%11 = OpLabel\n"
+ "OpBranch %7\n"
+ "%7 = OpLabel\n"
+ "OpReturnValue %6\n"
+ "OpFunctionEnd";
+ // clang-format on
+
+ EXPECT_EQ(modified_text, DisassembleModule(module.get()));
+
+ InstDefUse def_uses = {};
+ def_uses.defs = {
+ {1, "%1 = OpTypeInt 64 1"},
+ {2, "%2 = OpFunction %1 None %3"},
+ {4, "%4 = OpFunctionParameter %1"},
+ {5, "%5 = OpLabel"},
+ {6, "%6 = OpLoad %1 %4"},
+ {7, "%7 = OpLabel"},
+ {8, "%8 = OpLabel"},
+ {9, "%9 = OpLabel"},
+ {10, "%10 = OpLabel"},
+ {11, "%11 = OpLabel"},
+ };
+ CheckDef(def_uses, manager.id_to_defs());
+
+ {
+ auto* use_list = manager.GetUses(6);
+ ASSERT_NE(nullptr, use_list);
+ EXPECT_EQ(2u, use_list->size());
+ EXPECT_EQ(SpvOpSwitch, use_list->front().inst->opcode());
+ EXPECT_EQ(SpvOpReturnValue, use_list->back().inst->opcode());
+ }
+ {
+ auto* use_list = manager.GetUses(7);
+ ASSERT_NE(nullptr, use_list);
+ EXPECT_EQ(6u, use_list->size());
+ std::vector<SpvOp> opcodes;
+ for (const auto& use : *use_list) {
+ opcodes.push_back(use.inst->opcode());
+ }
+ // OpSwitch is now a user of %7.
+ EXPECT_THAT(opcodes,
+ ElementsAre(SpvOpSelectionMerge, SpvOpBranch, SpvOpBranch,
+ SpvOpBranch, SpvOpBranch, SpvOpSwitch));
+ }
+ // Check all ids only used by OpSwitch after replacement.
+ for (const auto id : {8, 900, 1000}) {
+ auto* use_list = manager.GetUses(id);
+ ASSERT_NE(nullptr, use_list);
+ EXPECT_EQ(1u, use_list->size());
+ EXPECT_EQ(SpvOpSwitch, use_list->front().inst->opcode());
+ }
+}
+
+} // anonymous namespace
diff --git a/test/opt/test_freeze_spec_const.cpp b/test/opt/test_freeze_spec_const.cpp
new file mode 100644
index 0000000..2be826b
--- /dev/null
+++ b/test/opt/test_freeze_spec_const.cpp
@@ -0,0 +1,136 @@
+// Copyright (c) 2016 Google Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+// https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#include "pass_fixture.h"
+#include "pass_utils.h"
+
+#include <algorithm>
+#include <tuple>
+#include <vector>
+
+namespace {
+
+using namespace spvtools;
+
+struct FreezeSpecConstantValueTypeTestCase {
+ const char* type_decl;
+ const char* spec_const;
+ const char* expected_frozen_const;
+};
+
+using FreezeSpecConstantValueTypeTest =
+ PassTest<::testing::TestWithParam<FreezeSpecConstantValueTypeTestCase>>;
+
+TEST_P(FreezeSpecConstantValueTypeTest, PrimaryType) {
+ auto& test_case = GetParam();
+ std::vector<const char*> text = {"OpCapability Shader",
+ "OpMemoryModel Logical GLSL450",
+ test_case.type_decl, test_case.spec_const};
+ std::vector<const char*> expected = {
+ "OpCapability Shader", "OpMemoryModel Logical GLSL450",
+ test_case.type_decl, test_case.expected_frozen_const};
+ SinglePassRunAndCheck<opt::FreezeSpecConstantValuePass>(
+ JoinAllInsts(text), JoinAllInsts(expected));
+}
+
+// Test each primary type.
+INSTANTIATE_TEST_CASE_P(
+ PrimaryTypeSpecConst, FreezeSpecConstantValueTypeTest,
+ ::testing::ValuesIn(std::vector<FreezeSpecConstantValueTypeTestCase>({
+ // Type declaration, original spec constant definition, expected frozen
+ // spec constants.
+ {"%int = OpTypeInt 32 1", "%2 = OpSpecConstant %int 1",
+ "%2 = OpConstant %int 1"},
+ {"%uint = OpTypeInt 32 0", "%2 = OpSpecConstant %uint 1",
+ "%2 = OpConstant %uint 1"},
+ {"%float = OpTypeFloat 32", "%2 = OpSpecConstant %float 3.14",
+ "%2 = OpConstant %float 3.14"},
+ {"%double = OpTypeFloat 64", "%2 = OpSpecConstant %double 3.1415926",
+ "%2 = OpConstant %double 3.1415926"},
+ {"%bool = OpTypeBool", "%2 = OpSpecConstantTrue %bool",
+ "%2 = OpConstantTrue %bool"},
+ {"%bool = OpTypeBool", "%2 = OpSpecConstantFalse %bool",
+ "%2 = OpConstantFalse %bool"},
+ })));
+
+using FreezeSpecConstantValueRemoveDecorationTest = PassTest<::testing::Test>;
+
+TEST_F(FreezeSpecConstantValueRemoveDecorationTest,
+ RemoveDecorationInstWithSpecId) {
+ std::vector<const char*> text = {
+ // clang-format off
+ "OpCapability Shader",
+ "OpCapability Float64",
+ "%1 = OpExtInstImport \"GLSL.std.450\"",
+ "OpMemoryModel Logical GLSL450",
+ "OpEntryPoint Vertex %main \"main\"",
+ "OpSource GLSL 450",
+ "OpSourceExtension \"GL_GOOGLE_cpp_style_line_directive\"",
+ "OpSourceExtension \"GL_GOOGLE_include_directive\"",
+ "OpName %main \"main\"",
+ "OpDecorate %3 SpecId 200",
+ "OpDecorate %4 SpecId 201",
+ "OpDecorate %5 SpecId 202",
+ "OpDecorate %6 SpecId 203",
+ "%void = OpTypeVoid",
+ "%8 = OpTypeFunction %void",
+ "%int = OpTypeInt 32 1",
+ "%3 = OpSpecConstant %int 3",
+ "%float = OpTypeFloat 32",
+ "%4 = OpSpecConstant %float 3.14",
+ "%double = OpTypeFloat 64",
+ "%5 = OpSpecConstant %double 3.14159265358979",
+ "%bool = OpTypeBool",
+ "%6 = OpSpecConstantTrue %bool",
+ "%13 = OpSpecConstantFalse %bool",
+ "%main = OpFunction %void None %8",
+ "%14 = OpLabel",
+ "OpReturn",
+ "OpFunctionEnd",
+ // clang-format on
+ };
+ std::string expected_disassembly = SelectiveJoin(text, [](const char* line) {
+ return std::string(line).find("SpecId") != std::string::npos;
+ });
+ std::vector<std::pair<const char*, const char*>> opcode_replacement_pairs = {
+ {" OpSpecConstant ", " OpConstant "},
+ {" OpSpecConstantTrue ", " OpConstantTrue "},
+ {" OpSpecConstantFalse ", " OpConstantFalse "},
+ };
+ for (auto& p : opcode_replacement_pairs) {
+ EXPECT_TRUE(FindAndReplace(&expected_disassembly, p.first, p.second))
+ << "text:\n"
+ << expected_disassembly << "\n"
+ << "find_str:\n"
+ << p.first << "\n"
+ << "replace_str:\n"
+ << p.second << "\n";
+ }
+ SinglePassRunAndCheck<opt::FreezeSpecConstantValuePass>(
+ JoinAllInsts(text), expected_disassembly,
+ /* skip_nop = */ true);
+}
+} // anonymous namespace
diff --git a/test/opt/test_ir_loader.cpp b/test/opt/test_ir_loader.cpp
index bb788f5..c5ccd5e 100644
--- a/test/opt/test_ir_loader.cpp
+++ b/test/opt/test_ir_loader.cpp
@@ -37,44 +37,46 @@
// int add(int a, int b) { return a + b; }
// void main() { add(1, 2); }
const std::string text =
- "OpCapability Shader\n"
- "%1 = OpExtInstImport \"GLSL.std.450\"\n"
- "OpMemoryModel Logical GLSL450\n"
- "OpEntryPoint Vertex %2 \"main\"\n"
- "OpSource ESSL 310\n"
- "OpSourceExtension \"GL_GOOGLE_cpp_style_line_directive\"\n"
- "OpSourceExtension \"GL_GOOGLE_include_directive\"\n"
- "OpName %2 \"main\"\n"
- "OpName %3 \"add(i1;i1;\"\n"
- "OpName %4 \"a\"\n"
- "OpName %5 \"b\"\n"
- "OpName %6 \"param\"\n"
- "OpName %7 \"param\"\n"
- "%8 = OpTypeVoid\n"
- "%9 = OpTypeFunction %8\n"
- "%10 = OpTypeInt 32 1\n"
- "%11 = OpTypePointer Function %10\n"
- "%12 = OpTypeFunction %10 %11 %11\n"
- "%13 = OpConstant %10 1\n"
- "%14 = OpConstant %10 2\n"
- "%2 = OpFunction %8 None %9\n"
- "%15 = OpLabel\n"
- "%6 = OpVariable %11 Function\n"
- "%7 = OpVariable %11 Function\n"
- "OpStore %6 %13\n"
- "OpStore %7 %14\n"
- "%16 = OpFunctionCall %10 %3 %6 %7\n"
- "OpReturn\n"
- "OpFunctionEnd\n"
- "%3 = OpFunction %10 None %12\n"
- "%4 = OpFunctionParameter %11\n"
- "%5 = OpFunctionParameter %11\n"
- "%17 = OpLabel\n"
- "%18 = OpLoad %10 %4\n"
- "%19 = OpLoad %10 %5\n"
- "%20 = OpIAdd %10 %18 %19\n"
- "OpReturnValue %20\n"
- "OpFunctionEnd\n";
+ // clang-format off
+ "OpCapability Shader\n"
+ "%1 = OpExtInstImport \"GLSL.std.450\"\n"
+ "OpMemoryModel Logical GLSL450\n"
+ "OpEntryPoint Vertex %main \"main\"\n"
+ "OpSource ESSL 310\n"
+ "OpSourceExtension \"GL_GOOGLE_cpp_style_line_directive\"\n"
+ "OpSourceExtension \"GL_GOOGLE_include_directive\"\n"
+ "OpName %main \"main\"\n"
+ "OpName %add_i1_i1_ \"add(i1;i1;\"\n"
+ "OpName %a \"a\"\n"
+ "OpName %b \"b\"\n"
+ "OpName %param \"param\"\n"
+ "OpName %param_0 \"param\"\n"
+ "%void = OpTypeVoid\n"
+ "%9 = OpTypeFunction %void\n"
+ "%int = OpTypeInt 32 1\n"
+ "%_ptr_Function_int = OpTypePointer Function %int\n"
+ "%12 = OpTypeFunction %int %_ptr_Function_int %_ptr_Function_int\n"
+ "%13 = OpConstant %int 1\n"
+ "%14 = OpConstant %int 2\n"
+ "%main = OpFunction %void None %9\n"
+ "%15 = OpLabel\n"
+ "%param = OpVariable %_ptr_Function_int Function\n"
+ "%param_0 = OpVariable %_ptr_Function_int Function\n"
+ "OpStore %param %13\n"
+ "OpStore %param_0 %14\n"
+ "%16 = OpFunctionCall %int %add_i1_i1_ %param %param_0\n"
+ "OpReturn\n"
+ "OpFunctionEnd\n"
+ "%add_i1_i1_ = OpFunction %int None %12\n"
+ "%a = OpFunctionParameter %_ptr_Function_int\n"
+ "%b = OpFunctionParameter %_ptr_Function_int\n"
+ "%17 = OpLabel\n"
+ "%18 = OpLoad %int %a\n"
+ "%19 = OpLoad %int %b\n"
+ "%20 = OpIAdd %int %18 %19\n"
+ "OpReturnValue %20\n"
+ "OpFunctionEnd\n";
+ // clang-format on
SpvTools t(SPV_ENV_UNIVERSAL_1_1);
std::unique_ptr<ir::Module> module = t.BuildModule(text);
@@ -92,27 +94,29 @@
// #version 310 es
// void main() {}
const std::string text =
- "OpCapability Shader\n"
- "%1 = OpExtInstImport \"GLSL.std.450\"\n"
- "OpMemoryModel Logical GLSL450\n"
- "OpEntryPoint Vertex %2 \"main\"\n"
- "%3 = OpString \"minimal.vert\"\n"
- "OpSource ESSL 310\n"
- "OpName %2 \"main\"\n"
- "OpLine %3 10 10\n"
- "%4 = OpTypeVoid\n"
- "OpLine %3 100 100\n"
- "%5 = OpTypeFunction %4\n"
- "%2 = OpFunction %4 None %5\n"
- "OpLine %3 1 1\n"
- "OpNoLine\n"
- "OpLine %3 2 2\n"
- "OpLine %3 3 3\n"
- "%6 = OpLabel\n"
- "OpLine %3 4 4\n"
- "OpNoLine\n"
- "OpReturn\n"
- "OpFunctionEnd\n";
+ // clang-format off
+ "OpCapability Shader\n"
+ "%1 = OpExtInstImport \"GLSL.std.450\"\n"
+ "OpMemoryModel Logical GLSL450\n"
+ "OpEntryPoint Vertex %main \"main\"\n"
+ "%3 = OpString \"minimal.vert\"\n"
+ "OpSource ESSL 310\n"
+ "OpName %main \"main\"\n"
+ "OpLine %3 10 10\n"
+ "%void = OpTypeVoid\n"
+ "OpLine %3 100 100\n"
+ "%5 = OpTypeFunction %void\n"
+ "%main = OpFunction %void None %5\n"
+ "OpLine %3 1 1\n"
+ "OpNoLine\n"
+ "OpLine %3 2 2\n"
+ "OpLine %3 3 3\n"
+ "%6 = OpLabel\n"
+ "OpLine %3 4 4\n"
+ "OpNoLine\n"
+ "OpReturn\n"
+ "OpFunctionEnd\n";
+ // clang-format on
SpvTools t(SPV_ENV_UNIVERSAL_1_1);
std::unique_ptr<ir::Module> module = t.BuildModule(text);
@@ -142,56 +146,58 @@
// float lv1 = gv1 - gv2;
// }
const std::string text =
- "OpCapability Shader\n"
- "%1 = OpExtInstImport \"GLSL.std.450\"\n"
- "OpMemoryModel Logical GLSL450\n"
- "OpEntryPoint Vertex %2 \"main\"\n"
- "OpSource ESSL 310\n"
- "OpName %2 \"main\"\n"
- "OpName %3 \"f(\"\n"
- "OpName %4 \"gv1\"\n"
- "OpName %5 \"gv2\"\n"
- "OpName %6 \"lv1\"\n"
- "OpName %7 \"lv2\"\n"
- "OpName %8 \"lv1\"\n"
- "%9 = OpTypeVoid\n"
- "%10 = OpTypeFunction %9\n"
- "%11 = OpTypeFloat 32\n"
- "%12 = OpTypeFunction %11\n"
- "%13 = OpTypePointer Private %11\n"
- "%4 = OpVariable %13 Private\n"
- "%14 = OpConstant %11 10\n"
- "%5 = OpVariable %13 Private\n"
- "%15 = OpConstant %11 100\n"
- "%16 = OpTypePointer Function %11\n"
- "%2 = OpFunction %9 None %10\n"
- "%17 = OpLabel\n"
- "%8 = OpVariable %16 Function\n"
- "OpStore %4 %14\n"
- "OpStore %5 %15\n"
- "%18 = OpLoad %11 %4\n"
- "%19 = OpLoad %11 %5\n"
- "%20 = OpFSub %11 %18 %19\n"
- "OpStore %8 %20\n"
- "OpReturn\n"
- "OpFunctionEnd\n"
- "%3 = OpFunction %11 None %12\n"
- "%21 = OpLabel\n"
- "%6 = OpVariable %16 Function\n"
- "%7 = OpVariable %16 Function\n"
- "%22 = OpLoad %11 %4\n"
- "%23 = OpLoad %11 %5\n"
- "%24 = OpFAdd %11 %22 %23\n"
- "OpStore %6 %24\n"
- "%25 = OpLoad %11 %4\n"
- "%26 = OpLoad %11 %5\n"
- "%27 = OpFMul %11 %25 %26\n"
- "OpStore %7 %27\n"
- "%28 = OpLoad %11 %6\n"
- "%29 = OpLoad %11 %7\n"
- "%30 = OpFDiv %11 %28 %29\n"
- "OpReturnValue %30\n"
- "OpFunctionEnd\n";
+ // clang-format off
+ "OpCapability Shader\n"
+ "%1 = OpExtInstImport \"GLSL.std.450\"\n"
+ "OpMemoryModel Logical GLSL450\n"
+ "OpEntryPoint Vertex %main \"main\"\n"
+ "OpSource ESSL 310\n"
+ "OpName %main \"main\"\n"
+ "OpName %f_ \"f(\"\n"
+ "OpName %gv1 \"gv1\"\n"
+ "OpName %gv2 \"gv2\"\n"
+ "OpName %lv1 \"lv1\"\n"
+ "OpName %lv2 \"lv2\"\n"
+ "OpName %lv1_0 \"lv1\"\n"
+ "%void = OpTypeVoid\n"
+ "%10 = OpTypeFunction %void\n"
+ "%float = OpTypeFloat 32\n"
+ "%12 = OpTypeFunction %float\n"
+ "%_ptr_Private_float = OpTypePointer Private %float\n"
+ "%gv1 = OpVariable %_ptr_Private_float Private\n"
+ "%14 = OpConstant %float 10\n"
+ "%gv2 = OpVariable %_ptr_Private_float Private\n"
+ "%15 = OpConstant %float 100\n"
+ "%_ptr_Function_float = OpTypePointer Function %float\n"
+ "%main = OpFunction %void None %10\n"
+ "%17 = OpLabel\n"
+ "%lv1_0 = OpVariable %_ptr_Function_float Function\n"
+ "OpStore %gv1 %14\n"
+ "OpStore %gv2 %15\n"
+ "%18 = OpLoad %float %gv1\n"
+ "%19 = OpLoad %float %gv2\n"
+ "%20 = OpFSub %float %18 %19\n"
+ "OpStore %lv1_0 %20\n"
+ "OpReturn\n"
+ "OpFunctionEnd\n"
+ "%f_ = OpFunction %float None %12\n"
+ "%21 = OpLabel\n"
+ "%lv1 = OpVariable %_ptr_Function_float Function\n"
+ "%lv2 = OpVariable %_ptr_Function_float Function\n"
+ "%22 = OpLoad %float %gv1\n"
+ "%23 = OpLoad %float %gv2\n"
+ "%24 = OpFAdd %float %22 %23\n"
+ "OpStore %lv1 %24\n"
+ "%25 = OpLoad %float %gv1\n"
+ "%26 = OpLoad %float %gv2\n"
+ "%27 = OpFMul %float %25 %26\n"
+ "OpStore %lv2 %27\n"
+ "%28 = OpLoad %float %lv1\n"
+ "%29 = OpLoad %float %lv2\n"
+ "%30 = OpFDiv %float %28 %29\n"
+ "OpReturnValue %30\n"
+ "OpFunctionEnd\n";
+ // clang-format on
SpvTools t(SPV_ENV_UNIVERSAL_1_1);
std::unique_ptr<ir::Module> module = t.BuildModule(text);
diff --git a/test/opt/test_pass_manager.cpp b/test/opt/test_pass_manager.cpp
index cf2f2f6..1ecde39 100644
--- a/test/opt/test_pass_manager.cpp
+++ b/test/opt/test_pass_manager.cpp
@@ -36,18 +36,18 @@
manager.AddPass<opt::StripDebugInfoPass>();
EXPECT_EQ(1u, manager.NumPasses());
- EXPECT_STREQ("StripDebugInfo", manager.GetPass(0)->name());
+ EXPECT_STREQ("strip-debug", manager.GetPass(0)->name());
manager.AddPass(std::unique_ptr<opt::NullPass>(new opt::NullPass));
EXPECT_EQ(2u, manager.NumPasses());
- EXPECT_STREQ("StripDebugInfo", manager.GetPass(0)->name());
- EXPECT_STREQ("Null", manager.GetPass(1)->name());
+ EXPECT_STREQ("strip-debug", manager.GetPass(0)->name());
+ EXPECT_STREQ("null", manager.GetPass(1)->name());
manager.AddPass<opt::StripDebugInfoPass>();
EXPECT_EQ(3u, manager.NumPasses());
- EXPECT_STREQ("StripDebugInfo", manager.GetPass(0)->name());
- EXPECT_STREQ("Null", manager.GetPass(1)->name());
- EXPECT_STREQ("StripDebugInfo", manager.GetPass(2)->name());
+ EXPECT_STREQ("strip-debug", manager.GetPass(0)->name());
+ EXPECT_STREQ("null", manager.GetPass(1)->name());
+ EXPECT_STREQ("strip-debug", manager.GetPass(2)->name());
}
// A pass that appends an OpNop instruction to the debug section.
diff --git a/test/opt/test_strip_debug_info.cpp b/test/opt/test_strip_debug_info.cpp
index 964b33c..d9b35e1 100644
--- a/test/opt/test_strip_debug_info.cpp
+++ b/test/opt/test_strip_debug_info.cpp
@@ -35,28 +35,30 @@
TEST_F(StripLineDebugInfoTest, LineNoLine) {
std::vector<const char*> text = {
- "OpCapability Shader",
- "%1 = OpExtInstImport \"GLSL.std.450\"",
- "OpMemoryModel Logical GLSL450",
- "OpEntryPoint Vertex %2 \"main\"",
- "%3 = OpString \"minimal.vert\"",
- "OpNoLine",
- "OpLine %3 10 10",
- "%4 = OpTypeVoid",
- "OpLine %3 100 100",
- "%5 = OpTypeFunction %4",
- "%2 = OpFunction %4 None %5",
- "OpLine %3 1 1",
- "OpNoLine",
- "OpLine %3 2 2",
- "OpLine %3 3 3",
- "%6 = OpLabel",
- "OpLine %3 4 4",
- "OpNoLine",
- "OpReturn",
- "OpLine %3 4 4",
- "OpNoLine",
- "OpFunctionEnd",
+ // clang-format off
+ "OpCapability Shader",
+ "%1 = OpExtInstImport \"GLSL.std.450\"",
+ "OpMemoryModel Logical GLSL450",
+ "OpEntryPoint Vertex %2 \"main\"",
+ "%3 = OpString \"minimal.vert\"",
+ "OpNoLine",
+ "OpLine %3 10 10",
+ "%void = OpTypeVoid",
+ "OpLine %3 100 100",
+ "%5 = OpTypeFunction %void",
+ "%2 = OpFunction %void None %5",
+ "OpLine %3 1 1",
+ "OpNoLine",
+ "OpLine %3 2 2",
+ "OpLine %3 3 3",
+ "%6 = OpLabel",
+ "OpLine %3 4 4",
+ "OpNoLine",
+ "OpReturn",
+ "OpLine %3 4 4",
+ "OpNoLine",
+ "OpFunctionEnd",
+ // clang-format on
};
SinglePassRunAndCheck<opt::StripDebugInfoPass>(JoinAllInsts(text),
JoinNonDebugInsts(text));
diff --git a/test/opt/test_utils.cpp b/test/opt/test_utils.cpp
index 4a96559..e9ebb31 100644
--- a/test/opt/test_utils.cpp
+++ b/test/opt/test_utils.cpp
@@ -55,4 +55,64 @@
"the only remaining string"}));
}
+namespace {
+struct SubstringReplacementTestCase {
+ const char* orig_str;
+ const char* find_substr;
+ const char* replace_substr;
+ const char* expected_str;
+ bool replace_should_succeed;
+};
+}
+using FindAndReplaceTest =
+ ::testing::TestWithParam<SubstringReplacementTestCase>;
+
+TEST_P(FindAndReplaceTest, SubstringReplacement) {
+ auto process = std::string(GetParam().orig_str);
+ EXPECT_EQ(GetParam().replace_should_succeed,
+ FindAndReplace(&process, GetParam().find_substr,
+ GetParam().replace_substr))
+ << "Original string: " << GetParam().orig_str
+ << " replace: " << GetParam().find_substr
+ << " to: " << GetParam().replace_substr
+ << " should returns: " << GetParam().replace_should_succeed;
+ EXPECT_STREQ(GetParam().expected_str, process.c_str())
+ << "Original string: " << GetParam().orig_str
+ << " replace: " << GetParam().find_substr
+ << " to: " << GetParam().replace_substr
+ << " expected string: " << GetParam().expected_str;
+}
+
+INSTANTIATE_TEST_CASE_P(
+ SubstringReplacement, FindAndReplaceTest,
+ ::testing::ValuesIn(std::vector<SubstringReplacementTestCase>({
+ // orig string, find substring, replace substring, expected string,
+ // replacement happened
+ {"", "", "", "", false},
+ {"", "b", "", "", false},
+ {"", "", "c", "", false},
+ {"", "a", "b", "", false},
+
+ {"a", "", "c", "a", false},
+ {"a", "b", "c", "a", false},
+ {"a", "b", "", "a", false},
+ {"a", "a", "", "", true},
+ {"a", "a", "b", "b", true},
+
+ {"ab", "a", "b", "bb", true},
+ {"ab", "a", "", "b", true},
+ {"ab", "b", "", "a", true},
+ {"ab", "ab", "", "", true},
+ {"ab", "ab", "cd", "cd", true},
+ {"bc", "abc", "efg", "bc", false},
+
+ {"abc", "ab", "bc", "bcc", true},
+ {"abc", "ab", "", "c", true},
+ {"abc", "bc", "", "a", true},
+ {"abc", "bc", "d", "ad", true},
+ {"abc", "a", "123", "123bc", true},
+ {"abc", "ab", "a", "ac", true},
+ {"abc", "a", "aab", "aabbc", true},
+ {"abc", "abcd", "efg", "abc", false},
+ })));
} // anonymous namespace
diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp
index e3246a1..3c3f79c 100644
--- a/tools/opt/opt.cpp
+++ b/tools/opt/opt.cpp
@@ -51,6 +51,9 @@
Options:
--strip-debug
Remove all debug instructions.
+ --freeze-spec-const
+ Freeze the values of specialization constants to their default
+ values.
-h, --help Print this help.
--version Display optimizer version information.
)",
@@ -83,6 +86,8 @@
}
} else if (0 == strcmp(cur_arg, "--strip-debug")) {
pass_manager.AddPass<opt::StripDebugInfoPass>();
+ } else if (0 == strcmp(cur_arg, "--freeze-spec-const")) {
+ pass_manager.AddPass<opt::FreezeSpecConstantValuePass>();
} else if ('\0' == cur_arg[1]) {
// Setting a filename of "-" to indicate stdin.
if (!in_file) {
diff --git a/utils/update_build_version.py b/utils/update_build_version.py
index 98ab5b1..9a3d5ac 100755
--- a/utils/update_build_version.py
+++ b/utils/update_build_version.py
@@ -25,7 +25,8 @@
# - A longer string with the project name, the software version number, and
# git commit information for the directory. The commit information
# is the output of "git describe" if that succeeds, or "git rev-parse HEAD"
-# if that succeeds, or otherwise a message containing the phrase "unknown hash".
+# if that succeeds, or otherwise a message containing the phrase
+# "unknown hash".
# The string contents are escaped as necessary.
from __future__ import print_function
@@ -37,7 +38,7 @@
import sys
-def command_output(cmd, dir):
+def command_output(cmd, directory):
"""Runs a command in a directory and returns its standard output stream.
Captures the standard error stream.
@@ -45,24 +46,24 @@
Raises a RuntimeError if the command fails to launch or otherwise fails.
"""
p = subprocess.Popen(cmd,
- cwd=dir,
+ cwd=directory,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
(stdout, _) = p.communicate()
if p.returncode != 0:
- raise RuntimeError('Failed to run %s in %s' % (cmd, dir))
+ raise RuntimeError('Failed to run %s in %s' % (cmd, directory))
return stdout
-def deduce_software_version(dir):
+def deduce_software_version(directory):
"""Returns a software version number parsed from the CHANGES file
- in the given dir.
+ in the given directory.
The CHANGES file describes most recent versions first.
"""
- pattern = re.compile('(v\d+\.\d+(-dev)?) \d\d\d\d-\d\d-\d\d$')
- changes_file = os.path.join(dir, 'CHANGES')
+ pattern = re.compile(r'(v\d+\.\d+(-dev)?) \d\d\d\d-\d\d-\d\d$')
+ changes_file = os.path.join(directory, 'CHANGES')
with open(changes_file) as f:
for line in f.readlines():
match = pattern.match(line)
@@ -71,11 +72,11 @@
raise Exception('No version number found in {}'.format(changes_file))
-def describe(dir):
+def describe(directory):
"""Returns a string describing the current Git HEAD version as descriptively
as possible.
- Runs 'git describe', or alternately 'git rev-parse HEAD', in dir. If
+ Runs 'git describe', or alternately 'git rev-parse HEAD', in directory. If
successful, returns the output; otherwise returns 'unknown hash, <date>'."""
try:
# decode() is needed here for Python3 compatibility. In Python2,
@@ -83,29 +84,37 @@
# Popen.communicate() returns a bytes instance, which needs to be
# decoded into text data first in Python3. And this decode() won't
# hurt Python2.
- return command_output(['git', 'describe'], dir).rstrip().decode()
+ return command_output(['git', 'describe'], directory).rstrip().decode()
except:
try:
return command_output(
- ['git', 'rev-parse', 'HEAD'], dir).rstrip().decode()
+ ['git', 'rev-parse', 'HEAD'], directory).rstrip().decode()
except:
return 'unknown hash, {}'.format(datetime.date.today().isoformat())
def main():
if len(sys.argv) != 3:
- print('usage: {0} <spirv-tools_dir> <output-file>'.format(sys.argv[0]))
+ print('usage: {} <spirv-tools-dir> <output-file>'.format(sys.argv[0]))
sys.exit(1)
output_file = sys.argv[2]
+ output_dir = os.path.dirname(output_file)
+ if not os.path.isdir(output_dir):
+ os.makedirs(output_dir)
software_version = deduce_software_version(sys.argv[1])
new_content = '"{}", "SPIRV-Tools {} {}"\n'.format(
software_version, software_version,
describe(sys.argv[1]).replace('"', '\\"'))
- if os.path.isfile(output_file) and new_content == open(output_file, 'r').read():
- sys.exit(0)
- open(output_file, 'w').write(new_content)
+
+ if os.path.isfile(output_file):
+ with open(output_file, 'r') as f:
+ if new_content == f.read():
+ return
+
+ with open(output_file, 'w') as f:
+ f.write(new_content)
if __name__ == '__main__':
main()
