Add MessageConsumer to PassManager, Pass, and analysis interfaces.
Also convert some uses of assert() in optimization code to use
SPIRV_ASSERT(), SPIRV_UNIMPLEMENTED(), or SPIRV_UNREACHABLE()
accordingly.
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index a045ce1..e999e6a 100644
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -143,6 +143,7 @@
${CMAKE_CURRENT_SOURCE_DIR}/disassemble.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ext_inst.cpp
${CMAKE_CURRENT_SOURCE_DIR}/instruction.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/message.cpp
${CMAKE_CURRENT_SOURCE_DIR}/name_mapper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/opcode.cpp
${CMAKE_CURRENT_SOURCE_DIR}/operand.cpp
diff --git a/source/message.cpp b/source/message.cpp
new file mode 100644
index 0000000..9d28c8c
--- /dev/null
+++ b/source/message.cpp
@@ -0,0 +1,55 @@
+// Copyright (c) 2016 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "message.h"
+
+#include <sstream>
+
+namespace spvtools {
+
+std::string StringifyMessage(MessageLevel level, const char* source,
+ const spv_position_t& position,
+ const char* message) {
+ const char* level_string = nullptr;
+ switch (level) {
+ case MessageLevel::Fatal:
+ level_string = "fatal";
+ break;
+ case MessageLevel::InternalError:
+ level_string = "internal error";
+ break;
+ case MessageLevel::Error:
+ level_string = "error";
+ break;
+ case MessageLevel::Warning:
+ level_string = "warning";
+ break;
+ case MessageLevel::Info:
+ level_string = "info";
+ break;
+ case MessageLevel::Debug:
+ level_string = "debug";
+ break;
+ }
+ std::ostringstream oss;
+ oss << level_string << ": ";
+ if (source) oss << source << ":";
+ oss << position.line << ":" << position.column << ":";
+ oss << position.index << ": ";
+ if (message) oss << message;
+ oss << "\n";
+ return oss.str();
+}
+
+} // namespace spvtools
diff --git a/source/message.h b/source/message.h
index 68e4cd7..7af4297 100644
--- a/source/message.h
+++ b/source/message.h
@@ -16,6 +16,7 @@
#define SPIRV_TOOLS_MESSAGE_H_
#include <functional>
+#include <string>
#include "spirv-tools/libspirv.h"
@@ -42,6 +43,17 @@
const spv_position_t& /* position */, const char* /* message */
)>;
+// A message consumer that ignores all messages.
+inline void IgnoreMessage(MessageLevel, const char*, const spv_position_t&,
+ const char*) {}
+
+// A helper function to compose and return a string from the message in the
+// following format:
+// "<level>: <source>:<line>:<column>:<index>: <message>"
+std::string StringifyMessage(MessageLevel level, const char* source,
+ const spv_position_t& position,
+ const char* message);
+
} // namespace spvtools
#endif // SPIRV_TOOLS_MESSAGE_H_
diff --git a/source/opt/def_use_manager.cpp b/source/opt/def_use_manager.cpp
index e829c5f..19178eb 100644
--- a/source/opt/def_use_manager.cpp
+++ b/source/opt/def_use_manager.cpp
@@ -14,10 +14,10 @@
#include "def_use_manager.h"
-#include <cassert>
#include <functional>
#include "instruction.h"
+#include "log.h"
#include "module.h"
#include "reflect.h"
@@ -80,11 +80,10 @@
return &iter->second;
}
-std::vector<ir::Instruction*> DefUseManager::GetAnnotations(
- uint32_t id) const {
+std::vector<ir::Instruction*> DefUseManager::GetAnnotations(uint32_t id) const {
std::vector<ir::Instruction*> annos;
const auto* uses = GetUses(id);
- if (!uses) return annos;
+ if (!uses) return annos;
for (const auto& c : *uses) {
if (ir::IsAnnotationInst(c.inst->opcode())) {
annos.push_back(c.inst);
@@ -121,11 +120,13 @@
if (it->inst->type_id() != 0 && it->operand_index == 0) {
it->inst->SetResultType(after);
} else if (it->inst->type_id() == 0) {
- assert(false &&
- "Result type id considered as using while the instruction "
- "doesn't have a result type id.");
+ SPIRV_ASSERT(consumer_, false,
+ "Result type id considered as use while the instruction "
+ "doesn't have a result type id.");
+ (void)consumer_; // Makes the compiler happy for release build.
} else {
- assert(false && "Trying Setting the result id which is immutable.");
+ SPIRV_ASSERT(consumer_, false,
+ "Trying setting the immutable result id.");
}
} else {
// Update an in-operand.
diff --git a/source/opt/def_use_manager.h b/source/opt/def_use_manager.h
index 23f098a..41c405a 100644
--- a/source/opt/def_use_manager.h
+++ b/source/opt/def_use_manager.h
@@ -21,6 +21,7 @@
#include <vector>
#include "instruction.h"
+#include "message.h"
#include "module.h"
namespace spvtools {
@@ -45,7 +46,15 @@
using IdToDefMap = std::unordered_map<uint32_t, ir::Instruction*>;
using IdToUsesMap = std::unordered_map<uint32_t, UseList>;
- inline explicit DefUseManager(ir::Module* module) { AnalyzeDefUse(module); }
+ // Constructs a def-use manager from the given |module|. All internal messages
+ // will be communicated to the outside via the given message |consumer|. This
+ // instance only keeps a reference to the |consumer|, so the |consumer| should
+ // outlive this instance.
+ DefUseManager(const MessageConsumer& consumer, ir::Module* module)
+ : consumer_(consumer) {
+ AnalyzeDefUse(module);
+ }
+
DefUseManager(const DefUseManager&) = delete;
DefUseManager(DefUseManager&&) = delete;
DefUseManager& operator=(const DefUseManager&) = delete;
@@ -106,8 +115,9 @@
// Erases the records that a given instruction uses its operand ids.
void EraseUseRecordsOfOperandIds(const ir::Instruction* inst);
- IdToDefMap id_to_def_; // Mapping from ids to their definitions
- IdToUsesMap id_to_uses_; // Mapping from ids to their uses
+ const MessageConsumer& consumer_; // Message consumer.
+ IdToDefMap id_to_def_; // Mapping from ids to their definitions
+ IdToUsesMap id_to_uses_; // Mapping from ids to their uses
// Mapping from instructions to the ids used in the instructions generating
// the result ids.
InstToUsedIdsMap inst_to_used_ids_;
diff --git a/source/opt/eliminate_dead_constant_pass.cpp b/source/opt/eliminate_dead_constant_pass.cpp
index 15f1e44..c7a921f 100644
--- a/source/opt/eliminate_dead_constant_pass.cpp
+++ b/source/opt/eliminate_dead_constant_pass.cpp
@@ -19,13 +19,14 @@
#include <unordered_set>
#include "def_use_manager.h"
+#include "log.h"
#include "reflect.h"
namespace spvtools {
namespace opt {
bool EliminateDeadConstantPass::Process(ir::Module* module) {
- analysis::DefUseManager def_use(module);
+ analysis::DefUseManager def_use(consumer(), module);
std::unordered_set<ir::Instruction*> working_list;
// Traverse all the instructions to get the initial set of dead constants as
// working list and count number of real uses for constants. Uses in
@@ -73,7 +74,7 @@
}
// The number of uses should never be less then 0, so it can not be
// less than 1 before it decreases.
- assert(use_counts[def_inst] > 0);
+ SPIRV_ASSERT(consumer(), use_counts[def_inst] > 0);
--use_counts[def_inst];
if (!use_counts[def_inst]) {
working_list.insert(def_inst);
diff --git a/source/opt/eliminate_dead_constant_pass.h b/source/opt/eliminate_dead_constant_pass.h
index fa09dba..bc24eba 100644
--- a/source/opt/eliminate_dead_constant_pass.h
+++ b/source/opt/eliminate_dead_constant_pass.h
@@ -28,6 +28,8 @@
// OpSpecConstantOp.
class EliminateDeadConstantPass : public Pass {
public:
+ explicit EliminateDeadConstantPass(const MessageConsumer& c) : Pass(c) {}
+
const char* name() const override { return "eliminate-dead-const"; }
bool Process(ir::Module*) override;
};
diff --git a/source/opt/fold_spec_constant_op_and_composite_pass.cpp b/source/opt/fold_spec_constant_op_and_composite_pass.cpp
index 1d5ffc2..6adb497 100644
--- a/source/opt/fold_spec_constant_op_and_composite_pass.cpp
+++ b/source/opt/fold_spec_constant_op_and_composite_pass.cpp
@@ -242,6 +242,15 @@
}
} // anonymous namespace
+FoldSpecConstantOpAndCompositePass::FoldSpecConstantOpAndCompositePass(
+ const MessageConsumer& c)
+ : Pass(c),
+ max_id_(0),
+ module_(nullptr),
+ def_use_mgr_(nullptr),
+ type_mgr_(nullptr),
+ id_to_const_val_() {}
+
bool FoldSpecConstantOpAndCompositePass::ProcessImpl(ir::Module* module) {
bool modified = false;
// Traverse through all the constant defining instructions. For Normal
diff --git a/source/opt/fold_spec_constant_op_and_composite_pass.h b/source/opt/fold_spec_constant_op_and_composite_pass.h
index e7205f3..8b913a3 100644
--- a/source/opt/fold_spec_constant_op_and_composite_pass.h
+++ b/source/opt/fold_spec_constant_op_and_composite_pass.h
@@ -50,12 +50,8 @@
// TODO(qining): Add support for the operations listed above.
class FoldSpecConstantOpAndCompositePass : public Pass {
public:
- FoldSpecConstantOpAndCompositePass()
- : max_id_(0),
- module_(nullptr),
- def_use_mgr_(nullptr),
- type_mgr_(nullptr),
- id_to_const_val_() {}
+ explicit FoldSpecConstantOpAndCompositePass(const MessageConsumer& c);
+
const char* name() const override { return "fold-spec-const-op-composite"; }
bool Process(ir::Module* module) override {
Initialize(module);
@@ -66,8 +62,8 @@
// Initializes the type manager, def-use manager and get the maximal id used
// in the module.
void Initialize(ir::Module* module) {
- type_mgr_.reset(new analysis::TypeManager(*module));
- def_use_mgr_.reset(new analysis::DefUseManager(module));
+ type_mgr_.reset(new analysis::TypeManager(consumer(), *module));
+ def_use_mgr_.reset(new analysis::DefUseManager(consumer(), module));
for (const auto& id_def : def_use_mgr_->id_to_defs()) {
max_id_ = std::max(max_id_, id_def.first);
}
diff --git a/source/opt/freeze_spec_constant_value_pass.h b/source/opt/freeze_spec_constant_value_pass.h
index efe98e7..8b21463 100644
--- a/source/opt/freeze_spec_constant_value_pass.h
+++ b/source/opt/freeze_spec_constant_value_pass.h
@@ -31,6 +31,8 @@
// other spec constants defined by OpSpecConstantComposite or OpSpecConstantOp.
class FreezeSpecConstantValuePass : public Pass {
public:
+ explicit FreezeSpecConstantValuePass(const MessageConsumer& c) : Pass(c) {}
+
const char* name() const override { return "freeze-spec-const"; }
bool Process(ir::Module*) override;
};
diff --git a/source/opt/ir_loader.cpp b/source/opt/ir_loader.cpp
index 3066a87..09106a3 100644
--- a/source/opt/ir_loader.cpp
+++ b/source/opt/ir_loader.cpp
@@ -14,8 +14,7 @@
#include "ir_loader.h"
-#include <cassert>
-
+#include "log.h"
#include "reflect.h"
namespace spvtools {
@@ -34,28 +33,28 @@
// Handle function and basic block boundaries first, then normal
// instructions.
if (opcode == SpvOpFunction) {
- assert(function_ == nullptr);
- assert(block_ == nullptr);
+ SPIRV_ASSERT(consumer_, function_ == nullptr);
+ SPIRV_ASSERT(consumer_, block_ == nullptr);
function_.reset(new Function(std::move(spv_inst)));
} else if (opcode == SpvOpFunctionEnd) {
- assert(function_ != nullptr);
- assert(block_ == nullptr);
+ SPIRV_ASSERT(consumer_, function_ != nullptr);
+ SPIRV_ASSERT(consumer_, block_ == nullptr);
function_->SetFunctionEnd(std::move(spv_inst));
module_->AddFunction(std::move(function_));
function_ = nullptr;
} else if (opcode == SpvOpLabel) {
- assert(function_ != nullptr);
- assert(block_ == nullptr);
+ SPIRV_ASSERT(consumer_, function_ != nullptr);
+ SPIRV_ASSERT(consumer_, block_ == nullptr);
block_.reset(new BasicBlock(std::move(spv_inst)));
} else if (IsTerminatorInst(opcode)) {
- assert(function_ != nullptr);
- assert(block_ != nullptr);
+ SPIRV_ASSERT(consumer_, function_ != nullptr);
+ SPIRV_ASSERT(consumer_, block_ != nullptr);
block_->AddInstruction(std::move(spv_inst));
function_->AddBasicBlock(std::move(block_));
block_ = nullptr;
} else {
if (function_ == nullptr) { // Outside function definition
- assert(block_ == nullptr);
+ SPIRV_ASSERT(consumer_, block_ == nullptr);
if (opcode == SpvOpCapability) {
module_->AddCapability(std::move(spv_inst));
} else if (opcode == SpvOpExtension) {
@@ -78,11 +77,12 @@
opcode == SpvOpUndef) {
module_->AddGlobalValue(std::move(spv_inst));
} else {
- assert(0 && "unhandled inst type outside function defintion");
+ SPIRV_UNIMPLEMENTED(consumer_,
+ "unhandled inst type outside function defintion");
}
} else {
if (block_ == nullptr) { // Inside function but outside blocks
- assert(opcode == SpvOpFunctionParameter);
+ SPIRV_ASSERT(consumer_, opcode == SpvOpFunctionParameter);
function_->AddParameter(std::move(spv_inst));
} else {
block_->AddInstruction(std::move(spv_inst));
diff --git a/source/opt/ir_loader.h b/source/opt/ir_loader.h
index 6795a5d..ce971d0 100644
--- a/source/opt/ir_loader.h
+++ b/source/opt/ir_loader.h
@@ -19,6 +19,7 @@
#include "basic_block.h"
#include "instruction.h"
+#include "message.h"
#include "module.h"
#include "spirv-tools/libspirv.h"
@@ -36,7 +37,11 @@
class IrLoader {
public:
// Instantiates a builder to construct the given |module| gradually.
- IrLoader(Module* module) : module_(module) {}
+ // All internal messages will be communicated to the outside via the given
+ // message |consumer|. This instance only keeps a reference to the |consumer|,
+ // so the |consumer| should outlive this instance.
+ IrLoader(const MessageConsumer& consumer, Module* module)
+ : consumer_(consumer), module_(module) {}
// Sets the fields in the module's header to the given parameters.
void SetModuleHeader(uint32_t magic, uint32_t version, uint32_t generator,
@@ -54,6 +59,8 @@
void EndModule();
private:
+ // Consumer for communicating messages to outside.
+ const MessageConsumer& consumer_;
// The module to be built.
Module* module_;
// The current Function under construction.
diff --git a/source/opt/libspirv.cpp b/source/opt/libspirv.cpp
index eabc260..47be681 100644
--- a/source/opt/libspirv.cpp
+++ b/source/opt/libspirv.cpp
@@ -83,7 +83,7 @@
spv_diagnostic diagnostic = nullptr;
auto module = MakeUnique<ir::Module>();
- ir::IrLoader loader(module.get());
+ ir::IrLoader loader(context_->consumer, module.get());
spv_result_t status =
spvBinaryParse(context_, &loader, binary.data(), binary.size(),
diff --git a/source/opt/null_pass.h b/source/opt/null_pass.h
index 0f87c61..7e10791 100644
--- a/source/opt/null_pass.h
+++ b/source/opt/null_pass.h
@@ -23,6 +23,9 @@
// A null pass that does nothing.
class NullPass : public Pass {
+ public:
+ explicit NullPass(const MessageConsumer& c) : Pass(c) {}
+
const char* name() const override { return "null"; }
bool Process(ir::Module*) override { return false; }
};
diff --git a/source/opt/pass.h b/source/opt/pass.h
index 22df24e..dadb53a 100644
--- a/source/opt/pass.h
+++ b/source/opt/pass.h
@@ -17,6 +17,7 @@
#include <memory>
+#include "message.h"
#include "module.h"
namespace spvtools {
@@ -26,11 +27,24 @@
// and all analysis and transformation is done via the Process() method.
class Pass {
public:
+ // Constructs a new pass with the given message consumer, which will be
+ // invoked every time there is a message to be communicated to the outside.
+ //
+ // This pass just keeps a reference to the message consumer; so the message
+ // consumer should outlive this pass.
+ explicit Pass(const MessageConsumer& c) : consumer_(c) {}
+
// Returns a descriptive name for this pass.
virtual const char* name() const = 0;
+ // Returns the reference to the message consumer for this pass.
+ const MessageConsumer& consumer() const { return consumer_; }
+
// Processes the given |module| and returns true if the given |module| is
// modified for optimization.
virtual bool Process(ir::Module* module) = 0;
+
+ private:
+ const MessageConsumer& consumer_; // Message consumer.
};
} // namespace opt
diff --git a/source/opt/pass_manager.h b/source/opt/pass_manager.h
index 6242a46..58c0537 100644
--- a/source/opt/pass_manager.h
+++ b/source/opt/pass_manager.h
@@ -15,10 +15,11 @@
#ifndef LIBSPIRV_OPT_PASS_MANAGER_H_
#define LIBSPIRV_OPT_PASS_MANAGER_H_
-#include <cassert>
#include <memory>
#include <vector>
+#include "log.h"
+#include "message.h"
#include "module.h"
#include "passes.h"
@@ -27,32 +28,35 @@
// The pass manager, responsible for tracking and running passes.
// Clients should first call AddPass() to add passes and then call Run()
-// to run on a module. Passes are executed in the exact order of added.
-//
-// TODO(antiagainst): The pass manager is fairly simple right now. Eventually it
-// should support pass dependency, common functionality (like def-use analysis)
-// sharing, etc.
+// to run on a module. Passes are executed in the exact order of addition.
class PassManager {
public:
- // Adds a pass.
+ // Constructs a pass manager with the given message consumer.
+ explicit PassManager(MessageConsumer c) : consumer_(std::move(c)) {}
+
+ // Adds an externally constructed pass.
void AddPass(std::unique_ptr<Pass> pass) {
passes_.push_back(std::move(pass));
}
- // Uses the argument to construct a pass instance of type PassT, and adds the
- // pass instance to this pass manger.
- template <typename PassT, typename... Args>
+ // Uses the argument |args| to construct a pass instance of type |T|, and adds
+ // the pass instance to this pass manger. The pass added will use this pass
+ // manager's message consumer.
+ template <typename T, typename... Args>
void AddPass(Args&&... args) {
- passes_.emplace_back(new PassT(std::forward<Args>(args)...));
+ passes_.emplace_back(new T(consumer_, std::forward<Args>(args)...));
}
// Returns the number of passes added.
uint32_t NumPasses() const { return static_cast<uint32_t>(passes_.size()); }
// Returns a pointer to the |index|th pass added.
Pass* GetPass(uint32_t index) const {
- assert(index < passes_.size() && "index out of bound");
+ SPIRV_ASSERT(consumer_, index < passes_.size(), "index out of bound");
return passes_[index].get();
}
+ // Returns the message consumer.
+ const MessageConsumer& consumer() const { return consumer_; }
+
// Runs all passes on the given |module|.
void Run(ir::Module* module) {
bool modified = false;
@@ -64,6 +68,8 @@
}
private:
+ // Consumer for messages.
+ MessageConsumer consumer_;
// A vector of passes. Order matters.
std::vector<std::unique_ptr<Pass>> passes_;
};
diff --git a/source/opt/set_spec_constant_default_value_pass.cpp b/source/opt/set_spec_constant_default_value_pass.cpp
index 9ea304d..68db8bf 100644
--- a/source/opt/set_spec_constant_default_value_pass.cpp
+++ b/source/opt/set_spec_constant_default_value_pass.cpp
@@ -14,8 +14,8 @@
#include "set_spec_constant_default_value_pass.h"
-#include <cstring>
#include <cctype>
+#include <cstring>
#include <string>
#include <tuple>
#include <unordered_map>
@@ -164,8 +164,8 @@
const uint32_t kOpSpecConstantLiteralInOperandIndex = 0;
bool modified = false;
- analysis::DefUseManager def_use_mgr(module);
- analysis::TypeManager type_mgr(*module);
+ analysis::DefUseManager def_use_mgr(consumer(), module);
+ analysis::TypeManager type_mgr(consumer(), *module);
// Scan through all the annotation instructions to find 'OpDecorate SpecId'
// instructions. Then extract the decoration target of those instructions.
// The decoration targets should be spec constant defining instructions with
diff --git a/source/opt/set_spec_constant_default_value_pass.h b/source/opt/set_spec_constant_default_value_pass.h
index 0958f19..7762050 100644
--- a/source/opt/set_spec_constant_default_value_pass.h
+++ b/source/opt/set_spec_constant_default_value_pass.h
@@ -34,11 +34,12 @@
using SpecIdToInstMap = std::unordered_map<uint32_t, ir::Instruction*>;
// Constructs a pass instance with a map from spec ids to default values.
- explicit SetSpecConstantDefaultValuePass(
- const SpecIdToValueStrMap& default_values)
- : Pass(), spec_id_to_value_(default_values) {}
- explicit SetSpecConstantDefaultValuePass(SpecIdToValueStrMap&& default_values)
- : Pass(), spec_id_to_value_(std::move(default_values)) {}
+ SetSpecConstantDefaultValuePass(const MessageConsumer& c,
+ const SpecIdToValueStrMap& default_values)
+ : Pass(c), spec_id_to_value_(default_values) {}
+ SetSpecConstantDefaultValuePass(const MessageConsumer& c,
+ SpecIdToValueStrMap&& default_values)
+ : Pass(c), spec_id_to_value_(std::move(default_values)) {}
const char* name() const override { return "set-spec-const-default-value"; }
bool Process(ir::Module*) override;
diff --git a/source/opt/strip_debug_info_pass.h b/source/opt/strip_debug_info_pass.h
index 2bf3512..9a8d27c 100644
--- a/source/opt/strip_debug_info_pass.h
+++ b/source/opt/strip_debug_info_pass.h
@@ -25,6 +25,8 @@
// Section 3.32.2 of the SPIR-V spec).
class StripDebugInfoPass : public Pass {
public:
+ explicit StripDebugInfoPass(const MessageConsumer& c) : Pass(c) {}
+
const char* name() const override { return "strip-debug"; }
bool Process(ir::Module* module) override;
};
diff --git a/source/opt/type_manager.cpp b/source/opt/type_manager.cpp
index f55cecc..ce4b676 100644
--- a/source/opt/type_manager.cpp
+++ b/source/opt/type_manager.cpp
@@ -13,8 +13,8 @@
// limitations under the License.
#include <algorithm>
-#include <cassert>
+#include "log.h"
#include "reflect.h"
#include "type_manager.h"
@@ -161,16 +161,17 @@
type = new NamedBarrier();
break;
default:
- assert(0 && "unhandled type found");
+ SPIRV_UNIMPLEMENTED(consumer_, "unhandled type");
break;
}
uint32_t id = inst.result_id();
if (id == 0) {
- assert(inst.opcode() == SpvOpTypeForwardPointer &&
- "instruction without result id found");
+ SPIRV_ASSERT(consumer_, inst.opcode() == SpvOpTypeForwardPointer,
+ "instruction without result id found");
} else {
- assert(type != nullptr && "type should not be nullptr at this point");
+ SPIRV_ASSERT(consumer_, type != nullptr,
+ "type should not be nullptr at this point");
id_to_type_[id].reset(type);
type_to_id_[type] = id;
}
@@ -204,16 +205,16 @@
if (Struct* st = target_type->AsStruct()) {
st->AddMemeberDecoration(index, std::move(data));
} else {
- assert(0 && "OpMemberDecorate on non-struct type");
+ SPIRV_UNIMPLEMENTED(consumer_, "OpMemberDecorate non-struct type");
}
} break;
case SpvOpDecorationGroup:
case SpvOpGroupDecorate:
case SpvOpGroupMemberDecorate:
- assert(0 && "unhandled decoration");
+ SPIRV_UNIMPLEMENTED(consumer_, "unhandled decoration");
break;
default:
- assert(0 && "unreachable");
+ SPIRV_UNREACHABLE(consumer_);
break;
}
}
diff --git a/source/opt/type_manager.h b/source/opt/type_manager.h
index a8a8155..48fa212 100644
--- a/source/opt/type_manager.h
+++ b/source/opt/type_manager.h
@@ -19,6 +19,7 @@
#include <unordered_map>
#include <unordered_set>
+#include "message.h"
#include "module.h"
#include "types.h"
@@ -33,7 +34,13 @@
using TypeToIdMap = std::unordered_map<const Type*, uint32_t>;
using ForwardPointerVector = std::vector<std::unique_ptr<ForwardPointer>>;
- inline explicit TypeManager(const spvtools::ir::Module& module);
+ // Constructs a type manager from the given |module|. All internal messages
+ // will be communicated to the outside via the given message |consumer|.
+ // This instance only keeps a reference to the |consumer|, so the |consumer|
+ // should outlive this instance.
+ TypeManager(const MessageConsumer& consumer,
+ const spvtools::ir::Module& module);
+
TypeManager(const TypeManager&) = delete;
TypeManager(TypeManager&&) = delete;
TypeManager& operator=(const TypeManager&) = delete;
@@ -64,6 +71,7 @@
// given instruction is not a decoration instruction or not decorating a type.
void AttachIfTypeDecoration(const spvtools::ir::Instruction& inst);
+ const MessageConsumer& consumer_; // Message consumer.
IdToTypeMap id_to_type_; // Mapping from ids to their type representations.
TypeToIdMap type_to_id_; // Mapping from types to their defining ids.
ForwardPointerVector forward_pointers_; // All forward pointer declarations.
@@ -72,7 +80,9 @@
std::unordered_set<ForwardPointer*> unresolved_forward_pointers_;
};
-inline TypeManager::TypeManager(const spvtools::ir::Module& module) {
+inline TypeManager::TypeManager(const spvtools::MessageConsumer& consumer,
+ const spvtools::ir::Module& module)
+ : consumer_(consumer) {
AnalyzeTypes(module);
}
diff --git a/source/opt/unify_const_pass.cpp b/source/opt/unify_const_pass.cpp
index 02a5c9c..72fb3cd 100644
--- a/source/opt/unify_const_pass.cpp
+++ b/source/opt/unify_const_pass.cpp
@@ -105,7 +105,7 @@
bool UnifyConstantPass::Process(ir::Module* module) {
bool modified = false;
ResultIdTrie defined_constants;
- analysis::DefUseManager def_use_mgr(module);
+ analysis::DefUseManager def_use_mgr(consumer(), module);
for (ir::Instruction& inst : module->types_values()) {
// Do not handle the instruction when there are decorations upon the result
diff --git a/source/opt/unify_const_pass.h b/source/opt/unify_const_pass.h
index 6debaad..db17b69 100644
--- a/source/opt/unify_const_pass.h
+++ b/source/opt/unify_const_pass.h
@@ -36,6 +36,8 @@
// 3) NaN in float point format with different bit patterns are not unified.
class UnifyConstantPass : public Pass {
public:
+ explicit UnifyConstantPass(const MessageConsumer& c) : Pass(c) {}
+
const char* name() const override { return "unify-const"; }
bool Process(ir::Module*) override;
};
@@ -43,4 +45,4 @@
} // namespace opt
} // namespace spvtools
-#endif // LIBSPIRV_OPT_UNIFY_CONSTANT_PASS_H_
+#endif // LIBSPIRV_OPT_UNIFY_CONSTANT_PASS_H_
diff --git a/test/opt/pass_fixture.h b/test/opt/pass_fixture.h
index ec8d569..436ed42 100644
--- a/test/opt/pass_fixture.h
+++ b/test/opt/pass_fixture.h
@@ -15,6 +15,7 @@
#ifndef LIBSPIRV_TEST_OPT_PASS_FIXTURE_H_
#define LIBSPIRV_TEST_OPT_PASS_FIXTURE_H_
+#include <iostream>
#include <string>
#include <tuple>
#include <vector>
@@ -39,7 +40,9 @@
class PassTest : public TestT {
public:
PassTest()
- : tools_(SPV_ENV_UNIVERSAL_1_1), manager_(new opt::PassManager()) {}
+ : consumer_(IgnoreMessage),
+ tools_(SPV_ENV_UNIVERSAL_1_1),
+ manager_(new opt::PassManager(consumer_)) {}
// Runs the given |pass| on the binary assembled from the |assembly|, and
// disassebles the optimized binary. Returns a tuple of disassembly string
@@ -70,7 +73,7 @@
template <typename PassT, typename... Args>
std::tuple<std::string, bool> SinglePassRunAndDisassemble(
const std::string& assembly, bool skip_nop, Args&&... args) {
- auto pass = MakeUnique<PassT>(std::forward<Args>(args)...);
+ auto pass = MakeUnique<PassT>(consumer_, std::forward<Args>(args)...);
return OptimizeAndDisassemble(pass.get(), assembly, skip_nop);
}
@@ -98,7 +101,7 @@
}
// Renews the pass manager, including clearing all previously added passes.
- void RenewPassManger() { manager_.reset(new opt::PassManager()); }
+ void RenewPassManger() { manager_.reset(new opt::PassManager(consumer_)); }
// Runs the passes added thus far using a pass manager on the binary assembled
// from the |original| assembly, and checks whether the optimized binary can
@@ -121,6 +124,7 @@
}
private:
+ MessageConsumer consumer_; // Message consumer.
SpvTools tools_; // An instance for calling SPIRV-Tools functionalities.
std::unique_ptr<opt::PassManager> manager_; // The pass manager.
};
diff --git a/test/opt/test_def_use.cpp b/test/opt/test_def_use.cpp
index 2f29c08..412bf64 100644
--- a/test/opt/test_def_use.cpp
+++ b/test/opt/test_def_use.cpp
@@ -132,7 +132,7 @@
ASSERT_NE(nullptr, module);
// Analyze def and use.
- opt::analysis::DefUseManager manager(module.get());
+ opt::analysis::DefUseManager manager(IgnoreMessage, module.get());
CheckDef(tc.du, manager.id_to_defs());
CheckUse(tc.du, manager.id_to_uses());
@@ -513,7 +513,7 @@
ASSERT_NE(nullptr, module);
// Analyze def and use.
- opt::analysis::DefUseManager manager(module.get());
+ opt::analysis::DefUseManager manager(IgnoreMessage, module.get());
// Do the substitution.
for (const auto& candiate : tc.candidates) {
@@ -815,7 +815,7 @@
ASSERT_NE(nullptr, module);
// Analyze def and use.
- opt::analysis::DefUseManager manager(module.get());
+ opt::analysis::DefUseManager manager(IgnoreMessage, module.get());
// Do the substitution.
for (const auto id : tc.ids_to_kill) manager.KillDef(id);
@@ -1065,7 +1065,7 @@
ASSERT_NE(nullptr, module);
// Analyze def and use.
- opt::analysis::DefUseManager manager(module.get());
+ opt::analysis::DefUseManager manager(IgnoreMessage, module.get());
// Do a bunch replacements.
manager.ReplaceAllUsesWith(9, 900); // to unused id
@@ -1188,7 +1188,7 @@
ASSERT_NE(nullptr, module);
// Analyze the instructions.
- opt::analysis::DefUseManager manager(module.get());
+ opt::analysis::DefUseManager manager(IgnoreMessage, module.get());
for (ir::Instruction& inst : tc.insts) {
manager.AnalyzeInstDefUse(&inst);
}
@@ -1312,7 +1312,7 @@
// KillInst
uint32_t index = 0;
- opt::analysis::DefUseManager manager(module.get());
+ opt::analysis::DefUseManager manager(IgnoreMessage, module.get());
module->ForEachInst([&index, &tc, &manager](ir::Instruction* inst) {
if (tc.indices_for_inst_to_kill.count(index) != 0) {
manager.KillInst(inst);
@@ -1419,7 +1419,7 @@
ASSERT_NE(nullptr, module);
// Get annotations
- opt::analysis::DefUseManager manager(module.get());
+ opt::analysis::DefUseManager manager(IgnoreMessage, module.get());
auto insts = manager.GetAnnotations(tc.id);
// Check
diff --git a/test/opt/test_line_debug_info.cpp b/test/opt/test_line_debug_info.cpp
index 81eed2b..3e86ed0 100644
--- a/test/opt/test_line_debug_info.cpp
+++ b/test/opt/test_line_debug_info.cpp
@@ -22,6 +22,8 @@
// A pass turning all none debug line instructions into Nop.
class NopifyPass : public opt::Pass {
public:
+ explicit NopifyPass(const MessageConsumer& c) : opt::Pass(c) {}
+
const char* name() const override { return "NopifyPass"; }
bool Process(ir::Module* module) override {
module->ForEachInst([](ir::Instruction* inst) { inst->ToNop(); },
diff --git a/test/opt/test_pass_manager.cpp b/test/opt/test_pass_manager.cpp
index cf653c2..b365ad2 100644
--- a/test/opt/test_pass_manager.cpp
+++ b/test/opt/test_pass_manager.cpp
@@ -29,23 +29,25 @@
// A null pass whose construtors accept arguments
class NullPassWithArgs : public opt::NullPass {
public:
- NullPassWithArgs(uint32_t) : NullPass() {}
- NullPassWithArgs(std::string) : NullPass() {}
- NullPassWithArgs(const std::vector<int>&) : NullPass() {}
- NullPassWithArgs(const std::vector<int>&, uint32_t) : NullPass() {}
+ NullPassWithArgs(const MessageConsumer& c, uint32_t) : NullPass(c) {}
+ NullPassWithArgs(const MessageConsumer& c, std::string) : NullPass(c) {}
+ NullPassWithArgs(const MessageConsumer& c, const std::vector<int>&)
+ : NullPass(c) {}
+ NullPassWithArgs(const MessageConsumer& c, const std::vector<int>&, uint32_t)
+ : NullPass(c) {}
const char* name() const override { return "null-with-args"; }
};
TEST(PassManager, Interface) {
- opt::PassManager manager;
+ opt::PassManager manager(IgnoreMessage);
EXPECT_EQ(0u, manager.NumPasses());
manager.AddPass<opt::StripDebugInfoPass>();
EXPECT_EQ(1u, manager.NumPasses());
EXPECT_STREQ("strip-debug", manager.GetPass(0)->name());
- manager.AddPass(MakeUnique<opt::NullPass>());
+ manager.AddPass(MakeUnique<opt::NullPass>(IgnoreMessage));
EXPECT_EQ(2u, manager.NumPasses());
EXPECT_STREQ("strip-debug", manager.GetPass(0)->name());
EXPECT_STREQ("null", manager.GetPass(1)->name());
@@ -72,6 +74,9 @@
// A pass that appends an OpNop instruction to the debug section.
class AppendOpNopPass : public opt::Pass {
+ public:
+ explicit AppendOpNopPass(const MessageConsumer& c) : opt::Pass(c) {}
+
const char* name() const override { return "AppendOpNop"; }
bool Process(ir::Module* module) override {
auto inst = MakeUnique<ir::Instruction>();
@@ -84,7 +89,9 @@
// section.
class AppendMultipleOpNopPass : public opt::Pass {
public:
- AppendMultipleOpNopPass(uint32_t num_nop) : num_nop_(num_nop) {}
+ AppendMultipleOpNopPass(const MessageConsumer& c, uint32_t num_nop)
+ : opt::Pass(c), num_nop_(num_nop) {}
+
const char* name() const override { return "AppendOpNop"; }
bool Process(ir::Module* module) override {
for (uint32_t i = 0; i < num_nop_; i++) {
@@ -100,6 +107,9 @@
// A pass that duplicates the last instruction in the debug section.
class DuplicateInstPass : public opt::Pass {
+ public:
+ explicit DuplicateInstPass(const MessageConsumer& c) : opt::Pass(c) {}
+
const char* name() const override { return "DuplicateInst"; }
bool Process(ir::Module* module) override {
auto inst = MakeUnique<ir::Instruction>(*(--module->debug_end()));
@@ -135,7 +145,9 @@
// A pass that appends an OpTypeVoid instruction that uses a given id.
class AppendTypeVoidInstPass : public opt::Pass {
public:
- AppendTypeVoidInstPass(uint32_t result_id) : result_id_(result_id) {}
+ AppendTypeVoidInstPass(const MessageConsumer& c, uint32_t result_id)
+ : opt::Pass(c), result_id_(result_id) {}
+
const char* name() const override { return "AppendTypeVoidInstPass"; }
bool Process(ir::Module* module) override {
auto inst = MakeUnique<ir::Instruction>(SpvOpTypeVoid, 0, result_id_,
@@ -152,14 +164,14 @@
ir::Module module;
EXPECT_THAT(GetIdBound(module), Eq(0u));
- opt::PassManager manager;
+ opt::PassManager manager(IgnoreMessage);
manager.Run(&module);
manager.AddPass<AppendOpNopPass>();
// With no ID changes, the ID bound does not change.
EXPECT_THAT(GetIdBound(module), Eq(0u));
// Now we force an Id of 100 to be used.
- manager.AddPass(MakeUnique<AppendTypeVoidInstPass>(100));
+ manager.AddPass(MakeUnique<AppendTypeVoidInstPass>(IgnoreMessage, 100));
EXPECT_THAT(GetIdBound(module), Eq(0u));
manager.Run(&module);
// The Id has been updated automatically, even though the pass
@@ -167,12 +179,12 @@
EXPECT_THAT(GetIdBound(module), Eq(101u));
// Try one more time!
- manager.AddPass(MakeUnique<AppendTypeVoidInstPass>(200));
+ manager.AddPass(MakeUnique<AppendTypeVoidInstPass>(IgnoreMessage, 200));
manager.Run(&module);
EXPECT_THAT(GetIdBound(module), Eq(201u));
// Add another pass, but which uses a lower Id.
- manager.AddPass(MakeUnique<AppendTypeVoidInstPass>(10));
+ manager.AddPass(MakeUnique<AppendTypeVoidInstPass>(IgnoreMessage, 10));
manager.Run(&module);
// The Id stays high.
EXPECT_THAT(GetIdBound(module), Eq(201u));
diff --git a/test/opt/test_type_manager.cpp b/test/opt/test_type_manager.cpp
index 7120a81..1fb2776 100644
--- a/test/opt/test_type_manager.cpp
+++ b/test/opt/test_type_manager.cpp
@@ -90,7 +90,7 @@
std::unique_ptr<ir::Module> module =
SpvTools(SPV_ENV_UNIVERSAL_1_1).BuildModule(text);
- opt::analysis::TypeManager manager(*module);
+ opt::analysis::TypeManager manager(IgnoreMessage, *module);
EXPECT_EQ(type_id_strs.size(), manager.NumTypes());
EXPECT_EQ(2u, manager.NumForwardPointers());
@@ -120,7 +120,7 @@
)";
std::unique_ptr<ir::Module> module =
SpvTools(SPV_ENV_UNIVERSAL_1_1).BuildModule(text);
- opt::analysis::TypeManager manager(*module);
+ opt::analysis::TypeManager manager(IgnoreMessage, *module);
ASSERT_EQ(7u, manager.NumTypes());
ASSERT_EQ(0u, manager.NumForwardPointers());
@@ -170,7 +170,7 @@
)";
std::unique_ptr<ir::Module> module =
SpvTools(SPV_ENV_UNIVERSAL_1_1).BuildModule(text);
- opt::analysis::TypeManager manager(*module);
+ opt::analysis::TypeManager manager(IgnoreMessage, *module);
ASSERT_EQ(10u, manager.NumTypes());
ASSERT_EQ(0u, manager.NumForwardPointers());
@@ -208,7 +208,7 @@
)";
std::unique_ptr<ir::Module> module =
SpvTools(SPV_ENV_UNIVERSAL_1_1).BuildModule(text);
- opt::analysis::TypeManager manager(*module);
+ opt::analysis::TypeManager manager(IgnoreMessage, *module);
ASSERT_EQ(5u, manager.NumTypes());
ASSERT_EQ(0u, manager.NumForwardPointers());
diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp
index 0e3be79..d5784e1 100644
--- a/tools/opt/opt.cpp
+++ b/tools/opt/opt.cpp
@@ -16,6 +16,7 @@
#include <iostream>
#include <vector>
+#include "message.h"
#include "source/opt/ir_loader.h"
#include "source/opt/libspirv.hpp"
#include "source/opt/pass_manager.h"
@@ -62,7 +63,11 @@
spv_target_env target_env = SPV_ENV_UNIVERSAL_1_1;
- opt::PassManager pass_manager;
+ opt::PassManager pass_manager([](MessageLevel level, const char* source,
+ const spv_position_t& position,
+ const char* message) {
+ std::cerr << StringifyMessage(level, source, position, message);
+ });
for (int argi = 1; argi < argc; ++argi) {
const char* cur_arg = argv[argi];
