const spv_opcode_table opcodeTable_;
const spv_ext_inst_table extInstTable_;
};
-}
+} // namespace libspirv
#endif // LIBSPIRV_ASSEMBLY_GRAMMAR_H_
uint32_t s64_chunk_length_ = 8;
uint32_t s64_block_exponent_ = 10;
- IdFallbackStrategy id_fallback_strategy_ = IdFallbackStrategy::kShortDescriptor;
+ IdFallbackStrategy id_fallback_strategy_ =
+ IdFallbackStrategy::kShortDescriptor;
uint32_t model_type_ = 0;
uint32_t model_version_ = 0;
}
}
- uint32_t descriptor = custom_hash_func_ ?
- custom_hash_func_(words_) : HashU32Array(words_);
- if (descriptor == 0)
- descriptor = 1;
+ uint32_t descriptor =
+ custom_hash_func_ ? custom_hash_func_(words_) : HashU32Array(words_);
+ if (descriptor == 0) descriptor = 1;
assert(descriptor);
words_.clear();
// Both |modules| and |max_id_bound| should not be null, and |modules| should
// not be empty either. Furthermore |modules| should not contain any null
// pointers.
-static spv_result_t ShiftIdsInModules(
- const MessageConsumer& consumer,
- std::vector<ir::Module*>* modules, uint32_t* max_id_bound);
+static spv_result_t ShiftIdsInModules(const MessageConsumer& consumer,
+ std::vector<ir::Module*>* modules,
+ uint32_t* max_id_bound);
// Generates the header for the linked module and returns it in |header|.
//
// TODO(pierremoreau): What to do when binaries use different versions of
// SPIR-V? For now, use the max of all versions found in
// the input modules.
-static spv_result_t GenerateHeader(
- const MessageConsumer& consumer,
- const std::vector<ir::Module*>& modules,
- uint32_t max_id_bound, ir::ModuleHeader* header);
+static spv_result_t GenerateHeader(const MessageConsumer& consumer,
+ const std::vector<ir::Module*>& modules,
+ uint32_t max_id_bound,
+ ir::ModuleHeader* header);
// Merge all the modules from |inModules| into a single module owned by
// |linked_context|.
//
// |linked_context| should not be null.
-static spv_result_t MergeModules(
- const MessageConsumer& consumer,
- const std::vector<Module*>& inModules,
- const libspirv::AssemblyGrammar& grammar,
- IRContext* linked_context);
+static spv_result_t MergeModules(const MessageConsumer& consumer,
+ const std::vector<Module*>& inModules,
+ const libspirv::AssemblyGrammar& grammar,
+ IRContext* linked_context);
// Compute all pairs of import and export and return it in |linkings_to_do|.
//
return SPV_SUCCESS;
}
-static spv_result_t ShiftIdsInModules(
- const MessageConsumer& consumer,
- std::vector<ir::Module*>* modules, uint32_t* max_id_bound) {
+static spv_result_t ShiftIdsInModules(const MessageConsumer& consumer,
+ std::vector<ir::Module*>* modules,
+ uint32_t* max_id_bound) {
spv_position_t position = {};
if (modules == nullptr)
return SPV_SUCCESS;
}
-static spv_result_t GenerateHeader(
- const MessageConsumer& consumer,
- const std::vector<ir::Module*>& modules,
- uint32_t max_id_bound, ir::ModuleHeader* header) {
+static spv_result_t GenerateHeader(const MessageConsumer& consumer,
+ const std::vector<ir::Module*>& modules,
+ uint32_t max_id_bound,
+ ir::ModuleHeader* header) {
spv_position_t position = {};
if (modules.empty())
return SPV_SUCCESS;
}
-static spv_result_t MergeModules(
- const MessageConsumer& consumer,
- const std::vector<Module*>& input_modules,
- const libspirv::AssemblyGrammar& grammar, IRContext* linked_context) {
+static spv_result_t MergeModules(const MessageConsumer& consumer,
+ const std::vector<Module*>& input_modules,
+ const libspirv::AssemblyGrammar& grammar,
+ IRContext* linked_context) {
spv_position_t position = {};
if (linked_context == nullptr)
}
if (memory_model_inst != nullptr)
- linked_module->SetMemoryModel(
- std::unique_ptr<Instruction>(memory_model_inst->Clone(linked_context)));
+ linked_module->SetMemoryModel(std::unique_ptr<Instruction>(
+ memory_model_inst->Clone(linked_context)));
} while (false);
std::vector<std::pair<uint32_t, const char*>> entry_points;
// Remove declarations of imported variables
for (const auto& linking_entry : linkings_to_do) {
for (auto& inst : linked_context->types_values())
- if (inst.result_id() == linking_entry.imported_symbol.id) linked_context->KillInst(&inst);
+ if (inst.result_id() == linking_entry.imported_symbol.id)
+ linked_context->KillInst(&inst);
}
// Remove import linkage attributes
return SPV_SUCCESS;
}
-spv_result_t VerifyIds(const MessageConsumer& consumer, ir::IRContext* linked_context) {
+spv_result_t VerifyIds(const MessageConsumer& consumer,
+ ir::IRContext* linked_context) {
std::unordered_set<uint32_t> ids;
bool ok = true;
- linked_context->module()->ForEachInst([&ids,&ok](const ir::Instruction* inst) {
- ok &= ids.insert(inst->unique_id()).second;
- });
+ linked_context->module()->ForEachInst(
+ [&ids, &ok](const ir::Instruction* inst) {
+ ok &= ids.insert(inst->unique_id()).second;
+ });
if (!ok) {
consumer(SPV_MSG_INTERNAL_ERROR, "", {}, "Non-unique id in merged module");
}
} break;
case SpvOpTypeVector:
- SaveName(result_id,
- std::string("v") + to_string(inst.words[3]) +
- NameForId(inst.words[2]));
+ SaveName(result_id, std::string("v") + to_string(inst.words[3]) +
+ NameForId(inst.words[2]));
break;
case SpvOpTypeMatrix:
- SaveName(result_id,
- std::string("mat") + to_string(inst.words[3]) +
- NameForId(inst.words[2]));
+ SaveName(result_id, std::string("mat") + to_string(inst.words[3]) +
+ NameForId(inst.words[2]));
break;
case SpvOpTypeArray:
- SaveName(result_id,
- std::string("_arr_") + NameForId(inst.words[2]) + "_" +
- NameForId(inst.words[3]));
+ SaveName(result_id, std::string("_arr_") + NameForId(inst.words[2]) +
+ "_" + NameForId(inst.words[3]));
break;
case SpvOpTypeRuntimeArray:
SaveName(result_id,
std::string("_runtimearr_") + NameForId(inst.words[2]));
break;
case SpvOpTypePointer:
- SaveName(result_id,
- std::string("_ptr_") +
- NameForEnumOperand(SPV_OPERAND_TYPE_STORAGE_CLASS,
- inst.words[2]) +
- "_" + NameForId(inst.words[3]));
+ SaveName(result_id, std::string("_ptr_") +
+ NameForEnumOperand(SPV_OPERAND_TYPE_STORAGE_CLASS,
+ inst.words[2]) +
+ "_" + NameForId(inst.words[3]));
break;
case SpvOpTypePipe:
SaveName(result_id,
} // namespace
BasicBlock* BasicBlock::Clone(IRContext* context) const {
- BasicBlock* clone =
- new BasicBlock(std::unique_ptr<Instruction>(GetLabelInst().Clone(context)));
+ BasicBlock* clone = new BasicBlock(
+ std::unique_ptr<Instruction>(GetLabelInst().Clone(context)));
for (const auto& inst : insts_)
// Use the incoming context
clone->AddInstruction(std::unique_ptr<Instruction>(inst.Clone(context)));
bool BlockMergePass::HasMultipleRefs(uint32_t labId) {
int rcnt = 0;
- get_def_use_mgr()->ForEachUser(
- labId, [&rcnt](ir::Instruction* user) {
- if (user->opcode() != SpvOpName) {
- ++rcnt;
- }
- });
+ get_def_use_mgr()->ForEachUser(labId, [&rcnt](ir::Instruction* user) {
+ if (user->opcode() != SpvOpName) {
+ ++rcnt;
+ }
+ });
return rcnt > 1;
}
to_kill.push_back(user);
}
});
- for (auto i: to_kill) {
+ for (auto i : to_kill) {
context()->KillInst(i);
}
context()->KillInst(inst);
#include "build_module.h"
-#include"ir_context.h"
+#include "ir_context.h"
#include "ir_loader.h"
#include "make_unique.h"
#include "table.h"
return SPV_ERROR_INVALID_BINARY;
};
-} // annoymous namespace
+} // namespace
std::unique_ptr<ir::IRContext> BuildModule(spv_target_env env,
- MessageConsumer consumer,
- const uint32_t* binary,
- const size_t size) {
+ MessageConsumer consumer,
+ const uint32_t* binary,
+ const size_t size) {
auto context = spvContextCreate(env);
libspirv::SetContextMessageConsumer(context, consumer);
// decoded according to the given target |env|. Returns nullptr if errors occur
// and sends the errors to |consumer|.
std::unique_ptr<ir::IRContext> BuildModule(spv_target_env env,
- MessageConsumer consumer,
- const uint32_t* binary, size_t size);
+ MessageConsumer consumer,
+ const uint32_t* binary, size_t size);
// Builds an ir::Module and returns the owning ir::IRContext from the given
// SPIR-V assembly |text|. The |text| will be encoded according to the given
: module_(module),
pseudo_entry_block_(std::unique_ptr<ir::Instruction>(
new ir::Instruction(module->context(), SpvOpLabel, 0, 0, {}))),
- pseudo_exit_block_(std::unique_ptr<ir::Instruction>(
- new ir::Instruction(module->context(), SpvOpLabel, 0, kInvalidId, {}))) {
+ pseudo_exit_block_(std::unique_ptr<ir::Instruction>(new ir::Instruction(
+ module->context(), SpvOpLabel, 0, kInvalidId, {}))) {
for (auto& fn : *module) {
for (auto& blk : fn) {
uint32_t blkId = blk.id();
}
}
-} // namespace opt
+} // namespace ir
} // namespace spvtools
std::unordered_map<uint32_t, ir::BasicBlock*> id2block_;
};
-} // namespace opt
+} // namespace ir
} // namespace spvtools
#endif // LIBSPIRV_OPT_CFG_H_
namespace spvtools {
namespace opt {
-void CFGCleanupPass::Initialize(ir::IRContext* c) {
- InitializeProcessing(c);
-}
+void CFGCleanupPass::Initialize(ir::IRContext* c) { InitializeProcessing(c); }
Pass::Status CFGCleanupPass::Process(ir::IRContext* c) {
Initialize(c);
bool CommonUniformElimPass::IsVolatileStruct(uint32_t type_id) {
assert(get_def_use_mgr()->GetDef(type_id)->opcode() == SpvOpTypeStruct);
bool has_volatile_deco = false;
- get_decoration_mgr()->ForEachDecoration(type_id, SpvDecorationVolatile,
- [&has_volatile_deco](const ir::Instruction&) {
- has_volatile_deco = true;
- });
+ get_decoration_mgr()->ForEachDecoration(
+ type_id, SpvDecorationVolatile,
+ [&has_volatile_deco](const ir::Instruction&) {
+ has_volatile_deco = true;
+ });
return has_volatile_deco;
}
}
++iidIdx;
});
- std::unique_ptr<ir::Instruction> newExt(new ir::Instruction(
- context(), SpvOpCompositeExtract, ptrPteTypeId, extResultId, ext_in_opnds));
+ std::unique_ptr<ir::Instruction> newExt(
+ new ir::Instruction(context(), SpvOpCompositeExtract, ptrPteTypeId,
+ extResultId, ext_in_opnds));
get_def_use_mgr()->AnalyzeInstDefUse(&*newExt);
newInsts->emplace_back(std::move(newExt));
*resultId = extResultId;
extensions_whitelist_.clear();
extensions_whitelist_.insert({
"SPV_AMD_shader_explicit_vertex_parameter",
- "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
- "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
- "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
- "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
- "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
- "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
+ "SPV_AMD_shader_trinary_minmax",
+ "SPV_AMD_gcn_shader",
+ "SPV_KHR_shader_ballot",
+ "SPV_AMD_shader_ballot",
+ "SPV_AMD_gpu_shader_half_float",
+ "SPV_KHR_shader_draw_parameters",
+ "SPV_KHR_subgroup_vote",
+ "SPV_KHR_16bit_storage",
+ "SPV_KHR_device_group",
+ "SPV_KHR_multiview",
+ "SPV_NVX_multiview_per_view_attributes",
+ "SPV_NV_viewport_array2",
+ "SPV_NV_stereo_view_rendering",
"SPV_NV_sample_mask_override_coverage",
- "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+ "SPV_NV_geometry_shader_passthrough",
+ "SPV_AMD_texture_gather_bias_lod",
"SPV_KHR_storage_buffer_storage_class",
// SPV_KHR_variable_pointers
// Currently do not support extended pointer expressions
- "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+ "SPV_AMD_gpu_shader_int16",
+ "SPV_KHR_post_depth_coverage",
"SPV_KHR_shader_atomic_counter_ops",
});
}
#include "dead_branch_elim_pass.h"
#include "cfa.h"
-#include "iterator.h"
#include "ir_context.h"
+#include "iterator.h"
namespace spvtools {
namespace opt {
#include "dead_variable_elimination.h"
-#include "reflect.h"
#include "ir_context.h"
+#include "reflect.h"
namespace spvtools {
namespace opt {
case SpvOpMemberDecorate:
case SpvOpDecorateId: {
// simply clone decoration and change |target-id| to |to|
- std::unique_ptr<ir::Instruction> new_inst(inst->Clone(module_->context()));
+ std::unique_ptr<ir::Instruction> new_inst(
+ inst->Clone(module_->context()));
new_inst->SetInOperand(0, {to});
id_to_decoration_insts_[to].push_back(new_inst.get());
module_->AddAnnotationInst(std::move(new_inst));
// Function |f| can be used to update context information and is called
// with |false|, before an instruction is going to be changed and
// with |true| afterwards.
- void CloneDecorations(uint32_t from, uint32_t to, std::function<void(ir::Instruction&, bool)> f);
+ void CloneDecorations(uint32_t from, uint32_t to,
+ std::function<void(ir::Instruction&, bool)> f);
// Informs the decoration manager of a new decoration that it needs to track.
void AddDecoration(ir::Instruction* inst);
return UsersNotEnd(iter, id_to_users_.end(), inst);
}
-void DefUseManager::ForEachUser(const ir::Instruction* def,
- const std::function<void(ir::Instruction*)>& f) const {
+void DefUseManager::ForEachUser(
+ const ir::Instruction* def,
+ const std::function<void(ir::Instruction*)>& f) const {
// Ensure that |def| has been registered.
- assert(def && def == GetDef(def->result_id()) && "Definition is not registered.");
+ assert(def && def == GetDef(def->result_id()) &&
+ "Definition is not registered.");
auto end = id_to_users_.end();
for (auto iter = UsersBegin(def); UsersNotEnd(iter, end, def); ++iter) {
f(iter->second);
}
}
-void DefUseManager::ForEachUser(uint32_t id,
- const std::function<void(ir::Instruction*)>& f) const {
+void DefUseManager::ForEachUser(
+ uint32_t id, const std::function<void(ir::Instruction*)>& f) const {
ForEachUser(GetDef(id), f);
}
-void DefUseManager::ForEachUse(const ir::Instruction* def,
- const std::function<void(ir::Instruction*, uint32_t)>& f) const {
+void DefUseManager::ForEachUse(
+ const ir::Instruction* def,
+ const std::function<void(ir::Instruction*, uint32_t)>& f) const {
// Ensure that |def| has been registered.
- assert(def && def == GetDef(def->result_id()) && "Definition is not registered.");
+ assert(def && def == GetDef(def->result_id()) &&
+ "Definition is not registered.");
auto end = id_to_users_.end();
for (auto iter = UsersBegin(def); UsersNotEnd(iter, end, def); ++iter) {
ir::Instruction* user = iter->second;
for (uint32_t idx = 0; idx != user->NumOperands(); ++idx) {
const ir::Operand& op = user->GetOperand(idx);
if (op.type != SPV_OPERAND_TYPE_RESULT_ID && spvIsIdType(op.type)) {
- if (def->result_id() == op.words[0])
- f(user, idx);
+ if (def->result_id() == op.words[0]) f(user, idx);
}
}
}
}
-void DefUseManager::ForEachUse(uint32_t id,
- const std::function<void(ir::Instruction*, uint32_t)>& f) const {
+void DefUseManager::ForEachUse(
+ uint32_t id,
+ const std::function<void(ir::Instruction*, uint32_t)>& f) const {
ForEachUse(GetDef(id), f);
}
void DefUseManager::AnalyzeDefUse(ir::Module* module) {
if (!module) return;
// Analyze all the defs before any uses to catch forward references.
- module->ForEachInst(std::bind(&DefUseManager::AnalyzeInstDef, this,
- std::placeholders::_1));
- module->ForEachInst(std::bind(&DefUseManager::AnalyzeInstUse, this,
- std::placeholders::_1));
+ module->ForEachInst(
+ std::bind(&DefUseManager::AnalyzeInstDef, this, std::placeholders::_1));
+ module->ForEachInst(
+ std::bind(&DefUseManager::AnalyzeInstUse, this, std::placeholders::_1));
}
void DefUseManager::ClearInst(ir::Instruction* inst) {
auto users_begin = UsersBegin(inst);
auto end = id_to_users_.end();
auto new_end = users_begin;
- for (; UsersNotEnd(new_end, end, inst); ++new_end) {}
+ for (; UsersNotEnd(new_end, end, inst); ++new_end) {
+ }
id_to_users_.erase(users_begin, new_end);
id_to_def_.erase(inst->result_id());
}
auto iter = inst_to_used_ids_.find(inst);
if (iter != inst_to_used_ids_.end()) {
for (auto use_id : iter->second) {
- id_to_users_.erase(UserEntry(GetDef(use_id), const_cast<ir::Instruction*>(inst)));
+ id_to_users_.erase(
+ UserEntry(GetDef(use_id), const_cast<ir::Instruction*>(inst)));
}
inst_to_used_ids_.erase(inst);
}
return lhs.inst == rhs.inst && lhs.operand_index == rhs.operand_index;
}
-inline bool operator!=(const Use& lhs, const Use& rhs) {
- return !(lhs == rhs);
-}
+inline bool operator!=(const Use& lhs, const Use& rhs) { return !(lhs == rhs); }
inline bool operator<(const Use& lhs, const Use& rhs) {
- if (lhs.inst < rhs.inst)
- return true;
- if (lhs.inst > rhs.inst)
- return false;
+ if (lhs.inst < rhs.inst) return true;
+ if (lhs.inst > rhs.inst) return false;
return lhs.operand_index < rhs.operand_index;
}
bool operator()(const UserEntry& lhs, const UserEntry& rhs) const {
// If lhs.first and rhs.first are both null, fall through to checking the
// second entries.
- if (!lhs.first && rhs.first)
- return true;
- if (lhs.first && !rhs.first)
- return false;
+ if (!lhs.first && rhs.first) return true;
+ if (lhs.first && !rhs.first) return false;
// If neither defintion is null, then compare unique ids.
if (lhs.first && rhs.first) {
- if (lhs.first->unique_id() < rhs.first->unique_id())
- return true;
- if (rhs.first->unique_id() < lhs.first->unique_id())
- return false;
+ if (lhs.first->unique_id() < rhs.first->unique_id()) return true;
+ if (rhs.first->unique_id() < lhs.first->unique_id()) return false;
}
// Return false on equality.
- if (!lhs.second && !rhs.second)
- return false;
- if (!lhs.second)
- return true;
- if (!rhs.second)
- return false;
+ if (!lhs.second && !rhs.second) return false;
+ if (!lhs.second) return true;
+ if (!rhs.second) return false;
// If neither user is null then compare unique ids.
return lhs.second->unique_id() < rhs.second->unique_id();
// visited separately.
//
// |def| (or |id|) must be registered as a definition.
- void ForEachUse(
- const ir::Instruction* def,
- const std::function<void(ir::Instruction*, uint32_t operand_index)>& f) const;
- void ForEachUse(
- uint32_t id,
- const std::function<void(ir::Instruction*, uint32_t operand_index)>& f) const;
+ void ForEachUse(const ir::Instruction* def,
+ const std::function<void(ir::Instruction*,
+ uint32_t operand_index)>& f) const;
+ void ForEachUse(uint32_t id,
+ const std::function<void(ir::Instruction*,
+ uint32_t operand_index)>& f) const;
// Returns the annotation instrunctions which are a direct use of the given
// |id|. This means when the decorations are applied through decoration
// Erases the records that a given instruction uses its operand ids.
void EraseUseRecordsOfOperandIds(const ir::Instruction* inst);
- friend bool operator==(const DefUseManager&, const DefUseManager&);
- friend bool operator!=(const DefUseManager& lhs, const DefUseManager& rhs) {
+ friend bool operator==(const DefUseManager&, const DefUseManager&);
+ friend bool operator!=(const DefUseManager& lhs, const DefUseManager& rhs) {
return !(lhs == rhs);
}
// structures in this class. Does nothing if |module| is nullptr.
void AnalyzeDefUse(ir::Module* module);
- IdToDefMap id_to_def_; // Mapping from ids to their definitions
- IdToUsersMap id_to_users_; // Mapping from ids to their users
+ IdToDefMap id_to_def_; // Mapping from ids to their definitions
+ IdToUsersMap id_to_users_; // Mapping from ids to their users
// Mapping from instructions to the ids used in the instruction.
InstToUsedIdsMap inst_to_used_ids_;
-
};
} // namespace analysis
// constants.
std::unordered_set<ir::Instruction*> dead_others;
for (auto* dc : dead_consts) {
- irContext->get_def_use_mgr()->ForEachUser(dc, [&dead_others](ir::Instruction* user) {
- SpvOp op = user->opcode();
- if (ir::IsAnnotationInst(op) ||
- ir::IsDebug1Inst(op) ||
- ir::IsDebug2Inst(op) ||
- ir::IsDebug3Inst(op)) {
- dead_others.insert(user);
- }
- });
+ irContext->get_def_use_mgr()->ForEachUser(
+ dc, [&dead_others](ir::Instruction* user) {
+ SpvOp op = user->opcode();
+ if (ir::IsAnnotationInst(op) || ir::IsDebug1Inst(op) ||
+ ir::IsDebug2Inst(op) || ir::IsDebug3Inst(op)) {
+ dead_others.insert(user);
+ }
+ });
}
// Turn all dead instructions and uses of them to nop
void EliminateDeadFunctionsPass::EliminateFunction(ir::Function* func) {
// Remove all of the instruction in the function body
func->ForEachInst(
- [this](ir::Instruction* inst) {
- context()->KillInst(inst);
- },
- true);
+ [this](ir::Instruction* inst) { context()->KillInst(inst); }, true);
}
} // namespace opt
} // namespace spvtools
}
return false;
}
-}
+} // namespace
ir::Instruction* FoldSpecConstantOpAndCompositePass::DoComponentWiseOperation(
ir::Module::inst_iterator* pos) {
operands.emplace_back(spv_operand_type_t::SPV_OPERAND_TYPE_ID,
std::initializer_list<uint32_t>{id});
}
- return MakeUnique<ir::Instruction>(context(),
- SpvOp::SpvOpConstantComposite,
+ return MakeUnique<ir::Instruction>(context(), SpvOp::SpvOpConstantComposite,
type_mgr_->GetId(cc->type()), result_id,
std::move(operands));
}
new Function(std::unique_ptr<Instruction>(DefInst().Clone(context)));
clone->params_.reserve(params_.size());
ForEachParam(
- [clone,context](const Instruction* inst) {
+ [clone, context](const Instruction* inst) {
clone->AddParameter(std::unique_ptr<Instruction>(inst->Clone(context)));
},
true);
clone->AddBasicBlock(std::move(bb));
}
- clone->SetFunctionEnd(std::unique_ptr<Instruction>(function_end().Clone(context)));
+ clone->SetFunctionEnd(
+ std::unique_ptr<Instruction>(function_end().Clone(context)));
return clone;
}
std::unique_ptr<ir::Instruction> var_inst(
callee_var_itr->Clone(callee_var_itr->context()));
uint32_t newId = TakeNextId();
- get_decoration_mgr()->CloneDecorations(callee_var_itr->result_id(), newId, update_def_use_mgr_);
+ get_decoration_mgr()->CloneDecorations(callee_var_itr->result_id(), newId,
+ update_def_use_mgr_);
var_inst->SetResultId(newId);
(*callee2caller)[callee_var_itr->result_id()] = newId;
new_vars->push_back(std::move(var_inst));
{SpvStorageClassFunction}}}));
new_vars->push_back(std::move(var_inst));
}
- get_decoration_mgr()->CloneDecorations(calleeFn->result_id(), returnVarId, update_def_use_mgr_);
+ get_decoration_mgr()->CloneDecorations(calleeFn->result_id(), returnVarId,
+ update_def_use_mgr_);
return returnVarId;
}
std::unordered_map<uint32_t, uint32_t>* postCallSB,
std::unordered_map<uint32_t, ir::Instruction*>* preCallSB,
std::unique_ptr<ir::BasicBlock>* block_ptr) {
- (*inst)->ForEachInId(
- [&postCallSB, &preCallSB, &block_ptr, this](uint32_t* iid) {
- const auto mapItr = (*postCallSB).find(*iid);
- if (mapItr == (*postCallSB).end()) {
- const auto mapItr2 = (*preCallSB).find(*iid);
- if (mapItr2 != (*preCallSB).end()) {
- // Clone pre-call same-block ops, map result id.
- const ir::Instruction* inInst = mapItr2->second;
- std::unique_ptr<ir::Instruction> sb_inst(
- inInst->Clone(inInst->context()));
- CloneSameBlockOps(&sb_inst, postCallSB, preCallSB, block_ptr);
- const uint32_t rid = sb_inst->result_id();
- const uint32_t nid = this->TakeNextId();
- get_decoration_mgr()->CloneDecorations(rid, nid, update_def_use_mgr_);
- sb_inst->SetResultId(nid);
- (*postCallSB)[rid] = nid;
- *iid = nid;
- (*block_ptr)->AddInstruction(std::move(sb_inst));
- }
- } else {
- // Reset same-block op operand.
- *iid = mapItr->second;
- }
- });
+ (*inst)->ForEachInId([&postCallSB, &preCallSB, &block_ptr,
+ this](uint32_t* iid) {
+ const auto mapItr = (*postCallSB).find(*iid);
+ if (mapItr == (*postCallSB).end()) {
+ const auto mapItr2 = (*preCallSB).find(*iid);
+ if (mapItr2 != (*preCallSB).end()) {
+ // Clone pre-call same-block ops, map result id.
+ const ir::Instruction* inInst = mapItr2->second;
+ std::unique_ptr<ir::Instruction> sb_inst(
+ inInst->Clone(inInst->context()));
+ CloneSameBlockOps(&sb_inst, postCallSB, preCallSB, block_ptr);
+ const uint32_t rid = sb_inst->result_id();
+ const uint32_t nid = this->TakeNextId();
+ get_decoration_mgr()->CloneDecorations(rid, nid, update_def_use_mgr_);
+ sb_inst->SetResultId(nid);
+ (*postCallSB)[rid] = nid;
+ *iid = nid;
+ (*block_ptr)->AddInstruction(std::move(sb_inst));
+ }
+ } else {
+ // Reset same-block op operand.
+ *iid = mapItr->second;
+ }
+ });
}
void InlinePass::GenInlineCode(
InitializeProcessing(c);
// Don't bother updating the DefUseManger
- update_def_use_mgr_ = [this] (ir::Instruction&, bool) {};
+ update_def_use_mgr_ = [this](ir::Instruction&, bool) {};
false_id_ = 0;
#include <unordered_map>
#include <vector>
-#include "def_use_manager.h"
#include "decoration_manager.h"
+#include "def_use_manager.h"
#include "module.h"
#include "pass.h"
return true;
}
-bool InsertExtractElimPass::ExtInsConflict(
- const ir::Instruction* extInst, const ir::Instruction* insInst,
- const uint32_t extOffset) const {
+bool InsertExtractElimPass::ExtInsConflict(const ir::Instruction* extInst,
+ const ir::Instruction* insInst,
+ const uint32_t extOffset) const {
if (extInst->NumInOperands() - extOffset == insInst->NumInOperands() - 1)
return false;
uint32_t extNumIdx = extInst->NumInOperands() - 1 - extOffset;
// Match! Use inserted value as replacement
replId = cinst->GetSingleWordInOperand(kInsertObjectIdInIdx);
break;
- }
- else if (ExtInsConflict(&*ii, cinst, extOffset)) {
+ } else if (ExtInsConflict(&*ii, cinst, extOffset)) {
// If extract has fewer indices than the insert, stop searching.
// Otherwise increment offset of extract indices considered and
// continue searching through the inserted value
if (ii->NumInOperands() - extOffset <
cinst->NumInOperands() - 1) {
break;
- }
- else {
+ } else {
extOffset += cinst->NumInOperands() - 2;
cid = cinst->GetSingleWordInOperand(kInsertObjectIdInIdx);
}
- }
- else {
+ } else {
// Consider next composite in insert chain
cid = cinst->GetSingleWordInOperand(kInsertCompositeIdInIdx);
}
private:
// Return true if indices of extract |extInst| starting at |extOffset|
- // match indices of insert |insInst|.
+ // match indices of insert |insInst|.
bool ExtInsMatch(const ir::Instruction* extInst,
const ir::Instruction* insInst,
const uint32_t extOffset) const;
// It is the responsibility of the caller to make sure that the storage is
// removed. It is the caller's responsibility to make sure that there is only
// one instruction for each result id.
- Instruction* Clone(IRContext *c) const;
+ Instruction* Clone(IRContext* c) const;
IRContext* context() const { return context_; }
if (before == after) return false;
// Ensure that |after| has been registered as def.
- assert(get_def_use_mgr()->GetDef(after) && "'after' is not a registered def.");
+ assert(get_def_use_mgr()->GetDef(after) &&
+ "'after' is not a registered def.");
- std::vector<std::pair<ir::Instruction*,uint32_t>> uses_to_update;
- get_def_use_mgr()->ForEachUse(before, [&uses_to_update](ir::Instruction* user, uint32_t index) {
- uses_to_update.emplace_back(user, index);
- });
+ std::vector<std::pair<ir::Instruction*, uint32_t>> uses_to_update;
+ get_def_use_mgr()->ForEachUse(
+ before, [&uses_to_update](ir::Instruction* user, uint32_t index) {
+ uses_to_update.emplace_back(user, index);
+ });
ir::Instruction* prev = nullptr;
for (auto p : uses_to_update) {
}
void IRContext::InitializeCombinators() {
- for( auto& capability : module()->capabilities()) {
+ for (auto& capability : module()->capabilities()) {
AddCombinatorsForCapability(capability.GetSingleWordInOperand(0));
}
- for( auto& extension : module()->ext_inst_imports()) {
+ for (auto& extension : module()->ext_inst_imports()) {
AddCombinatorsForExtension(&extension);
}
// Opcodes of shader capability core executable instructions
// without side-effect.
- std::unordered_map<uint32_t, std::unordered_set<uint32_t>> combinator_ops_;
+ std::unordered_map<uint32_t, std::unordered_set<uint32_t>> combinator_ops_;
};
inline ir::IRContext::Analysis operator|(ir::IRContext::Analysis lhs,
#include "local_access_chain_convert_pass.h"
-#include "iterator.h"
#include "ir_context.h"
+#include "iterator.h"
namespace spvtools {
namespace opt {
bool LocalAccessChainConvertPass::HasOnlySupportedRefs(uint32_t ptrId) {
if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end()) return true;
bool hasOnlySupportedRefs = true;
- get_def_use_mgr()->ForEachUser(ptrId, [this,&hasOnlySupportedRefs](ir::Instruction* user) {
- SpvOp op = user->opcode();
- if (IsNonPtrAccessChain(op) || op == SpvOpCopyObject) {
- if (!HasOnlySupportedRefs(user->result_id())) {
- hasOnlySupportedRefs = false;
- }
- } else if (op != SpvOpStore && op != SpvOpLoad && op != SpvOpName &&
- !IsNonTypeDecorate(op)) {
- hasOnlySupportedRefs = false;
- }
- });
+ get_def_use_mgr()->ForEachUser(
+ ptrId, [this, &hasOnlySupportedRefs](ir::Instruction* user) {
+ SpvOp op = user->opcode();
+ if (IsNonPtrAccessChain(op) || op == SpvOpCopyObject) {
+ if (!HasOnlySupportedRefs(user->result_id())) {
+ hasOnlySupportedRefs = false;
+ }
+ } else if (op != SpvOpStore && op != SpvOpLoad && op != SpvOpName &&
+ !IsNonTypeDecorate(op)) {
+ hasOnlySupportedRefs = false;
+ }
+ });
if (hasOnlySupportedRefs) {
supported_ref_ptrs_.insert(ptrId);
}
}
// Rule out variables with nested access chains
// TODO(): Convert nested access chains
- if (IsNonPtrAccessChain(op) &&
- ptrInst->GetSingleWordInOperand(kAccessChainPtrIdInIdx) !=
- varId) {
+ if (IsNonPtrAccessChain(op) && ptrInst->GetSingleWordInOperand(
+ kAccessChainPtrIdInIdx) != varId) {
seen_non_target_vars_.insert(varId);
seen_target_vars_.erase(varId);
break;
extensions_whitelist_.clear();
extensions_whitelist_.insert({
"SPV_AMD_shader_explicit_vertex_parameter",
- "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
- "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
- "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
- "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
- "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
- "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
+ "SPV_AMD_shader_trinary_minmax",
+ "SPV_AMD_gcn_shader",
+ "SPV_KHR_shader_ballot",
+ "SPV_AMD_shader_ballot",
+ "SPV_AMD_gpu_shader_half_float",
+ "SPV_KHR_shader_draw_parameters",
+ "SPV_KHR_subgroup_vote",
+ "SPV_KHR_16bit_storage",
+ "SPV_KHR_device_group",
+ "SPV_KHR_multiview",
+ "SPV_NVX_multiview_per_view_attributes",
+ "SPV_NV_viewport_array2",
+ "SPV_NV_stereo_view_rendering",
"SPV_NV_sample_mask_override_coverage",
- "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+ "SPV_NV_geometry_shader_passthrough",
+ "SPV_AMD_texture_gather_bias_lod",
"SPV_KHR_storage_buffer_storage_class",
// SPV_KHR_variable_pointers
// Currently do not support extended pointer expressions
- "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+ "SPV_AMD_gpu_shader_int16",
+ "SPV_KHR_post_depth_coverage",
"SPV_KHR_shader_atomic_counter_ops",
});
}
bool LocalSingleBlockLoadStoreElimPass::HasOnlySupportedRefs(uint32_t ptrId) {
if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end()) return true;
bool hasOnlySupportedRefs = true;
- get_def_use_mgr()->ForEachUser(ptrId, [this,&hasOnlySupportedRefs](ir::Instruction* user) {
- SpvOp op = user->opcode();
- if (IsNonPtrAccessChain(op) || op == SpvOpCopyObject) {
- if (!HasOnlySupportedRefs(user->result_id())) {
- hasOnlySupportedRefs = false;
- }
- } else if (op != SpvOpStore && op != SpvOpLoad && op != SpvOpName &&
- !this->IsNonTypeDecorate(op)) {
- hasOnlySupportedRefs = false;
- }
- });
+ get_def_use_mgr()->ForEachUser(
+ ptrId, [this, &hasOnlySupportedRefs](ir::Instruction* user) {
+ SpvOp op = user->opcode();
+ if (IsNonPtrAccessChain(op) || op == SpvOpCopyObject) {
+ if (!HasOnlySupportedRefs(user->result_id())) {
+ hasOnlySupportedRefs = false;
+ }
+ } else if (op != SpvOpStore && op != SpvOpLoad && op != SpvOpName &&
+ !this->IsNonTypeDecorate(op)) {
+ hasOnlySupportedRefs = false;
+ }
+ });
if (hasOnlySupportedRefs) {
supported_ref_ptrs_.insert(ptrId);
}
extensions_whitelist_.clear();
extensions_whitelist_.insert({
"SPV_AMD_shader_explicit_vertex_parameter",
- "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
- "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
- "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
- "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
- "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
- "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
+ "SPV_AMD_shader_trinary_minmax",
+ "SPV_AMD_gcn_shader",
+ "SPV_KHR_shader_ballot",
+ "SPV_AMD_shader_ballot",
+ "SPV_AMD_gpu_shader_half_float",
+ "SPV_KHR_shader_draw_parameters",
+ "SPV_KHR_subgroup_vote",
+ "SPV_KHR_16bit_storage",
+ "SPV_KHR_device_group",
+ "SPV_KHR_multiview",
+ "SPV_NVX_multiview_per_view_attributes",
+ "SPV_NV_viewport_array2",
+ "SPV_NV_stereo_view_rendering",
"SPV_NV_sample_mask_override_coverage",
- "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+ "SPV_NV_geometry_shader_passthrough",
+ "SPV_AMD_texture_gather_bias_lod",
"SPV_KHR_storage_buffer_storage_class",
// SPV_KHR_variable_pointers
// Currently do not support extended pointer expressions
- "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+ "SPV_AMD_gpu_shader_int16",
+ "SPV_KHR_post_depth_coverage",
"SPV_KHR_shader_atomic_counter_ops",
});
}
ir::IRContext::Analysis GetPreservedAnalyses() override {
return ir::IRContext::kAnalysisDefUse;
}
-
+
private:
// Return true if all uses of |varId| are only through supported reference
// operations ie. loads and store. Also cache in supported_ref_ptrs_.
bool LocalSingleStoreElimPass::HasOnlySupportedRefs(uint32_t ptrId) {
if (supported_ref_ptrs_.find(ptrId) != supported_ref_ptrs_.end()) return true;
bool hasOnlySupportedRefs = true;
- get_def_use_mgr()->ForEachUser(ptrId, [this,&hasOnlySupportedRefs](ir::Instruction* user) {
- SpvOp op = user->opcode();
- if (IsNonPtrAccessChain(op) || op == SpvOpCopyObject) {
- if (!HasOnlySupportedRefs(user->result_id())) {
- hasOnlySupportedRefs = false;
- }
- } else if (op != SpvOpStore && op != SpvOpLoad && op != SpvOpName &&
- !IsNonTypeDecorate(op)) {
- hasOnlySupportedRefs = false;
- }
- });
+ get_def_use_mgr()->ForEachUser(
+ ptrId, [this, &hasOnlySupportedRefs](ir::Instruction* user) {
+ SpvOp op = user->opcode();
+ if (IsNonPtrAccessChain(op) || op == SpvOpCopyObject) {
+ if (!HasOnlySupportedRefs(user->result_id())) {
+ hasOnlySupportedRefs = false;
+ }
+ } else if (op != SpvOpStore && op != SpvOpLoad && op != SpvOpName &&
+ !IsNonTypeDecorate(op)) {
+ hasOnlySupportedRefs = false;
+ }
+ });
if (hasOnlySupportedRefs) {
supported_ref_ptrs_.insert(ptrId);
}
extensions_whitelist_.clear();
extensions_whitelist_.insert({
"SPV_AMD_shader_explicit_vertex_parameter",
- "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
- "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
- "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
- "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
- "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
- "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
+ "SPV_AMD_shader_trinary_minmax",
+ "SPV_AMD_gcn_shader",
+ "SPV_KHR_shader_ballot",
+ "SPV_AMD_shader_ballot",
+ "SPV_AMD_gpu_shader_half_float",
+ "SPV_KHR_shader_draw_parameters",
+ "SPV_KHR_subgroup_vote",
+ "SPV_KHR_16bit_storage",
+ "SPV_KHR_device_group",
+ "SPV_KHR_multiview",
+ "SPV_NVX_multiview_per_view_attributes",
+ "SPV_NV_viewport_array2",
+ "SPV_NV_stereo_view_rendering",
"SPV_NV_sample_mask_override_coverage",
- "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+ "SPV_NV_geometry_shader_passthrough",
+ "SPV_AMD_texture_gather_bias_lod",
"SPV_KHR_storage_buffer_storage_class",
// SPV_KHR_variable_pointers
// Currently do not support extended pointer expressions
- "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+ "SPV_AMD_gpu_shader_int16",
+ "SPV_KHR_post_depth_coverage",
"SPV_KHR_shader_atomic_counter_ops",
});
}
LocalSingleStoreElimPass();
const char* name() const override { return "eliminate-local-single-store"; }
Status Process(ir::IRContext* irContext) override;
-
+
ir::IRContext::Analysis GetPreservedAnalyses() override {
return ir::IRContext::kAnalysisDefUse;
}
extensions_whitelist_.clear();
extensions_whitelist_.insert({
"SPV_AMD_shader_explicit_vertex_parameter",
- "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
- "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
- "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
- "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage", "SPV_KHR_device_group",
- "SPV_KHR_multiview", "SPV_NVX_multiview_per_view_attributes",
- "SPV_NV_viewport_array2", "SPV_NV_stereo_view_rendering",
+ "SPV_AMD_shader_trinary_minmax",
+ "SPV_AMD_gcn_shader",
+ "SPV_KHR_shader_ballot",
+ "SPV_AMD_shader_ballot",
+ "SPV_AMD_gpu_shader_half_float",
+ "SPV_KHR_shader_draw_parameters",
+ "SPV_KHR_subgroup_vote",
+ "SPV_KHR_16bit_storage",
+ "SPV_KHR_device_group",
+ "SPV_KHR_multiview",
+ "SPV_NVX_multiview_per_view_attributes",
+ "SPV_NV_viewport_array2",
+ "SPV_NV_stereo_view_rendering",
"SPV_NV_sample_mask_override_coverage",
- "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+ "SPV_NV_geometry_shader_passthrough",
+ "SPV_AMD_texture_gather_bias_lod",
"SPV_KHR_storage_buffer_storage_class",
// SPV_KHR_variable_pointers
// Currently do not support extended pointer expressions
- "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+ "SPV_AMD_gpu_shader_int16",
+ "SPV_KHR_post_depth_coverage",
"SPV_KHR_shader_atomic_counter_ops",
});
}
#include "basic_block.h"
#include "cfa.h"
-#include "iterator.h"
#include "ir_context.h"
+#include "iterator.h"
namespace spvtools {
namespace opt {
bool MemPass::HasOnlyNamesAndDecorates(uint32_t id) const {
bool hasOnlyNamesAndDecorates = true;
- get_def_use_mgr()->ForEachUser(id, [this, &hasOnlyNamesAndDecorates](ir::Instruction* user) {
- SpvOp op = user->opcode();
- if (op != SpvOpName && !IsNonTypeDecorate(op)) {
- hasOnlyNamesAndDecorates = false;
- }
- });
+ get_def_use_mgr()->ForEachUser(
+ id, [this, &hasOnlyNamesAndDecorates](ir::Instruction* user) {
+ SpvOp op = user->opcode();
+ if (op != SpvOpName && !IsNonTypeDecorate(op)) {
+ hasOnlyNamesAndDecorates = false;
+ }
+ });
return hasOnlyNamesAndDecorates;
}
void MemPass::KillAllInsts(ir::BasicBlock* bp) {
- bp->ForEachInst([this](ir::Instruction* ip) {
- context()->KillInst(ip);
- });
+ bp->ForEachInst([this](ir::Instruction* ip) { context()->KillInst(ip); });
}
bool MemPass::HasLoads(uint32_t varId) const {
bool hasLoads = false;
- get_def_use_mgr()->ForEachUser(varId, [this, &hasLoads](ir::Instruction* user) {
+ get_def_use_mgr()->ForEachUser(varId, [this,
+ &hasLoads](ir::Instruction* user) {
SpvOp op = user->opcode();
// TODO(): The following is slightly conservative. Could be
// better handling of non-store/name.
}
void MemPass::AddStores(uint32_t ptr_id, std::queue<ir::Instruction*>* insts) {
- get_def_use_mgr()->ForEachUser(ptr_id, [this,insts](ir::Instruction* user) {
+ get_def_use_mgr()->ForEachUser(ptr_id, [this, insts](ir::Instruction* user) {
SpvOp op = user->opcode();
if (IsNonPtrAccessChain(op)) {
AddStores(user->result_id(), insts);
bool MemPass::HasOnlySupportedRefs(uint32_t varId) {
if (supported_ref_vars_.find(varId) != supported_ref_vars_.end()) return true;
bool hasOnlySupportedRefs = true;
- get_def_use_mgr()->ForEachUser(varId, [this,&hasOnlySupportedRefs](ir::Instruction* user) {
- SpvOp op = user->opcode();
- if (op != SpvOpStore && op != SpvOpLoad && op != SpvOpName &&
- !IsNonTypeDecorate(op)) {
- hasOnlySupportedRefs = false;
- }
- });
+ get_def_use_mgr()->ForEachUser(
+ varId, [this, &hasOnlySupportedRefs](ir::Instruction* user) {
+ SpvOp op = user->opcode();
+ if (op != SpvOpStore && op != SpvOpLoad && op != SpvOpName &&
+ !IsNonTypeDecorate(op)) {
+ hasOnlySupportedRefs = false;
+ }
+ });
return hasOnlySupportedRefs;
}
{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {predLabel}});
}
const uint32_t phiId = TakeNextId();
- std::unique_ptr<ir::Instruction> newPhi(
- new ir::Instruction(context(), SpvOpPhi, typeId, phiId, phi_in_operands));
+ std::unique_ptr<ir::Instruction> newPhi(new ir::Instruction(
+ context(), SpvOpPhi, typeId, phiId, phi_in_operands));
// The only phis requiring patching are the ones we create.
phis_to_patch_.insert(phiId);
// Only analyze the phi define now; analyze the phi uses after the
{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {predLabel}});
}
const uint32_t phiId = TakeNextId();
- std::unique_ptr<ir::Instruction> newPhi(
- new ir::Instruction(context(), SpvOpPhi, typeId, phiId, phi_in_operands));
+ std::unique_ptr<ir::Instruction> newPhi(new ir::Instruction(
+ context(), SpvOpPhi, typeId, phiId, phi_in_operands));
get_def_use_mgr()->AnalyzeInstDefUse(&*newPhi);
insertItr = insertItr.InsertBefore(std::move(newPhi));
++insertItr;
// In all other cases, the operand must be kept but may need to be changed.
uint32_t arg_id = phi->GetSingleWordOperand(i);
- ir::Instruction *arg_def_instr = get_def_use_mgr()->GetDef(arg_id);
+ ir::Instruction* arg_def_instr = get_def_use_mgr()->GetDef(arg_id);
ir::BasicBlock* def_block = context()->get_instr_block(arg_def_instr);
if (def_block &&
reachable_blocks.find(def_block) == reachable_blocks.end()) {
// If the block is reachable and has Phi instructions, remove all
// operands from its Phi instructions that reference unreachable blocks.
// If the block has no Phi instructions, this is a no-op.
- block.ForEachPhiInst([&block, &reachable_blocks, this](
- ir::Instruction* phi) { RemovePhiOperands(phi, reachable_blocks); });
+ block.ForEachPhiInst(
+ [&block, &reachable_blocks, this](ir::Instruction* phi) {
+ RemovePhiOperands(phi, reachable_blocks);
+ });
}
// Erase unreachable blocks.
#include "inline_opaque_pass.h"
#include "insert_extract_elim.h"
#include "local_access_chain_convert_pass.h"
+#include "local_redundancy_elimination.h"
#include "local_single_block_elim_pass.h"
#include "local_single_store_elim_pass.h"
#include "local_ssa_elim_pass.h"
+#include "merge_return_pass.h"
#include "null_pass.h"
#include "set_spec_constant_default_value_pass.h"
#include "strength_reduction_pass.h"
#include "strip_debug_info_pass.h"
#include "unify_const_pass.h"
-#include "merge_return_pass.h"
-#include "local_redundancy_elimination.h"
#endif // LIBSPIRV_OPT_PASSES_H_
using ir::Instruction;
using ir::Module;
using ir::Operand;
-using opt::analysis::DefUseManager;
using opt::analysis::DecorationManager;
+using opt::analysis::DefUseManager;
Pass::Status RemoveDuplicatesPass::Process(ir::IRContext* irContext) {
bool modified = RemoveDuplicateCapabilities(irContext);
return modified;
}
-bool RemoveDuplicatesPass::RemoveDuplicateTypes(ir::IRContext* irContext) const {
+bool RemoveDuplicatesPass::RemoveDuplicateTypes(
+ ir::IRContext* irContext) const {
bool modified = false;
std::vector<Instruction> visitedTypes;
// Is the current type equal to one of the types we have aready visited?
SpvId idToKeep = 0u;
for (auto j : visitedTypes) {
- if (AreTypesEqual(*i, j, *irContext->get_def_use_mgr(), *irContext->get_decoration_mgr())) {
+ if (AreTypesEqual(*i, j, *irContext->get_def_use_mgr(),
+ *irContext->get_decoration_mgr())) {
idToKeep = j.result_id();
break;
}
namespace opt {
namespace {
-using spvutils::NumberType;
using spvutils::EncodeNumberStatus;
-using spvutils::ParseNumber;
+using spvutils::NumberType;
using spvutils::ParseAndEncodeNumber;
+using spvutils::ParseNumber;
// Given a numeric value in a null-terminated c string and the expected type of
// the value, parses the string and encodes it in a vector of words. If the
// the first OpGroupDecoration instruction that uses the given decoration
// group.
ir::Instruction* group_decorate_inst = nullptr;
- def_use_mgr->ForEachUser(&decoration_group_defining_inst, [&group_decorate_inst](ir::Instruction* user) {
- if (user->opcode() == SpvOp::SpvOpGroupDecorate) {
- group_decorate_inst = user;
- }
- });
+ def_use_mgr->ForEachUser(&decoration_group_defining_inst,
+ [&group_decorate_inst](ir::Instruction* user) {
+ if (user->opcode() == SpvOp::SpvOpGroupDecorate) {
+ group_decorate_inst = user;
+ }
+ });
if (!group_decorate_inst) return nullptr;
// Scan through the target ids of the OpGroupDecorate instruction. There
}
return target_inst;
}
-};
+}; // namespace
Pass::Status SetSpecConstantDefaultValuePass::Process(
ir::IRContext* irContext) {
{shiftConstResultId});
newOperands.push_back(shiftOperand);
std::unique_ptr<ir::Instruction> newInstruction(
- new ir::Instruction(context(), SpvOp::SpvOpShiftLeftLogical, inst->type_id(),
- newResultId, newOperands));
+ new ir::Instruction(context(), SpvOp::SpvOpShiftLeftLogical,
+ inst->type_id(), newResultId, newOperands));
// Insert the new instruction and update the data structures.
inst = inst.InsertBefore(std::move(newInstruction));
uint32_t resultId = TakeNextId();
ir::Operand constant(spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER,
{val});
- std::unique_ptr<ir::Instruction> newConstant(new ir::Instruction(
- context(), SpvOp::SpvOpConstant, uint32_type_id_, resultId, {constant}));
+ std::unique_ptr<ir::Instruction> newConstant(
+ new ir::Instruction(context(), SpvOp::SpvOpConstant, uint32_type_id_,
+ resultId, {constant}));
get_module()->AddGlobalValue(std::move(newConstant));
// Notify the DefUseManager about this constant.
return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
}
-} // opt
+} // namespace opt
} // namespace spvtools
}
}
- return lhs.context()->get_decoration_mgr()->HaveTheSameDecorations(lhs.result_id(), rhs.result_id());
+ return lhs.context()->get_decoration_mgr()->HaveTheSameDecorations(
+ lhs.result_id(), rhs.result_id());
}
std::size_t ValueTableHash::operator()(
uint32_t next_id_;
std::set<uint32_t> ids_to_preserve_;
};
-}
+} // namespace libspirv
#endif // _LIBSPIRV_TEXT_HANDLER_H_
// destructor is called.
std::string* error_msg_sink_;
};
-}
+} // namespace
EncodeNumberStatus ParseAndEncodeIntegerNumber(
const char* text, const NumberType& type,
bool operator!=(const BasicBlock::DominatorIterator& lhs,
const BasicBlock::DominatorIterator& rhs);
-} /// namespace libspirv
+} // namespace libspirv
#endif /// LIBSPIRV_VAL_BASICBLOCK_H_
BasicBlock* Construct::exit_block() { return exit_block_; }
void Construct::set_exit(BasicBlock* block) { exit_block_ = block; }
-} /// namespace libspirv
+} // namespace libspirv
BasicBlock* exit_block_;
};
-} /// namespace libspirv
+} // namespace libspirv
#endif /// LIBSPIRV_VAL_CONSTRUCT_H_
#include <unordered_map>
#include <vector>
+#include "spirv/1.2/spirv.h"
+
namespace libspirv {
// An object of this class represents a specific decoration including its
for (const auto& kv : execution_model_limitations_) {
if (kv.first != model) {
- if (!reason)
- return false;
+ if (!reason) return false;
is_compatible = false;
ss_reason << kv.second << "\n";
}
return is_compatible;
}
-} /// namespace libspirv
+} // namespace libspirv
std::set<uint32_t> function_call_targets_;
};
-} /// namespace libspirv
+} // namespace libspirv
#endif /// LIBSPIRV_VAL_FUNCTION_H_
return hash<uint32_t>()(inst.id());
}
};
-} /// namespace std
+} // namespace std
#endif // LIBSPIRV_VAL_INSTRUCTION_H_
const Function* ValidationState_t::function(uint32_t id) const {
const auto it = id_to_function_.find(id);
- if (it == id_to_function_.end())
- return nullptr;
+ if (it == id_to_function_.end()) return nullptr;
return it->second;
}
if (inst->opcode() != SpvOpConstant && inst->opcode() != SpvOpSpecConstant)
return false;
- if (!IsIntScalarType(inst->type_id()))
- return false;
+ if (!IsIntScalarType(inst->type_id())) return false;
if (inst->words().size() == 4) {
*val = inst->word(3);
std::unordered_map<uint32_t, Function*> id_to_function_;
};
-} /// namespace libspirv
+} // namespace libspirv
#endif /// LIBSPIRV_VAL_VALIDATIONSTATE_H_
using std::function;
using std::ostream_iterator;
-using std::placeholders::_1;
using std::string;
using std::stringstream;
using std::transform;
using std::vector;
+using std::placeholders::_1;
using libspirv::CfgPass;
+using libspirv::DataRulesPass;
using libspirv::Extension;
+using libspirv::IdPass;
using libspirv::InstructionPass;
using libspirv::ModuleLayoutPass;
-using libspirv::DataRulesPass;
-using libspirv::IdPass;
using libspirv::ValidationState_t;
spv_result_t spvValidateIDs(const spv_instruction_t* pInsts,
size_t operand_index) {
return _.GetTypeId(GetOperandWord(inst, operand_index));
}
-}
+} // namespace
// Validates correctness of arithmetic instructions.
spv_result_t ArithmeticsPass(ValidationState_t& _,
size_t operand_index) {
return _.GetTypeId(GetOperandWord(inst, operand_index));
}
-}
+} // namespace
// Validates correctness of bitwise instructions.
spv_result_t BitwisePass(ValidationState_t& _,
// Validates correctness of derivative instructions.
spv_result_t DerivativesPass(ValidationState_t& _,
- const spv_parsed_instruction_t* inst) {
+ const spv_parsed_instruction_t* inst) {
const SpvOp opcode = static_cast<SpvOp>(inst->opcode);
const uint32_t result_type = inst->type_id;
for (size_t constituentIndex = 3; constituentIndex < inst->words.size();
constituentIndex++) {
auto constituent = module_.FindDef(inst->words[constituentIndex]);
- if (!constituent ||
- !(SpvOpConstantComposite == constituent->opcode() ||
- SpvOpUndef == constituent->opcode())) {
+ if (!constituent || !(SpvOpConstantComposite == constituent->opcode() ||
+ SpvOpUndef == constituent->opcode())) {
// The message says "... or undef" because the spec does not say
// undef is a constant.
DIAG(constituentIndex) << "OpConstantComposite Constituent <id> '"
<< "All OpSampledImage instructions must be in the same block in "
"which their Result <id> are consumed. OpSampledImage Result "
"Type <id> '"
- << resultID << "' has a consumer in a different basic "
- "block. The consumer instruction <id> is '"
+ << resultID
+ << "' has a consumer in a different basic "
+ "block. The consumer instruction <id> is '"
<< consumer_id << "'.";
return false;
}
constituentIndex++) {
auto constituent = module_.FindDef(inst->words[constituentIndex]);
auto constituentOpCode = constituent->opcode();
- if (!constituent ||
- !(SpvOpSpecConstantComposite == constituentOpCode ||
- SpvOpConstantComposite == constituentOpCode ||
- SpvOpUndef == constituentOpCode)) {
+ if (!constituent || !(SpvOpSpecConstantComposite == constituentOpCode ||
+ SpvOpConstantComposite == constituentOpCode ||
+ SpvOpUndef == constituentOpCode)) {
// The message says "... or undef" because the spec does not say
// undef is a constant.
DIAG(constituentIndex) << "OpSpecConstantComposite Constituent <id> '"
}
default: {
// Give an error. reached non-composite type while indexes still remain.
- DIAG(i) << instr_name << " reached non-composite type while indexes "
- "still remain to be traversed.";
+ DIAG(i) << instr_name
+ << " reached non-composite type while indexes "
+ "still remain to be traversed.";
return false;
}
}
auto resultVectorDimension = resultType->words()[vectorComponentCountIndex];
if (componentCount != resultVectorDimension) {
DIAG(inst->words.size() - 1)
- << instr_name() << " component literals count does not match "
- "Result Type <id> '"
+ << instr_name()
+ << " component literals count does not match "
+ "Result Type <id> '"
<< resultType->id() << "'s vector component count.";
return false;
}
}
default: {
// Give an error. reached non-composite type while indexes still remain.
- *error << instr_name() << " reached non-composite type while indexes "
- "still remain to be traversed.";
+ *error << instr_name()
+ << " reached non-composite type while indexes "
+ "still remain to be traversed.";
return false;
}
}
DIAG(objectIdIndex)
<< "The Object type (Op"
<< spvOpcodeString(static_cast<SpvOp>(objectTypeInstr->opcode()))
- << ") in " << instr_name() << " does not match the type that results "
- "from indexing into the Composite (Op"
+ << ") in " << instr_name()
+ << " does not match the type that results "
+ "from indexing into the Composite (Op"
<< spvOpcodeString(static_cast<SpvOp>(indexedTypeInstr->opcode()))
<< ").";
return false;
// (not a valid id, failed to parse the instruction, etc).
bool GetImageTypeInfo(const ValidationState_t& _, uint32_t id,
ImageTypeInfo* info) {
- if (!id || !info)
- return false;
+ if (!id || !info) return false;
const Instruction* inst = _.FindDef(id);
assert(inst);
assert(inst);
}
- if (inst->opcode() != SpvOpTypeImage)
- return false;
+ if (inst->opcode() != SpvOpTypeImage) return false;
const size_t num_words = inst->words().size();
- if (num_words != 9 && num_words != 10)
- return false;
+ if (num_words != 9 && num_words != 10) return false;
info->sampled_type = inst->word(2);
info->dim = static_cast<SpvDim>(inst->word(3));
info->multisampled = inst->word(6);
info->sampled = inst->word(7);
info->format = static_cast<SpvImageFormat>(inst->word(8));
- info->access_qualifier = num_words < 10 ? SpvAccessQualifierMax :
- static_cast<SpvAccessQualifier>(inst->word(9));
+ info->access_qualifier = num_words < 10
+ ? SpvAccessQualifierMax
+ : static_cast<SpvAccessQualifier>(inst->word(9));
return true;
}
// Checks ImageOperand bitfield and respective operands.
spv_result_t ValidateImageOperands(ValidationState_t& _,
const spv_parsed_instruction_t& inst,
- const ImageTypeInfo& info,
- uint32_t mask, uint32_t word_index) {
+ const ImageTypeInfo& info, uint32_t mask,
+ uint32_t word_index) {
static const bool kAllImageOperandsHandled = CheckAllImageOperandsHandled();
(void)kAllImageOperandsHandled;
if (expected_num_image_operand_words != num_words - word_index) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Number of image operand ids doesn't correspond to the bit mask: "
- << spvOpcodeString(opcode);
+ << "Number of image operand ids doesn't correspond to the bit mask: "
+ << spvOpcodeString(opcode);
}
if (CountSetBits(mask & (SpvImageOperandsOffsetMask |
SpvImageOperandsConstOffsetMask |
SpvImageOperandsConstOffsetsMask)) > 1) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operands Offset, ConstOffset, ConstOffsets cannot be used "
- << "together: " << spvOpcodeString(opcode);
+ << "Image Operands Offset, ConstOffset, ConstOffsets cannot be used "
+ << "together: " << spvOpcodeString(opcode);
};
const bool is_implicit_lod = IsImplicitLod(opcode);
if (mask & SpvImageOperandsBiasMask) {
if (!is_implicit_lod) {
- return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Bias can only be used with ImplicitLod opcodes: "
- << spvOpcodeString(opcode);
+ return _.diag(SPV_ERROR_INVALID_DATA)
+ << "Image Operand Bias can only be used with ImplicitLod opcodes: "
+ << spvOpcodeString(opcode);
};
const uint32_t type_id = _.GetTypeId(inst.words[word_index++]);
if (!_.IsFloatScalarType(type_id)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand Bias to be float scalar: "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand Bias to be float scalar: "
+ << spvOpcodeString(opcode);
}
if (info.dim != SpvDim1D && info.dim != SpvDim2D && info.dim != SpvDim3D &&
info.dim != SpvDimCube) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Bias requires 'Dim' parameter to be 1D, 2D, 3D or "
- << "Cube: " << spvOpcodeString(opcode);
+ << "Image Operand Bias requires 'Dim' parameter to be 1D, 2D, 3D "
+ "or "
+ << "Cube: " << spvOpcodeString(opcode);
}
if (info.multisampled != 0) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Bias requires 'MS' parameter to be 0: "
- << spvOpcodeString(opcode);
+ << "Image Operand Bias requires 'MS' parameter to be 0: "
+ << spvOpcodeString(opcode);
}
}
// TODO(atgoo@github.com) Check which opcodes are allowed to use this
// ImageOperand.
if (is_implicit_lod) {
- return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Lod cannot be used with ImplicitLod opcodes: "
- << spvOpcodeString(opcode);
+ return _.diag(SPV_ERROR_INVALID_DATA)
+ << "Image Operand Lod cannot be used with ImplicitLod opcodes: "
+ << spvOpcodeString(opcode);
};
if (mask & SpvImageOperandsGradMask) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand bits Lod and Grad cannot be set at the same time: "
- << spvOpcodeString(opcode);
+ << "Image Operand bits Lod and Grad cannot be set at the same "
+ "time: "
+ << spvOpcodeString(opcode);
}
const uint32_t type_id = _.GetTypeId(inst.words[word_index++]);
// with ints. The spec is unclear.
if (!_.IsFloatScalarType(type_id) && !_.IsIntScalarType(type_id)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand Lod to be int or float scalar: "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand Lod to be int or float scalar: "
+ << spvOpcodeString(opcode);
}
if (info.dim != SpvDim1D && info.dim != SpvDim2D && info.dim != SpvDim3D &&
info.dim != SpvDimCube) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Lod requires 'Dim' parameter to be 1D, 2D, 3D or "
- << "Cube: " << spvOpcodeString(opcode);
+ << "Image Operand Lod requires 'Dim' parameter to be 1D, 2D, 3D "
+ "or "
+ << "Cube: " << spvOpcodeString(opcode);
}
if (info.multisampled != 0) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Lod requires 'MS' parameter to be 0: "
- << spvOpcodeString(opcode);
+ << "Image Operand Lod requires 'MS' parameter to be 0: "
+ << spvOpcodeString(opcode);
}
}
if (mask & SpvImageOperandsGradMask) {
if (!is_explicit_lod) {
- return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Grad can only be used with ExplicitLod opcodes: "
- << spvOpcodeString(opcode);
+ return _.diag(SPV_ERROR_INVALID_DATA)
+ << "Image Operand Grad can only be used with ExplicitLod opcodes: "
+ << spvOpcodeString(opcode);
};
const uint32_t dx_type_id = _.GetTypeId(inst.words[word_index++]);
if (!_.IsFloatScalarOrVectorType(dx_type_id) ||
!_.IsFloatScalarOrVectorType(dy_type_id)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected both Image Operand Grad ids to be float scalars or "
- << "vectors: " << spvOpcodeString(opcode);
+ << "Expected both Image Operand Grad ids to be float scalars or "
+ << "vectors: " << spvOpcodeString(opcode);
}
const uint32_t plane_size = GetPlaneCoordSize(info);
const uint32_t dy_size = _.GetDimension(dy_type_id);
if (plane_size != dx_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand Grad dx to have " << plane_size
- << " components, but given " << dx_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand Grad dx to have " << plane_size
+ << " components, but given " << dx_size << ": "
+ << spvOpcodeString(opcode);
}
if (plane_size != dy_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand Grad dy to have " << plane_size
- << " components, but given " << dy_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand Grad dy to have " << plane_size
+ << " components, but given " << dy_size << ": "
+ << spvOpcodeString(opcode);
}
if (info.multisampled != 0) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Grad requires 'MS' parameter to be 0: "
- << spvOpcodeString(opcode);
+ << "Image Operand Grad requires 'MS' parameter to be 0: "
+ << spvOpcodeString(opcode);
}
}
if (mask & SpvImageOperandsConstOffsetMask) {
if (info.dim == SpvDimCube) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand ConstOffset cannot be used with Cube Image 'Dim': "
- << spvOpcodeString(opcode);
+ << "Image Operand ConstOffset cannot be used with Cube Image "
+ "'Dim': "
+ << spvOpcodeString(opcode);
}
const uint32_t id = inst.words[word_index++];
const uint32_t type_id = _.GetTypeId(id);
if (!_.IsIntScalarOrVectorType(type_id)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand ConstOffset to be int scalar or "
- << "vector: " << spvOpcodeString(opcode);
+ << "Expected Image Operand ConstOffset to be int scalar or "
+ << "vector: " << spvOpcodeString(opcode);
}
if (!spvOpcodeIsConstant(_.GetIdOpcode(id))) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand ConstOffset to be a const object: "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand ConstOffset to be a const object: "
+ << spvOpcodeString(opcode);
}
const uint32_t plane_size = GetPlaneCoordSize(info);
const uint32_t offset_size = _.GetDimension(type_id);
if (plane_size != offset_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand ConstOffset to have " << plane_size
- << " components, but given " << offset_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand ConstOffset to have " << plane_size
+ << " components, but given " << offset_size << ": "
+ << spvOpcodeString(opcode);
}
}
if (mask & SpvImageOperandsOffsetMask) {
if (info.dim == SpvDimCube) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Offset cannot be used with Cube Image 'Dim': "
- << spvOpcodeString(opcode);
+ << "Image Operand Offset cannot be used with Cube Image 'Dim': "
+ << spvOpcodeString(opcode);
}
const uint32_t id = inst.words[word_index++];
const uint32_t type_id = _.GetTypeId(id);
if (!_.IsIntScalarOrVectorType(type_id)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand Offset to be int scalar or "
- << "vector: " << spvOpcodeString(opcode);
+ << "Expected Image Operand Offset to be int scalar or "
+ << "vector: " << spvOpcodeString(opcode);
}
const uint32_t plane_size = GetPlaneCoordSize(info);
const uint32_t offset_size = _.GetDimension(type_id);
if (plane_size != offset_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand Offset to have " << plane_size
- << " components, but given " << offset_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand Offset to have " << plane_size
+ << " components, but given " << offset_size << ": "
+ << spvOpcodeString(opcode);
}
}
if (mask & SpvImageOperandsConstOffsetsMask) {
if (opcode != SpvOpImageGather && opcode != SpvOpImageDrefGather) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand ConstOffsets can only be used with OpImageGather "
- << "and OpImageDrefGather: " << spvOpcodeString(opcode);
+ << "Image Operand ConstOffsets can only be used with "
+ "OpImageGather "
+ << "and OpImageDrefGather: " << spvOpcodeString(opcode);
}
if (info.dim == SpvDimCube) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand ConstOffsets cannot be used with Cube Image 'Dim': "
- << spvOpcodeString(opcode);
+ << "Image Operand ConstOffsets cannot be used with Cube Image "
+ "'Dim': "
+ << spvOpcodeString(opcode);
}
const uint32_t id = inst.words[word_index++];
if (type_inst->opcode() != SpvOpTypeArray) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand ConstOffsets to be an array of size 4: "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand ConstOffsets to be an array of size 4: "
+ << spvOpcodeString(opcode);
}
uint64_t array_size = 0;
if (array_size != 4) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand ConstOffsets to be an array of size 4: "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand ConstOffsets to be an array of size 4: "
+ << spvOpcodeString(opcode);
}
const uint32_t component_type = type_inst->word(2);
if (!_.IsIntVectorType(component_type) ||
_.GetDimension(component_type) != 2) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand ConstOffsets array componenets to be int "
- << "vectors of size 2: " << spvOpcodeString(opcode);
+ << "Expected Image Operand ConstOffsets array componenets to be "
+ "int "
+ << "vectors of size 2: " << spvOpcodeString(opcode);
}
if (!spvOpcodeIsConstant(_.GetIdOpcode(id))) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand ConstOffsets to be a const object: "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand ConstOffsets to be a const object: "
+ << spvOpcodeString(opcode);
}
}
if (opcode != SpvOpImageFetch && opcode != SpvOpImageRead &&
opcode != SpvOpImageWrite) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Sample can only be used with OpImageFetch, "
- << "OpImageRead and OpImageWrite: " << spvOpcodeString(opcode);
+ << "Image Operand Sample can only be used with OpImageFetch, "
+ << "OpImageRead and OpImageWrite: " << spvOpcodeString(opcode);
}
if (info.multisampled == 0) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand Sample requires non-zero 'MS' parameter: "
- << spvOpcodeString(opcode);
+ << "Image Operand Sample requires non-zero 'MS' parameter: "
+ << spvOpcodeString(opcode);
}
const uint32_t type_id = _.GetTypeId(inst.words[word_index++]);
if (!_.IsIntScalarType(type_id)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand Sample to be int scalar: "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand Sample to be int scalar: "
+ << spvOpcodeString(opcode);
}
}
if (mask & SpvImageOperandsMinLodMask) {
if (!is_implicit_lod && !(mask & SpvImageOperandsGradMask)) {
- return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand MinLod can only be used with ImplicitLod "
- << "opcodes or together with Image Operand Grad: "
- << spvOpcodeString(opcode);
+ return _.diag(SPV_ERROR_INVALID_DATA)
+ << "Image Operand MinLod can only be used with ImplicitLod "
+ << "opcodes or together with Image Operand Grad: "
+ << spvOpcodeString(opcode);
};
const uint32_t type_id = _.GetTypeId(inst.words[word_index++]);
if (!_.IsFloatScalarType(type_id)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image Operand MinLod to be float scalar: "
- << spvOpcodeString(opcode);
+ << "Expected Image Operand MinLod to be float scalar: "
+ << spvOpcodeString(opcode);
}
if (info.dim != SpvDim1D && info.dim != SpvDim2D && info.dim != SpvDim3D &&
info.dim != SpvDimCube) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand MinLod requires 'Dim' parameter to be 1D, 2D, 3D "
- << "or Cube: " << spvOpcodeString(opcode);
+ << "Image Operand MinLod requires 'Dim' parameter to be 1D, 2D, "
+ "3D "
+ << "or Cube: " << spvOpcodeString(opcode);
}
if (info.multisampled != 0) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Operand MinLod requires 'MS' parameter to be 0: "
- << spvOpcodeString(opcode);
+ << "Image Operand MinLod requires 'MS' parameter to be 0: "
+ << spvOpcodeString(opcode);
}
}
const ImageTypeInfo& info) {
const SpvOp opcode = static_cast<SpvOp>(inst.opcode);
if (IsProj(opcode)) {
- if (info.dim != SpvDim1D && info.dim != SpvDim2D &&
- info.dim != SpvDim3D && info.dim != SpvDimRect) {
+ if (info.dim != SpvDim1D && info.dim != SpvDim2D && info.dim != SpvDim3D &&
+ info.dim != SpvDimRect) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Dim' parameter to be 1D, 2D, 3D or Rect: "
- << spvOpcodeString(opcode);
+ << "Expected Image 'Dim' parameter to be 1D, 2D, 3D or Rect: "
+ << spvOpcodeString(opcode);
}
if (info.multisampled != 0) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Image 'MS' parameter to be 0: "
- << spvOpcodeString(opcode);
+ << "Image Image 'MS' parameter to be 0: "
+ << spvOpcodeString(opcode);
}
if (info.arrayed != 0) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image Image 'arrayed' parameter to be 0: "
- << spvOpcodeString(opcode);
+ << "Image Image 'arrayed' parameter to be 0: "
+ << spvOpcodeString(opcode);
}
}
} else if (info.sampled == 2) {
if (info.dim == SpvDim1D && !_.HasCapability(SpvCapabilityImage1D)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Capability Image1D is required to access storage image: "
- << spvOpcodeString(opcode);
+ << "Capability Image1D is required to access storage image: "
+ << spvOpcodeString(opcode);
} else if (info.dim == SpvDimRect &&
!_.HasCapability(SpvCapabilityImageRect)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Capability ImageRect is required to access storage image: "
- << spvOpcodeString(opcode);
+ << "Capability ImageRect is required to access storage image: "
+ << spvOpcodeString(opcode);
} else if (info.dim == SpvDimBuffer &&
!_.HasCapability(SpvCapabilityImageBuffer)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Capability ImageBuffer is required to access storage image: "
- << spvOpcodeString(opcode);
+ << "Capability ImageBuffer is required to access storage image: "
+ << spvOpcodeString(opcode);
} else if (info.dim == SpvDimCube && info.arrayed == 1 &&
!_.HasCapability(SpvCapabilityImageCubeArray)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Capability ImageCubeArray is required to access storage "
- << "image: " << spvOpcodeString(opcode);
+ << "Capability ImageCubeArray is required to access storage "
+ << "image: " << spvOpcodeString(opcode);
}
if (info.multisampled == 1 &&
}
} else {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Sampled' parameter to be 0 or 2: "
- << spvOpcodeString(opcode);
+ << "Expected Image 'Sampled' parameter to be 0 or 2: "
+ << spvOpcodeString(opcode);
}
}
case SpvOpSampledImage: {
if (_.GetIdOpcode(result_type) != SpvOpTypeSampledImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be OpTypeSampledImage: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be OpTypeSampledImage: "
+ << spvOpcodeString(opcode);
}
const uint32_t image_type = _.GetOperandTypeId(inst, 2);
if (_.GetIdOpcode(image_type) != SpvOpTypeImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image to be of type OpTypeImage: "
- << spvOpcodeString(opcode);
+ << "Expected Image to be of type OpTypeImage: "
+ << spvOpcodeString(opcode);
}
ImageTypeInfo info;
if (!GetImageTypeInfo(_, image_type, &info)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Corrupt image type definition";
+ << "Corrupt image type definition";
}
// TODO(atgoo@github.com) Check compatibility of result type and received
if (info.sampled != 0 && info.sampled != 1) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Sampled' parameter to be 0 or 1: "
- << spvOpcodeString(opcode);
+ << "Expected Image 'Sampled' parameter to be 0 or 1: "
+ << spvOpcodeString(opcode);
}
if (info.dim == SpvDimSubpassData) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Dim' parameter to be not SubpassData: "
- << spvOpcodeString(opcode);
+ << "Expected Image 'Dim' parameter to be not SubpassData: "
+ << spvOpcodeString(opcode);
}
if (_.GetIdOpcode(_.GetOperandTypeId(inst, 3)) != SpvOpTypeSampler) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Sampler to be of type OpTypeSampler: "
- << spvOpcodeString(opcode);
+ << "Expected Sampler to be of type OpTypeSampler: "
+ << spvOpcodeString(opcode);
}
break;
if (!_.IsIntVectorType(result_type) &&
!_.IsFloatVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be int or float vector type: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be int or float vector type: "
+ << spvOpcodeString(opcode);
}
if (_.GetDimension(result_type) != 4) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to have 4 components: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to have 4 components: "
+ << spvOpcodeString(opcode);
}
const uint32_t image_type = _.GetOperandTypeId(inst, 2);
if (_.GetIdOpcode(image_type) != SpvOpTypeSampledImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Sampled Image to be of type OpTypeSampledImage: "
- << spvOpcodeString(opcode);
+ << "Expected Sampled Image to be of type OpTypeSampledImage: "
+ << spvOpcodeString(opcode);
}
ImageTypeInfo info;
if (!GetImageTypeInfo(_, image_type, &info)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Corrupt image type definition";
+ << "Corrupt image type definition";
}
if (spv_result_t result = ValidateImageCommon(_, *inst, info))
const uint32_t result_component_type = _.GetComponentType(result_type);
if (result_component_type != info.sampled_type) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Sampled Type' to be the same as Result Type "
- << "components: " << spvOpcodeString(opcode);
+ << "Expected Image 'Sampled Type' to be the same as Result "
+ "Type "
+ << "components: " << spvOpcodeString(opcode);
}
}
if (!_.IsFloatScalarOrVectorType(coord_type) &&
!_.IsIntScalarOrVectorType(coord_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to be int or float scalar or vector: "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to be int or float scalar or vector: "
+ << spvOpcodeString(opcode);
}
} else {
if (!_.IsFloatScalarOrVectorType(coord_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to be float scalar or vector: "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to be float scalar or vector: "
+ << spvOpcodeString(opcode);
}
}
const uint32_t actual_coord_size = _.GetDimension(coord_type);
if (min_coord_size > actual_coord_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to have at least " << min_coord_size
- << " components, but given only " << actual_coord_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to have at least " << min_coord_size
+ << " components, but given only " << actual_coord_size << ": "
+ << spvOpcodeString(opcode);
}
if (inst->num_words <= 5) {
}
const uint32_t mask = inst->words[5];
- if (spv_result_t result = ValidateImageOperands(
- _, *inst, info, mask, /* word_index = */ 6))
+ if (spv_result_t result =
+ ValidateImageOperands(_, *inst, info, mask, /* word_index = */ 6))
return result;
break;
if (!_.IsIntScalarType(result_type) &&
!_.IsFloatScalarType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be int or float scalar type: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be int or float scalar type: "
+ << spvOpcodeString(opcode);
}
const uint32_t image_type = _.GetOperandTypeId(inst, 2);
if (_.GetIdOpcode(image_type) != SpvOpTypeSampledImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Sampled Image to be of type OpTypeSampledImage: "
- << spvOpcodeString(opcode);
+ << "Expected Sampled Image to be of type OpTypeSampledImage: "
+ << spvOpcodeString(opcode);
}
ImageTypeInfo info;
if (!GetImageTypeInfo(_, image_type, &info)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Corrupt image type definition";
+ << "Corrupt image type definition";
}
if (spv_result_t result = ValidateImageCommon(_, *inst, info))
if (result_type != info.sampled_type) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Sampled Type' to be the same as Result Type: "
- << spvOpcodeString(opcode);
+ << "Expected Image 'Sampled Type' to be the same as Result "
+ "Type: "
+ << spvOpcodeString(opcode);
}
const uint32_t coord_type = _.GetOperandTypeId(inst, 3);
if (!_.IsFloatScalarOrVectorType(coord_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to be float scalar or vector: "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to be float scalar or vector: "
+ << spvOpcodeString(opcode);
}
const uint32_t min_coord_size = GetMinCoordSize(opcode, info);
const uint32_t actual_coord_size = _.GetDimension(coord_type);
if (min_coord_size > actual_coord_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to have at least " << min_coord_size
- << " components, but given only " << actual_coord_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to have at least " << min_coord_size
+ << " components, but given only " << actual_coord_size << ": "
+ << spvOpcodeString(opcode);
}
const uint32_t dref_type = _.GetOperandTypeId(inst, 4);
if (dref_type != info.sampled_type) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Dref to be of Image 'Sampled Type': "
- << spvOpcodeString(opcode);
+ << "Expected Dref to be of Image 'Sampled Type': "
+ << spvOpcodeString(opcode);
}
-
if (inst->num_words <= 6) {
assert(IsImplicitLod(opcode));
break;
}
const uint32_t mask = inst->words[6];
- if (spv_result_t result = ValidateImageOperands(
- _, *inst, info, mask, /* word_index = */ 7))
+ if (spv_result_t result =
+ ValidateImageOperands(_, *inst, info, mask, /* word_index = */ 7))
return result;
break;
if (!_.IsIntVectorType(result_type) &&
!_.IsFloatVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be int or float vector type: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be int or float vector type: "
+ << spvOpcodeString(opcode);
}
if (_.GetDimension(result_type) != 4) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to have 4 components: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to have 4 components: "
+ << spvOpcodeString(opcode);
}
const uint32_t image_type = _.GetOperandTypeId(inst, 2);
if (_.GetIdOpcode(image_type) != SpvOpTypeImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image to be of type OpTypeImage: "
- << spvOpcodeString(opcode);
+ << "Expected Image to be of type OpTypeImage: "
+ << spvOpcodeString(opcode);
}
ImageTypeInfo info;
if (!GetImageTypeInfo(_, image_type, &info)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Corrupt image type definition";
+ << "Corrupt image type definition";
}
if (_.GetIdOpcode(info.sampled_type) != SpvOpTypeVoid) {
const uint32_t result_component_type = _.GetComponentType(result_type);
if (result_component_type != info.sampled_type) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Sampled Type' to be the same as Result Type "
- << "components: " << spvOpcodeString(opcode);
+ << "Expected Image 'Sampled Type' to be the same as Result "
+ "Type "
+ << "components: " << spvOpcodeString(opcode);
}
}
if (info.dim == SpvDimCube) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image 'Dim' cannot be Cube: "
- << spvOpcodeString(opcode);
+ << "Image 'Dim' cannot be Cube: " << spvOpcodeString(opcode);
}
if (info.sampled != 1) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Sampled' parameter to be 1: "
- << spvOpcodeString(opcode);
+ << "Expected Image 'Sampled' parameter to be 1: "
+ << spvOpcodeString(opcode);
}
const uint32_t coord_type = _.GetOperandTypeId(inst, 3);
if (!_.IsIntScalarOrVectorType(coord_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to be int scalar or vector: "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to be int scalar or vector: "
+ << spvOpcodeString(opcode);
}
const uint32_t min_coord_size = GetMinCoordSize(opcode, info);
const uint32_t actual_coord_size = _.GetDimension(coord_type);
if (min_coord_size > actual_coord_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to have at least " << min_coord_size
- << " components, but given only " << actual_coord_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to have at least " << min_coord_size
+ << " components, but given only " << actual_coord_size << ": "
+ << spvOpcodeString(opcode);
}
- if (inst->num_words <= 5)
- break;
+ if (inst->num_words <= 5) break;
const uint32_t mask = inst->words[5];
- if (spv_result_t result = ValidateImageOperands(
- _, *inst, info, mask, /* word_index = */ 6))
+ if (spv_result_t result =
+ ValidateImageOperands(_, *inst, info, mask, /* word_index = */ 6))
return result;
break;
if (!_.IsIntVectorType(result_type) &&
!_.IsFloatVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be int or float vector type: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be int or float vector type: "
+ << spvOpcodeString(opcode);
}
if (_.GetDimension(result_type) != 4) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to have 4 components: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to have 4 components: "
+ << spvOpcodeString(opcode);
}
const uint32_t image_type = _.GetOperandTypeId(inst, 2);
if (_.GetIdOpcode(image_type) != SpvOpTypeSampledImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Sampled Image to be of type OpTypeSampledImage: "
- << spvOpcodeString(opcode);
+ << "Expected Sampled Image to be of type OpTypeSampledImage: "
+ << spvOpcodeString(opcode);
}
ImageTypeInfo info;
if (!GetImageTypeInfo(_, image_type, &info)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Corrupt image type definition";
+ << "Corrupt image type definition";
}
if (opcode == SpvOpImageDrefGather ||
const uint32_t result_component_type = _.GetComponentType(result_type);
if (result_component_type != info.sampled_type) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Sampled Type' to be the same as Result Type "
- << "components: " << spvOpcodeString(opcode);
+ << "Expected Image 'Sampled Type' to be the same as Result "
+ "Type "
+ << "components: " << spvOpcodeString(opcode);
}
}
if (info.dim != SpvDim2D && info.dim != SpvDimCube &&
info.dim != SpvDimRect) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Dim' cannot be Cube: "
- << spvOpcodeString(opcode);
+ << "Expected Image 'Dim' cannot be Cube: "
+ << spvOpcodeString(opcode);
}
const uint32_t coord_type = _.GetOperandTypeId(inst, 3);
if (!_.IsFloatScalarOrVectorType(coord_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to be float scalar or vector: "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to be float scalar or vector: "
+ << spvOpcodeString(opcode);
}
const uint32_t min_coord_size = GetMinCoordSize(opcode, info);
const uint32_t actual_coord_size = _.GetDimension(coord_type);
if (min_coord_size > actual_coord_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to have at least " << min_coord_size
- << " components, but given only " << actual_coord_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to have at least " << min_coord_size
+ << " components, but given only " << actual_coord_size << ": "
+ << spvOpcodeString(opcode);
}
if (opcode == SpvOpImageGather) {
const uint32_t component_index_type = _.GetOperandTypeId(inst, 4);
if (!_.IsIntScalarType(component_index_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Component to be int scalar: "
- << spvOpcodeString(opcode);
+ << "Expected Component to be int scalar: "
+ << spvOpcodeString(opcode);
}
} else {
assert(opcode == SpvOpImageDrefGather);
const uint32_t dref_type = _.GetOperandTypeId(inst, 4);
if (dref_type != info.sampled_type) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Dref to be of Image 'Sampled Type': "
- << spvOpcodeString(opcode);
+ << "Expected Dref to be of Image 'Sampled Type': "
+ << spvOpcodeString(opcode);
}
}
- if (inst->num_words <= 6)
- break;
+ if (inst->num_words <= 6) break;
const uint32_t mask = inst->words[6];
- if (spv_result_t result = ValidateImageOperands(
- _, *inst, info, mask, /* word_index = */ 7))
+ if (spv_result_t result =
+ ValidateImageOperands(_, *inst, info, mask, /* word_index = */ 7))
return result;
break;
if (!_.IsIntScalarOrVectorType(result_type) &&
!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be int or float scalar or vector type: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be int or float scalar or vector "
+ "type: "
+ << spvOpcodeString(opcode);
}
#if 0
const uint32_t image_type = _.GetOperandTypeId(inst, 2);
if (_.GetIdOpcode(image_type) != SpvOpTypeImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image to be of type OpTypeImage: "
- << spvOpcodeString(opcode);
+ << "Expected Image to be of type OpTypeImage: "
+ << spvOpcodeString(opcode);
}
ImageTypeInfo info;
if (!GetImageTypeInfo(_, image_type, &info)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Corrupt image type definition";
+ << "Corrupt image type definition";
}
if (_.GetIdOpcode(info.sampled_type) != SpvOpTypeVoid) {
const uint32_t result_component_type = _.GetComponentType(result_type);
if (result_component_type != info.sampled_type) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Sampled Type' to be the same as Result Type "
- << "components: " << spvOpcodeString(opcode);
+ << "Expected Image 'Sampled Type' to be the same as Result "
+ "Type "
+ << "components: " << spvOpcodeString(opcode);
}
}
const uint32_t coord_type = _.GetOperandTypeId(inst, 3);
if (!_.IsIntScalarOrVectorType(coord_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to be int scalar or vector: "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to be int scalar or vector: "
+ << spvOpcodeString(opcode);
}
const uint32_t min_coord_size = GetMinCoordSize(opcode, info);
const uint32_t actual_coord_size = _.GetDimension(coord_type);
if (min_coord_size > actual_coord_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to have at least " << min_coord_size
- << " components, but given only " << actual_coord_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to have at least " << min_coord_size
+ << " components, but given only " << actual_coord_size << ": "
+ << spvOpcodeString(opcode);
}
if (info.format == SpvImageFormatUnknown &&
info.dim != SpvDimSubpassData &&
!_.HasCapability(SpvCapabilityStorageImageReadWithoutFormat)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Capability StorageImageReadWithoutFormat is required to read "
- << "storage image: " << spvOpcodeString(opcode);
+ << "Capability StorageImageReadWithoutFormat is required to "
+ "read "
+ << "storage image: " << spvOpcodeString(opcode);
}
- if (inst->num_words <= 5)
- break;
+ if (inst->num_words <= 5) break;
const uint32_t mask = inst->words[5];
- if (spv_result_t result = ValidateImageOperands(
- _, *inst, info, mask, /* word_index = */ 6))
+ if (spv_result_t result =
+ ValidateImageOperands(_, *inst, info, mask, /* word_index = */ 6))
return result;
break;
const uint32_t image_type = _.GetOperandTypeId(inst, 0);
if (_.GetIdOpcode(image_type) != SpvOpTypeImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image to be of type OpTypeImage: "
- << spvOpcodeString(opcode);
+ << "Expected Image to be of type OpTypeImage: "
+ << spvOpcodeString(opcode);
}
ImageTypeInfo info;
if (!GetImageTypeInfo(_, image_type, &info)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Corrupt image type definition";
+ << "Corrupt image type definition";
}
if (info.dim == SpvDimSubpassData) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image 'Dim' cannot be SubpassData: " << spvOpcodeString(opcode);
+ << "Image 'Dim' cannot be SubpassData: "
+ << spvOpcodeString(opcode);
}
if (spv_result_t result = ValidateImageCommon(_, *inst, info))
const uint32_t coord_type = _.GetOperandTypeId(inst, 1);
if (!_.IsIntScalarOrVectorType(coord_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to be int scalar or vector: "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to be int scalar or vector: "
+ << spvOpcodeString(opcode);
}
const uint32_t min_coord_size = GetMinCoordSize(opcode, info);
const uint32_t actual_coord_size = _.GetDimension(coord_type);
if (min_coord_size > actual_coord_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to have at least " << min_coord_size
- << " components, but given only " << actual_coord_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to have at least " << min_coord_size
+ << " components, but given only " << actual_coord_size << ": "
+ << spvOpcodeString(opcode);
}
// TODO(atgoo@github.com) The spec doesn't explicitely say what the type
if (!_.IsIntScalarOrVectorType(texel_type) &&
!_.IsFloatScalarOrVectorType(texel_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Texel to be int or float vector or scalar: "
- << spvOpcodeString(opcode);
+ << "Expected Texel to be int or float vector or scalar: "
+ << spvOpcodeString(opcode);
}
#if 0
const uint32_t texel_component_type = _.GetComponentType(texel_type);
if (texel_component_type != info.sampled_type) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image 'Sampled Type' to be the same as Texel "
- << "components: " << spvOpcodeString(opcode);
+ << "Expected Image 'Sampled Type' to be the same as Texel "
+ << "components: " << spvOpcodeString(opcode);
}
}
info.dim != SpvDimSubpassData &&
!_.HasCapability(SpvCapabilityStorageImageWriteWithoutFormat)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Capability StorageImageWriteWithoutFormat is required to write "
- << "to storage image: " << spvOpcodeString(opcode);
+ << "Capability StorageImageWriteWithoutFormat is required to "
+ "write "
+ << "to storage image: " << spvOpcodeString(opcode);
}
- if (inst->num_words <= 4)
- break;
+ if (inst->num_words <= 4) break;
const uint32_t mask = inst->words[4];
- if (spv_result_t result = ValidateImageOperands(
- _, *inst, info, mask, /* word_index = */ 5))
+ if (spv_result_t result =
+ ValidateImageOperands(_, *inst, info, mask, /* word_index = */ 5))
return result;
break;
case SpvOpImage: {
if (_.GetIdOpcode(result_type) != SpvOpTypeImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be OpTypeImage: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be OpTypeImage: "
+ << spvOpcodeString(opcode);
}
const uint32_t sampled_image_type = _.GetOperandTypeId(inst, 2);
if (sampled_image_type_inst->opcode() != SpvOpTypeSampledImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Sample Image to be of type OpTypeSampleImage: "
- << spvOpcodeString(opcode);
+ << "Expected Sample Image to be of type OpTypeSampleImage: "
+ << spvOpcodeString(opcode);
}
if (sampled_image_type_inst->word(2) != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Sample Image image type to be equal to Result Type: "
- << spvOpcodeString(opcode);
+ << "Expected Sample Image image type to be equal to Result "
+ "Type: "
+ << spvOpcodeString(opcode);
}
break;
case SpvOpImageQueryOrder: {
if (!_.IsIntScalarType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be int scalar type: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be int scalar type: "
+ << spvOpcodeString(opcode);
}
if (_.GetIdOpcode(_.GetOperandTypeId(inst, 2)) != SpvOpTypeImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected operand to be of type OpTypeImage: "
- << spvOpcodeString(opcode);
+ << "Expected operand to be of type OpTypeImage: "
+ << spvOpcodeString(opcode);
}
break;
}
case SpvOpImageQuerySizeLod: {
if (!_.IsIntScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be int scalar or vector type: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be int scalar or vector type: "
+ << spvOpcodeString(opcode);
}
const uint32_t image_type = _.GetOperandTypeId(inst, 2);
if (_.GetIdOpcode(image_type) != SpvOpTypeImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image to be of type OpTypeImage: "
- << spvOpcodeString(opcode);
+ << "Expected Image to be of type OpTypeImage: "
+ << spvOpcodeString(opcode);
}
ImageTypeInfo info;
if (!GetImageTypeInfo(_, image_type, &info)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Corrupt image type definition";
+ << "Corrupt image type definition";
}
uint32_t expected_num_components = info.arrayed;
break;
default:
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image 'Dim' must be 1D, 2D, 3D or Cube: "
- << spvOpcodeString(opcode);
+ << "Image 'Dim' must be 1D, 2D, 3D or Cube: "
+ << spvOpcodeString(opcode);
};
if (info.multisampled != 0) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image 'MS' must be 0: " << spvOpcodeString(opcode);
+ << "Image 'MS' must be 0: " << spvOpcodeString(opcode);
}
uint32_t result_num_components = _.GetDimension(result_type);
if (result_num_components != expected_num_components) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Result Type has " << result_num_components << " components, "
- << "but " << expected_num_components << " expected: "
- << spvOpcodeString(opcode);
+ << "Result Type has " << result_num_components << " components, "
+ << "but " << expected_num_components
+ << " expected: " << spvOpcodeString(opcode);
}
const uint32_t lod_type = _.GetOperandTypeId(inst, 3);
if (!_.IsIntScalarType(lod_type) && !_.IsFloatScalarType(lod_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Level of Detail to be int or float scalar: "
- << spvOpcodeString(opcode);
+ << "Expected Level of Detail to be int or float scalar: "
+ << spvOpcodeString(opcode);
}
break;
case SpvOpImageQuerySize: {
if (!_.IsIntScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be int scalar or vector type: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be int scalar or vector type: "
+ << spvOpcodeString(opcode);
}
const uint32_t image_type = _.GetOperandTypeId(inst, 2);
if (_.GetIdOpcode(image_type) != SpvOpTypeImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image to be of type OpTypeImage: "
- << spvOpcodeString(opcode);
+ << "Expected Image to be of type OpTypeImage: "
+ << spvOpcodeString(opcode);
}
#if 0
if (!_.IsFloatVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be float vector type: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be float vector type: "
+ << spvOpcodeString(opcode);
}
if (_.GetDimension(result_type) != 2) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to have 2 components: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to have 2 components: "
+ << spvOpcodeString(opcode);
}
const uint32_t image_type = _.GetOperandTypeId(inst, 2);
if (_.GetIdOpcode(image_type) != SpvOpTypeSampledImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image operand to be of type OpTypeSampledImage: "
- << spvOpcodeString(opcode);
+ << "Expected Image operand to be of type OpTypeSampledImage: "
+ << spvOpcodeString(opcode);
}
ImageTypeInfo info;
if (!GetImageTypeInfo(_, image_type, &info)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Corrupt image type definition";
+ << "Corrupt image type definition";
}
- if (info.dim != SpvDim1D && info.dim != SpvDim2D
- && info.dim != SpvDim3D && info.dim != SpvDimCube) {
+ if (info.dim != SpvDim1D && info.dim != SpvDim2D &&
+ info.dim != SpvDim3D && info.dim != SpvDimCube) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image 'Dim' must be 1D, 2D, 3D or Cube: "
- << spvOpcodeString(opcode);
+ << "Image 'Dim' must be 1D, 2D, 3D or Cube: "
+ << spvOpcodeString(opcode);
}
const uint32_t coord_type = _.GetOperandTypeId(inst, 3);
if (!_.IsFloatScalarOrVectorType(coord_type) &&
!_.IsIntScalarOrVectorType(coord_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to be int or float scalar or vector: "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to be int or float scalar or vector: "
+ << spvOpcodeString(opcode);
}
} else {
if (!_.IsFloatScalarOrVectorType(coord_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to be float scalar or vector: "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to be float scalar or vector: "
+ << spvOpcodeString(opcode);
}
}
const uint32_t actual_coord_size = _.GetDimension(coord_type);
if (min_coord_size > actual_coord_size) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Coordinate to have at least " << min_coord_size
- << " components, but given only " << actual_coord_size << ": "
- << spvOpcodeString(opcode);
+ << "Expected Coordinate to have at least " << min_coord_size
+ << " components, but given only " << actual_coord_size << ": "
+ << spvOpcodeString(opcode);
}
break;
}
case SpvOpImageQuerySamples: {
if (!_.IsIntScalarType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Result Type to be int scalar type: "
- << spvOpcodeString(opcode);
+ << "Expected Result Type to be int scalar type: "
+ << spvOpcodeString(opcode);
}
const uint32_t image_type = _.GetOperandTypeId(inst, 2);
if (_.GetIdOpcode(image_type) != SpvOpTypeImage) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Expected Image to be of type OpTypeImage: "
- << spvOpcodeString(opcode);
+ << "Expected Image to be of type OpTypeImage: "
+ << spvOpcodeString(opcode);
}
ImageTypeInfo info;
if (!GetImageTypeInfo(_, image_type, &info)) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Corrupt image type definition";
+ << "Corrupt image type definition";
}
if (opcode == SpvOpImageQueryLevels) {
- if (info.dim != SpvDim1D && info.dim != SpvDim2D
- && info.dim != SpvDim3D && info.dim != SpvDimCube) {
+ if (info.dim != SpvDim1D && info.dim != SpvDim2D &&
+ info.dim != SpvDim3D && info.dim != SpvDimCube) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image 'Dim' must be 1D, 2D, 3D or Cube: "
- << spvOpcodeString(opcode);
+ << "Image 'Dim' must be 1D, 2D, 3D or Cube: "
+ << spvOpcodeString(opcode);
}
} else {
assert(opcode == SpvOpImageQuerySamples);
if (info.dim != SpvDim2D) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image 'Dim' must be 2D: " << spvOpcodeString(opcode);
+ << "Image 'Dim' must be 2D: " << spvOpcodeString(opcode);
}
if (info.multisampled != 1) {
return _.diag(SPV_ERROR_INVALID_DATA)
- << "Image 'MS' must be 1: " << spvOpcodeString(opcode);
+ << "Image 'MS' must be 1: " << spvOpcodeString(opcode);
}
}
#include "val/function.h"
#include "val/validation_state.h"
-using libspirv::ValidationState_t;
-using libspirv::kLayoutMemoryModel;
+using libspirv::FunctionDecl;
using libspirv::kLayoutFunctionDeclarations;
using libspirv::kLayoutFunctionDefinitions;
-using libspirv::FunctionDecl;
+using libspirv::kLayoutMemoryModel;
+using libspirv::ValidationState_t;
namespace {
// Module scoped instructions are processed by determining if the opcode
}
return SPV_SUCCESS;
}
-} /// namespace
+} // namespace
namespace libspirv {
// TODO(umar): Check linkage capabilities for function declarations
}
return SPV_SUCCESS;
}
-} /// namespace libspirv
+} // namespace libspirv
size_t operand_index) {
return _.GetTypeId(GetOperandWord(inst, operand_index));
}
-}
+} // namespace
// Validates correctness of logical instructions.
spv_result_t LogicalsPass(ValidationState_t& _,
#include "unit_spirv.h"
-#include <vector>
#include <gmock/gmock.h>
+#include <vector>
#include "source/instruction.h"
#include <string>
#include <vector>
-#include "test_fixture.h"
-#include "unit_spirv.h"
#include "gmock/gmock.h"
#include "source/message.h"
#include "source/table.h"
#include "spirv/1.0/OpenCL.std.h"
+#include "test_fixture.h"
+#include "unit_spirv.h"
// Returns true if two spv_parsed_operand_t values are equal.
// To use this operator, this definition must appear in the same namespace
using ::spvtest::MakeInstruction;
using ::spvtest::MakeVector;
using ::spvtest::ScopedContext;
+using ::testing::_;
using ::testing::AnyOf;
using ::testing::Eq;
using ::testing::InSequence;
using ::testing::Return;
-using ::testing::_;
// An easily-constructible and comparable object for the contents of an
// spv_parsed_instruction_t. Unlike spv_parsed_instruction_t, owns the memory
}),
"Type Id 2 is not a type"},
{Concatenate({
- ExpectedHeaderForBound(3), MakeInstruction(SpvOpTypeBool, {1}),
+ ExpectedHeaderForBound(3),
+ MakeInstruction(SpvOpTypeBool, {1}),
MakeInstruction(SpvOpConstant, {1, 2, 42}),
}),
"Type Id 1 is not a scalar numeric type"},
#include "gmock/gmock.h"
-#include "test_fixture.h"
#include "source/spirv_constant.h"
+#include "test_fixture.h"
namespace {
-using ::testing::Combine;
-using ::testing::Eq;
-using ::testing::HasSubstr;
using spvtest::AutoText;
using spvtest::ScopedContext;
using spvtest::TextToBinaryTest;
using std::get;
using std::tuple;
+using ::testing::Combine;
+using ::testing::Eq;
+using ::testing::HasSubstr;
class BinaryToText : public ::testing::Test {
public:
::testing::ValuesIn(std::vector<std::string>{
"OpStore %1 %2\n", // 3 words long.
"OpStore %1 %2 None\n", // 4 words long, explicit final 0.
- "OpStore %1 %2 Volatile\n", "OpStore %1 %2 Aligned 8\n",
+ "OpStore %1 %2 Volatile\n",
+ "OpStore %1 %2 Aligned 8\n",
"OpStore %1 %2 Nontemporal\n",
// Combinations show the names from LSB to MSB
"OpStore %1 %2 Volatile|Aligned 16\n",
"OpDecorate %1 FPFastMathMode NotNaN|NotInf|NSZ|AllowRecip|Fast\n",
})), );
-INSTANTIATE_TEST_CASE_P(
- LoopControlMasks, RoundTripInstructionsTest,
- Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
- SPV_ENV_UNIVERSAL_1_2),
- ::testing::ValuesIn(std::vector<std::string>{
- "OpLoopMerge %1 %2 None\n", "OpLoopMerge %1 %2 Unroll\n",
- "OpLoopMerge %1 %2 DontUnroll\n",
- "OpLoopMerge %1 %2 Unroll|DontUnroll\n",
- })), );
+INSTANTIATE_TEST_CASE_P(LoopControlMasks, RoundTripInstructionsTest,
+ Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0,
+ SPV_ENV_UNIVERSAL_1_1,
+ SPV_ENV_UNIVERSAL_1_2),
+ ::testing::ValuesIn(std::vector<std::string>{
+ "OpLoopMerge %1 %2 None\n",
+ "OpLoopMerge %1 %2 Unroll\n",
+ "OpLoopMerge %1 %2 DontUnroll\n",
+ "OpLoopMerge %1 %2 Unroll|DontUnroll\n",
+ })), );
INSTANTIATE_TEST_CASE_P(LoopControlMasksV11, RoundTripInstructionsTest,
Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_1,
"OpLoopMerge %1 %2 DependencyLength 8\n",
})), );
-INSTANTIATE_TEST_CASE_P(
- SelectionControlMasks, RoundTripInstructionsTest,
- Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
- SPV_ENV_UNIVERSAL_1_2),
- ::testing::ValuesIn(std::vector<std::string>{
- "OpSelectionMerge %1 None\n", "OpSelectionMerge %1 Flatten\n",
- "OpSelectionMerge %1 DontFlatten\n",
- "OpSelectionMerge %1 Flatten|DontFlatten\n",
- })), );
+INSTANTIATE_TEST_CASE_P(SelectionControlMasks, RoundTripInstructionsTest,
+ Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0,
+ SPV_ENV_UNIVERSAL_1_1,
+ SPV_ENV_UNIVERSAL_1_2),
+ ::testing::ValuesIn(std::vector<std::string>{
+ "OpSelectionMerge %1 None\n",
+ "OpSelectionMerge %1 Flatten\n",
+ "OpSelectionMerge %1 DontFlatten\n",
+ "OpSelectionMerge %1 Flatten|DontFlatten\n",
+ })), );
-INSTANTIATE_TEST_CASE_P(
- FunctionControlMasks, RoundTripInstructionsTest,
- Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
- SPV_ENV_UNIVERSAL_1_2),
- ::testing::ValuesIn(std::vector<std::string>{
- "%2 = OpFunction %1 None %3\n",
- "%2 = OpFunction %1 Inline %3\n",
- "%2 = OpFunction %1 DontInline %3\n",
- "%2 = OpFunction %1 Pure %3\n", "%2 = OpFunction %1 Const %3\n",
- "%2 = OpFunction %1 Inline|Pure|Const %3\n",
- "%2 = OpFunction %1 DontInline|Const %3\n",
- })), );
+INSTANTIATE_TEST_CASE_P(FunctionControlMasks, RoundTripInstructionsTest,
+ Combine(::testing::Values(SPV_ENV_UNIVERSAL_1_0,
+ SPV_ENV_UNIVERSAL_1_1,
+ SPV_ENV_UNIVERSAL_1_2),
+ ::testing::ValuesIn(std::vector<std::string>{
+ "%2 = OpFunction %1 None %3\n",
+ "%2 = OpFunction %1 Inline %3\n",
+ "%2 = OpFunction %1 DontInline %3\n",
+ "%2 = OpFunction %1 Pure %3\n",
+ "%2 = OpFunction %1 Const %3\n",
+ "%2 = OpFunction %1 Inline|Pure|Const %3\n",
+ "%2 = OpFunction %1 DontInline|Const %3\n",
+ })), );
INSTANTIATE_TEST_CASE_P(
ImageMasks, RoundTripInstructionsTest,
{SPV_GENERATOR_KHRONOS, 12, "Khronos; 12"},
{SPV_GENERATOR_LUNARG, 99, "LunarG; 99"},
{SPV_GENERATOR_VALVE, 1, "Valve; 1"},
- {SPV_GENERATOR_CODEPLAY, 65535,
- "Codeplay; 65535"},
+ {SPV_GENERATOR_CODEPLAY, 65535, "Codeplay; 65535"},
{SPV_GENERATOR_NVIDIA, 19, "NVIDIA; 19"},
{SPV_GENERATOR_ARM, 1000, "ARM; 1000"},
{SPV_GENERATOR_KHRONOS_LLVM_TRANSLATOR, 38,
namespace {
-using spvutils::BitWriterInterface;
using spvutils::BitReaderInterface;
-using spvutils::BitWriterWord64;
using spvutils::BitReaderWord64;
-using spvutils::StreamToBuffer;
-using spvutils::BufferToStream;
-using spvutils::NumBitsToNumWords;
-using spvutils::PadToWord;
-using spvutils::StreamToBitset;
using spvutils::BitsetToStream;
using spvutils::BitsToStream;
-using spvutils::StreamToBits;
-using spvutils::GetLowerBits;
-using spvutils::EncodeZigZag;
+using spvutils::BitWriterInterface;
+using spvutils::BitWriterWord64;
+using spvutils::BufferToStream;
using spvutils::DecodeZigZag;
+using spvutils::EncodeZigZag;
+using spvutils::GetLowerBits;
using spvutils::Log2U64;
+using spvutils::NumBitsToNumWords;
+using spvutils::PadToWord;
+using spvutils::StreamToBits;
+using spvutils::StreamToBitset;
+using spvutils::StreamToBuffer;
// A simple and inefficient implementatition of BitWriterInterface,
// using std::stringstream. Intended for tests only.
class BitWriterStringStream : public BitWriterInterface {
public:
- void WriteStream(const std::string& bits) override {
- ss_ << bits;
- }
+ void WriteStream(const std::string& bits) override { ss_ << bits; }
void WriteBits(uint64_t bits, size_t num_bits) override {
assert(num_bits <= 64);
ss_ << BitsToStream(bits, num_bits);
}
- size_t GetNumBits() const override {
- return ss_.str().size();
- }
+ size_t GetNumBits() const override { return ss_.str().size(); }
std::vector<uint8_t> GetDataCopy() const override {
return StreamToBuffer<uint8_t>(ss_.str());
}
- std::string GetStreamRaw() const {
- return ss_.str();
- }
+ std::string GetStreamRaw() const { return ss_.str(); }
private:
std::stringstream ss_;
: str_(PadToWord<64>(BufferToStream(buffer))), pos_(0) {}
size_t ReadBits(uint64_t* bits, size_t num_bits) override {
- if (ReachedEnd())
- return 0;
+ if (ReachedEnd()) return 0;
std::string sub = str_.substr(pos_, num_bits);
*bits = StreamToBits(sub);
pos_ += sub.length();
return sub.length();
}
- size_t GetNumReadBits() const override {
- return pos_;
- }
+ size_t GetNumReadBits() const override { return pos_; }
- bool ReachedEnd() const override {
- return pos_ >= str_.length();
- }
+ bool ReachedEnd() const override { return pos_ >= str_.length(); }
- const std::string& GetStreamPadded64() const {
- return str_;
- }
+ const std::string& GetStreamPadded64() const { return str_; }
private:
std::string str_;
EXPECT_EQ(0u, EncodeZigZag(0, 63));
for (int64_t i = 0; i < 0xFFFFFFFF; i += 1234567) {
- const int64_t positive_val = GetLowerBits(i * i * i + i * i, 63) | 1UL;
+ const int64_t positive_val = GetLowerBits(i * i * i + i * i, 63) | 1UL;
ASSERT_EQ(static_cast<uint64_t>(positive_val),
EncodeZigZag(positive_val, 63));
ASSERT_EQ((1ULL << 63) - 1 + positive_val, EncodeZigZag(-positive_val, 63));
TEST(BufToStream, UInt8_OneWord) {
const std::string expected_bits = "00101100";
std::vector<uint8_t> buffer = StreamToBuffer<uint8_t>(expected_bits);
- EXPECT_EQ(
- std::vector<uint8_t>(
- {static_cast<uint8_t>(StreamToBitset<8>(expected_bits).to_ulong())}),
- buffer);
+ EXPECT_EQ(std::vector<uint8_t>({static_cast<uint8_t>(
+ StreamToBitset<8>(expected_bits).to_ulong())}),
+ buffer);
const std::string result_bits = BufferToStream(buffer);
EXPECT_EQ(expected_bits, result_bits);
}
TEST(BufToStream, UInt8_MultipleWords) {
- const std::string expected_bits = "00100010""01101010""01111101""00100010";
+ const std::string expected_bits =
+ "00100010"
+ "01101010"
+ "01111101"
+ "00100010";
std::vector<uint8_t> buffer = StreamToBuffer<uint8_t>(expected_bits);
- EXPECT_EQ(
- std::vector<uint8_t>({
- static_cast<uint8_t>(StreamToBitset<8>("00100010").to_ulong()),
- static_cast<uint8_t>(StreamToBitset<8>("01101010").to_ulong()),
- static_cast<uint8_t>(StreamToBitset<8>("01111101").to_ulong()),
- static_cast<uint8_t>(StreamToBitset<8>("00100010").to_ulong()),
- }), buffer);
+ EXPECT_EQ(std::vector<uint8_t>({
+ static_cast<uint8_t>(StreamToBitset<8>("00100010").to_ulong()),
+ static_cast<uint8_t>(StreamToBitset<8>("01101010").to_ulong()),
+ static_cast<uint8_t>(StreamToBitset<8>("01111101").to_ulong()),
+ static_cast<uint8_t>(StreamToBitset<8>("00100010").to_ulong()),
+ }),
+ buffer);
const std::string result_bits = BufferToStream(buffer);
EXPECT_EQ(expected_bits, result_bits);
}
"0010001001101010011111111111111111111111";
std::vector<uint64_t> buffer = StreamToBuffer<uint64_t>(expected_bits);
EXPECT_EQ(std::vector<uint64_t>({
- StreamToBits(expected_bits.substr(0, 64)),
- StreamToBits(expected_bits.substr(64, 64)),
- }), buffer);
+ StreamToBits(expected_bits.substr(0, 64)),
+ StreamToBits(expected_bits.substr(64, 64)),
+ }),
+ buffer);
const std::string result_bits = BufferToStream(buffer);
EXPECT_EQ(PadToWord<64>(expected_bits), result_bits);
}
"0000000000000000000000000000000000000000000000000010010011111111";
std::vector<uint64_t> buffer = StreamToBuffer<uint64_t>(expected_bits);
EXPECT_EQ(std::vector<uint64_t>({
- StreamToBits(expected_bits.substr(0, 64)),
- StreamToBits(expected_bits.substr(64, 64)),
- StreamToBits(expected_bits.substr(128, 64)),
- }), buffer);
+ StreamToBits(expected_bits.substr(0, 64)),
+ StreamToBits(expected_bits.substr(64, 64)),
+ StreamToBits(expected_bits.substr(128, 64)),
+ }),
+ buffer);
const std::string result_bits = BufferToStream(buffer);
EXPECT_EQ(expected_bits, result_bits);
}
TEST(PadToWord, Test) {
EXPECT_EQ("10100000", PadToWord<8>("101"));
- EXPECT_EQ("10100000""00000000", PadToWord<16>("101"));
- EXPECT_EQ("10100000""00000000""00000000""00000000",
- PadToWord<32>("101"));
- EXPECT_EQ("10100000""00000000""00000000""00000000"
- "00000000""00000000""00000000""00000000",
- PadToWord<64>("101"));
+ EXPECT_EQ(
+ "10100000"
+ "00000000",
+ PadToWord<16>("101"));
+ EXPECT_EQ(
+ "10100000"
+ "00000000"
+ "00000000"
+ "00000000",
+ PadToWord<32>("101"));
+ EXPECT_EQ(
+ "10100000"
+ "00000000"
+ "00000000"
+ "00000000"
+ "00000000"
+ "00000000"
+ "00000000"
+ "00000000",
+ PadToWord<64>("101"));
}
TEST(BitWriterStringStream, Empty) {
writer.WriteBits(0, 0);
writer.WriteBits(7, 3);
writer.WriteBits(0, 0);
- EXPECT_EQ(PadToWord<64>(
+ EXPECT_EQ(
+ PadToWord<64>(
"1"
"000000000000000000000000000000000000000000000000000000000000000"
- "111"), writer.GetStreamPadded64());
+ "111"),
+ writer.GetStreamPadded64());
}
TEST(BitWriterWord64, ComparisonTestWriteLotsOfBits) {
ASSERT_EQ(writer1.GetNumBits(), writer2.GetNumBits());
}
- EXPECT_EQ(PadToWord<64>(writer1.GetStreamRaw()),
- writer2.GetStreamPadded64());
+ EXPECT_EQ(PadToWord<64>(writer1.GetStreamRaw()), writer2.GetStreamPadded64());
}
TEST(BitWriterWord64, ComparisonTestWriteLotsOfStreams) {
for (int i = 0; i < 1000; ++i) {
std::string bits = "1111100000";
- if (i % 2)
- bits += "101010";
- if (i % 3)
- bits += "1110100";
- if (i % 5)
- bits += "1110100111111111111";
+ if (i % 2) bits += "101010";
+ if (i % 3) bits += "1110100";
+ if (i % 5) bits += "1110100111111111111";
writer1.WriteStream(bits);
writer2.WriteStream(bits);
ASSERT_EQ(writer1.GetNumBits(), writer2.GetNumBits());
}
- EXPECT_EQ(PadToWord<64>(writer1.GetStreamRaw()),
- writer2.GetStreamPadded64());
+ EXPECT_EQ(PadToWord<64>(writer1.GetStreamRaw()), writer2.GetStreamPadded64());
}
TEST(BitWriterWord64, ComparisonTestWriteLotsOfBitsets) {
ASSERT_EQ(writer1.GetNumBits(), writer2.GetNumBits());
}
- EXPECT_EQ(PadToWord<64>(writer1.GetStreamRaw()),
- writer2.GetStreamPadded64());
+ EXPECT_EQ(PadToWord<64>(writer1.GetStreamRaw()), writer2.GetStreamPadded64());
}
TEST(GetLowerBits, Test) {
EXPECT_EQ(0xFFFFFFFFFFFFFFFFu,
GetLowerBits<uint64_t>(0xFFFFFFFFFFFFFFFFu, 64));
EXPECT_EQ(StreamToBits("1010001110"),
- GetLowerBits<uint64_t>(
- StreamToBits("1010001110111101111111"), 10));
+ GetLowerBits<uint64_t>(StreamToBits("1010001110111101111111"), 10));
}
TEST(BitReaderFromString, FromU8) {
std::vector<uint8_t> buffer = {
- 0xAA, 0xBB, 0xCC, 0xDD,
+ 0xAA,
+ 0xBB,
+ 0xCC,
+ 0xDD,
};
const std::string total_stream =
- "01010101""11011101""00110011""10111011";
+ "01010101"
+ "11011101"
+ "00110011"
+ "10111011";
BitReaderFromString reader(buffer);
EXPECT_EQ(PadToWord<64>(total_stream), reader.GetStreamPadded64());
TEST(BitReaderFromString, FromU64) {
std::vector<uint64_t> buffer = {
- 0xAAAAAAAAAAAAAAAA,
- 0xBBBBBBBBBBBBBBBB,
- 0xCCCCCCCCCCCCCCCC,
- 0xDDDDDDDDDDDDDDDD,
+ 0xAAAAAAAAAAAAAAAA,
+ 0xBBBBBBBBBBBBBBBB,
+ 0xCCCCCCCCCCCCCCCC,
+ 0xDDDDDDDDDDDDDDDD,
};
const std::string total_stream =
}
TEST(BitReaderWord64, ReadBitsTwoWords) {
- std::vector<uint64_t> buffer = {
- 0x0000000000000001,
- 0x0000000000FFFFFF
- };
+ std::vector<uint64_t> buffer = {0x0000000000000001, 0x0000000000FFFFFF};
BitReaderWord64 reader(std::move(buffer));
TEST(BitReaderWord64, FromU8) {
std::vector<uint8_t> buffer = {
- 0xAA, 0xBB, 0xCC, 0xDD,
+ 0xAA,
+ 0xBB,
+ 0xCC,
+ 0xDD,
};
BitReaderWord64 reader(std::move(buffer));
TEST(BitReaderWord64, FromU64) {
std::vector<uint64_t> buffer = {
- 0xAAAAAAAAAAAAAAAA,
- 0xBBBBBBBBBBBBBBBB,
- 0xCCCCCCCCCCCCCCCC,
- 0xDDDDDDDDDDDDDDDD,
+ 0xAAAAAAAAAAAAAAAA,
+ 0xBBBBBBBBBBBBBBBB,
+ 0xCCCCCCCCCCCCCCCC,
+ 0xDDDDDDDDDDDDDDDD,
};
const std::string total_stream =
TEST(BitReaderWord64, ComparisonLotsOfU8) {
std::vector<uint8_t> buffer;
- for(uint32_t i = 0; i < 10003; ++i) {
+ for (uint32_t i = 0; i < 10003; ++i) {
buffer.push_back(static_cast<uint8_t>(i % 255));
}
TEST(BitReaderWord64, ComparisonLotsOfU64) {
std::vector<uint64_t> buffer;
- for(uint64_t i = 0; i < 1000; ++i) {
+ for (uint64_t i = 0; i < 1000; ++i) {
buffer.push_back(i);
}
TEST(VariableWidthWrite, Write0U) {
BitWriterStringStream writer;
writer.WriteVariableWidthU64(0, 2);
- EXPECT_EQ("000", writer.GetStreamRaw ());
+ EXPECT_EQ("000", writer.GetStreamRaw());
writer.WriteVariableWidthU32(0, 2);
- EXPECT_EQ("000""000", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "000"
+ "000",
+ writer.GetStreamRaw());
writer.WriteVariableWidthU16(0, 2);
- EXPECT_EQ("000""000""000", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "000"
+ "000"
+ "000",
+ writer.GetStreamRaw());
writer.WriteVariableWidthU8(0, 2);
- EXPECT_EQ("000""000""000""000", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "000"
+ "000"
+ "000"
+ "000",
+ writer.GetStreamRaw());
}
TEST(VariableWidthWrite, Write0S) {
BitWriterStringStream writer;
writer.WriteVariableWidthS64(0, 2, 0);
- EXPECT_EQ("000", writer.GetStreamRaw ());
+ EXPECT_EQ("000", writer.GetStreamRaw());
writer.WriteVariableWidthS32(0, 2, 0);
- EXPECT_EQ("000""000", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "000"
+ "000",
+ writer.GetStreamRaw());
writer.WriteVariableWidthS16(0, 2, 0);
- EXPECT_EQ("000""000""000", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "000"
+ "000"
+ "000",
+ writer.GetStreamRaw());
writer.WriteVariableWidthS8(0, 2, 0);
- EXPECT_EQ("000""000""000""000", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "000"
+ "000"
+ "000"
+ "000",
+ writer.GetStreamRaw());
}
TEST(VariableWidthWrite, WriteSmallUnsigned) {
BitWriterStringStream writer;
writer.WriteVariableWidthU64(1, 2);
- EXPECT_EQ("100", writer.GetStreamRaw ());
+ EXPECT_EQ("100", writer.GetStreamRaw());
writer.WriteVariableWidthU32(2, 2);
- EXPECT_EQ("100""010", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "100"
+ "010",
+ writer.GetStreamRaw());
writer.WriteVariableWidthU16(3, 2);
- EXPECT_EQ("100""010""110", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "100"
+ "010"
+ "110",
+ writer.GetStreamRaw());
writer.WriteVariableWidthU8(4, 2);
- EXPECT_EQ("100""010""110""001100", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "100"
+ "010"
+ "110"
+ "001100",
+ writer.GetStreamRaw());
}
TEST(VariableWidthWrite, WriteSmallSigned) {
BitWriterStringStream writer;
writer.WriteVariableWidthS64(1, 2, 0);
- EXPECT_EQ("010", writer.GetStreamRaw ());
+ EXPECT_EQ("010", writer.GetStreamRaw());
writer.WriteVariableWidthS64(-1, 2, 0);
- EXPECT_EQ("010""100", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "010"
+ "100",
+ writer.GetStreamRaw());
writer.WriteVariableWidthS16(3, 2, 0);
- EXPECT_EQ("010""100""011100", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "010"
+ "100"
+ "011100",
+ writer.GetStreamRaw());
writer.WriteVariableWidthS8(-4, 2, 0);
- EXPECT_EQ("010""100""011100""111100", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "010"
+ "100"
+ "011100"
+ "111100",
+ writer.GetStreamRaw());
}
TEST(VariableWidthWrite, U64Val127ChunkLength7) {
BitWriterStringStream writer;
writer.WriteVariableWidthU64(127, 7);
- EXPECT_EQ("1111111""0", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "1111111"
+ "0",
+ writer.GetStreamRaw());
}
TEST(VariableWidthWrite, U32Val255ChunkLength7) {
BitWriterStringStream writer;
writer.WriteVariableWidthU32(255, 7);
- EXPECT_EQ("1111111""1""1000000""0", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "1111111"
+ "1"
+ "1000000"
+ "0",
+ writer.GetStreamRaw());
}
TEST(VariableWidthWrite, U16Val2ChunkLength4) {
BitWriterStringStream writer;
writer.WriteVariableWidthU16(2, 4);
- EXPECT_EQ("0100""0", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "0100"
+ "0",
+ writer.GetStreamRaw());
}
TEST(VariableWidthWrite, U8Val128ChunkLength7) {
BitWriterStringStream writer;
writer.WriteVariableWidthU8(128, 7);
- EXPECT_EQ("0000000""1""1", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "0000000"
+ "1"
+ "1",
+ writer.GetStreamRaw());
}
TEST(VariableWidthWrite, U64ValAAAAChunkLength2) {
BitWriterStringStream writer;
writer.WriteVariableWidthU64(0xAAAA, 2);
- EXPECT_EQ("01""1""01""1""01""1""01""1"
- "01""1""01""1""01""1""01""0", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "0",
+ writer.GetStreamRaw());
}
TEST(VariableWidthWrite, S8ValM128ChunkLength7) {
BitWriterStringStream writer;
writer.WriteVariableWidthS8(-128, 7, 0);
- EXPECT_EQ("1111111""1""1", writer.GetStreamRaw());
+ EXPECT_EQ(
+ "1111111"
+ "1"
+ "1",
+ writer.GetStreamRaw());
}
TEST(VariableWidthRead, U64Val127ChunkLength7) {
- BitReaderFromString reader("1111111""0");
+ BitReaderFromString reader(
+ "1111111"
+ "0");
uint64_t val = 0;
ASSERT_TRUE(reader.ReadVariableWidthU64(&val, 7));
EXPECT_EQ(127u, val);
}
TEST(VariableWidthRead, U32Val255ChunkLength7) {
- BitReaderFromString reader("1111111""1""1000000""0");
+ BitReaderFromString reader(
+ "1111111"
+ "1"
+ "1000000"
+ "0");
uint32_t val = 0;
ASSERT_TRUE(reader.ReadVariableWidthU32(&val, 7));
EXPECT_EQ(255u, val);
}
TEST(VariableWidthRead, U16Val2ChunkLength4) {
- BitReaderFromString reader("0100""0");
+ BitReaderFromString reader(
+ "0100"
+ "0");
uint16_t val = 0;
ASSERT_TRUE(reader.ReadVariableWidthU16(&val, 4));
EXPECT_EQ(2u, val);
}
TEST(VariableWidthRead, U8Val128ChunkLength7) {
- BitReaderFromString reader("0000000""1""1");
+ BitReaderFromString reader(
+ "0000000"
+ "1"
+ "1");
uint8_t val = 0;
ASSERT_TRUE(reader.ReadVariableWidthU8(&val, 7));
EXPECT_EQ(128u, val);
}
TEST(VariableWidthRead, U64ValAAAAChunkLength2) {
- BitReaderFromString reader("01""1""01""1""01""1""01""1"
- "01""1""01""1""01""1""01""0");
+ BitReaderFromString reader(
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "1"
+ "01"
+ "0");
uint64_t val = 0;
ASSERT_TRUE(reader.ReadVariableWidthU64(&val, 2));
EXPECT_EQ(0xAAAAu, val);
}
TEST(VariableWidthRead, S8ValM128ChunkLength7) {
- BitReaderFromString reader("1111111""1""1");
+ BitReaderFromString reader(
+ "1111111"
+ "1"
+ "1");
int8_t val = 0;
ASSERT_TRUE(reader.ReadVariableWidthS8(&val, 7, 0));
EXPECT_EQ(-128, val);
BitReaderWord64 reader(writer.GetDataCopy());
int64_t read_val = 0;
- ASSERT_TRUE(reader.ReadVariableWidthS64(&read_val, chunk_length,
- zigzag_exponent));
+ ASSERT_TRUE(
+ reader.ReadVariableWidthS64(&read_val, chunk_length, zigzag_exponent));
ASSERT_EQ(val, read_val) << "Chunk length " << chunk_length;
}
BitReaderWord64 reader(writer.GetDataCopy());
int32_t read_val = 0;
- ASSERT_TRUE(reader.ReadVariableWidthS32(
- &read_val, chunk_length, zigzag_exponent));
+ ASSERT_TRUE(
+ reader.ReadVariableWidthS32(&read_val, chunk_length, zigzag_exponent));
ASSERT_EQ(val, read_val) << "Chunk length " << chunk_length;
}
BitReaderWord64 reader(writer.GetDataCopy());
int16_t read_val = 0;
- ASSERT_TRUE(reader.ReadVariableWidthS16(&read_val, chunk_length,
- zigzag_exponent));
+ ASSERT_TRUE(
+ reader.ReadVariableWidthS16(&read_val, chunk_length, zigzag_exponent));
ASSERT_EQ(val, read_val) << "Chunk length " << chunk_length;
}
BitReaderWord64 reader(writer.GetDataCopy());
int8_t read_val = 0;
- ASSERT_TRUE(reader.ReadVariableWidthS8(&read_val, chunk_length,
- zigzag_exponent));
+ ASSERT_TRUE(
+ reader.ReadVariableWidthS8(&read_val, chunk_length, zigzag_exponent));
ASSERT_EQ(val, read_val) << "Chunk length " << chunk_length;
}
std::vector<uint64_t> actual_values;
BitReaderWord64 reader(writer.GetDataCopy());
- while(!reader.OnlyZeroesLeft()) {
+ while (!reader.OnlyZeroesLeft()) {
uint64_t val = 0;
ASSERT_TRUE(reader.ReadVariableWidthU64(&val, 4));
actual_values.push_back(val);
namespace {
using libspirv::SetContextMessageConsumer;
-using spvtools::MarkvModelType;
using spvtest::ScopedContext;
+using spvtools::MarkvModelType;
using MarkvTest = ::testing::TestWithParam<MarkvModelType>;
void DiagnosticsMessageHandler(spv_message_level_t level, const char*,
case SPV_MSG_FATAL:
case SPV_MSG_INTERNAL_ERROR:
case SPV_MSG_ERROR:
- std::cerr << "error: " << position.index << ": " << message
- << std::endl;
+ std::cerr << "error: " << position.index << ": " << message << std::endl;
break;
case SPV_MSG_WARNING:
std::cout << "warning: " << position.index << ": " << message
SetContextMessageConsumer(ctx.context, DiagnosticsMessageHandler);
spv_binary spirv_binary;
- ASSERT_EQ(SPV_SUCCESS, spvTextToBinaryWithOptions(
- ctx.context, code.c_str(), code.size(), options, &spirv_binary, nullptr));
+ ASSERT_EQ(SPV_SUCCESS,
+ spvTextToBinaryWithOptions(ctx.context, code.c_str(), code.size(),
+ options, &spirv_binary, nullptr));
- *words = std::vector<uint32_t>(
- spirv_binary->code, spirv_binary->code + spirv_binary->wordCount);
+ *words = std::vector<uint32_t>(spirv_binary->code,
+ spirv_binary->code + spirv_binary->wordCount);
spvBinaryDestroy(spirv_binary);
}
// Disassembles SPIR-V |words| to |out_text|.
-void Disassemble(const std::vector<uint32_t>& words,
- std::string* out_text,
+void Disassemble(const std::vector<uint32_t>& words, std::string* out_text,
spv_target_env env = SPV_ENV_UNIVERSAL_1_2) {
ScopedContext ctx(env);
SetContextMessageConsumer(ctx.context, DiagnosticsMessageHandler);
std::stringstream encoder_comments;
const auto output_to_string_stream =
- [&encoder_comments](const std::string& str) {
- encoder_comments << str;
- };
+ [&encoder_comments](const std::string& str) { encoder_comments << str; };
std::vector<uint8_t> markv;
ASSERT_EQ(SPV_SUCCESS, spvtools::SpirvToMarkv(
- ctx.context, binary_to_encode, options, *model,
- DiagnosticsMessageHandler, output_to_string_stream,
- spvtools::MarkvDebugConsumer(), &markv));
+ ctx.context, binary_to_encode, options, *model,
+ DiagnosticsMessageHandler, output_to_string_stream,
+ spvtools::MarkvDebugConsumer(), &markv));
ASSERT_FALSE(markv.empty());
std::vector<uint32_t> decoded_binary;
- ASSERT_EQ(SPV_SUCCESS, spvtools::MarkvToSpirv(
- ctx.context, markv, options, *model,
- DiagnosticsMessageHandler, spvtools::MarkvLogConsumer(),
- spvtools::MarkvDebugConsumer(), &decoded_binary));
+ ASSERT_EQ(SPV_SUCCESS,
+ spvtools::MarkvToSpirv(
+ ctx.context, markv, options, *model, DiagnosticsMessageHandler,
+ spvtools::MarkvLogConsumer(), spvtools::MarkvDebugConsumer(),
+ &decoded_binary));
ASSERT_FALSE(decoded_binary.empty());
EXPECT_EQ(expected_binary, decoded_binary) << encoder_comments.str();
void TestEncodeDecodeShaderMainBody(MarkvModelType model_type,
const std::string& body) {
const std::string prefix =
-R"(
+ R"(
OpCapability Shader
OpCapability Int64
OpCapability Float64
%main_entry = OpLabel)";
const std::string suffix =
-R"(
+ R"(
OpReturn
OpFunctionEnd)";
)");
}
-INSTANTIATE_TEST_CASE_P(
- AllMarkvModels, MarkvTest,
- ::testing::ValuesIn(std::vector<MarkvModelType>{
- spvtools::kMarkvModelShaderLite,
- spvtools::kMarkvModelShaderMid,
- spvtools::kMarkvModelShaderMax,
- }),);
+INSTANTIATE_TEST_CASE_P(AllMarkvModels, MarkvTest,
+ ::testing::ValuesIn(std::vector<MarkvModelType>{
+ spvtools::kMarkvModelShaderLite,
+ spvtools::kMarkvModelShaderMid,
+ spvtools::kMarkvModelShaderMax,
+ }), );
} // namespace
spv_result_t(DiagnosticStream({}, nullptr, SPV_FAILED_MATCH)));
}
-TEST(DiagnosticStream, MoveConstructorPreservesPreviousMessagesAndPreventsOutputFromExpiringValue) {
+TEST(
+ DiagnosticStream,
+ MoveConstructorPreservesPreviousMessagesAndPreventsOutputFromExpiringValue) {
std::ostringstream messages;
int message_count = 0;
auto consumer = [&messages, &message_count](spv_message_level_t, const char*,
namespace {
-using libspirv::EnumSet;
using libspirv::CapabilitySet;
+using libspirv::EnumSet;
using spvtest::ElementsIn;
using ::testing::Eq;
using ::testing::ValuesIn;
using ::testing::Values;
using ::testing::ValuesIn;
-using ExtensionTest = ::testing::TestWithParam<std::pair<Extension, std::string>>;
+using ExtensionTest =
+ ::testing::TestWithParam<std::pair<Extension, std::string>>;
using UnknownExtensionTest = ::testing::TestWithParam<std::string>;
-using CapabilityTest = ::testing::TestWithParam<std::pair<SpvCapability, std::string>>;
+using CapabilityTest =
+ ::testing::TestWithParam<std::pair<SpvCapability, std::string>>;
TEST_P(ExtensionTest, TestExtensionFromString) {
const std::pair<Extension, std::string>& param = GetParam();
const Extension extension = param.first;
const std::string extension_str = param.second;
Extension result_extension;
- ASSERT_TRUE(libspirv::GetExtensionFromString(extension_str, &result_extension));
+ ASSERT_TRUE(
+ libspirv::GetExtensionFromString(extension_str, &result_extension));
EXPECT_EQ(extension, result_extension);
}
EXPECT_EQ(capability_str, result_str);
}
-INSTANTIATE_TEST_CASE_P(AllExtensions, ExtensionTest,
- ValuesIn(std::vector<std::pair<Extension, std::string>>({
- {Extension::kSPV_KHR_16bit_storage,
- "SPV_KHR_16bit_storage"},
- {Extension::kSPV_KHR_device_group,
- "SPV_KHR_device_group"},
- {Extension::kSPV_KHR_multiview,
- "SPV_KHR_multiview"},
- {Extension::kSPV_KHR_shader_ballot,
- "SPV_KHR_shader_ballot"},
- {Extension::kSPV_KHR_shader_draw_parameters,
- "SPV_KHR_shader_draw_parameters"},
- {Extension::kSPV_KHR_subgroup_vote,
- "SPV_KHR_subgroup_vote"},
- {Extension::kSPV_NVX_multiview_per_view_attributes,
- "SPV_NVX_multiview_per_view_attributes"},
- {Extension::kSPV_NV_geometry_shader_passthrough,
- "SPV_NV_geometry_shader_passthrough"},
- {Extension::kSPV_NV_sample_mask_override_coverage,
- "SPV_NV_sample_mask_override_coverage"},
- {Extension::kSPV_NV_stereo_view_rendering,
- "SPV_NV_stereo_view_rendering"},
- {Extension::kSPV_NV_viewport_array2,
- "SPV_NV_viewport_array2"}
- })));
+INSTANTIATE_TEST_CASE_P(
+ AllExtensions, ExtensionTest,
+ ValuesIn(std::vector<std::pair<Extension, std::string>>(
+ {{Extension::kSPV_KHR_16bit_storage, "SPV_KHR_16bit_storage"},
+ {Extension::kSPV_KHR_device_group, "SPV_KHR_device_group"},
+ {Extension::kSPV_KHR_multiview, "SPV_KHR_multiview"},
+ {Extension::kSPV_KHR_shader_ballot, "SPV_KHR_shader_ballot"},
+ {Extension::kSPV_KHR_shader_draw_parameters,
+ "SPV_KHR_shader_draw_parameters"},
+ {Extension::kSPV_KHR_subgroup_vote, "SPV_KHR_subgroup_vote"},
+ {Extension::kSPV_NVX_multiview_per_view_attributes,
+ "SPV_NVX_multiview_per_view_attributes"},
+ {Extension::kSPV_NV_geometry_shader_passthrough,
+ "SPV_NV_geometry_shader_passthrough"},
+ {Extension::kSPV_NV_sample_mask_override_coverage,
+ "SPV_NV_sample_mask_override_coverage"},
+ {Extension::kSPV_NV_stereo_view_rendering,
+ "SPV_NV_stereo_view_rendering"},
+ {Extension::kSPV_NV_viewport_array2, "SPV_NV_viewport_array2"}})));
-INSTANTIATE_TEST_CASE_P(UnknownExtensions, UnknownExtensionTest, Values(
- "",
- "SPV_KHR_",
- "SPV_KHR_device_group_ERROR",
- "SPV_ERROR_random_string_hfsdklhlktherh"
- ));
+INSTANTIATE_TEST_CASE_P(UnknownExtensions, UnknownExtensionTest,
+ Values("", "SPV_KHR_", "SPV_KHR_device_group_ERROR",
+ "SPV_ERROR_random_string_hfsdklhlktherh"));
-INSTANTIATE_TEST_CASE_P(AllCapabilities, CapabilityTest,
- ValuesIn(std::vector<std::pair<SpvCapability, std::string>>({
- {SpvCapabilityMatrix,
- "Matrix"},
- {SpvCapabilityShader,
- "Shader"},
- {SpvCapabilityGeometry,
- "Geometry"},
- {SpvCapabilityTessellation,
- "Tessellation"},
- {SpvCapabilityAddresses,
- "Addresses"},
- {SpvCapabilityLinkage,
- "Linkage"},
- {SpvCapabilityKernel,
- "Kernel"},
- {SpvCapabilityVector16,
- "Vector16"},
- {SpvCapabilityFloat16Buffer,
- "Float16Buffer"},
- {SpvCapabilityFloat16,
- "Float16"},
- {SpvCapabilityFloat64,
- "Float64"},
- {SpvCapabilityInt64,
- "Int64"},
- {SpvCapabilityInt64Atomics,
- "Int64Atomics"},
- {SpvCapabilityImageBasic,
- "ImageBasic"},
- {SpvCapabilityImageReadWrite,
- "ImageReadWrite"},
- {SpvCapabilityImageMipmap,
- "ImageMipmap"},
- {SpvCapabilityPipes,
- "Pipes"},
- {SpvCapabilityGroups,
- "Groups"},
- {SpvCapabilityDeviceEnqueue,
- "DeviceEnqueue"},
- {SpvCapabilityLiteralSampler,
- "LiteralSampler"},
- {SpvCapabilityAtomicStorage,
- "AtomicStorage"},
- {SpvCapabilityInt16,
- "Int16"},
- {SpvCapabilityTessellationPointSize,
- "TessellationPointSize"},
- {SpvCapabilityGeometryPointSize,
- "GeometryPointSize"},
- {SpvCapabilityImageGatherExtended,
- "ImageGatherExtended"},
- {SpvCapabilityStorageImageMultisample,
- "StorageImageMultisample"},
- {SpvCapabilityUniformBufferArrayDynamicIndexing,
- "UniformBufferArrayDynamicIndexing"},
- {SpvCapabilitySampledImageArrayDynamicIndexing,
- "SampledImageArrayDynamicIndexing"},
- {SpvCapabilityStorageBufferArrayDynamicIndexing,
- "StorageBufferArrayDynamicIndexing"},
- {SpvCapabilityStorageImageArrayDynamicIndexing,
- "StorageImageArrayDynamicIndexing"},
- {SpvCapabilityClipDistance,
- "ClipDistance"},
- {SpvCapabilityCullDistance,
- "CullDistance"},
- {SpvCapabilityImageCubeArray,
- "ImageCubeArray"},
- {SpvCapabilitySampleRateShading,
- "SampleRateShading"},
- {SpvCapabilityImageRect,
- "ImageRect"},
- {SpvCapabilitySampledRect,
- "SampledRect"},
- {SpvCapabilityGenericPointer,
- "GenericPointer"},
- {SpvCapabilityInt8,
- "Int8"},
- {SpvCapabilityInputAttachment,
- "InputAttachment"},
- {SpvCapabilitySparseResidency,
- "SparseResidency"},
- {SpvCapabilityMinLod,
- "MinLod"},
- {SpvCapabilitySampled1D,
- "Sampled1D"},
- {SpvCapabilityImage1D,
- "Image1D"},
- {SpvCapabilitySampledCubeArray,
- "SampledCubeArray"},
- {SpvCapabilitySampledBuffer,
- "SampledBuffer"},
- {SpvCapabilityImageBuffer,
- "ImageBuffer"},
- {SpvCapabilityImageMSArray,
- "ImageMSArray"},
- {SpvCapabilityStorageImageExtendedFormats,
- "StorageImageExtendedFormats"},
- {SpvCapabilityImageQuery,
- "ImageQuery"},
- {SpvCapabilityDerivativeControl,
- "DerivativeControl"},
- {SpvCapabilityInterpolationFunction,
- "InterpolationFunction"},
- {SpvCapabilityTransformFeedback,
- "TransformFeedback"},
- {SpvCapabilityGeometryStreams,
- "GeometryStreams"},
- {SpvCapabilityStorageImageReadWithoutFormat,
- "StorageImageReadWithoutFormat"},
- {SpvCapabilityStorageImageWriteWithoutFormat,
- "StorageImageWriteWithoutFormat"},
- {SpvCapabilityMultiViewport,
- "MultiViewport"},
- {SpvCapabilitySubgroupDispatch,
- "SubgroupDispatch"},
- {SpvCapabilityNamedBarrier,
- "NamedBarrier"},
- {SpvCapabilityPipeStorage,
- "PipeStorage"},
- {SpvCapabilitySubgroupBallotKHR,
- "SubgroupBallotKHR"},
- {SpvCapabilityDrawParameters,
- "DrawParameters"},
- {SpvCapabilitySubgroupVoteKHR,
- "SubgroupVoteKHR"},
- {SpvCapabilityStorageBuffer16BitAccess,
- "StorageBuffer16BitAccess"},
- {SpvCapabilityStorageUniformBufferBlock16,
- "StorageBuffer16BitAccess"}, // Preferred name
- {SpvCapabilityUniformAndStorageBuffer16BitAccess,
- "UniformAndStorageBuffer16BitAccess"},
- {SpvCapabilityStorageUniform16,
- "UniformAndStorageBuffer16BitAccess"}, // Preferred name
- {SpvCapabilityStoragePushConstant16,
- "StoragePushConstant16"},
- {SpvCapabilityStorageInputOutput16,
- "StorageInputOutput16"},
- {SpvCapabilityDeviceGroup,
- "DeviceGroup"},
- {SpvCapabilityMultiView,
- "MultiView"},
- {SpvCapabilitySampleMaskOverrideCoverageNV,
- "SampleMaskOverrideCoverageNV"},
- {SpvCapabilityGeometryShaderPassthroughNV,
- "GeometryShaderPassthroughNV"},
- // The next two are different names for the same token.
- {SpvCapabilityShaderViewportIndexLayerNV,
- "ShaderViewportIndexLayerEXT"},
- {SpvCapabilityShaderViewportIndexLayerEXT,
- "ShaderViewportIndexLayerEXT"},
- {SpvCapabilityShaderViewportMaskNV,
- "ShaderViewportMaskNV"},
- {SpvCapabilityShaderStereoViewNV,
- "ShaderStereoViewNV"},
- {SpvCapabilityPerViewAttributesNV,
- "PerViewAttributesNV"}
- })), );
+INSTANTIATE_TEST_CASE_P(
+ AllCapabilities, CapabilityTest,
+ ValuesIn(std::vector<std::pair<SpvCapability, std::string>>(
+ {{SpvCapabilityMatrix, "Matrix"},
+ {SpvCapabilityShader, "Shader"},
+ {SpvCapabilityGeometry, "Geometry"},
+ {SpvCapabilityTessellation, "Tessellation"},
+ {SpvCapabilityAddresses, "Addresses"},
+ {SpvCapabilityLinkage, "Linkage"},
+ {SpvCapabilityKernel, "Kernel"},
+ {SpvCapabilityVector16, "Vector16"},
+ {SpvCapabilityFloat16Buffer, "Float16Buffer"},
+ {SpvCapabilityFloat16, "Float16"},
+ {SpvCapabilityFloat64, "Float64"},
+ {SpvCapabilityInt64, "Int64"},
+ {SpvCapabilityInt64Atomics, "Int64Atomics"},
+ {SpvCapabilityImageBasic, "ImageBasic"},
+ {SpvCapabilityImageReadWrite, "ImageReadWrite"},
+ {SpvCapabilityImageMipmap, "ImageMipmap"},
+ {SpvCapabilityPipes, "Pipes"},
+ {SpvCapabilityGroups, "Groups"},
+ {SpvCapabilityDeviceEnqueue, "DeviceEnqueue"},
+ {SpvCapabilityLiteralSampler, "LiteralSampler"},
+ {SpvCapabilityAtomicStorage, "AtomicStorage"},
+ {SpvCapabilityInt16, "Int16"},
+ {SpvCapabilityTessellationPointSize, "TessellationPointSize"},
+ {SpvCapabilityGeometryPointSize, "GeometryPointSize"},
+ {SpvCapabilityImageGatherExtended, "ImageGatherExtended"},
+ {SpvCapabilityStorageImageMultisample, "StorageImageMultisample"},
+ {SpvCapabilityUniformBufferArrayDynamicIndexing,
+ "UniformBufferArrayDynamicIndexing"},
+ {SpvCapabilitySampledImageArrayDynamicIndexing,
+ "SampledImageArrayDynamicIndexing"},
+ {SpvCapabilityStorageBufferArrayDynamicIndexing,
+ "StorageBufferArrayDynamicIndexing"},
+ {SpvCapabilityStorageImageArrayDynamicIndexing,
+ "StorageImageArrayDynamicIndexing"},
+ {SpvCapabilityClipDistance, "ClipDistance"},
+ {SpvCapabilityCullDistance, "CullDistance"},
+ {SpvCapabilityImageCubeArray, "ImageCubeArray"},
+ {SpvCapabilitySampleRateShading, "SampleRateShading"},
+ {SpvCapabilityImageRect, "ImageRect"},
+ {SpvCapabilitySampledRect, "SampledRect"},
+ {SpvCapabilityGenericPointer, "GenericPointer"},
+ {SpvCapabilityInt8, "Int8"},
+ {SpvCapabilityInputAttachment, "InputAttachment"},
+ {SpvCapabilitySparseResidency, "SparseResidency"},
+ {SpvCapabilityMinLod, "MinLod"},
+ {SpvCapabilitySampled1D, "Sampled1D"},
+ {SpvCapabilityImage1D, "Image1D"},
+ {SpvCapabilitySampledCubeArray, "SampledCubeArray"},
+ {SpvCapabilitySampledBuffer, "SampledBuffer"},
+ {SpvCapabilityImageBuffer, "ImageBuffer"},
+ {SpvCapabilityImageMSArray, "ImageMSArray"},
+ {SpvCapabilityStorageImageExtendedFormats,
+ "StorageImageExtendedFormats"},
+ {SpvCapabilityImageQuery, "ImageQuery"},
+ {SpvCapabilityDerivativeControl, "DerivativeControl"},
+ {SpvCapabilityInterpolationFunction, "InterpolationFunction"},
+ {SpvCapabilityTransformFeedback, "TransformFeedback"},
+ {SpvCapabilityGeometryStreams, "GeometryStreams"},
+ {SpvCapabilityStorageImageReadWithoutFormat,
+ "StorageImageReadWithoutFormat"},
+ {SpvCapabilityStorageImageWriteWithoutFormat,
+ "StorageImageWriteWithoutFormat"},
+ {SpvCapabilityMultiViewport, "MultiViewport"},
+ {SpvCapabilitySubgroupDispatch, "SubgroupDispatch"},
+ {SpvCapabilityNamedBarrier, "NamedBarrier"},
+ {SpvCapabilityPipeStorage, "PipeStorage"},
+ {SpvCapabilitySubgroupBallotKHR, "SubgroupBallotKHR"},
+ {SpvCapabilityDrawParameters, "DrawParameters"},
+ {SpvCapabilitySubgroupVoteKHR, "SubgroupVoteKHR"},
+ {SpvCapabilityStorageBuffer16BitAccess, "StorageBuffer16BitAccess"},
+ {SpvCapabilityStorageUniformBufferBlock16,
+ "StorageBuffer16BitAccess"}, // Preferred name
+ {SpvCapabilityUniformAndStorageBuffer16BitAccess,
+ "UniformAndStorageBuffer16BitAccess"},
+ {SpvCapabilityStorageUniform16,
+ "UniformAndStorageBuffer16BitAccess"}, // Preferred name
+ {SpvCapabilityStoragePushConstant16, "StoragePushConstant16"},
+ {SpvCapabilityStorageInputOutput16, "StorageInputOutput16"},
+ {SpvCapabilityDeviceGroup, "DeviceGroup"},
+ {SpvCapabilityMultiView, "MultiView"},
+ {SpvCapabilitySampleMaskOverrideCoverageNV,
+ "SampleMaskOverrideCoverageNV"},
+ {SpvCapabilityGeometryShaderPassthroughNV,
+ "GeometryShaderPassthroughNV"},
+ // The next two are different names for the same token.
+ {SpvCapabilityShaderViewportIndexLayerNV,
+ "ShaderViewportIndexLayerEXT"},
+ {SpvCapabilityShaderViewportIndexLayerEXT,
+ "ShaderViewportIndexLayerEXT"},
+ {SpvCapabilityShaderViewportMaskNV, "ShaderViewportMaskNV"},
+ {SpvCapabilityShaderStereoViewNV, "ShaderStereoViewNV"},
+ {SpvCapabilityPerViewAttributesNV, "PerViewAttributesNV"}})), );
} // anonymous namespace
#include <algorithm>
#include <vector>
-#include "unit_spirv.h"
#include "spirv/1.0/GLSL.std.450.h"
+#include "unit_spirv.h"
namespace {
#include "unit_spirv.h"
#include <gmock/gmock.h>
-#include "test_fixture.h"
#include "spirv/1.0/OpenCL.std.h"
+#include "test_fixture.h"
namespace {
"Khronos LLVM/SPIR-V Translator"},
{SPV_GENERATOR_KHRONOS_ASSEMBLER, "Khronos SPIR-V Tools Assembler"},
{SPV_GENERATOR_KHRONOS_GLSLANG, "Khronos Glslang Reference Front End"},
- }),);
+ }), );
INSTANTIATE_TEST_CASE_P(
Unregistered, GeneratorMagicNumberTest,
// which can change over time.
{spv_generator_t(1000), "Unknown"},
{spv_generator_t(9999), "Unknown"},
- }),);
+ }), );
} // anonymous namespace
#include "unit_spirv.h"
namespace {
-using ::testing::Eq;
using spvutils::BitwiseCast;
using spvutils::Float16;
using spvutils::FloatProxy;
using spvutils::HexFloat;
using spvutils::ParseNormalFloat;
+using ::testing::Eq;
// In this file "encode" means converting a number into a string,
// and "decode" means converting a string into a number.
{float(ldexp(1.0, -127) / 2.0 + (ldexp(1.0, -127) / 4.0f)),
"0x1.8p-128"},
- })),);
+ })), );
INSTANTIATE_TEST_CASE_P(
Float32NanTests, HexFloatTest,
{uint32_t(0x7f800c00), "0x1.0018p+128"}, // +nan
{uint32_t(0x7F80F000), "0x1.01ep+128"}, // +nan
{uint32_t(0x7FFFFFFF), "0x1.fffffep+128"}, // +nan
- })),);
+ })), );
INSTANTIATE_TEST_CASE_P(
Float64Tests, HexDoubleTest,
{ldexp(1.0, -1023) / 2.0 + (ldexp(1.0, -1023) / 4.0),
"0x1.8p-1024"},
- })),);
+ })), );
INSTANTIATE_TEST_CASE_P(
Float64NanTests, HexDoubleTest,
{uint64_t(0x7FF0000000000001LL), "0x1.0000000000001p+1024"}, // -nan
{uint64_t(0x7FF0000300000000LL), "0x1.00003p+1024"}, // -nan
{uint64_t(0x7FFFFFFFFFFFFFFFLL), "0x1.fffffffffffffp+1024"}, // -nan
- })),);
+ })), );
TEST(HexFloatStreamTest, OperatorLeftShiftPreservesFloatAndFill) {
std::stringstream s;
{"0xFFp+0", 255.f},
{"0x0.8p+0", 0.5f},
{"0x0.4p+0", 0.25f},
- })),);
+ })), );
INSTANTIATE_TEST_CASE_P(
Float32DecodeInfTests, DecodeHexFloatTest,
{"0x32p+127", uint32_t(0x7F800000)}, // inf
{"0x32p+500", uint32_t(0x7F800000)}, // inf
{"-0x32p+127", uint32_t(0xFF800000)}, // -inf
- })),);
+ })), );
INSTANTIATE_TEST_CASE_P(
Float64DecodeTests, DecodeHexDoubleTest,
{"0xFFp+0", 255.},
{"0x0.8p+0", 0.5},
{"0x0.4p+0", 0.25},
- })),);
+ })), );
INSTANTIATE_TEST_CASE_P(
Float64DecodeInfTests, DecodeHexDoubleTest,
{"0x32p+1023", uint64_t(0x7FF0000000000000)}, // inf
{"0x32p+5000", uint64_t(0x7FF0000000000000)}, // inf
{"-0x32p+1023", uint64_t(0xFFF0000000000000)}, // -inf
- })),);
+ })), );
TEST(FloatProxy, ValidConversion) {
EXPECT_THAT(FloatProxy<float>(1.f).getAsFloat(), Eq(1.0f));
{std::numeric_limits<float>::infinity(), "0x1p+128"},
{-std::numeric_limits<float>::infinity(), "-0x1p+128"},
- })),);
+ })), );
INSTANTIATE_TEST_CASE_P(
Float64Tests, FloatProxyDoubleTest,
{std::numeric_limits<double>::infinity(), "0x1p+1024"},
{-std::numeric_limits<double>::infinity(), "-0x1p+1024"},
- })),);
+ })), );
// double is used so that unbiased_exponent can be used with the output
// of ldexp directly.
int32_t unbiased_exponent(double f) {
- return spvutils::HexFloat<spvutils::FloatProxy<float>>(
- static_cast<float>(f)).getUnbiasedNormalizedExponent();
+ return spvutils::HexFloat<spvutils::FloatProxy<float>>(static_cast<float>(f))
+ .getUnbiasedNormalizedExponent();
}
int16_t unbiased_half_exponent(uint16_t f) {
EXPECT_EQ(128, unbiased_exponent(ldexp(1.0f, 256)));
EXPECT_EQ(-100, unbiased_exponent(ldexp(1.0f, -100)));
- EXPECT_EQ(-127, unbiased_exponent(ldexp(1.0f, -127))); // First denorm
+ EXPECT_EQ(-127, unbiased_exponent(ldexp(1.0f, -127))); // First denorm
EXPECT_EQ(-128, unbiased_exponent(ldexp(1.0f, -128)));
EXPECT_EQ(-129, unbiased_exponent(ldexp(1.0f, -129)));
EXPECT_EQ(-140, unbiased_exponent(ldexp(1.0f, -140)));
// Creates a float that is the sum of 1/(2 ^ fractions[i]) for i in factions
float float_fractions(const std::vector<uint32_t>& fractions) {
float f = 0;
- for(int32_t i: fractions) {
+ for (int32_t i : fractions) {
f += std::ldexp(1.0f, -i);
}
return f;
// Returns the normalized significand of a HexFloat<FloatProxy<float>>
// that was created by calling float_fractions with the input fractions,
// raised to the power of exp.
-uint32_t normalized_significand(const std::vector<uint32_t>& fractions, uint32_t exp) {
+uint32_t normalized_significand(const std::vector<uint32_t>& fractions,
+ uint32_t exp) {
return spvutils::HexFloat<spvutils::FloatProxy<float>>(
static_cast<float>(ldexp(float_fractions(fractions), exp)))
.getNormalizedSignificand();
// and 1 would set the 22nd bit.
uint32_t bits_set(const std::vector<uint32_t>& bits) {
const uint32_t top_bit = 1u << 22u;
- uint32_t val= 0;
- for(uint32_t i: bits) {
+ uint32_t val = 0;
+ for (uint32_t i : bits) {
val |= top_bit >> i;
}
return val;
// point.
uint16_t half_bits_set(const std::vector<uint32_t>& bits) {
const uint32_t top_bit = 1u << 9u;
- uint32_t val= 0;
- for(uint32_t i: bits) {
+ uint32_t val = 0;
+ for (uint32_t i : bits) {
val |= top_bit >> i;
}
return static_cast<uint16_t>(val);
// calling setFromSignUnbiasedExponentAndNormalizedSignificand
// on a HexFloat<FloatProxy<float>>
float set_from_sign(bool negative, int32_t unbiased_exponent,
- uint32_t significand, bool round_denorm_up) {
- spvutils::HexFloat<spvutils::FloatProxy<float>> f(0.f);
+ uint32_t significand, bool round_denorm_up) {
+ spvutils::HexFloat<spvutils::FloatProxy<float>> f(0.f);
f.setFromSignUnbiasedExponentAndNormalizedSignificand(
negative, unbiased_exponent, significand, round_denorm_up);
return f.value().getAsFloat();
TEST(HexFloatOperationTests,
SetFromSignUnbiasedExponentAndNormalizedSignificand) {
-
EXPECT_EQ(1.f, set_from_sign(false, 0, 0, false));
// Tests insertion of various denormalized numbers with and without round up.
- EXPECT_EQ(static_cast<float>(ldexp(1.f, -149)), set_from_sign(false, -149, 0, false));
- EXPECT_EQ(static_cast<float>(ldexp(1.f, -149)), set_from_sign(false, -149, 0, true));
+ EXPECT_EQ(static_cast<float>(ldexp(1.f, -149)),
+ set_from_sign(false, -149, 0, false));
+ EXPECT_EQ(static_cast<float>(ldexp(1.f, -149)),
+ set_from_sign(false, -149, 0, true));
EXPECT_EQ(0.f, set_from_sign(false, -150, 1, false));
- EXPECT_EQ(static_cast<float>(ldexp(1.f, -149)), set_from_sign(false, -150, 1, true));
+ EXPECT_EQ(static_cast<float>(ldexp(1.f, -149)),
+ set_from_sign(false, -150, 1, true));
EXPECT_EQ(ldexp(1.0f, -127), set_from_sign(false, -127, 0, false));
EXPECT_EQ(ldexp(1.0f, -128), set_from_sign(false, -128, 0, false));
// Everything fits, so this should be straight-forward
for (spvutils::round_direction round : rounding) {
- EXPECT_EQ(bits_set({}), HF(0.f).getRoundedNormalizedSignificand<HF>(
- round, &carry_bit));
+ EXPECT_EQ(bits_set({}),
+ HF(0.f).getRoundedNormalizedSignificand<HF>(round, &carry_bit));
EXPECT_FALSE(carry_bit);
EXPECT_EQ(bits_set({0}),
.getRoundedNormalizedSignificand<HF>(round, &carry_bit));
EXPECT_FALSE(carry_bit);
- EXPECT_EQ(
- bits_set({0, 1, 4, 22}),
- HF(static_cast<float>(float_fractions({0, 1, 2, 5, 23})))
- .getRoundedNormalizedSignificand<HF>(round, &carry_bit));
+ EXPECT_EQ(bits_set({0, 1, 4, 22}),
+ HF(static_cast<float>(float_fractions({0, 1, 2, 5, 23})))
+ .getRoundedNormalizedSignificand<HF>(round, &carry_bit));
EXPECT_FALSE(carry_bit);
}
}
spvutils::round_direction round;
};
-using HexFloatRoundTest =
- ::testing::TestWithParam<RoundSignificandCase>;
+using HexFloatRoundTest = ::testing::TestWithParam<RoundSignificandCase>;
TEST_P(HexFloatRoundTest, RoundDownToFP16) {
using HF = spvutils::HexFloat<spvutils::FloatProxy<float>>;
HF input_value(GetParam().source_float);
bool carry_bit = false;
EXPECT_EQ(GetParam().expected_results.first,
- input_value.getRoundedNormalizedSignificand<HF16>(
- GetParam().round, &carry_bit));
+ input_value.getRoundedNormalizedSignificand<HF16>(GetParam().round,
+ &carry_bit));
EXPECT_EQ(carry_bit, GetParam().expected_results.second);
}
}
}
-INSTANTIATE_TEST_CASE_P(F16toF32, HexFloatRoundUpSignificandTest,
- // 0xFC00 of the source 16-bit hex value cover the sign and the exponent.
- // They are ignored for this test.
- ::testing::ValuesIn(std::vector<UpCastSignificandCase>(
- {
- {0x3F00, 0x600000},
- {0x0F00, 0x600000},
- {0x0F01, 0x602000},
- {0x0FFF, 0x7FE000},
- })),);
+INSTANTIATE_TEST_CASE_P(
+ F16toF32, HexFloatRoundUpSignificandTest,
+ // 0xFC00 of the source 16-bit hex value cover the sign and the exponent.
+ // They are ignored for this test.
+ ::testing::ValuesIn(std::vector<UpCastSignificandCase>({
+ {0x3F00, 0x600000},
+ {0x0F00, 0x600000},
+ {0x0F01, 0x602000},
+ {0x0FFF, 0x7FE000},
+ })), );
struct DownCastTest {
float source_float;
std::string get_round_text(spvutils::round_direction direction) {
#define CASE(round_direction) \
- case round_direction: \
+ case round_direction: \
return #round_direction
switch (direction) {
const uint16_t positive_infinity = 0x7C00;
const uint16_t negative_infinity = 0xFC00;
-INSTANTIATE_TEST_CASE_P(F32ToF16, HexFloatFP32To16Tests,
- ::testing::ValuesIn(std::vector<DownCastTest>(
- {
- // Exactly representable as half.
- {0.f, 0x0, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {-0.f, 0x8000, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {1.0f, 0x3C00, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {-1.0f, 0xBC00, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
-
- {float_fractions({0, 1, 10}) , 0x3E01, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {-float_fractions({0, 1, 10}) , 0xBE01, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {static_cast<float>(ldexp(float_fractions({0, 1, 10}), 3)), 0x4A01, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {static_cast<float>(-ldexp(float_fractions({0, 1, 10}), 3)), 0xCA01, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
-
-
- // Underflow
- {static_cast<float>(ldexp(1.0f, -25)), 0x0, {RD::kToZero, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {static_cast<float>(ldexp(1.0f, -25)), 0x1, {RD::kToPositiveInfinity}},
- {static_cast<float>(-ldexp(1.0f, -25)), 0x8000, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNearestEven}},
- {static_cast<float>(-ldexp(1.0f, -25)), 0x8001, {RD::kToNegativeInfinity}},
- {static_cast<float>(ldexp(1.0f, -24)), 0x1, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
-
- // Overflow
- {static_cast<float>(ldexp(1.0f, 16)), positive_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {static_cast<float>(ldexp(1.0f, 18)), positive_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {static_cast<float>(ldexp(1.3f, 16)), positive_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {static_cast<float>(-ldexp(1.0f, 16)), negative_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {static_cast<float>(-ldexp(1.0f, 18)), negative_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {static_cast<float>(-ldexp(1.3f, 16)), negative_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
-
- // Transfer of Infinities
- {std::numeric_limits<float>::infinity(), positive_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
- {-std::numeric_limits<float>::infinity(), negative_infinity, {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity, RD::kToNearestEven}},
-
- // Nans are below because we cannot test for equality.
- })),);
-
-struct UpCastCase{
+INSTANTIATE_TEST_CASE_P(
+ F32ToF16, HexFloatFP32To16Tests,
+ ::testing::ValuesIn(std::vector<DownCastTest>({
+ // Exactly representable as half.
+ {0.f,
+ 0x0,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {-0.f,
+ 0x8000,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {1.0f,
+ 0x3C00,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {-1.0f,
+ 0xBC00,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+
+ {float_fractions({0, 1, 10}),
+ 0x3E01,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {-float_fractions({0, 1, 10}),
+ 0xBE01,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {static_cast<float>(ldexp(float_fractions({0, 1, 10}), 3)),
+ 0x4A01,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {static_cast<float>(-ldexp(float_fractions({0, 1, 10}), 3)),
+ 0xCA01,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+
+ // Underflow
+ {static_cast<float>(ldexp(1.0f, -25)),
+ 0x0,
+ {RD::kToZero, RD::kToNegativeInfinity, RD::kToNearestEven}},
+ {static_cast<float>(ldexp(1.0f, -25)), 0x1, {RD::kToPositiveInfinity}},
+ {static_cast<float>(-ldexp(1.0f, -25)),
+ 0x8000,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNearestEven}},
+ {static_cast<float>(-ldexp(1.0f, -25)),
+ 0x8001,
+ {RD::kToNegativeInfinity}},
+ {static_cast<float>(ldexp(1.0f, -24)),
+ 0x1,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+
+ // Overflow
+ {static_cast<float>(ldexp(1.0f, 16)),
+ positive_infinity,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {static_cast<float>(ldexp(1.0f, 18)),
+ positive_infinity,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {static_cast<float>(ldexp(1.3f, 16)),
+ positive_infinity,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {static_cast<float>(-ldexp(1.0f, 16)),
+ negative_infinity,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {static_cast<float>(-ldexp(1.0f, 18)),
+ negative_infinity,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {static_cast<float>(-ldexp(1.3f, 16)),
+ negative_infinity,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+
+ // Transfer of Infinities
+ {std::numeric_limits<float>::infinity(),
+ positive_infinity,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+ {-std::numeric_limits<float>::infinity(),
+ negative_infinity,
+ {RD::kToZero, RD::kToPositiveInfinity, RD::kToNegativeInfinity,
+ RD::kToNearestEven}},
+
+ // Nans are below because we cannot test for equality.
+ })), );
+
+struct UpCastCase {
uint16_t source_half;
float expected_float;
};
}
}
-INSTANTIATE_TEST_CASE_P(F16ToF32, HexFloatFP16To32Tests,
- ::testing::ValuesIn(std::vector<UpCastCase>(
- {
- {0x0000, 0.f},
- {0x8000, -0.f},
- {0x3C00, 1.0f},
- {0xBC00, -1.0f},
- {0x3F00, float_fractions({0, 1, 2})},
- {0xBF00, -float_fractions({0, 1, 2})},
- {0x3F01, float_fractions({0, 1, 2, 10})},
- {0xBF01, -float_fractions({0, 1, 2, 10})},
-
- // denorm
- {0x0001, static_cast<float>(ldexp(1.0, -24))},
- {0x0002, static_cast<float>(ldexp(1.0, -23))},
- {0x8001, static_cast<float>(-ldexp(1.0, -24))},
- {0x8011, static_cast<float>(-ldexp(1.0, -20) + -ldexp(1.0, -24))},
-
- // inf
- {0x7C00, std::numeric_limits<float>::infinity()},
- {0xFC00, -std::numeric_limits<float>::infinity()},
- })),);
+INSTANTIATE_TEST_CASE_P(
+ F16ToF32, HexFloatFP16To32Tests,
+ ::testing::ValuesIn(std::vector<UpCastCase>({
+ {0x0000, 0.f},
+ {0x8000, -0.f},
+ {0x3C00, 1.0f},
+ {0xBC00, -1.0f},
+ {0x3F00, float_fractions({0, 1, 2})},
+ {0xBF00, -float_fractions({0, 1, 2})},
+ {0x3F01, float_fractions({0, 1, 2, 10})},
+ {0xBF01, -float_fractions({0, 1, 2, 10})},
+
+ // denorm
+ {0x0001, static_cast<float>(ldexp(1.0, -24))},
+ {0x0002, static_cast<float>(ldexp(1.0, -23))},
+ {0x8001, static_cast<float>(-ldexp(1.0, -24))},
+ {0x8011, static_cast<float>(-ldexp(1.0, -20) + -ldexp(1.0, -24))},
+
+ // inf
+ {0x7C00, std::numeric_limits<float>::infinity()},
+ {0xFC00, -std::numeric_limits<float>::infinity()},
+ })), );
TEST(HexFloatOperationTests, NanTests) {
using HF = spvutils::HexFloat<spvutils::FloatProxy<float>>;
// We can't have -1e40 and negate_value == true since
// that represents an original case of "--1e40" which
// is invalid.
- }),);
+ }), );
using ParseNormalFloat16Test =
::testing::TestWithParam<FloatParseCase<Float16>>;
BadFloatParseCase<Float16>("-2.0", true, uint16_t{0}),
BadFloatParseCase<Float16>("+0.0", true, uint16_t{0}),
BadFloatParseCase<Float16>("+2.0", true, uint16_t{0}),
- }),);
+ }), );
// A test case for detecting infinities.
template <typename T>
{"-1e40", false, -FLT_MAX},
{"1e400", false, FLT_MAX},
{"-1e400", false, -FLT_MAX},
- })),);
+ })), );
using FloatProxyParseOverflowDoubleTest =
::testing::TestWithParam<OverflowParseCase<double>>;
{"-1e40", true, -1e40},
{"1e400", false, DBL_MAX},
{"-1e400", false, -DBL_MAX},
- })),);
+ })), );
using FloatProxyParseOverflowFloat16Test =
::testing::TestWithParam<OverflowParseCase<uint16_t>>;
std::istringstream input(GetParam().input);
HexFloat<FloatProxy<Float16>> value(0);
input >> value;
- EXPECT_NE(GetParam().expect_success, input.fail()) << " literal: "
- << GetParam().input;
+ EXPECT_NE(GetParam().expect_success, input.fail())
+ << " literal: " << GetParam().input;
if (GetParam().expect_success) {
EXPECT_THAT(value.value().data(), Eq(GetParam().expected_value))
<< " literal: " << GetParam().input;
{"-1e38", false, uint16_t{0xfbff}},
{"-1e40", false, uint16_t{0xfbff}},
{"-1e400", false, uint16_t{0xfbff}},
- })),);
+ })), );
TEST(FloatProxy, Max) {
EXPECT_THAT(FloatProxy<Float16>::max().getAsFloat().get_value(),
#include <string>
#include <unordered_map>
-#include "util/huffman_codec.h"
-#include "util/bit_stream.h"
#include "gmock/gmock.h"
+#include "util/bit_stream.h"
+#include "util/huffman_codec.h"
namespace {
-using spvutils::HuffmanCodec;
using spvutils::BitsToStream;
+using spvutils::HuffmanCodec;
const std::map<std::string, uint32_t>& GetTestSet() {
static const std::map<std::string, uint32_t> hist = {
- {"a", 4},
- {"e", 7},
- {"f", 3},
- {"h", 2},
- {"i", 3},
- {"m", 2},
- {"n", 2},
- {"s", 2},
- {"t", 2},
- {"l", 1},
- {"o", 2},
- {"p", 1},
- {"r", 1},
- {"u", 1},
- {"x", 1},
+ {"a", 4}, {"e", 7}, {"f", 3}, {"h", 2}, {"i", 3},
+ {"m", 2}, {"n", 2}, {"s", 2}, {"t", 2}, {"l", 1},
+ {"o", 2}, {"p", 1}, {"r", 1}, {"u", 1}, {"x", 1},
};
return hist;
std::stringstream ss;
huffman.PrintTree(ss);
+ // clang-format off
const std::string expected = std::string(R"(
15-----7------e
8------4------a
3------1------x
2------h
)").substr(1);
+ // clang-format on
EXPECT_EQ(expected, ss.str());
}
r 1 00111
p 1 01000
l 1 01001
-)").substr(1);
+)")
+ .substr(1);
EXPECT_EQ(expected, ss.str());
}
TEST(Huffman, TestDecode) {
HuffmanCodec<std::string> huffman(GetTestSet());
- TestBitReader bit_reader("01001""0001""1000""00110""00001""00");
- auto read_bit = [&bit_reader](bool* bit) {
- return bit_reader.ReadBit(bit);
- };
+ TestBitReader bit_reader(
+ "01001"
+ "0001"
+ "1000"
+ "00110"
+ "00001"
+ "00");
+ auto read_bit = [&bit_reader](bool* bit) { return bit_reader.ReadBit(bit); };
std::string decoded;
}
TEST(Huffman, TestDecodeNumbers) {
- const std::map<uint32_t, uint32_t> hist = { {1, 10}, {2, 5}, {3, 15} };
+ const std::map<uint32_t, uint32_t> hist = {{1, 10}, {2, 5}, {3, 15}};
HuffmanCodec<uint32_t> huffman(hist);
- TestBitReader bit_reader("1""1""01""00""01""1");
- auto read_bit = [&bit_reader](bool* bit) {
- return bit_reader.ReadBit(bit);
- };
+ TestBitReader bit_reader(
+ "1"
+ "1"
+ "01"
+ "00"
+ "01"
+ "1");
+ auto read_bit = [&bit_reader](bool* bit) { return bit_reader.ReadBit(bit); };
uint32_t decoded;
}
TEST(Huffman, SerializeToTextU64) {
- const std::map<uint64_t, uint32_t> hist =
- { {1001, 10}, {1002, 5}, {1003, 15} };
+ const std::map<uint64_t, uint32_t> hist = {{1001, 10}, {1002, 5}, {1003, 15}};
HuffmanCodec<uint64_t> huffman(hist);
const std::string code = huffman.SerializeToText(2);
{0, 4, 3},
}))";
-
ASSERT_EQ(expected, code);
}
TEST(Huffman, SerializeToTextString) {
- const std::map<std::string, uint32_t> hist =
- { {"aaa", 10}, {"bbb", 20}, {"ccc", 15} };
+ const std::map<std::string, uint32_t> hist = {
+ {"aaa", 10}, {"bbb", 20}, {"ccc", 15}};
HuffmanCodec<std::string> huffman(hist);
const std::string code = huffman.SerializeToText(4);
TEST(Huffman, CreateFromTextString) {
std::vector<HuffmanCodec<std::string>::Node> nodes = {
- {},
- {"root", 2, 3},
- {"left", 0, 0},
- {"right", 0, 0},
+ {},
+ {"root", 2, 3},
+ {"left", 0, 0},
+ {"right", 0, 0},
};
HuffmanCodec<std::string> huffman(1, std::move(nodes));
const std::string expected = std::string(R"(
0------right
0------left
-)").substr(1);
+)")
+ .substr(1);
EXPECT_EQ(expected, ss.str());
}
TEST(Huffman, CreateFromTextU64) {
HuffmanCodec<uint64_t> huffman(5, {
- {0, 0, 0},
- {1001, 0, 0},
- {1002, 0, 0},
- {1003, 0, 0},
- {0, 1, 2},
- {0, 4, 3},
- });
+ {0, 0, 0},
+ {1001, 0, 0},
+ {1002, 0, 0},
+ {1003, 0, 0},
+ {0, 1, 2},
+ {0, 4, 3},
+ });
std::stringstream ss;
huffman.PrintTree(ss);
0------1003
0------0------1002
0------1001
-)").substr(1);
+)")
+ .substr(1);
EXPECT_EQ(expected, ss.str());
TestBitReader bit_reader("01");
- auto read_bit = [&bit_reader](bool* bit) {
- return bit_reader.ReadBit(bit);
- };
+ auto read_bit = [&bit_reader](bool* bit) { return bit_reader.ReadBit(bit); };
uint64_t decoded = 0;
ASSERT_TRUE(huffman.DecodeFromStream(read_bit, &decoded));
#include <gmock/gmock.h>
-#include "test_fixture.h"
#include "source/util/bitutils.h"
+#include "test_fixture.h"
namespace {
using BinaryVersion = spvtest::LinkerTest;
TEST_F(BinaryVersion, LinkerChoosesMaxSpirvVersion) {
+ // clang-format off
spvtest::Binaries binaries = {
{
SpvMagicNumber,
0u // NOTE: Schema; reserved
}
};
+ // clang-format on
spvtest::Binary linked_binary;
ASSERT_EQ(SPV_SUCCESS, Link(binaries, &linked_binary));
TEST_F(IdsLimit, UnderLimit) {
spvtest::Binaries binaries = {
{
- SpvMagicNumber,
- SpvVersion,
- SPV_GENERATOR_CODEPLAY,
- 0x2FFFFFu, // NOTE: Bound
- 0u, // NOTE: Schema; reserved
+ SpvMagicNumber, SpvVersion, SPV_GENERATOR_CODEPLAY,
+ 0x2FFFFFu, // NOTE: Bound
+ 0u, // NOTE: Schema; reserved
},
{
- SpvMagicNumber,
- SpvVersion,
- SPV_GENERATOR_CODEPLAY,
- 0x100000u, // NOTE: Bound
- 0u, // NOTE: Schema; reserved
- }
- };
+ SpvMagicNumber, SpvVersion, SPV_GENERATOR_CODEPLAY,
+ 0x100000u, // NOTE: Bound
+ 0u, // NOTE: Schema; reserved
+ }};
spvtest::Binary linked_binary;
ASSERT_EQ(SPV_SUCCESS, Link(binaries, &linked_binary));
TEST_F(IdsLimit, OverLimit) {
spvtest::Binaries binaries = {
{
- SpvMagicNumber,
- SpvVersion,
- SPV_GENERATOR_CODEPLAY,
- 0x2FFFFFu, // NOTE: Bound
- 0u, // NOTE: Schema; reserved
+ SpvMagicNumber, SpvVersion, SPV_GENERATOR_CODEPLAY,
+ 0x2FFFFFu, // NOTE: Bound
+ 0u, // NOTE: Schema; reserved
},
{
- SpvMagicNumber,
- SpvVersion,
- SPV_GENERATOR_CODEPLAY,
- 0x100000u, // NOTE: Bound
- 0u, // NOTE: Schema; reserved
+ SpvMagicNumber, SpvVersion, SPV_GENERATOR_CODEPLAY,
+ 0x100000u, // NOTE: Bound
+ 0u, // NOTE: Schema; reserved
},
{
- SpvMagicNumber,
- SpvVersion,
- SPV_GENERATOR_CODEPLAY,
+ SpvMagicNumber, SpvVersion, SPV_GENERATOR_CODEPLAY,
3u, // NOTE: Bound
0u, // NOTE: Schema; reserved
- }
- };
+ }};
spvtest::Binary linked_binary;
EXPECT_EQ(SPV_SUCCESS, res);
}
-} // anonymous namespace
+} // anonymous namespace
class MoveToFrontTester : public MoveToFront<uint32_t> {
public:
// Inserts the value in the internal tree data structure. For testing only.
- void TestInsert(uint32_t val) {
- InsertNode(CreateNode(val, val));
- }
+ void TestInsert(uint32_t val) { InsertNode(CreateNode(val, val)); }
// Removes the value from the internal tree data structure. For testing only.
void TestRemove(uint32_t val) {
// Prints the internal tree data structure to |out|. For testing only.
void PrintTree(std::ostream& out, bool print_timestamp = false) const {
- if (root_)
- PrintTreeInternal(out, root_, 1, print_timestamp);
+ if (root_) PrintTreeInternal(out, root_, 1, print_timestamp);
}
- // Returns node handle corresponding to the value. The value may not be in the tree.
+ // Returns node handle corresponding to the value. The value may not be in the
+ // tree.
uint32_t GetNodeHandle(uint32_t value) const {
const auto it = value_to_node_.find(value);
- if (it == value_to_node_.end())
- return 0;
+ if (it == value_to_node_.end()) return 0;
return it->second;
}
return nodes_.size() - 1;
}
- uint32_t GetLastAccessedValue() const {
- return last_accessed_value_;
- }
+ uint32_t GetLastAccessedValue() const { return last_accessed_value_; }
private:
// Prints the internal tree data structure for debug purposes in the following
bool print_timestamp) const;
};
-void MoveToFrontTester::PrintTreeInternal(
- std::ostream& out, uint32_t node,
- size_t depth, bool print_timestamp) const {
+void MoveToFrontTester::PrintTreeInternal(std::ostream& out, uint32_t node,
+ size_t depth,
+ bool print_timestamp) const {
if (!node) {
out << "D" << depth - 1 << std::endl;
return;
const size_t kTextFieldWvaluethWithoutTimestamp = 10;
const size_t kTextFieldWvaluethWithTimestamp = 14;
- const size_t text_field_wvalueth = print_timestamp ?
- kTextFieldWvaluethWithTimestamp : kTextFieldWvaluethWithoutTimestamp;
+ const size_t text_field_wvalueth = print_timestamp
+ ? kTextFieldWvaluethWithTimestamp
+ : kTextFieldWvaluethWithoutTimestamp;
std::stringstream label;
label << ValueOf(node) << "H" << HeightOf(node) << "S" << SizeOf(node);
- if (print_timestamp)
- label << "T" << TimestampOf(node);
+ if (print_timestamp) label << "T" << TimestampOf(node);
const size_t label_length = label.str().length();
if (label_length < text_field_wvalueth)
label << std::string(text_field_wvalueth - label_length, '-');
CheckTree(mtf, std::string(R"(
30H2S2----20H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
mtf.TestInsert(10);
CheckTree(mtf, std::string(R"(
20H2S3----10H1S1----D2
30H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, InsertRightRotation) {
CheckTree(mtf, std::string(R"(
10H2S2----D1
20H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
mtf.TestInsert(30);
CheckTree(mtf, std::string(R"(
20H2S3----10H1S1----D2
30H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, InsertRightLeftRotation) {
CheckTree(mtf, std::string(R"(
30H2S2----20H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
mtf.TestInsert(25);
CheckTree(mtf, std::string(R"(
25H2S3----20H1S1----D2
30H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, InsertLeftRightRotation) {
CheckTree(mtf, std::string(R"(
10H2S2----D1
20H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
mtf.TestInsert(15);
CheckTree(mtf, std::string(R"(
15H2S3----10H1S1----D2
20H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, RemoveSingleton) {
mtf.TestInsert(10);
CheckTree(mtf, std::string(R"(
10H1S1----D1
-)").substr(1));
+)")
+ .substr(1));
mtf.TestRemove(10);
CheckTree(mtf, "");
CheckTree(mtf, std::string(R"(
10H2S3----5H1S1-----D2
15H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
mtf.TestRemove(10);
CheckTree(mtf, std::string(R"(
15H2S2----5H1S1-----D2
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, RemoveRightRotation) {
10H3S4----5H1S1-----D2
15H2S2----D2
20H1S1----D3
-)").substr(1));
+)")
+ .substr(1));
mtf.TestRemove(5);
CheckTree(mtf, std::string(R"(
15H2S3----10H1S1----D2
20H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, RemoveLeftRotation) {
CheckTree(mtf, std::string(R"(
10H3S4----5H2S2-----1H1S1-----D3
15H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
mtf.TestRemove(15);
CheckTree(mtf, std::string(R"(
5H2S3-----1H1S1-----D2
10H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, RemoveLeftRightRotation) {
CheckTree(mtf, std::string(R"(
10H3S4----5H1S1-----D2
15H2S2----12H1S1----D3
-)").substr(1));
+)")
+ .substr(1));
mtf.TestRemove(5);
CheckTree(mtf, std::string(R"(
12H2S3----10H1S1----D2
15H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, RemoveRightLeftRotation) {
10H3S4----5H2S2-----D2
8H1S1-----D3
15H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
mtf.TestRemove(15);
CheckTree(mtf, std::string(R"(
8H2S3-----5H1S1-----D2
10H1S1----D2
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, MultipleOperations) {
MoveToFrontTester mtf;
- std::vector<uint32_t> vals =
- { 5, 11, 12, 16, 15, 6, 14, 2, 7, 10, 4, 8, 9, 3, 1, 13 };
+ std::vector<uint32_t> vals = {5, 11, 12, 16, 15, 6, 14, 2,
+ 7, 10, 4, 8, 9, 3, 1, 13};
for (uint32_t i : vals) {
mtf.TestInsert(i);
15H3S5----13H2S3----12H1S1----D4
14H1S1----D4
16H1S1----D3
-)").substr(1));
+)")
+ .substr(1));
mtf.TestRemove(11);
15H3S5----13H2S3----12H1S1----D4
14H1S1----D4
16H1S1----D3
-)").substr(1));
+)")
+ .substr(1));
mtf.TestInsert(11);
13H3S6----12H2S2----11H1S1----D4
15H2S3----14H1S1----D4
16H1S1----D4
-)").substr(1));
+)")
+ .substr(1));
mtf.TestRemove(5);
13H3S6----12H2S2----11H1S1----D4
15H2S3----14H1S1----D4
16H1S1----D4
-)").substr(1));
+)")
+ .substr(1));
mtf.TestInsert(5);
13H3S6----12H2S2----11H1S1----D4
15H2S3----14H1S1----D4
16H1S1----D4
-)").substr(1));
+)")
+ .substr(1));
mtf.TestRemove(2);
mtf.TestRemove(1);
12H2S2----11H1S1----D4
15H2S3----14H1S1----D3
16H1S1----D3
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, BiggerScaleTreeTest) {
24H1S1----D4
37H2S3----35H1S1----D3
46H1S1----D3
-)").substr(1));
+)")
+ .substr(1));
}
TEST(MoveToFront, RankFromValue) {
EXPECT_TRUE(mtf.Insert(2));
EXPECT_TRUE(mtf.Insert(3));
EXPECT_FALSE(mtf.Insert(2));
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
2H2S3T2-------1H1S1T1-------D2
3H1S1T3-------D2
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
EXPECT_FALSE(mtf.RankFromValue(4, &rank));
EXPECT_TRUE(mtf.RankFromValue(1, &rank));
EXPECT_EQ(3u, rank);
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
3H2S3T3-------2H1S1T2-------D2
1H1S1T4-------D2
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
EXPECT_TRUE(mtf.RankFromValue(1, &rank));
EXPECT_EQ(1u, rank);
EXPECT_TRUE(mtf.RankFromValue(1, &rank));
EXPECT_EQ(2u, rank);
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
2H3S5T6-------3H1S1T5-------D2
50H2S3T9------40H1S1T7------D3
1H1S1T10------D3
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
EXPECT_TRUE(mtf.RankFromValue(50, &rank));
EXPECT_EQ(2u, rank);
EXPECT_EQ(5u, mtf.GetSize());
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
2H3S5T6-------3H1S1T5-------D2
1H2S3T10------40H1S1T7------D3
50H1S1T11-----D3
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
EXPECT_FALSE(mtf.RankFromValue(0, &rank));
EXPECT_FALSE(mtf.RankFromValue(20, &rank));
EXPECT_EQ(1u, value);
EXPECT_EQ(1u, mtf.GetLastAccessedValue());
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
3H2S3T3-------2H1S1T2-------D2
1H1S1T4-------D2
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
EXPECT_TRUE(mtf.ValueFromRank(2, &value));
EXPECT_EQ(3u, value);
EXPECT_EQ(3u, mtf.GetSize());
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
1H2S3T4-------2H1S1T2-------D2
3H1S1T5-------D2
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
EXPECT_TRUE(mtf.ValueFromRank(3, &value));
EXPECT_EQ(2u, value);
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
3H2S3T5-------1H1S1T4-------D2
2H1S1T6-------D2
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
EXPECT_TRUE(mtf.Insert(10));
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
3H3S4T5-------1H1S1T4-------D2
2H2S2T6-------D2
10H1S1T7------D3
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
EXPECT_TRUE(mtf.ValueFromRank(1, &value));
EXPECT_EQ(10u, value);
EXPECT_TRUE(mtf.Insert(2));
EXPECT_TRUE(mtf.Insert(3));
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
2H2S3T2-------1H1S1T1-------D2
3H1S1T3-------D2
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
EXPECT_EQ(1u, mtf.GetNodeHandle(1));
EXPECT_EQ(3u, mtf.GetTotalNodeCount());
EXPECT_TRUE(mtf.Remove(1));
EXPECT_EQ(3u, mtf.GetTotalNodeCount());
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
2H2S2T2-------D1
3H1S1T3-------D2
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
uint32_t value = 0;
EXPECT_TRUE(mtf.ValueFromRank(2, &value));
EXPECT_EQ(2u, value);
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
3H2S2T3-------D1
2H1S1T4-------D2
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
EXPECT_TRUE(mtf.Insert(1));
EXPECT_EQ(1u, mtf.GetNodeHandle(1));
}
}
- CheckTree(mtf, std::string(R"(
+ CheckTree(mtf,
+ std::string(R"(
6H4S9T1029----8H2S3T8-------7H1S1T7-------D3
9H1S1T9-------D3
2H3S5T1033----4H2S3T1031----5H1S1T1030----D4
3H1S1T1032----D4
1H1S1T1034----D3
-)").substr(1), /* print_timestamp = */ true);
+)")
+ .substr(1),
+ /* print_timestamp = */ true);
ASSERT_TRUE(mtf.Insert(1000));
ASSERT_TRUE(mtf.ValueFromRank(1, &value));
EXPECT_FALSE(multi_mtf.Remove(1001, "AAA"));
}
-
TEST(MultiMoveToFront, TwoSequences) {
MultiMoveToFront<std::string> multi_mtf;
#include "source/name_mapper.h"
-using libspirv::NameMapper;
using libspirv::FriendlyNameMapper;
+using libspirv::NameMapper;
using spvtest::ScopedContext;
using ::testing::Eq;
{"%1 = OpTypeDeviceEvent", 1, "DeviceEvent"},
{"%1 = OpTypeReserveId", 1, "ReserveId"},
{"%1 = OpTypeQueue", 1, "Queue"},
- {"%1 = OpTypeOpaque \"hello world!\"", 1, "Opaque_hello_world_"},
+ {"%1 = OpTypeOpaque \"hello world!\"", 1,
+ "Opaque_hello_world_"},
{"%1 = OpTypePipe ReadOnly", 1, "PipeReadOnly"},
{"%1 = OpTypePipe WriteOnly", 1, "PipeWriteOnly"},
{"%1 = OpTypePipe ReadWrite", 1, "PipeReadWrite"},
INSTANTIATE_TEST_CASE_P(
ValidAndInvalidIds, IdValidityTest,
- ::testing::ValuesIn(std::vector<IdCheckCase>({{"%1", true},
- {"%2abc", true},
- {"%3Def", true},
- {"%4GHI", true},
- {"%5_j_k", true},
- {"%6J_M", true},
- {"%n", true},
- {"%O", true},
- {"%p7", true},
- {"%Q8", true},
- {"%R_S", true},
- {"%T_10_U", true},
- {"%V_11", true},
- {"%W_X_13", true},
- {"%_A", true},
- {"%_", true},
- {"%__", true},
- {"%A_", true},
- {"%_A_", true},
+ ::testing::ValuesIn(std::vector<IdCheckCase>(
+ {{"%1", true}, {"%2abc", true}, {"%3Def", true},
+ {"%4GHI", true}, {"%5_j_k", true}, {"%6J_M", true},
+ {"%n", true}, {"%O", true}, {"%p7", true},
+ {"%Q8", true}, {"%R_S", true}, {"%T_10_U", true},
+ {"%V_11", true}, {"%W_X_13", true}, {"%_A", true},
+ {"%_", true}, {"%__", true}, {"%A_", true},
+ {"%_A_", true},
- {"%@", false},
- {"%!", false},
- {"%ABC!", false},
- {"%__A__@", false},
- {"%%", false},
- {"%-", false},
- {"%foo_@_bar", false},
- {"%", false},
+ {"%@", false}, {"%!", false}, {"%ABC!", false},
+ {"%__A__@", false}, {"%%", false}, {"%-", false},
+ {"%foo_@_bar", false}, {"%", false},
- {"5", false},
- {"32", false},
- {"foo", false},
- {"a%bar", false}})),);
+ {"5", false}, {"32", false}, {"foo", false},
+ {"a%bar", false}})), );
} // anonymous namespace
Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
ValuesIn(std::vector<EnumCapabilityCase>{
CASE1(DIMENSIONALITY, Dim1D, Sampled1D),
- CASE0(DIMENSIONALITY, Dim2D), CASE0(DIMENSIONALITY, Dim3D),
+ CASE0(DIMENSIONALITY, Dim2D),
+ CASE0(DIMENSIONALITY, Dim3D),
CASE1(DIMENSIONALITY, DimCube, Shader),
CASE1(DIMENSIONALITY, DimRect, SampledRect),
CASE1(DIMENSIONALITY, DimBuffer, SampledBuffer),
})), );
// See SPIR-V Section 3.27 Scope <id>
-INSTANTIATE_TEST_CASE_P(
- Scope, EnumCapabilityTest,
- Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1),
- ValuesIn(std::vector<EnumCapabilityCase>{
- CASE0(SCOPE_ID, ScopeCrossDevice), CASE0(SCOPE_ID, ScopeDevice),
- CASE0(SCOPE_ID, ScopeWorkgroup), CASE0(SCOPE_ID, ScopeSubgroup),
- CASE0(SCOPE_ID, ScopeInvocation),
- })), );
+INSTANTIATE_TEST_CASE_P(Scope, EnumCapabilityTest,
+ Combine(Values(SPV_ENV_UNIVERSAL_1_0,
+ SPV_ENV_UNIVERSAL_1_1),
+ ValuesIn(std::vector<EnumCapabilityCase>{
+ CASE0(SCOPE_ID, ScopeCrossDevice),
+ CASE0(SCOPE_ID, ScopeDevice),
+ CASE0(SCOPE_ID, ScopeWorkgroup),
+ CASE0(SCOPE_ID, ScopeSubgroup),
+ CASE0(SCOPE_ID, ScopeInvocation),
+ })), );
// See SPIR-V Section 3.28 Group Operation
INSTANTIATE_TEST_CASE_P(
spv_operand_pattern_t pattern(GetParam().initial);
spvPushOperandTypesForMask(operandTable, GetParam().type, GetParam().mask,
- &pattern);
+ &pattern);
EXPECT_THAT(pattern, Eq(GetParam().expected));
}
// These macros let us write non-trivial examples without too much text.
#define PREFIX0 SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_NONE
-#define PREFIX1 \
+#define PREFIX1 \
SPV_OPERAND_TYPE_STORAGE_CLASS, SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE, \
SPV_OPERAND_TYPE_ID
INSTANTIATE_TEST_CASE_P(
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV,
SPV_OPERAND_TYPE_RESULT_ID,
SPV_OPERAND_TYPE_OPTIONAL_CIV}));
- EXPECT_THAT(spvAlternatePatternFollowingImmediate(
- {SPV_OPERAND_TYPE_RESULT_ID,
- SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID}),
- Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV,
- SPV_OPERAND_TYPE_RESULT_ID,
- SPV_OPERAND_TYPE_OPTIONAL_CIV,
- SPV_OPERAND_TYPE_OPTIONAL_CIV}));
- EXPECT_THAT(spvAlternatePatternFollowingImmediate(
- {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_DIMENSIONALITY,
- SPV_OPERAND_TYPE_LINKAGE_TYPE,
- SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE,
- SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID,
- SPV_OPERAND_TYPE_VARIABLE_ID}),
- Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV,
- SPV_OPERAND_TYPE_RESULT_ID,
- SPV_OPERAND_TYPE_OPTIONAL_CIV,
- SPV_OPERAND_TYPE_OPTIONAL_CIV,
- SPV_OPERAND_TYPE_OPTIONAL_CIV,
- SPV_OPERAND_TYPE_OPTIONAL_CIV,
- SPV_OPERAND_TYPE_OPTIONAL_CIV,
- SPV_OPERAND_TYPE_OPTIONAL_CIV}));
+ EXPECT_THAT(
+ spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_RESULT_ID,
+ SPV_OPERAND_TYPE_FP_ROUNDING_MODE,
+ SPV_OPERAND_TYPE_ID}),
+ Eq(spv_operand_pattern_t{
+ SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID,
+ SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV}));
+ EXPECT_THAT(
+ spvAlternatePatternFollowingImmediate(
+ {SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_DIMENSIONALITY,
+ SPV_OPERAND_TYPE_LINKAGE_TYPE,
+ SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE,
+ SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID,
+ SPV_OPERAND_TYPE_VARIABLE_ID}),
+ Eq(spv_operand_pattern_t{
+ SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID,
+ SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV,
+ SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV,
+ SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV}));
}
TEST(AlternatePatternFollowingImmediate, ResultIdMiddle) {
EXPECT_THAT(spvAlternatePatternFollowingImmediate(
{SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID,
SPV_OPERAND_TYPE_RESULT_ID}),
- Eq(spv_operand_pattern_t{
- SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID}));
+ Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV,
+ SPV_OPERAND_TYPE_RESULT_ID}));
EXPECT_THAT(
spvAlternatePatternFollowingImmediate(
{SPV_OPERAND_TYPE_DIMENSIONALITY, SPV_OPERAND_TYPE_LINKAGE_TYPE,
SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE,
SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID,
SPV_OPERAND_TYPE_VARIABLE_ID, SPV_OPERAND_TYPE_RESULT_ID}),
- Eq(spv_operand_pattern_t{
- SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID}));
+ Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV,
+ SPV_OPERAND_TYPE_RESULT_ID}));
}
} // anonymous namespace
namespace {
using GetTargetTest = ::testing::TestWithParam<spv_target_env>;
-using ::testing::ValuesIn;
using std::vector;
+using ::testing::ValuesIn;
TEST_P(GetTargetTest, Default) {
spv_operand_table table;
TEST_F(AggressiveDCETest, EliminateExtendedInst) {
// #version 140
- //
+ //
// in vec4 BaseColor;
// in vec4 Dead;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
)";
SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- predefs1 + names_before + predefs2 + func_before,
- predefs1 + names_after + predefs2 + func_after,
- true, true);
+ predefs1 + names_before + predefs2 + func_before,
+ predefs1 + names_after + predefs2 + func_after, true, true);
}
TEST_F(AggressiveDCETest, NoEliminateFrexp) {
// Note: SPIR-V hand-edited to utilize Frexp
//
// #version 450
- //
+ //
// in vec4 BaseColor;
// in vec4 Dead;
// out vec4 Color;
// out ivec4 iv2;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
)";
SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- predefs1 + names_before + predefs2 + func_before,
- predefs1 + names_after + predefs2 + func_after,
- true, true);
+ predefs1 + names_before + predefs2 + func_before,
+ predefs1 + names_after + predefs2 + func_after, true, true);
}
TEST_F(AggressiveDCETest, EliminateDecorate) {
// Note: The SPIR-V was hand-edited to add the OpDecorate
//
// #version 140
- //
+ //
// in vec4 BaseColor;
// in vec4 Dead;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
)";
SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- predefs1 + names_before + predefs2 + func_before,
- predefs1 + names_after + predefs2 + func_after,
- true, true);
+ predefs1 + names_before + predefs2 + func_before,
+ predefs1 + names_after + predefs2 + func_after, true, true);
}
TEST_F(AggressiveDCETest, Simple) {
// #version 140
- //
+ //
// in vec4 BaseColor;
// in vec4 Dead;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
)";
SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- predefs1 + names_before + predefs2 + func_before,
- predefs1 + names_after + predefs2 + func_after,
- true, true);
+ predefs1 + names_before + predefs2 + func_before,
+ predefs1 + names_after + predefs2 + func_after, true, true);
}
TEST_F(AggressiveDCETest, DeadCycle) {
// #version 140
// in vec4 BaseColor;
- //
+ //
// layout(std140) uniform U_t
// {
// int g_I ;
// } ;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
)";
SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- predefs1 + names_before + predefs2 + func_before,
- predefs1 + names_after + predefs2 + func_after,
- true, true);
+ predefs1 + names_before + predefs2 + func_before,
+ predefs1 + names_after + predefs2 + func_after, true, true);
}
TEST_F(AggressiveDCETest, OptWhitelistExtension) {
// #version 140
- //
+ //
// in vec4 BaseColor;
// in vec4 Dead;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
)";
SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- predefs1 + names_before + predefs2 + func_before,
- predefs1 + names_after + predefs2 + func_after,
- true, true);
+ predefs1 + names_before + predefs2 + func_before,
+ predefs1 + names_after + predefs2 + func_after, true, true);
}
TEST_F(AggressiveDCETest, NoOptBlacklistExtension) {
// #version 140
- //
+ //
// in vec4 BaseColor;
// in vec4 Dead;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- assembly, assembly, true, true);
+ SinglePassRunAndCheck<opt::AggressiveDCEPass>(assembly, assembly, true, true);
}
TEST_F(AggressiveDCETest, ElimWithCall) {
// #version 140
// in vec4 i1;
// in vec4 i2;
- //
+ //
// void nothing(vec4 v)
// {
// }
- //
+ //
// void main()
// {
// vec4 v1 = i1;
// This demonstrates that unused parameters are not eliminated, but
// dead uses of them are.
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// vec4 foo(vec4 v1, vec4 v2)
// {
// vec4 t = -v1;
// return v2;
// }
- //
+ //
// void main()
// {
// vec4 dead;
)";
const std::string func_after =
- R"(%main = OpFunction %void None %9
+ R"(%main = OpFunction %void None %9
%25 = OpLabel
%26 = OpLoad %v2float %texCoords
%29 = OpLoad %15 %sampler15
// Should not eliminate stores to params
//
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
- //
+ //
// void foo(in vec4 v1, out vec4 v2)
// {
// v2 = -v1;
// }
- //
+ //
// void main()
// {
// foo(BaseColor, OutColor);
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- assembly, assembly, true, true);
+ SinglePassRunAndCheck<opt::AggressiveDCEPass>(assembly, assembly, true, true);
}
TEST_F(AggressiveDCETest, PrivateStoreElimInEntryNoCalls) {
// layout(location = 0) out vec4 OutColor;
//
// private vec4 dv;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
// Note: Not legal GLSL
//
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
//
// private vec4 pv;
- //
+ //
// void main()
// {
// pv = BaseColor;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- assembly, assembly, true, true);
+ SinglePassRunAndCheck<opt::AggressiveDCEPass>(assembly, assembly, true, true);
}
TEST_F(AggressiveDCETest, NoPrivateStoreElimWithCall) {
// Note: Not legal GLSL
//
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
//
// private vec4 v1;
- //
+ //
// void foo()
// {
// OutColor = -v1;
// }
- //
+ //
// void main()
// {
// v1 = BaseColor;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- assembly, assembly, true, true);
+ SinglePassRunAndCheck<opt::AggressiveDCEPass>(assembly, assembly, true, true);
}
TEST_F(AggressiveDCETest, NoPrivateStoreElimInNonEntry) {
// Note: Not legal GLSL
//
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
//
// private vec4 v1;
- //
+ //
// void foo()
// {
// v1 = BaseColor;
// }
- //
+ //
// void main()
// {
// foo();
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- assembly, assembly, true, true);
+ SinglePassRunAndCheck<opt::AggressiveDCEPass>(assembly, assembly, true, true);
}
TEST_F(AggressiveDCETest, EliminateDeadIfThenElse) {
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
- //
+ //
// void main()
// {
// float d;
)";
SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- predefs_before + func_before,
- predefs_after + func_after,
- true, true);
+ predefs_before + func_before, predefs_after + func_after, true, true);
}
TEST_F(AggressiveDCETest, EliminateDeadIfThen) {
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
- //
+ //
// void main()
// {
// float d;
)";
SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- predefs_before + func_before,
- predefs_after + func_after,
- true, true);
+ predefs_before + func_before, predefs_after + func_after, true, true);
}
TEST_F(AggressiveDCETest, EliminateDeadIfThenElseNested) {
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
- //
+ //
// void main()
// {
// float d;
)";
SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- predefs_before + func_before,
- predefs_after + func_after,
- true, true);
+ predefs_before + func_before, predefs_after + func_after, true, true);
}
TEST_F(AggressiveDCETest, NoEliminateLiveIfThenElse) {
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
- //
+ //
// void main()
// {
// float t;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- assembly, assembly, true, true);
+ SinglePassRunAndCheck<opt::AggressiveDCEPass>(assembly, assembly, true, true);
}
TEST_F(AggressiveDCETest, NoEliminateLiveIfThenElseNested) {
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
- //
+ //
// void main()
// {
// float t;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- assembly, assembly, true, true);
+ SinglePassRunAndCheck<opt::AggressiveDCEPass>(assembly, assembly, true, true);
}
TEST_F(AggressiveDCETest, NoEliminateIfWithPhi) {
// Note: Assembly hand-optimized from GLSL
//
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
- //
+ //
// void main()
// {
// float t;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- assembly, assembly, true, true);
+ SinglePassRunAndCheck<opt::AggressiveDCEPass>(assembly, assembly, true, true);
}
TEST_F(AggressiveDCETest, EliminateEntireFunctionBody) {
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
- //
+ //
// void main()
// {
// float d;
)";
SinglePassRunAndCheck<opt::AggressiveDCEPass>(
- predefs_before + func_before,
- predefs_after + func_after,
- true, true);
+ predefs_before + func_before, predefs_after + func_after, true, true);
}
-
// TODO(greg-lunarg): Add tests to verify handling of these cases:
//
// Check that logical addressing required
types_consts_globals_(),
main_func_(),
main_func_postamble_({
- "OpReturn", "OpFunctionEnd",
+ "OpReturn",
+ "OpFunctionEnd",
}) {
AppendTypesConstantsGlobals({
- "%void = OpTypeVoid", "%main_func_type = OpTypeFunction %void",
+ "%void = OpTypeVoid",
+ "%main_func_type = OpTypeFunction %void",
});
AppendInMain({
"%main = OpFunction %void None %main_func_type",
TEST_F(AssemblyBuilderTest, SpecConstants) {
AssemblyBuilder builder;
builder.AppendTypesConstantsGlobals({
- "%bool = OpTypeBool", "%uint = OpTypeInt 32 0", "%int = OpTypeInt 32 1",
- "%float = OpTypeFloat 32", "%double = OpTypeFloat 64",
+ "%bool = OpTypeBool",
+ "%uint = OpTypeInt 32 0",
+ "%int = OpTypeInt 32 1",
+ "%float = OpTypeFloat 32",
+ "%double = OpTypeFloat 64",
"%v2int = OpTypeVector %int 2",
"%spec_true = OpSpecConstantTrue %bool",
// between two statements in main.
//
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::BlockMergePass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::BlockMergePass>(predefs + before, predefs + after,
+ true, true);
}
TEST_F(BlockMergeTest, EmptyBlock) {
// after two statements in main.
//
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::BlockMergePass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::BlockMergePass>(predefs + before, predefs + after,
+ true, true);
}
TEST_F(BlockMergeTest, NoOptOfMergeOrContinueBlock) {
//
// #version 140
// in vec4 BaseColor;
- //
+ //
// void main()
// {
// while (true) {
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::BlockMergePass>(
- assembly, assembly, true, true);
+ SinglePassRunAndCheck<opt::BlockMergePass>(assembly, assembly, true, true);
}
TEST_F(BlockMergeTest, NestedInControlFlow) {
//
// #version 140
// in vec4 BaseColor;
- //
+ //
// layout(std140) uniform U_t
// {
// bool g_B ;
// } ;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
- // if (g_B)
+ // if (g_B)
// vec4 v = v * 0.25;
// gl_FragColor = v;
// }
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::BlockMergePass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::BlockMergePass>(predefs + before, predefs + after,
+ true, true);
}
// TODO(greg-lunarg): Add tests to verify handling of these cases:
SinglePassRunAndCheck<opt::CFGCleanupPass>(before, after, true, true);
}
-
TEST_F(CFGCleanupTest, UpdatePhis) {
const std::string before = R"(
OpCapability Shader
OpReturn
OpFunctionEnd)";
- const std::string after = R"(OpCapability Shader
+ const std::string after = R"(OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %main "main"
}
TEST_F(CFGCleanupTest, RemovePhiArgsFromFarBlocks) {
- const std::string before = R"(
+ const std::string before = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpReturn
OpFunctionEnd)";
- const std::string after = R"(OpCapability Shader
+ const std::string after = R"(OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %y %outparm
}
TEST_F(CFGCleanupTest, RemovePhiConstantArgs) {
- const std::string before = R"(
+ const std::string before = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpReturn
OpFunctionEnd)";
- const std::string after = R"(OpCapability Shader
+ const std::string after = R"(OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %y %outparm
// #version 140
// in vec4 BaseColor;
// in float fi;
- //
+ //
// layout(std140) uniform U_t
// {
// float g_F;
// float g_F2;
// } ;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
// in vec4 BaseColor;
// in float fi;
// in float fi2;
- //
+ //
// layout(std140) uniform U_t
// {
// float g_F;
// float g_F2;
// } ;
- //
+ //
// void main()
// {
// float f = fi;
// #version 140
// in vec4 BaseColor;
// in float fi;
- //
+ //
// layout(std140) uniform U_t
// {
// bool g_B;
// float g_F;
// } ;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
// #version 140
// in vec4 BC;
// in vec4 BC2;
- //
+ //
// layout(std140) uniform U_t
// {
// float g_F;
// } ;
- //
+ //
// void main()
// {
// vec4 v = BC;
predefs + before, predefs + after, true, true);
}
- TEST_F(CommonUniformElimTest, Volatile1) {
+TEST_F(CommonUniformElimTest, Volatile1) {
// Note: This test exemplifies the following:
// - Same test as Basic1 with the exception that
// the Load of g_F in else-branch is volatile
)";
SinglePassRunAndCheck<opt::CommonUniformElimPass>(
- predefs + before, predefs + after, true, true);
+ predefs + before, predefs + after, true, true);
}
TEST_F(CommonUniformElimTest, Volatile2) {
OpFunctionEnd
)";
- opt::Pass::Status res = std::get<1>(SinglePassRunAndDisassemble<opt::CommonUniformElimPass>(text, true));
+ opt::Pass::Status res = std::get<1>(
+ SinglePassRunAndDisassemble<opt::CommonUniformElimPass>(text, true));
EXPECT_EQ(res, opt::Pass::Status::SuccessWithoutChange);
}
// }
const std::string text =
- R"(OpCapability Shader
+ R"(OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %BaseColor %fi
OpFunctionEnd
)";
- opt::Pass::Status res = std::get<1>(SinglePassRunAndDisassemble<opt::CommonUniformElimPass>(text, true));
+ opt::Pass::Status res = std::get<1>(
+ SinglePassRunAndDisassemble<opt::CommonUniformElimPass>(text, true));
EXPECT_EQ(res, opt::Pass::Status::SuccessWithoutChange);
}
// TODO(greg-lunarg): Add tests to verify handling of these cases:
TEST_F(CompactIdsTest, PassOff) {
const std::string before =
-R"(OpCapability Addresses
+ R"(OpCapability Addresses
OpCapability Kernel
OpCapability GenericPointer
OpCapability Linkage
TEST_F(CompactIdsTest, PassOn) {
const std::string before =
-R"(OpCapability Addresses
+ R"(OpCapability Addresses
OpCapability Kernel
OpCapability GenericPointer
OpCapability Linkage
)";
const std::string after =
-R"(OpCapability Addresses
+ R"(OpCapability Addresses
OpCapability Kernel
OpCapability GenericPointer
OpCapability Linkage
TEST_F(DeadBranchElimTest, IfThenElseTrue) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// void main()
// {
// vec4 v;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, IfThenElseFalse) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// void main()
// {
// vec4 v;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, IfThenTrue) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, IfThenFalse) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, IfThenElsePhiTrue) {
// Note: The SPIR-V has had store/load elimination and phi insertion
//
// #version 140
- //
+ //
// void main()
// {
// vec4 v;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, IfThenElsePhiFalse) {
// Note: The SPIR-V has had store/load elimination and phi insertion
//
// #version 140
- //
+ //
// void main()
// {
// vec4 v;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, CompoundIfThenElseFalse) {
// #version 140
- //
+ //
// layout(std140) uniform U_t
// {
// bool g_B ;
// } ;
- //
+ //
// void main()
// {
// vec4 v;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, PreventOrphanMerge) {
-
const std::string predefs =
R"(OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, HandleOrphanMerge) {
-
const std::string predefs =
R"(OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, KeepContinueTargetWhenKillAfterMerge) {
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, DecorateDeleted) {
// Note: SPIR-V hand-edited to add decoration
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
TEST_F(DeadBranchElimTest, LoopInDeadBranch) {
// #version 450
- //
+ //
// layout(location = 0) in vec4 BaseColor;
// layout(location = 0) out vec4 OutColor;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, SwitchLiveCase) {
// #version 450
- //
+ //
// layout (location=0) in vec4 BaseColor;
// layout (location=0) out vec4 OutColor;
- //
+ //
// void main()
// {
// switch (1) {
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, SwitchLiveDefault) {
// #version 450
- //
+ //
// layout (location=0) in vec4 BaseColor;
// layout (location=0) out vec4 OutColor;
- //
+ //
// void main()
// {
// switch (7) {
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
TEST_F(DeadBranchElimTest, SwitchLiveCaseBreakFromLoop) {
// This construct is currently formed by inlining a function
// containing early returns from the cases of a switch. The
// function is wrapped in a one-trip loop and returns are
- // translated to branches to the loop's merge block.
+ // translated to branches to the loop's merge block.
const std::string predefs =
R"(OpCapability Shader
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::DeadBranchElimPass>(
- predefs + before, predefs + after, true, true);
+ SinglePassRunAndCheck<opt::DeadBranchElimPass>(predefs + before,
+ predefs + after, true, true);
}
// TODO(greg-lunarg): Add tests to verify handling of these cases:
using spvtools::opt::analysis::DefUseManager;
// Returns the number of uses of |id|.
-uint32_t NumUses(const std::unique_ptr<ir::IRContext> &context, uint32_t id) {
+uint32_t NumUses(const std::unique_ptr<ir::IRContext>& context, uint32_t id) {
uint32_t count = 0;
- context->get_def_use_mgr()->ForEachUse(id, [&count](ir::Instruction*, uint32_t) {
- ++count;
- });
+ context->get_def_use_mgr()->ForEachUse(
+ id, [&count](ir::Instruction*, uint32_t) { ++count; });
return count;
}
//
// If |id| is used multiple times in a single instruction, that instruction's
// opcode will appear a corresponding number of times.
-std::vector<SpvOp> GetUseOpcodes(const std::unique_ptr<ir::IRContext> &context, uint32_t id) {
+std::vector<SpvOp> GetUseOpcodes(const std::unique_ptr<ir::IRContext>& context,
+ uint32_t id) {
std::vector<SpvOp> opcodes;
- context->get_def_use_mgr()->ForEachUse(id, [&opcodes](ir::Instruction* user, uint32_t) {
- opcodes.push_back(user->opcode());
- });
+ context->get_def_use_mgr()->ForEachUse(
+ id, [&opcodes](ir::Instruction* user, uint32_t) {
+ opcodes.push_back(user->opcode());
+ });
return opcodes;
}
UserMap userMap;
for (uint32_t id = 0; id != idBound; ++id) {
if (mgr->GetDef(id)) {
- mgr->ForEachUser(id, [id,&userMap](ir::Instruction* user) {
+ mgr->ForEachUser(id, [id, &userMap](ir::Instruction* user) {
if (user->opcode() != SpvOpConstant) {
userMap[id].push_back(user);
}
// Constants don't disassemble properly without a full context, so skip them as
// checks.
-void CheckUse(const InstDefUse& expected_defs_uses,
- const DefUseManager* mgr,
+void CheckUse(const InstDefUse& expected_defs_uses, const DefUseManager* mgr,
uint32_t idBound) {
UserMap actual_uses = BuildAllUsers(mgr, idBound);
// Check uses.
(void)context->get_def_use_mgr();
// Do a bunch replacements.
- context->ReplaceAllUsesWith(11, 7); // to existing id
+ context->ReplaceAllUsesWith(11, 7); // to existing id
context->ReplaceAllUsesWith(10, 11); // to existing id
- context->ReplaceAllUsesWith(9, 10); // to existing id
+ context->ReplaceAllUsesWith(9, 10); // to existing id
// clang-format off
const char modified_text[] =
CheckDef(tc.expected_define_use, manager.id_to_defs());
CheckUse(tc.expected_define_use, &manager, context->module()->IdBound());
- //CheckUse(tc.expected_define_use, manager.id_to_uses());
+ // CheckUse(tc.expected_define_use, manager.id_to_uses());
}
// clang-format off
manager.AnalyzeInstDefUse(&branch);
context.module()->SetIdBound(3);
- InstDefUse expected =
- {
- // defs
- {
- {2, "%2 = OpLabel"},
- },
- // uses
- {{2, {"OpBranch %2"}}},
+ InstDefUse expected = {
+ // defs
+ {
+ {2, "%2 = OpLabel"},
+ },
+ // uses
+ {{2, {"OpBranch %2"}}},
};
CheckDef(expected, manager.id_to_defs());
ir::Instruction newInst(context.get(), SpvOpConstantTrue, 1, 2, {});
manager.AnalyzeInstDefUse(&newInst);
- InstDefUse expected =
- {
- { // defs
- {1, "%1 = OpTypeBool"},
- {2, "%2 = OpConstantTrue %1"},
- },
- { // uses
- {1, {"%2 = OpConstantTrue %1"}},
- },
+ InstDefUse expected = {
+ {
+ // defs
+ {1, "%1 = OpTypeBool"},
+ {2, "%2 = OpConstantTrue %1"},
+ },
+ {
+ // uses
+ {1, {"%2 = OpConstantTrue %1"}},
+ },
};
CheckDef(expected, manager.id_to_defs());
EXPECT_EQ(tc.after, DisassembleModule(context->module()));
CheckDef(tc.expected_define_use, context->get_def_use_mgr()->id_to_defs());
- CheckUse(tc.expected_define_use, context->get_def_use_mgr(), context->module()->IdBound());
+ CheckUse(tc.expected_define_use, context->get_def_use_mgr(),
+ context->module()->IdBound());
}
// clang-format off
// None of the above constants is ever used, so all of them should be
// eliminated.
const char* const_decl_opcodes[] = {
- " OpConstantTrue ", " OpConstantFalse ", " OpConstant ",
+ " OpConstantTrue ",
+ " OpConstantFalse ",
+ " OpConstant ",
};
// Skip lines that have any one of const_decl_opcodes.
const std::string expected_disassembly =
)";
SinglePassRunAndCheck<opt::InlineOpaquePass>(
- predefs + before + post_defs,
- predefs + after + post_defs, true, true);
+ predefs + before + post_defs, predefs + after + post_defs, true, true);
}
TEST_F(InlineOpaqueTest, InlineOpaqueReturn) {
)";
SinglePassRunAndCheck<opt::InlineOpaquePass>(
- predefs + before + post_defs,
- predefs + after + post_defs, true, true);
+ predefs + before + post_defs, predefs + after + post_defs, true, true);
}
TEST_F(InlineOpaqueTest, InlineInNonEntryPointFunction) {
)";
SinglePassRunAndCheck<opt::InlineOpaquePass>(
- predefs + before + post_defs,
- predefs + after + post_defs, true, true);
+ predefs + before + post_defs, predefs + after + post_defs, true, true);
}
TEST_F(InlineOpaqueTest, NoInlineNoOpaque) {
// Function without opaque interface is not inlined.
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// float foo(vec4 bar)
// {
// return bar.x + bar.y;
// }
- //
+ //
// void main()
// {
// vec4 color = vec4(foo(BaseColor));
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::InlineOpaquePass>(
- assembly, assembly, true, true);
+ SinglePassRunAndCheck<opt::InlineOpaquePass>(assembly, assembly, true, true);
}
} // anonymous namespace
TEST_F(InlineTest, Simple) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// float foo(vec4 bar)
// {
// return bar.x + bar.y;
// }
- //
+ //
// void main()
// {
// vec4 color = vec4(foo(BaseColor));
TEST_F(InlineTest, Nested) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// float foo2(float f, float f2)
// {
// return f * f2;
// }
- //
+ //
// float foo(vec4 bar)
// {
// return foo2(bar.x + bar.y, bar.z);
// }
- //
+ //
// void main()
// {
// vec4 color = vec4(foo(BaseColor));
- // gl_FragColor = color;
+ // gl_FragColor = color;
// }
const std::vector<const char*> predefs = {
// clang-format off
TEST_F(InlineTest, InOutParameter) {
// #version 400
- //
+ //
// in vec4 Basecolor;
- //
+ //
// void foo(inout vec4 bar)
// {
// bar.z = bar.x + bar.y;
// }
- //
+ //
// void main()
// {
// vec4 b = Basecolor;
// foo(b);
// vec4 color = vec4(b.z);
- // gl_FragColor = color;
+ // gl_FragColor = color;
// }
const std::vector<const char*> predefs = {
// clang-format off
TEST_F(InlineTest, BranchInCallee) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// float foo(vec4 bar)
// {
// float r = bar.x;
// r = -r;
// return r;
// }
- //
+ //
// void main()
// {
// vec4 color = vec4(foo(BaseColor));
- //
- // gl_FragColor = color;
+ //
+ // gl_FragColor = color;
// }
const std::vector<const char*> predefs = {
// clang-format off
TEST_F(InlineTest, PhiAfterCall) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// float foo(float bar)
// {
// float r = bar;
// r = -r;
// return r;
// }
- //
+ //
// void main()
// {
// vec4 color = BaseColor;
// if (foo(color.x) > 2.0 && foo(color.y) > 2.0)
// color = vec4(0.0);
- // gl_FragColor = color;
+ // gl_FragColor = color;
// }
const std::vector<const char*> predefs = {
// clang-format off
TEST_F(InlineTest, OpSampledImageOutOfBlock) {
// #version 450
- //
+ //
// uniform texture2D t2D;
// uniform sampler samp;
// out vec4 FragColor;
// in vec4 BaseColor;
- //
+ //
// float foo(vec4 bar)
// {
// float r = bar.x;
// r = -r;
// return r;
// }
- //
+ //
// void main()
// {
// vec4 color1 = texture(sampler2D(t2D, samp), vec2(1.0));
// vec4 color2 = vec4(foo(BaseColor));
// vec4 color3 = texture(sampler2D(t2D, samp), vec2(0.5));
- // FragColor = (color1 + color2 + color3)/3;
+ // FragColor = (color1 + color2 + color3)/3;
// }
//
// Note: the before SPIR-V will need to be edited to create a use of
TEST_F(InlineTest, OpImageOutOfBlock) {
// #version 450
- //
+ //
// uniform texture2D t2D;
// uniform sampler samp;
// uniform sampler samp2;
- //
+ //
// out vec4 FragColor;
- //
+ //
// in vec4 BaseColor;
- //
+ //
// float foo(vec4 bar)
// {
// float r = bar.x;
// r = -r;
// return r;
// }
- //
+ //
// void main()
// {
// vec4 color1 = texture(sampler2D(t2D, samp), vec2(1.0));
// vec4 color2 = vec4(foo(BaseColor));
// vec4 color3 = texture(sampler2D(t2D, samp2), vec2(0.5));
- // FragColor = (color1 + color2 + color3)/3;
+ // FragColor = (color1 + color2 + color3)/3;
// }
// Note: the before SPIR-V will need to be edited to create an OpImage
// from the first OpSampledImage, place it before the call and use it
TEST_F(InlineTest, OpImageAndOpSampledImageOutOfBlock) {
// #version 450
- //
+ //
// uniform texture2D t2D;
// uniform sampler samp;
// uniform sampler samp2;
- //
+ //
// out vec4 FragColor;
- //
+ //
// in vec4 BaseColor;
- //
+ //
// float foo(vec4 bar)
// {
// float r = bar.x;
// r = -r;
// return r;
// }
- //
+ //
// void main()
// {
// vec4 color1 = texture(sampler2D(t2D, samp), vec2(1.0));
// vec4 color2 = vec4(foo(BaseColor));
// vec4 color3 = texture(sampler2D(t2D, samp2), vec2(0.5));
- // FragColor = (color1 + color2 + color3)/3;
+ // FragColor = (color1 + color2 + color3)/3;
// }
// Note: the before SPIR-V will need to be edited to create an OpImage
// and subsequent OpSampledImage that is used across the function call.
TEST_F(InlineTest, EarlyReturnFunctionInlined) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// float foo(vec4 bar)
// {
// if (bar.x < 0.0)
// return 0.0;
// return bar.x;
// }
- //
+ //
// void main()
// {
// vec4 color = vec4(foo(BaseColor));
- // gl_FragColor = color;
+ // gl_FragColor = color;
// }
const std::string predefs =
)";
SinglePassRunAndCheck<opt::InlineExhaustivePass>(
- predefs + before + nonEntryFuncs,
- predefs + after + nonEntryFuncs, false, true);
+ predefs + before + nonEntryFuncs, predefs + after + nonEntryFuncs, false,
+ true);
}
TEST_F(InlineTest, EarlyReturnNotAppearingLastInFunctionInlined) {
)";
const std::string after =
-R"(%main = OpFunction %void None %4
+ R"(%main = OpFunction %void None %4
%10 = OpLabel
OpSelectionMerge %12 None
OpBranchConditional %true %13 %12
)";
SinglePassRunAndCheck<opt::InlineExhaustivePass>(
- predefs + nonEntryFuncs + before,
- predefs + nonEntryFuncs + after, false, true);
+ predefs + nonEntryFuncs + before, predefs + nonEntryFuncs + after, false,
+ true);
}
TEST_F(InlineTest, ForwardReferencesInPhiInlined) {
// The basic structure of the test case is like this:
- //
+ //
// int foo() {
// int result = 1;
// if (true) {
// result = 1;
- // }
+ // }
// return result;
- // }
- //
+ // }
+ //
// void main() {
// int x = foo();
// }
- //
+ //
// but with modifications: Using Phi instead of load/store, and the
// return block in foo appears before the "then" block.
)";
const std::string after =
-R"(%main = OpFunction %void None %6
+ R"(%main = OpFunction %void None %6
%19 = OpLabel
%21 = OpVariable %_ptr_Function_int Function
%x = OpVariable %_ptr_Function_int Function
)";
SinglePassRunAndCheck<opt::InlineExhaustivePass>(
- predefs + nonEntryFuncs + before,
- predefs + nonEntryFuncs + after, false, true);
+ predefs + nonEntryFuncs + before, predefs + nonEntryFuncs + after, false,
+ true);
}
TEST_F(InlineTest, EarlyReturnInLoopIsNotInlined) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// float foo(vec4 bar)
// {
// while (true) {
// return bar.x;
// }
// }
- //
+ //
// void main()
// {
// vec4 color = vec4(foo(BaseColor));
- // gl_FragColor = color;
+ // gl_FragColor = color;
// }
const std::string assembly =
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::InlineExhaustivePass>(
- assembly, assembly, false, true);
+ SinglePassRunAndCheck<opt::InlineExhaustivePass>(assembly, assembly, false,
+ true);
}
TEST_F(InlineTest, ExternalFunctionIsNotInlined) {
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::InlineExhaustivePass>(
- assembly, assembly, false, true);
+ SinglePassRunAndCheck<opt::InlineExhaustivePass>(assembly, assembly, false,
+ true);
}
TEST_F(InlineTest, SingleBlockLoopCallsMultiBlockCallee) {
true);
}
-TEST_F(InlineTest, MultiBlockLoopHeaderCallsFromToMultiBlockCalleeHavingSelectionMerge) {
+TEST_F(InlineTest,
+ MultiBlockLoopHeaderCallsFromToMultiBlockCalleeHavingSelectionMerge) {
// This is similar to SingleBlockLoopCallsMultiBlockCalleeHavingSelectionMerge
// but the call is in the header block of a multi block loop.
const std::string predefs =
-R"(OpCapability Shader
+ R"(OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %1 "main"
OpSource OpenCL_C 120
)";
const std::string nonEntryFuncs =
- R"(%12 = OpFunction %void None %11
+ R"(%12 = OpFunction %void None %11
%13 = OpLabel
%14 = OpCopyObject %int %int_1
OpSelectionMerge %15 None
true);
}
-TEST_F(InlineTest, SingleBlockLoopCallsMultiBlockCalleeHavingSelectionMergeAndMultiReturns) {
+TEST_F(
+ InlineTest,
+ SingleBlockLoopCallsMultiBlockCalleeHavingSelectionMergeAndMultiReturns) {
// This is similar to SingleBlockLoopCallsMultiBlockCalleeHavingSelectionMerge
// except that in addition to starting with a selection header, the
// callee also has multi returns.
// }
const std::string predefs =
- R"(OpCapability Shader
+ R"(OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor
)";
const std::string before =
- R"(%void = OpTypeVoid
+ R"(%void = OpTypeVoid
%11 = OpTypeFunction %void
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
OpFunctionEnd
)";
-
const std::string after =
- R"(OpDecorate %37 RelaxedPrecision
+ R"(OpDecorate %37 RelaxedPrecision
%void = OpTypeVoid
%11 = OpTypeFunction %void
%float = OpTypeFloat 32
)";
const std::string nonEntryFuncs =
- R"(%foo_vf4_ = OpFunction %float None %15
+ R"(%foo_vf4_ = OpFunction %float None %15
%bar = OpFunctionParameter %_ptr_Function_v4float
%27 = OpLabel
%28 = OpAccessChain %_ptr_Function_float %bar %uint_0
OpFunctionEnd
)";
SinglePassRunAndCheck<opt::InlineExhaustivePass>(
- predefs + before + nonEntryFuncs, predefs + after + nonEntryFuncs, false,
- true);
+ predefs + before + nonEntryFuncs, predefs + after + nonEntryFuncs, false,
+ true);
}
TEST_F(InlineTest, Decorated2) {
// }
const std::string predefs =
- R"(OpCapability Shader
+ R"(OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %BaseColor %gl_FragColor
)";
const std::string before =
- R"(%void = OpTypeVoid
+ R"(%void = OpTypeVoid
%10 = OpTypeFunction %void
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
OpFunctionEnd
)";
-
const std::string after =
- R"(OpDecorate %32 RelaxedPrecision
+ R"(OpDecorate %32 RelaxedPrecision
%void = OpTypeVoid
%10 = OpTypeFunction %void
%float = OpTypeFloat 32
)";
const std::string nonEntryFuncs =
- R"(%foo_vf4_ = OpFunction %float None %14
+ R"(%foo_vf4_ = OpFunction %float None %14
%bar = OpFunctionParameter %_ptr_Function_v4float
%26 = OpLabel
%27 = OpAccessChain %_ptr_Function_float %bar %uint_0
OpFunctionEnd
)";
SinglePassRunAndCheck<opt::InlineExhaustivePass>(
- predefs + before + nonEntryFuncs, predefs + after + nonEntryFuncs, false,
- true);
+ predefs + before + nonEntryFuncs, predefs + after + nonEntryFuncs, false,
+ true);
}
// TODO(greg-lunarg): Add tests to verify handling of these cases:
//
// #version 140
//
// in vec4 BaseColor;
- //
+ //
// struct S_t {
// vec4 v0;
// vec4 v1;
// };
- //
+ //
// void main()
// {
// S_t s0;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::InsertExtractElimPass>(predefs + before,
- predefs + after, true, true);
+ SinglePassRunAndCheck<opt::InsertExtractElimPass>(
+ predefs + before, predefs + after, true, true);
}
TEST_F(InsertExtractElimTest, OptimizeAcrossNonConflictingInsert) {
// #version 140
//
// in vec4 BaseColor;
- //
+ //
// struct S_t {
// vec4 v0;
// vec4 v1;
// };
- //
+ //
// void main()
// {
// S_t s0;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::InsertExtractElimPass>(predefs + before,
- predefs + after, true, true);
+ SinglePassRunAndCheck<opt::InsertExtractElimPass>(
+ predefs + before, predefs + after, true, true);
}
TEST_F(InsertExtractElimTest, OptimizeOpaque) {
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::InsertExtractElimPass>(predefs + before,
- predefs + after, true, true);
+ SinglePassRunAndCheck<opt::InsertExtractElimPass>(
+ predefs + before, predefs + after, true, true);
}
TEST_F(InsertExtractElimTest, OptimizeNestedStruct) {
// int x;
// SamplerState ss;
// };
- //
+ //
// struct S1
// {
// float b;
// S0 s0;
// };
- //
+ //
// struct S2
// {
// int a1;
// S1 resources;
// };
- //
+ //
// SamplerState samp;
// Texture2D tex;
- //
+ //
// float4 main(float4 vpos : VPOS) : COLOR0
// {
// S1 s1;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::InsertExtractElimPass>(predefs + before,
- predefs + after, true, true);
+ SinglePassRunAndCheck<opt::InsertExtractElimPass>(
+ predefs + before, predefs + after, true, true);
}
TEST_F(InsertExtractElimTest, ConflictingInsertPreventsOptimization) {
// #version 140
//
// in vec4 BaseColor;
- //
+ //
// struct S_t {
// vec4 v0;
// vec4 v1;
// };
- //
+ //
// void main()
// {
// S_t s0;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::InsertExtractElimPass>(assembly,
- assembly, true, true);
+ SinglePassRunAndCheck<opt::InsertExtractElimPass>(assembly, assembly, true,
+ true);
}
TEST_F(InsertExtractElimTest, ConflictingInsertPreventsOptimization2) {
// #version 140
//
// in vec4 BaseColor;
- //
+ //
// struct S_t {
// vec4 v0;
// vec4 v1;
// };
- //
+ //
// void main()
// {
// S_t s0;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::InsertExtractElimPass>(assembly,
- assembly, true, true);
+ SinglePassRunAndCheck<opt::InsertExtractElimPass>(assembly, assembly, true,
+ true);
}
// TODO(greg-lunarg): Add tests to verify handling of these cases:
#include "gmock/gmock.h"
-#include "spirv-tools/libspirv.h"
-#include "unit_spirv.h"
#include "pass_fixture.h"
#include "pass_utils.h"
+#include "spirv-tools/libspirv.h"
+#include "unit_spirv.h"
namespace {
using namespace spvtools;
-using spvtest::MakeInstruction;
using ir::Instruction;
using ir::IRContext;
using ir::Operand;
+using spvtest::MakeInstruction;
using ::testing::Eq;
using DescriptorTypeTest = PassTest<::testing::Test>;
ASSERT_NE(nullptr, context);
const auto opundef_count = std::count_if(
- context->module()->types_values_begin(), context->module()->types_values_end(),
+ context->module()->types_values_begin(),
+ context->module()->types_values_end(),
[](const ir::Instruction& inst) { return inst.opcode() == SpvOpUndef; });
EXPECT_EQ(3, opundef_count);
TEST(IrBuilder, KeepModuleProcessedInRightPlace) {
DoRoundTripCheck(
- // clang-format off
+ // clang-format off
"OpCapability Shader\n"
"OpMemoryModel Logical GLSL450\n"
"%1 = OpString \"minimal.vert\"\n"
using LocalAccessChainConvertTest = PassTest<::testing::Test>;
TEST_F(LocalAccessChainConvertTest, StructOfVecsOfFloatConverted) {
-
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// struct S_t {
// vec4 v0;
// vec4 v1;
// };
- //
+ //
// void main()
// {
// S_t s0;
}
TEST_F(LocalAccessChainConvertTest, InBoundsAccessChainsConverted) {
-
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// struct S_t {
// vec4 v0;
// vec4 v1;
// };
- //
+ //
// void main()
// {
// S_t s0;
}
TEST_F(LocalAccessChainConvertTest, TwoUsesofSingleChainConverted) {
-
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// struct S_t {
// vec4 v0;
// vec4 v1;
// };
- //
+ //
// void main()
// {
// S_t s0;
predefs + before + remain, predefs + after + remain, true, true);
}
-TEST_F(LocalAccessChainConvertTest,
- NestedStructsConverted) {
-
+TEST_F(LocalAccessChainConvertTest, NestedStructsConverted) {
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// struct S1_t {
// vec4 v1;
// };
- //
+ //
// struct S2_t {
// vec4 v2;
// S1_t s1;
// };
- //
+ //
// void main()
// {
// S2_t s2;
)";
SinglePassRunAndCheck<opt::LocalAccessChainConvertPass>(
- predefs_before + before , predefs_after + after, true, true);
+ predefs_before + before, predefs_after + after, true, true);
}
-TEST_F(LocalAccessChainConvertTest,
- DynamicallyIndexedVarNotConverted) {
-
+TEST_F(LocalAccessChainConvertTest, DynamicallyIndexedVarNotConverted) {
// #version 140
- //
+ //
// in vec4 BaseColor;
// flat in int Idx;
// in float Bi;
// vec4 v0;
// vec4 v1;
// };
- //
+ //
// void main()
// {
// S_t s0;
OpFunctionEnd
)";
- SinglePassRunAndCheck<opt::LocalAccessChainConvertPass>(
- assembly, assembly, false, true);
+ SinglePassRunAndCheck<opt::LocalAccessChainConvertPass>(assembly, assembly,
+ false, true);
}
TEST_F(LocalAccessChainConvertTest, SomeAccessChainsHaveNoUse) {
OpReturn
OpFunctionEnd
)";
-SinglePassRunAndMatch<opt::LocalRedundancyEliminationPass>(text);
+ SinglePassRunAndMatch<opt::LocalRedundancyEliminationPass>(text);
}
// Make sure we keep instruction that are different, but look similar.
// Note that the call tree function bar is optimized, but foo is not
//
// #version 140
- //
+ //
// in vec4 BaseColor;
- //
+ //
// vec4 foo(vec4 v1)
// {
// vec4 t = v1;
// return t;
// }
- //
+ //
// vec4 bar(vec4 v1)
// {
// vec4 t = v1;
// return t;
// }
- //
+ //
// void main()
// {
// gl_FragColor = bar(BaseColor);
)";
SinglePassRunAndCheck<opt::LocalSingleStoreElimPass>(
- predefs_before + before,
- predefs_after + after, true, true);
+ predefs_before + before, predefs_after + after, true, true);
}
TEST_F(LocalSingleStoreElimTest, MultipleLoads) {
)";
SinglePassRunAndCheck<opt::LocalSingleStoreElimPass>(
- predefs_before + before,
- predefs_after + after, true, true);
+ predefs_before + before, predefs_after + after, true, true);
}
TEST_F(LocalSingleStoreElimTest, NoStoreElimWithInterveningAccessChainLoad) {
)";
SinglePassRunAndCheck<opt::LocalSingleStoreElimPass>(
- predefs_before + before,
- predefs_after + after, true, true);
+ predefs_before + before, predefs_after + after, true, true);
}
TEST_F(LocalSingleStoreElimTest, NoReplaceOfDominatingPartialStore) {
TEST_F(LocalSSAElimTest, ForLoop) {
// #version 140
- //
+ //
// in vec4 BC;
// out float fo;
- //
+ //
// void main()
// {
// float f = 0.0;
SinglePassRunAndCheck<opt::LocalMultiStoreElimPass>(
predefs + names_before + predefs2 + before,
- predefs + names_after + predefs2 + after,
- true, true);
+ predefs + names_after + predefs2 + after, true, true);
}
TEST_F(LocalSSAElimTest, ForLoopWithContinue) {
// #version 140
- //
+ //
// in vec4 BC;
// out float fo;
- //
+ //
// void main()
// {
// float f = 0.0;
SinglePassRunAndCheck<opt::LocalMultiStoreElimPass>(
predefs + names_before + predefs2 + before,
- predefs + names_after + predefs2 + after,
- true, true);
+ predefs + names_after + predefs2 + after, true, true);
}
TEST_F(LocalSSAElimTest, ForLoopWithBreak) {
// #version 140
- //
+ //
// in vec4 BC;
// out float fo;
- //
+ //
// void main()
// {
// float f = 0.0;
SinglePassRunAndCheck<opt::LocalMultiStoreElimPass>(
predefs + names_before + predefs2 + before,
- predefs + names_after + predefs2 + after,
- true, true);
+ predefs + names_after + predefs2 + after, true, true);
}
TEST_F(LocalSSAElimTest, SwapProblem) {
// #version 140
- //
+ //
// in float fe;
// out float fo;
- //
+ //
// void main()
// {
// float f1 = 0.0;
SinglePassRunAndCheck<opt::LocalMultiStoreElimPass>(
predefs + names_before + predefs2 + before,
- predefs + names_after + predefs2 + after,
- true, true);
+ predefs + names_after + predefs2 + after, true, true);
}
TEST_F(LocalSSAElimTest, LostCopyProblem) {
// #version 140
- //
+ //
// in vec4 BC;
// out float fo;
- //
+ //
// void main()
// {
// float f = 0.0;
SinglePassRunAndCheck<opt::LocalMultiStoreElimPass>(
predefs + names_before + predefs2 + before,
- predefs + names_after + predefs2 + after,
- true, true);
+ predefs + names_after + predefs2 + after, true, true);
}
TEST_F(LocalSSAElimTest, IfThenElse) {
// #version 140
- //
+ //
// in vec4 BaseColor;
// in float f;
- //
+ //
// void main()
// {
// vec4 v;
SinglePassRunAndCheck<opt::LocalMultiStoreElimPass>(
predefs + names_before + predefs2 + before,
- predefs + names_after + predefs2 + after,
- true, true);
+ predefs + names_after + predefs2 + after, true, true);
}
TEST_F(LocalSSAElimTest, DecoratedVar) {
// SPIR-V hand edited to decorate v
// #version 450
- //
+ //
// layout (location=0) in vec4 BaseColor;
// layout (location=1) in float f;
// layout (location=0) out vec4 OutColor;
- //
+ //
// void main()
// {
// vec4 v;
)";
SinglePassRunAndCheck<opt::LocalMultiStoreElimPass>(
- predefs_before + before,
- predefs_after + after,
- true, true);
+ predefs_before + before, predefs_after + after, true, true);
}
TEST_F(LocalSSAElimTest, IfThen) {
// #version 140
- //
+ //
// in vec4 BaseColor;
// in float f;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
SinglePassRunAndCheck<opt::LocalMultiStoreElimPass>(
predefs + names_before + predefs2 + before,
- predefs + names_after + predefs2 + after,
- true, true);
+ predefs + names_after + predefs2 + after, true, true);
}
TEST_F(LocalSSAElimTest, Switch) {
// #version 140
- //
+ //
// in vec4 BaseColor;
// in float f;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
SinglePassRunAndCheck<opt::LocalMultiStoreElimPass>(
predefs + names_before + predefs2 + before,
- predefs + names_after + predefs2 + after,
- true, true);
+ predefs + names_after + predefs2 + after, true, true);
}
TEST_F(LocalSSAElimTest, SwitchWithFallThrough) {
// #version 140
- //
+ //
// in vec4 BaseColor;
// in float f;
- //
+ //
// void main()
// {
// vec4 v = BaseColor;
SinglePassRunAndCheck<opt::LocalMultiStoreElimPass>(
predefs + names_before + predefs2 + before,
- predefs + names_after + predefs2 + after,
- true, true);
+ predefs + names_after + predefs2 + after, true, true);
}
TEST_F(LocalSSAElimTest, DontPatchPhiInLoopHeaderThatIsNotAVar) {
namespace {
+using spvtest::GetIdBound;
using spvtools::ir::IRContext;
using spvtools::ir::Module;
-using spvtest::GetIdBound;
using ::testing::Eq;
TEST(ModuleTest, SetIdBound) {
// Sensitive to result id
EXPECT_EQ(2u, BuildModule("%void = OpTypeVoid")->module()->ComputeIdBound());
// Sensitive to type id
- EXPECT_EQ(1000u, BuildModule("%a = OpTypeArray !999 3")->module()->ComputeIdBound());
+ EXPECT_EQ(1000u,
+ BuildModule("%a = OpTypeArray !999 3")->module()->ComputeIdBound());
// Sensitive to a regular Id parameter
- EXPECT_EQ(2000u, BuildModule("OpDecorate !1999 0")->module()->ComputeIdBound());
+ EXPECT_EQ(2000u,
+ BuildModule("OpDecorate !1999 0")->module()->ComputeIdBound());
// Sensitive to a scope Id parameter.
EXPECT_EQ(3000u,
BuildModule("%f = OpFunction %void None %fntype %a = OpLabel "
"OpMemoryBarrier !2999 %b\n")
- ->module()->ComputeIdBound());
+ ->module()
+ ->ComputeIdBound());
// Sensitive to a semantics Id parameter
EXPECT_EQ(4000u,
BuildModule("%f = OpFunction %void None %fntype %a = OpLabel "
"OpMemoryBarrier %b !3999\n")
- ->module()->ComputeIdBound());
+ ->module()
+ ->ComputeIdBound());
}
} // anonymous namespace
} // namespace spvtest
-#endif // LIBSPIRV_TEST_OPT_MODULE_UTILS_H_
+#endif // LIBSPIRV_TEST_OPT_MODULE_UTILS_H_
<< original << std::endl;
if (!context()) {
return std::make_tuple(std::vector<uint32_t>(),
- opt::Pass::Status::Failure);
+ opt::Pass::Status::Failure);
}
const auto status = pass->Run(context());
std::tie(optimized_bin, status) = SinglePassRunToBinary<PassT>(
assembly, skip_nop, std::forward<Args>(args)...);
std::string optimized_asm;
- EXPECT_TRUE(tools_.Disassemble(optimized_bin, &optimized_asm,
- disassemble_options_))
+ EXPECT_TRUE(
+ tools_.Disassemble(optimized_bin, &optimized_asm, disassemble_options_))
<< "Disassembling failed for shader:\n"
<< assembly << std::endl;
return std::make_tuple(optimized_asm, status);
spv_target_env target_env = SPV_ENV_UNIVERSAL_1_1;
spv_context spvContext = spvContextCreate(target_env);
spv_diagnostic diagnostic = nullptr;
- spv_const_binary_t binary = {optimized_bin.data(),
- optimized_bin.size()};
+ spv_const_binary_t binary = {optimized_bin.data(), optimized_bin.size()};
spv_result_t error = spvValidate(spvContext, &binary, &diagnostic);
EXPECT_EQ(error, 0);
- if (error != 0)
- spvDiagnosticPrint(diagnostic);
+ if (error != 0) spvDiagnosticPrint(diagnostic);
spvDiagnosticDestroy(diagnostic);
spvContextDestroy(spvContext);
}
std::string optimized_asm;
- EXPECT_TRUE(tools_.Disassemble(optimized_bin, &optimized_asm,
- disassemble_options_))
+ EXPECT_TRUE(
+ tools_.Disassemble(optimized_bin, &optimized_asm, disassemble_options_))
<< "Disassembling failed for shader:\n"
<< original << std::endl;
EXPECT_EQ(expected, optimized_asm);
const std::string& expected, bool skip_nop,
Args&&... args) {
SinglePassRunAndCheck<PassT>(original, expected, skip_nop, false,
- std::forward<Args>(args)...);
+
std::forward<Args>(args)...);
}
#ifdef SPIRV_EFFCEE
context()->module()->ToBinary(&binary, /* skip_nop = */ false);
std::string optimized;
- EXPECT_TRUE(tools_.Disassemble(binary, &optimized,
- disassemble_options_));
+ EXPECT_TRUE(tools_.Disassemble(binary, &optimized, disassemble_options_));
EXPECT_EQ(expected, optimized);
}
disassemble_options_ = disassemble_options;
}
- MessageConsumer consumer() { return consumer_;}
+ MessageConsumer consumer() { return consumer_; }
ir::IRContext* context() { return context_.get(); }
+
private:
- MessageConsumer consumer_; // Message consumer.
- std::unique_ptr<ir::IRContext> context_; // IR context
+ MessageConsumer consumer_; // Message consumer.
+ std::unique_ptr<ir::IRContext> context_; // IR context
SpirvTools tools_; // An instance for calling SPIRV-Tools functionalities.
std::unique_ptr<opt::PassManager> manager_; // The pass manager.
uint32_t assemble_options_;
const char* name() const override { return "AppendTypeVoidInstPass"; }
Status Process(ir::IRContext* irContext) override {
- auto inst = MakeUnique<ir::Instruction>(irContext, SpvOpTypeVoid, 0, result_id_,
- std::vector<ir::Operand>{});
+ auto inst = MakeUnique<ir::Instruction>(
+ irContext, SpvOpTypeVoid, 0, result_id_, std::vector<ir::Operand>{});
irContext->AddType(std::move(inst));
return Status::SuccessWithChange;
}
ir::IRContext context(std::move(module), manager.consumer());
EXPECT_THAT(GetIdBound(*context.module()), Eq(0u));
-
manager.Run(&context);
manager.AddPass<AppendOpNopPass>();
// With no ID changes, the ID bound does not change.
tc.default_values_str);
if (tc.expect_success) {
EXPECT_NE(nullptr, actual_map);
- if (actual_map) { EXPECT_THAT(*actual_map, Eq(tc.expected_map)); }
+ if (actual_map) {
+ EXPECT_THAT(*actual_map, Eq(tc.expected_map));
+ }
} else {
EXPECT_EQ(nullptr, actual_map);
}
"%3 = OpSpecConstantTrue %bool\n",
// default values
SpecIdToValueStrMap{
- {201, "0x1.fffffffffffffp+1024"}, {202, "2048"}, {203, "false"},
+ {201, "0x1.fffffffffffffp+1024"},
+ {202, "2048"},
+ {203, "false"},
},
// expected
"OpDecorate %1 SpecId 201\n"
TEST_P(StripDebugInfoTest, Kind) {
std::vector<const char*> text = {
- "OpCapability Shader", "OpMemoryModel Logical GLSL450", GetParam(),
+ "OpCapability Shader",
+ "OpMemoryModel Logical GLSL450",
+ GetParam(),
};
SinglePassRunAndCheck<opt::StripDebugInfoPass>(JoinAllInsts(text),
JoinNonDebugInsts(text),
expected_builder
.AppendTypesConstantsGlobals({
- "%uint = OpTypeInt 32 0", "%_pf_uint = OpTypePointer Function %uint",
+ "%uint = OpTypeInt 32 0",
+ "%_pf_uint = OpTypePointer Function %uint",
"%unsigned_1 = OpConstant %uint 1",
})
.AppendInMain({
"OpStore %flat_d_var %flat_d_1",
})
.AppendNames({
- "OpName %flat_1 \"flat_1_dup\"", "OpName %flat_d_1 \"flat_d_1_dup\"",
+ "OpName %flat_1 \"flat_1_dup\"",
+ "OpName %flat_d_1 \"flat_d_1_dup\"",
});
Check(expected_builder, test_builder);
const char* expected_str;
bool replace_should_succeed;
};
-}
+} // namespace
using FindAndReplaceTest =
::testing::TestWithParam<SubstringReplacementTestCase>;
)";
auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text);
opt::ValueNumberTable vtable(context.get());
- ir::Instruction* inst= context->get_def_use_mgr()->GetDef(10);
+ ir::Instruction* inst = context->get_def_use_mgr()->GetDef(10);
EXPECT_EQ(vtable.GetValueNumber(inst), vtable.GetValueNumber(inst));
}
)";
auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text);
opt::ValueNumberTable vtable(context.get());
- ir::Instruction* inst1= context->get_def_use_mgr()->GetDef(10);
+ ir::Instruction* inst1 = context->get_def_use_mgr()->GetDef(10);
ir::Instruction* inst2 = context->get_def_use_mgr()->GetDef(12);
EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2));
}
)";
auto context = BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text);
opt::ValueNumberTable vtable(context.get());
- ir::Instruction* inst1= context->get_def_use_mgr()->GetDef(11);
+ ir::Instruction* inst1 = context->get_def_use_mgr()->GetDef(11);
ir::Instruction* inst2 = context->get_def_use_mgr()->GetDef(12);
EXPECT_NE(vtable.GetValueNumber(inst1), vtable.GetValueNumber(inst2));
}
#include "spirv-tools/libspirv.h"
namespace {
-using spvutils::NumberType;
using spvutils::EncodeNumberStatus;
-using spvutils::ParseNumber;
-using spvutils::ParseAndEncodeIntegerNumber;
+using spvutils::NumberType;
using spvutils::ParseAndEncodeFloatingPointNumber;
+using spvutils::ParseAndEncodeIntegerNumber;
using spvutils::ParseAndEncodeNumber;
+using spvutils::ParseNumber;
using testing::Eq;
using testing::IsNull;
using testing::NotNull;
spv_binary binary;
spv_text text;
- spv_result_t result = spvTextToBinaryWithOptions(
- ctx.context, before.c_str(), before.size(), text_to_binary_options,
- &binary, nullptr);
+ spv_result_t result =
+ spvTextToBinaryWithOptions(ctx.context, before.c_str(), before.size(),
+ text_to_binary_options, &binary, nullptr);
if (result != SPV_SUCCESS) {
return result;
}
- result = spvBinaryToText(
- ctx.context, binary->code, binary->wordCount, binary_to_text_options,
- &text, nullptr);
+ result = spvBinaryToText(ctx.context, binary->code, binary->wordCount,
+ binary_to_text_options, &text, nullptr);
if (result != SPV_SUCCESS) {
return result;
}
TEST(ToBinaryAndBack, DontPreserveNumericIds) {
const std::string before =
-R"(OpCapability Addresses
+ R"(OpCapability Addresses
OpCapability Kernel
OpCapability GenericPointer
OpCapability Linkage
)";
const std::string expected =
-R"(OpCapability Addresses
+ R"(OpCapability Addresses
OpCapability Kernel
OpCapability GenericPointer
OpCapability Linkage
)";
std::string after;
- EXPECT_EQ(SPV_SUCCESS, ToBinaryAndBack(before, &after,
- SPV_TEXT_TO_BINARY_OPTION_NONE,
- SPV_BINARY_TO_TEXT_OPTION_NO_HEADER));
+ EXPECT_EQ(SPV_SUCCESS,
+ ToBinaryAndBack(before, &after, SPV_TEXT_TO_BINARY_OPTION_NONE,
+ SPV_BINARY_TO_TEXT_OPTION_NO_HEADER));
EXPECT_EQ(expected, after);
}
TEST(TextHandler, PreserveNumericIds) {
const std::string before =
-R"(OpCapability Addresses
+ R"(OpCapability Addresses
OpCapability Kernel
OpCapability GenericPointer
OpCapability Linkage
)";
const std::string expected =
-R"(OpCapability Addresses
+ R"(OpCapability Addresses
OpCapability Kernel
OpCapability GenericPointer
OpCapability Linkage
case SPV_MSG_FATAL:
case SPV_MSG_INTERNAL_ERROR:
case SPV_MSG_ERROR:
- std::cerr << "error: " << position.index << ": " << message
- << std::endl;
+ std::cerr << "error: " << position.index << ": " << message << std::endl;
break;
case SPV_MSG_WARNING:
std::cout << "warning: " << position.index << ": " << message
// Calls libspirv::AggregateStats for binary compiled from |code|.
void CompileAndAggregateStats(const std::string& code, SpirvStats* stats,
- spv_target_env env = SPV_ENV_UNIVERSAL_1_1) {
+ spv_target_env env = SPV_ENV_UNIVERSAL_1_1) {
ScopedContext ctx(env);
SetContextMessageConsumer(ctx.context, DiagnosticsMessageHandler);
spv_binary binary;
- ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(
- ctx.context, code.c_str(), code.size(), &binary, nullptr));
+ ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(ctx.context, code.c_str(), code.size(),
+ &binary, nullptr));
ASSERT_EQ(SPV_SUCCESS, AggregateStats(*ctx.context, binary->code,
binary->wordCount, nullptr, stats));
OpMemoryModel Logical GLSL450
)";
- const uint32_t kGeneratorKhronosAssembler =
- SPV_GENERATOR_KHRONOS_ASSEMBLER << 16;
+ const uint32_t kGeneratorKhronosAssembler = SPV_GENERATOR_KHRONOS_ASSEMBLER
+ << 16;
SpirvStats stats;
EXPECT_EQ(1u, stats.opcode_markov_hist[0].at(SpvOpExtension).size());
EXPECT_EQ(
1u, stats.opcode_markov_hist[0].at(SpvOpCapability).at(SpvOpCapability));
- EXPECT_EQ(
- 1u, stats.opcode_markov_hist[0].at(SpvOpCapability).at(SpvOpExtension));
+ EXPECT_EQ(1u,
+ stats.opcode_markov_hist[0].at(SpvOpCapability).at(SpvOpExtension));
EXPECT_EQ(
1u, stats.opcode_markov_hist[0].at(SpvOpExtension).at(SpvOpMemoryModel));
EXPECT_EQ(1u, stats.opcode_markov_hist[1].size());
EXPECT_EQ(2u, stats.opcode_markov_hist[1].at(SpvOpCapability).size());
- EXPECT_EQ(
- 1u, stats.opcode_markov_hist[1].at(SpvOpCapability).at(SpvOpExtension));
+ EXPECT_EQ(1u,
+ stats.opcode_markov_hist[1].at(SpvOpCapability).at(SpvOpExtension));
EXPECT_EQ(
1u, stats.opcode_markov_hist[1].at(SpvOpCapability).at(SpvOpMemoryModel));
EXPECT_EQ(2u, stats.opcode_markov_hist[0].at(SpvOpTypeInt).size());
EXPECT_EQ(
4u, stats.opcode_markov_hist[0].at(SpvOpCapability).at(SpvOpCapability));
- EXPECT_EQ(
- 1u, stats.opcode_markov_hist[0].at(SpvOpCapability).at(SpvOpExtension));
+ EXPECT_EQ(1u,
+ stats.opcode_markov_hist[0].at(SpvOpCapability).at(SpvOpExtension));
EXPECT_EQ(
1u, stats.opcode_markov_hist[0].at(SpvOpCapability).at(SpvOpMemoryModel));
EXPECT_EQ(
1u, stats.opcode_markov_hist[0].at(SpvOpExtension).at(SpvOpMemoryModel));
- EXPECT_EQ(
- 1u, stats.opcode_markov_hist[0].at(SpvOpMemoryModel).at(SpvOpTypeInt));
- EXPECT_EQ(
- 1u, stats.opcode_markov_hist[0].at(SpvOpTypeInt).at(SpvOpTypeInt));
- EXPECT_EQ(
- 1u, stats.opcode_markov_hist[0].at(SpvOpTypeInt).at(SpvOpTypeFloat));
+ EXPECT_EQ(1u,
+ stats.opcode_markov_hist[0].at(SpvOpMemoryModel).at(SpvOpTypeInt));
+ EXPECT_EQ(1u, stats.opcode_markov_hist[0].at(SpvOpTypeInt).at(SpvOpTypeInt));
+ EXPECT_EQ(1u,
+ stats.opcode_markov_hist[0].at(SpvOpTypeInt).at(SpvOpTypeFloat));
EXPECT_EQ(3u, stats.opcode_markov_hist[1].size());
EXPECT_EQ(4u, stats.opcode_markov_hist[1].at(SpvOpCapability).size());
EXPECT_EQ(1u, stats.opcode_markov_hist[1].at(SpvOpTypeInt).size());
EXPECT_EQ(
2u, stats.opcode_markov_hist[1].at(SpvOpCapability).at(SpvOpCapability));
- EXPECT_EQ(
- 1u, stats.opcode_markov_hist[1].at(SpvOpCapability).at(SpvOpExtension));
+ EXPECT_EQ(1u,
+ stats.opcode_markov_hist[1].at(SpvOpCapability).at(SpvOpExtension));
EXPECT_EQ(
2u, stats.opcode_markov_hist[1].at(SpvOpCapability).at(SpvOpMemoryModel));
- EXPECT_EQ(
- 1u, stats.opcode_markov_hist[1].at(SpvOpCapability).at(SpvOpTypeInt));
- EXPECT_EQ(
- 1u, stats.opcode_markov_hist[1].at(SpvOpMemoryModel).at(SpvOpTypeInt));
- EXPECT_EQ(
- 1u, stats.opcode_markov_hist[1].at(SpvOpTypeInt).at(SpvOpTypeFloat));
+ EXPECT_EQ(1u,
+ stats.opcode_markov_hist[1].at(SpvOpCapability).at(SpvOpTypeInt));
+ EXPECT_EQ(1u,
+ stats.opcode_markov_hist[1].at(SpvOpMemoryModel).at(SpvOpTypeInt));
+ EXPECT_EQ(1u,
+ stats.opcode_markov_hist[1].at(SpvOpTypeInt).at(SpvOpTypeFloat));
}
TEST(AggregateStats, ConstantLiteralsHistogram) {
{
const std::unordered_map<uint32_t, uint32_t> expected = {
- {kF32, 3}, {kU32, 2}, {kF32_1, 2}, {kU32_32, 1}
- };
+ {kF32, 3}, {kU32, 2}, {kF32_1, 2}, {kU32_32, 1}};
EXPECT_EQ(expected, stats.id_descriptor_hist);
}
CompileAndAggregateStats(code2, &stats);
{
const std::unordered_map<uint32_t, uint32_t> expected = {
- {kF32, 6}, {kU32, 4}, {kF32_1, 3}, {kF32_3, 1}, {kU32_32, 2}
- };
+ {kF32, 6}, {kU32, 4}, {kF32_1, 3}, {kF32_3, 1}, {kU32_32, 2}};
EXPECT_EQ(expected, stats.id_descriptor_hist);
}
}
// Tests for unique type declaration rules validator.
-#include <string>
#include <sstream>
+#include <string>
#include "spirv/1.1/spirv.h"
#include "test_fixture.h"
using ::testing::AnyOf;
using ::testing::Eq;
-using ::testing::ValuesIn;
using ::testing::StartsWith;
+using ::testing::ValuesIn;
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
+ spvContextDestroy(context); // Avoid leaking
}
TEST_P(TargetEnvTest, ValidDescription) {
#include "unit_spirv.h"
-#include "test_fixture.h"
#include "gmock/gmock.h"
#include "message.h"
+#include "test_fixture.h"
#include <string>
#include <sstream>
#include <tuple>
-#include "test_fixture.h"
#include "gmock/gmock.h"
+#include "test_fixture.h"
namespace {
-using ::testing::Combine;
-using ::testing::Eq;
-using ::testing::Values;
-using ::testing::ValuesIn;
using spvtest::EnumCase;
using spvtest::MakeInstruction;
using spvtest::MakeVector;
using spvtest::TextToBinaryTest;
using std::get;
using std::tuple;
+using ::testing::Combine;
+using ::testing::Eq;
+using ::testing::Values;
+using ::testing::ValuesIn;
// Test OpDecorate
#include "unit_spirv.h"
-#include "test_fixture.h"
#include "gmock/gmock.h"
+#include "test_fixture.h"
namespace {
-using ::testing::ElementsAre;
-using ::testing::Eq;
-using ::testing::_;
using spvtest::MakeInstruction;
using spvtest::TextToBinaryTest;
+using ::testing::_;
+using ::testing::ElementsAre;
+using ::testing::Eq;
// Test OpMemoryBarrier
#include <cstdint>
#include <limits>
-#include "test_fixture.h"
#include "gmock/gmock.h"
+#include "test_fixture.h"
namespace {
+using spvtest::Concatenate;
using spvtest::EnumCase;
using spvtest::MakeInstruction;
-using spvtest::Concatenate;
using ::testing::Eq;
// Test Sampler Addressing Mode enum values
}),);
// clang-format on
-// A test case for checking OpConstant with invalid literals with a leading minus.
+// A test case for checking OpConstant with invalid literals with a leading
+// minus.
struct InvalidLeadingMinusCase {
std::string type;
std::string literal;
};
-using OpConstantInvalidLeadingMinusTest =
- spvtest::TextToBinaryTestBase<::testing::TestWithParam<InvalidLeadingMinusCase>>;
+using OpConstantInvalidLeadingMinusTest = spvtest::TextToBinaryTestBase<
+ ::testing::TestWithParam<InvalidLeadingMinusCase>>;
TEST_P(OpConstantInvalidLeadingMinusTest, InvalidCase) {
const std::string input = "%1 = " + GetParam().type +
"%1 = OpTypeFloat 64\n%2 = OpConstant %1 0\n",
"%1 = OpTypeFloat 64\n%2 = OpConstant %1 1.79769e+308\n",
"%1 = OpTypeFloat 64\n%2 = OpConstant %1 -1.79769e+308\n",
- }),);
+ }), );
INSTANTIATE_TEST_CASE_P(
OpConstantHalfRoundTrip, RoundTripTest,
"%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.8p+1\n",
"%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.ffcp+1\n",
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1p-16\n", // some denorms
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1p-16\n", // some denorms
"%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1p-24\n",
"%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1p-24\n",
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1p+16\n", // +inf
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1p+16\n", // -inf
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.01p+16\n", // -inf
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.01p+16\n", // nan
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.11p+16\n", // nan
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.ffp+16\n", // nan
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.ffcp+16\n", // nan
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.004p+16\n", // nan
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.01p+16\n", // -nan
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.11p+16\n", // -nan
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.ffp+16\n", // -nan
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.ffcp+16\n", // -nan
- "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.004p+16\n", // -nan
- }),);
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1p+16\n", // +inf
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1p+16\n", // -inf
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.01p+16\n", // -inf
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.01p+16\n", // nan
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.11p+16\n", // nan
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.ffp+16\n", // nan
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.ffcp+16\n", // nan
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 0x1.004p+16\n", // nan
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.01p+16\n", // -nan
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.11p+16\n", // -nan
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.ffp+16\n", // -nan
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.ffcp+16\n", // -nan
+ "%1 = OpTypeFloat 16\n%2 = OpConstant %1 -0x1.004p+16\n", // -nan
+ }), );
// clang-format off
// (Clang-format really wants to break up these strings across lines.
"%1 = OpTypeFloat 64\n%2 = OpSpecConstant %1 0\n",
"%1 = OpTypeFloat 64\n%2 = OpSpecConstant %1 1.79769e+308\n",
"%1 = OpTypeFloat 64\n%2 = OpSpecConstant %1 -1.79769e+308\n",
- }),);
+ }), );
// Test OpSpecConstantOp
// composite, and then literal indices.
{CASE(CompositeInsert), {0}},
{CASE(CompositeInsert), {4, 3, 99, 1}},
- }),);
+ }), );
using OpSpecConstantOpTestWithOneIdThenLiteralNumbers =
spvtest::TextToBinaryTestBase<::testing::TestWithParam<EnumCase<SpvOp>>>;
// indices. Let's only test a few.
{CASE(CompositeExtract), {0}},
{CASE(CompositeExtract), {0, 99, 42, 16, 17, 12, 19}},
- }),);
+ }), );
// TODO(dneto): OpConstantTrue
// TODO(dneto): OpConstantFalse
#include "unit_spirv.h"
-#include "test_fixture.h"
#include "gmock/gmock.h"
+#include "test_fixture.h"
namespace {
-using ::testing::Combine;
-using ::testing::Eq;
-using ::testing::TestWithParam;
-using ::testing::Values;
-using ::testing::ValuesIn;
using spvtest::Concatenate;
using spvtest::EnumCase;
using spvtest::MakeInstruction;
using std::get;
using std::ostringstream;
using std::tuple;
+using ::testing::Combine;
+using ::testing::Eq;
+using ::testing::TestWithParam;
+using ::testing::Values;
+using ::testing::ValuesIn;
// Test OpSelectionMerge
#include <string>
-#include "test_fixture.h"
#include "gmock/gmock.h"
+#include "test_fixture.h"
namespace {
{13, 14, 15, 16, 17, 18, 19, 20, 21}},
{"%l0 %l1 %l2 %l3 %l4 %l5 %l6 %l7 %l8 %l9",
{13, 14, 15, 16, 17, 18, 19, 20, 21, 22}},
- }),);
+ }), );
// Test some bad parses of OpEnqueueKernel. For other cases, we're relying
// on the uniformity of the parsing algorithm. The following two tests, ensure
#include "unit_spirv.h"
-#include "test_fixture.h"
#include "gmock/gmock.h"
#include "spirv/1.0/GLSL.std.450.h"
#include "spirv/1.0/OpenCL.std.h"
+#include "test_fixture.h"
namespace {
EXPECT_THAT(EncodeAndDecodeSuccessfully(input), Eq(input));
}
-
// A test case for assembling into words in an instruction.
struct AssemblyCase {
std::string input;
SPV_KHR_subgroup_vote, ExtensionRoundTripTest,
// We'll get coverage over operand tables by trying the universal
// environments, and at least one specific environment.
- Combine(
- Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
- SPV_ENV_VULKAN_1_0),
- ValuesIn(std::vector<AssemblyCase>{
- {"OpCapability SubgroupVoteKHR\n",
- MakeInstruction(SpvOpCapability, {SpvCapabilitySubgroupVoteKHR})},
- {"%2 = OpSubgroupAnyKHR %1 %3\n",
- MakeInstruction(SpvOpSubgroupAnyKHR, {1, 2, 3})},
- {"%2 = OpSubgroupAllKHR %1 %3\n",
- MakeInstruction(SpvOpSubgroupAllKHR, {1, 2, 3})},
- {"%2 = OpSubgroupAllEqualKHR %1 %3\n",
- MakeInstruction(SpvOpSubgroupAllEqualKHR, {1, 2, 3})},
- })), );
+ Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
+ SPV_ENV_VULKAN_1_0),
+ ValuesIn(std::vector<AssemblyCase>{
+ {"OpCapability SubgroupVoteKHR\n",
+ MakeInstruction(SpvOpCapability,
+ {SpvCapabilitySubgroupVoteKHR})},
+ {"%2 = OpSubgroupAnyKHR %1 %3\n",
+ MakeInstruction(SpvOpSubgroupAnyKHR, {1, 2, 3})},
+ {"%2 = OpSubgroupAllKHR %1 %3\n",
+ MakeInstruction(SpvOpSubgroupAllKHR, {1, 2, 3})},
+ {"%2 = OpSubgroupAllEqualKHR %1 %3\n",
+ MakeInstruction(SpvOpSubgroupAllEqualKHR, {1, 2, 3})},
+ })), );
// SPV_KHR_16bit_storage
SpvBuiltInViewIndex})},
})), );
-
// SPV_AMD_shader_explicit_vertex_parameter
-#define PREAMBLE "%1 = OpExtInstImport \"SPV_AMD_shader_explicit_vertex_parameter\"\n"
+#define PREAMBLE \
+ "%1 = OpExtInstImport \"SPV_AMD_shader_explicit_vertex_parameter\"\n"
INSTANTIATE_TEST_CASE_P(
SPV_AMD_shader_explicit_vertex_parameter, ExtensionRoundTripTest,
// We'll get coverage over operand tables by trying the universal
// environments, and at least one specific environment.
- Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
- SPV_ENV_VULKAN_1_0),
- ValuesIn(std::vector<AssemblyCase>{
- {PREAMBLE "%3 = OpExtInst %2 %1 InterpolateAtVertexAMD %4 %5\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_explicit_vertex_parameter")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 1, 4, 5})})},
- })), );
+ Combine(
+ Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
+ SPV_ENV_VULKAN_1_0),
+ ValuesIn(std::vector<AssemblyCase>{
+ {PREAMBLE "%3 = OpExtInst %2 %1 InterpolateAtVertexAMD %4 %5\n",
+ Concatenate(
+ {MakeInstruction(
+ SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_explicit_vertex_parameter")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 1, 4, 5})})},
+ })), );
#undef PREAMBLE
-
// SPV_AMD_shader_trinary_minmax
#define PREAMBLE "%1 = OpExtInstImport \"SPV_AMD_shader_trinary_minmax\"\n"
SPV_AMD_shader_trinary_minmax, ExtensionRoundTripTest,
// We'll get coverage over operand tables by trying the universal
// environments, and at least one specific environment.
- Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
- SPV_ENV_VULKAN_1_0),
- ValuesIn(std::vector<AssemblyCase>{
- {PREAMBLE "%3 = OpExtInst %2 %1 FMin3AMD %4 %5 %6\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_trinary_minmax")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 1, 4, 5, 6})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 UMin3AMD %4 %5 %6\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_trinary_minmax")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 2, 4, 5, 6})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 SMin3AMD %4 %5 %6\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_trinary_minmax")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 3, 4, 5, 6})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 FMax3AMD %4 %5 %6\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_trinary_minmax")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 4, 4, 5, 6})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 UMax3AMD %4 %5 %6\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_trinary_minmax")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 5, 4, 5, 6})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 SMax3AMD %4 %5 %6\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_trinary_minmax")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 6, 4, 5, 6})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 FMid3AMD %4 %5 %6\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_trinary_minmax")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 7, 4, 5, 6})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 UMid3AMD %4 %5 %6\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_trinary_minmax")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 8, 4, 5, 6})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 SMid3AMD %4 %5 %6\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_trinary_minmax")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 9, 4, 5, 6})})},
- })), );
+ Combine(
+ Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
+ SPV_ENV_VULKAN_1_0),
+ ValuesIn(std::vector<AssemblyCase>{
+ {PREAMBLE "%3 = OpExtInst %2 %1 FMin3AMD %4 %5 %6\n",
+ Concatenate(
+ {MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_trinary_minmax")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 1, 4, 5, 6})})},
+ {PREAMBLE "%3 = OpExtInst %2 %1 UMin3AMD %4 %5 %6\n",
+ Concatenate(
+ {MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_trinary_minmax")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 2, 4, 5, 6})})},
+ {PREAMBLE "%3 = OpExtInst %2 %1 SMin3AMD %4 %5 %6\n",
+ Concatenate(
+ {MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_trinary_minmax")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 3, 4, 5, 6})})},
+ {PREAMBLE "%3 = OpExtInst %2 %1 FMax3AMD %4 %5 %6\n",
+ Concatenate(
+ {MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_trinary_minmax")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 4, 4, 5, 6})})},
+ {PREAMBLE "%3 = OpExtInst %2 %1 UMax3AMD %4 %5 %6\n",
+ Concatenate(
+ {MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_trinary_minmax")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 5, 4, 5, 6})})},
+ {PREAMBLE "%3 = OpExtInst %2 %1 SMax3AMD %4 %5 %6\n",
+ Concatenate(
+ {MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_trinary_minmax")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 6, 4, 5, 6})})},
+ {PREAMBLE "%3 = OpExtInst %2 %1 FMid3AMD %4 %5 %6\n",
+ Concatenate(
+ {MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_trinary_minmax")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 7, 4, 5, 6})})},
+ {PREAMBLE "%3 = OpExtInst %2 %1 UMid3AMD %4 %5 %6\n",
+ Concatenate(
+ {MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_trinary_minmax")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 8, 4, 5, 6})})},
+ {PREAMBLE "%3 = OpExtInst %2 %1 SMid3AMD %4 %5 %6\n",
+ Concatenate(
+ {MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_trinary_minmax")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 9, 4, 5, 6})})},
+ })), );
#undef PREAMBLE
-
// SPV_AMD_gcn_shader
#define PREAMBLE "%1 = OpExtInstImport \"SPV_AMD_gcn_shader\"\n"
})), );
#undef PREAMBLE
-
// SPV_AMD_shader_ballot
#define PREAMBLE "%1 = OpExtInstImport \"SPV_AMD_shader_ballot\"\n"
SPV_AMD_shader_ballot, ExtensionRoundTripTest,
// We'll get coverage over operand tables by trying the universal
// environments, and at least one specific environment.
- Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
- SPV_ENV_VULKAN_1_0),
- ValuesIn(std::vector<AssemblyCase>{
- {PREAMBLE "%3 = OpExtInst %2 %1 SwizzleInvocationsAMD %4 %5\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_ballot")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 1, 4, 5})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 SwizzleInvocationsMaskedAMD %4 %5\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_ballot")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 2, 4, 5})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 WriteInvocationAMD %4 %5 %6\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_ballot")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 3, 4, 5, 6})})},
- {PREAMBLE "%3 = OpExtInst %2 %1 MbcntAMD %4\n",
- Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
- MakeVector("SPV_AMD_shader_ballot")),
- MakeInstruction(SpvOpExtInst, {2, 3, 1, 4, 4})})},
- })), );
+ Combine(
+ Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1,
+ SPV_ENV_VULKAN_1_0),
+ ValuesIn(std::vector<AssemblyCase>{
+ {PREAMBLE "%3 = OpExtInst %2 %1 SwizzleInvocationsAMD %4 %5\n",
+ Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_ballot")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 1, 4, 5})})},
+ {PREAMBLE
+ "%3 = OpExtInst %2 %1 SwizzleInvocationsMaskedAMD %4 %5\n",
+ Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_ballot")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 2, 4, 5})})},
+ {PREAMBLE "%3 = OpExtInst %2 %1 WriteInvocationAMD %4 %5 %6\n",
+ Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_ballot")),
+ MakeInstruction(SpvOpExtInst,
+ {2, 3, 1, 3, 4, 5, 6})})},
+ {PREAMBLE "%3 = OpExtInst %2 %1 MbcntAMD %4\n",
+ Concatenate({MakeInstruction(SpvOpExtInstImport, {1},
+ MakeVector("SPV_AMD_shader_ballot")),
+ MakeInstruction(SpvOpExtInst, {2, 3, 1, 4, 4})})},
+ })), );
#undef PREAMBLE
-
// SPV_KHR_variable_pointers
INSTANTIATE_TEST_CASE_P(
MakeInstruction(SpvOpCapability,
{SpvCapabilityVariablePointers})},
{"OpCapability VariablePointersStorageBuffer\n",
- MakeInstruction(
- SpvOpCapability,
- {SpvCapabilityVariablePointersStorageBuffer})},
+ MakeInstruction(SpvOpCapability,
+ {SpvCapabilityVariablePointersStorageBuffer})},
})), );
} // anonymous namespace
{" ConstOffsets %5", {MASK(ConstOffsets), 5}},
{" Sample %5", {MASK(Sample), 5}},
{" MinLod %5", {MASK(MinLod), 5}},
- }),);
+ }), );
#undef MASK
#define MASK(NAME) static_cast<uint32_t>(SpvImageOperands##NAME##Mask)
INSTANTIATE_TEST_CASE_P(
{" Lod|Grad %5 %6 %7", {MASK(Lod) | MASK(Grad), 5, 6, 7}},
{" Grad|ConstOffset %5 %6 %7",
{MASK(Grad) | MASK(ConstOffset), 5, 6, 7}},
- {" ConstOffset|Offset %5 %6",
- {MASK(ConstOffset) | MASK(Offset), 5, 6}},
+ {" ConstOffset|Offset %5 %6", {MASK(ConstOffset) | MASK(Offset), 5, 6}},
{" Offset|ConstOffsets %5 %6",
{MASK(Offset) | MASK(ConstOffsets), 5, 6}},
{" ConstOffsets|Sample %5 %6",
" %5 %6 %7 %8 %9 %10 %11 %12",
{MASK(Bias) | MASK(Lod) | MASK(Grad) | MASK(ConstOffset) |
MASK(Offset) | MASK(ConstOffsets) | MASK(Sample),
- 5, 6, 7, 8, 9, 10, 11, 12}}}),);
+ 5, 6, 7, 8, 9, 10, 11, 12}}}), );
#undef MASK
TEST_F(ImageOperandsTest, WrongOperand) {
TEST_F(OpImageTest, TooManyOperands) {
// We should improve this message, to say what instruction we're trying to
// parse.
- EXPECT_THAT(CompileFailure("%2 = OpImage %1 %3 %4"), // an Id
+ EXPECT_THAT(CompileFailure("%2 = OpImage %1 %3 %4"), // an Id
Eq("Expected '=', found end of stream."));
EXPECT_THAT(CompileFailure("%2 = OpImage %1 %3 99"), // a number
{" ConstOffsets %5", {MASK(ConstOffsets), 5}},
{" Sample %5", {MASK(Sample), 5}},
{" MinLod %5", {MASK(MinLod), 5}},
- }),);
+ }), );
#undef MASK
#define MASK(NAME) static_cast<uint32_t>(SpvImageOperands##NAME##Mask)
INSTANTIATE_TEST_CASE_P(
5, 6, 7, 8, 9, 10, 11, 12}},
// Don't try the masks reversed, since this is a round trip test,
// and the disassembler will sort them.
- }),);
+ }), );
#undef MASK
TEST_F(OpImageSparseReadTest, InvalidTypeOperand) {
{SpvMemoryAccessVolatileMask, "Volatile", {}},
{SpvMemoryAccessAlignedMask, "Aligned", {16}},
{SpvMemoryAccessNontemporalMask, "Nontemporal", {}},
- }),);
+ }), );
TEST_F(TextToBinaryTest, CombinedMemoryAccessMask) {
const std::string input = "OpStore %ptr %value Volatile|Aligned 16";
#include "unit_spirv.h"
-#include "test_fixture.h"
#include "gmock/gmock.h"
+#include "test_fixture.h"
namespace {
#include "unit_spirv.h"
-#include "test_fixture.h"
#include "gmock/gmock.h"
+#include "test_fixture.h"
namespace {
-using ::testing::Combine;
-using ::testing::Eq;
-using ::testing::TestWithParam;
-using ::testing::Values;
-using ::testing::ValuesIn;
using spvtest::EnumCase;
using spvtest::MakeInstruction;
using spvtest::MakeVector;
using std::get;
using std::tuple;
+using ::testing::Combine;
+using ::testing::Eq;
+using ::testing::TestWithParam;
+using ::testing::Values;
+using ::testing::ValuesIn;
// Test OpMemoryModel
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "test_fixture.h"
#include "gmock/gmock.h"
+#include "test_fixture.h"
namespace {
#include "unit_spirv.h"
-#include "test_fixture.h"
#include "gmock/gmock.h"
+#include "test_fixture.h"
namespace {
using ::spvtest::MakeInstruction;
-using ::testing::Eq;
using std::vector;
+using ::testing::Eq;
using OpGetKernelLocalSizeForSubgroupCountTest = spvtest::TextToBinaryTest;
#include "unit_spirv.h"
-#include "test_fixture.h"
#include "gmock/gmock.h"
+#include "test_fixture.h"
namespace {
#include "gmock/gmock.h"
-#include "test_fixture.h"
-#include "unit_spirv.h"
#include "source/spirv_constant.h"
#include "source/util/bitutils.h"
#include "source/util/hex_float.h"
+#include "test_fixture.h"
+#include "unit_spirv.h"
namespace {
#include "source/assembly_grammar.h"
#include "source/binary.h"
-#include "source/enum_set.h"
#include "source/diagnostic.h"
+#include "source/enum_set.h"
#include "source/opcode.h"
#include "source/spirv_endian.h"
#include "source/text.h"
os << val;
return os.str();
}
-}
+} // namespace std
#endif
// Determine endianness & predicate tests on it
namespace {
-using ::testing::ElementsAre;
using spvtools::utils::IntrusiveList;
using spvtools::utils::IntrusiveNodeBase;
+using ::testing::ElementsAre;
using IListTest = ::testing::Test;
class TestNode : public IntrusiveNodeBase<TestNode> {
std::string GenerateCode(const std::string& main_body) {
const std::string prefix =
-R"(
+ R"(
OpCapability Shader
OpCapability Int64
OpCapability Float64
%main_entry = OpLabel)";
const std::string suffix =
-R"(
+ R"(
OpReturn
OpFunctionEnd)";
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected floating scalar or vector type as Result Type: FNegate"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected floating scalar or vector type as Result Type: FNegate"));
}
TEST_F(ValidateArithmetics, FNegateTypeIdVec2U32) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected floating scalar or vector type as Result Type: FNegate"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected floating scalar or vector type as Result Type: FNegate"));
}
TEST_F(ValidateArithmetics, FNegateWrongOperand) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to be of Result Type: "
- "FNegate operand index 2"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to be of Result Type: "
+ "FNegate operand index 2"));
}
TEST_F(ValidateArithmetics, FMulTypeIdU32) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected floating scalar or vector type as Result Type: FMul"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected floating scalar or vector type as Result Type: FMul"));
}
TEST_F(ValidateArithmetics, FMulTypeIdVec2U32) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected floating scalar or vector type as Result Type: FMul"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected floating scalar or vector type as Result Type: FMul"));
}
TEST_F(ValidateArithmetics, FMulWrongOperand1) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to be of Result Type: "
- "FMul operand index 2"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to be of Result Type: "
+ "FMul operand index 2"));
}
TEST_F(ValidateArithmetics, FMulWrongOperand2) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to be of Result Type: "
- "FMul operand index 3"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to be of Result Type: "
+ "FMul operand index 3"));
}
TEST_F(ValidateArithmetics, FMulWrongVectorOperand1) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to be of Result Type: "
- "FMul operand index 2"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to be of Result Type: "
+ "FMul operand index 2"));
}
TEST_F(ValidateArithmetics, FMulWrongVectorOperand2) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to be of Result Type: "
- "FMul operand index 3"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to be of Result Type: "
+ "FMul operand index 3"));
}
TEST_F(ValidateArithmetics, IMulFloatTypeId) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as Result Type: IMul"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector type as Result Type: IMul"));
}
TEST_F(ValidateArithmetics, IMulFloatOperand1) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as operand: "
- "IMul operand index 2"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector type as operand: "
+ "IMul operand index 2"));
}
TEST_F(ValidateArithmetics, IMulFloatOperand2) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as operand: "
- "IMul operand index 3"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector type as operand: "
+ "IMul operand index 3"));
}
TEST_F(ValidateArithmetics, IMulWrongBitWidthOperand1) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to have the same bit width "
- "as Result Type: IMul operand index 2"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to have the same bit width "
+ "as Result Type: IMul operand index 2"));
}
TEST_F(ValidateArithmetics, IMulWrongBitWidthOperand2) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to have the same bit width "
- "as Result Type: IMul operand index 3"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to have the same bit width "
+ "as Result Type: IMul operand index 3"));
}
TEST_F(ValidateArithmetics, IMulWrongBitWidthVector) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to have the same bit width "
- "as Result Type: IMul operand index 2"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to have the same bit width "
+ "as Result Type: IMul operand index 2"));
}
TEST_F(ValidateArithmetics, IMulVectorScalarOperand1) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to have the same dimension "
- "as Result Type: IMul operand index 2"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to have the same dimension "
+ "as Result Type: IMul operand index 2"));
}
TEST_F(ValidateArithmetics, IMulVectorScalarOperand2) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to have the same dimension "
- "as Result Type: IMul operand index 3"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to have the same dimension "
+ "as Result Type: IMul operand index 3"));
}
TEST_F(ValidateArithmetics, IMulScalarVectorOperand1) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to have the same dimension "
- "as Result Type: IMul operand index 2"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to have the same dimension "
+ "as Result Type: IMul operand index 2"));
}
TEST_F(ValidateArithmetics, IMulScalarVectorOperand2) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to have the same dimension "
- "as Result Type: IMul operand index 3"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to have the same dimension "
+ "as Result Type: IMul operand index 3"));
}
TEST_F(ValidateArithmetics, SNegateFloat) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as operand: "
- "SNegate operand index 2"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector type as operand: "
+ "SNegate operand index 2"));
}
TEST_F(ValidateArithmetics, UDivFloatType) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected unsigned int scalar or vector type as Result Type: UDiv"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected unsigned int scalar or vector type as Result Type: UDiv"));
}
TEST_F(ValidateArithmetics, UDivSignedIntType) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected unsigned int scalar or vector type as Result Type: UDiv"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected unsigned int scalar or vector type as Result Type: UDiv"));
}
TEST_F(ValidateArithmetics, UDivWrongOperand1) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to be of Result Type: "
- "UDiv operand index 2"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to be of Result Type: "
+ "UDiv operand index 2"));
}
TEST_F(ValidateArithmetics, UDivWrongOperand2) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected arithmetic operands to be of Result Type: "
- "UDiv operand index 3"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected arithmetic operands to be of Result Type: "
+ "UDiv operand index 3"));
}
TEST_F(ValidateArithmetics, DotSuccess) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float scalar type as Result Type: Dot"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected float scalar type as Result Type: Dot"));
}
TEST_F(ValidateArithmetics, DotNotVectorTypeOperand1) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float vector as operand: Dot operand index 2"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected float vector as operand: Dot operand index 2"));
}
TEST_F(ValidateArithmetics, DotNotVectorTypeOperand2) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float vector as operand: Dot operand index 3"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected float vector as operand: Dot operand index 3"));
}
TEST_F(ValidateArithmetics, DotWrongComponentOperand1) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected component type to be equal to Result Type: "
- "Dot operand index 2"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected component type to be equal to Result Type: "
+ "Dot operand index 2"));
}
TEST_F(ValidateArithmetics, DotWrongComponentOperand2) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected component type to be equal to Result Type: "
- "Dot operand index 3"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected component type to be equal to Result Type: "
+ "Dot operand index 3"));
}
TEST_F(ValidateArithmetics, DotDifferentVectorSize) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to have the same number of componenets: Dot"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected operands to have the same number of componenets: Dot"));
}
TEST_F(ValidateArithmetics, VectorTimesScalarSuccess) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float vector type as Result Type: "
- "VectorTimesScalar"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected float vector type as Result Type: "
+ "VectorTimesScalar"));
}
TEST_F(ValidateArithmetics, VectorTimesScalarWrongVector) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected vector operand type to be equal to Result Type: "
- "VectorTimesScalar"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected vector operand type to be equal to Result Type: "
+ "VectorTimesScalar"));
}
TEST_F(ValidateArithmetics, VectorTimesScalarWrongScalar) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected scalar operand type to be equal to the component "
- "type of the vector operand: VectorTimesScalar"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected scalar operand type to be equal to the component "
+ "type of the vector operand: VectorTimesScalar"));
}
TEST_F(ValidateArithmetics, MatrixTimesScalarSuccess) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float matrix type as Result Type: "
- "MatrixTimesScalar"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected float matrix type as Result Type: "
+ "MatrixTimesScalar"));
}
TEST_F(ValidateArithmetics, MatrixTimesScalarWrongMatrix) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected matrix operand type to be equal to Result Type: "
- "MatrixTimesScalar"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected matrix operand type to be equal to Result Type: "
+ "MatrixTimesScalar"));
}
TEST_F(ValidateArithmetics, MatrixTimesScalarWrongScalar) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected scalar operand type to be equal to the component "
- "type of the matrix operand: MatrixTimesScalar"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected scalar operand type to be equal to the component "
+ "type of the matrix operand: MatrixTimesScalar"));
}
TEST_F(ValidateArithmetics, VectorTimesMatrix2x22Success) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float vector type as Result Type: "
- "VectorTimesMatrix"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected float vector type as Result Type: "
+ "VectorTimesMatrix"));
}
TEST_F(ValidateArithmetics, VectorTimesMatrixNotFloatVector) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float vector type as left operand: "
- "VectorTimesMatrix"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected float vector type as left operand: "
+ "VectorTimesMatrix"));
}
TEST_F(ValidateArithmetics, VectorTimesMatrixWrongVectorComponent) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected component types of Result Type and vector to be equal: "
- "VectorTimesMatrix"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected component types of Result Type and vector to be equal: "
+ "VectorTimesMatrix"));
}
TEST_F(ValidateArithmetics, VectorTimesMatrixWrongMatrix) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float matrix type as right operand: "
- "VectorTimesMatrix"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected float matrix type as right operand: "
+ "VectorTimesMatrix"));
}
TEST_F(ValidateArithmetics, VectorTimesMatrixWrongMatrixComponent) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected component types of Result Type and matrix to be equal: "
- "VectorTimesMatrix"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected component types of Result Type and matrix to be equal: "
+ "VectorTimesMatrix"));
}
TEST_F(ValidateArithmetics, VectorTimesMatrix2eq2x23Fail) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected number of columns of the matrix to be equal to Result Type "
- "vector size: VectorTimesMatrix"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected number of columns of the matrix to be equal to Result Type "
+ "vector size: VectorTimesMatrix"));
}
TEST_F(ValidateArithmetics, VectorTimesMatrix2x32Fail) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected number of rows of the matrix to be equal to the vector "
- "operand size: VectorTimesMatrix"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected number of rows of the matrix to be equal to the vector "
+ "operand size: VectorTimesMatrix"));
}
TEST_F(ValidateArithmetics, MatrixTimesVector22x2Success) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float vector type as Result Type: "
- "MatrixTimesVector"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected float vector type as Result Type: "
+ "MatrixTimesVector"));
}
TEST_F(ValidateArithmetics, MatrixTimesVectorWrongMatrix) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float matrix type as left operand: "
- "MatrixTimesVector"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected float matrix type as left operand: "
+ "MatrixTimesVector"));
}
TEST_F(ValidateArithmetics, MatrixTimesVectorWrongMatrixCol) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected column type of the matrix to be equal to Result Type: "
- "MatrixTimesVector"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected column type of the matrix to be equal to Result Type: "
+ "MatrixTimesVector"));
}
TEST_F(ValidateArithmetics, MatrixTimesVectorWrongVector) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float vector type as right operand: "
- "MatrixTimesVector"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected float vector type as right operand: "
+ "MatrixTimesVector"));
}
TEST_F(ValidateArithmetics, MatrixTimesVectorDifferentComponents) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected component types of the operands to be equal: "
- "MatrixTimesVector"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected component types of the operands to be equal: "
+ "MatrixTimesVector"));
}
TEST_F(ValidateArithmetics, MatrixTimesVector22x3Fail) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected number of columns of the matrix to be equal to the vector "
- "size: MatrixTimesVector"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected number of columns of the matrix to be equal to the vector "
+ "size: MatrixTimesVector"));
}
TEST_F(ValidateArithmetics, MatrixTimesMatrix22x22Success) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float matrix type as Result Type: MatrixTimesMatrix"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected float matrix type as Result Type: MatrixTimesMatrix"));
}
TEST_F(ValidateArithmetics, MatrixTimesMatrixWrongLeftOperand) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float matrix type as left operand: MatrixTimesMatrix"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected float matrix type as left operand: MatrixTimesMatrix"));
}
TEST_F(ValidateArithmetics, MatrixTimesMatrixWrongRightOperand) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float matrix type as right operand: MatrixTimesMatrix"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected float matrix type as right operand: MatrixTimesMatrix"));
}
TEST_F(ValidateArithmetics, MatrixTimesMatrix32x23Fail) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected column types of Result Type and left matrix to be equal: "
- "MatrixTimesMatrix"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected column types of Result Type and left matrix to be equal: "
+ "MatrixTimesMatrix"));
}
TEST_F(ValidateArithmetics, MatrixTimesMatrixDifferentComponents) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected component types of Result Type and right matrix to be equal: "
- "MatrixTimesMatrix"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected component types of Result Type and right "
+ "matrix to be equal: "
+ "MatrixTimesMatrix"));
}
TEST_F(ValidateArithmetics, MatrixTimesMatrix23x23Fail) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected number of columns of Result Type and right matrix to be equal: "
- "MatrixTimesMatrix"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected number of columns of Result Type and right "
+ "matrix to be equal: "
+ "MatrixTimesMatrix"));
}
TEST_F(ValidateArithmetics, MatrixTimesMatrix23x22Fail) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected number of columns of left matrix and number of rows of right "
- "matrix to be equal: MatrixTimesMatrix"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected number of columns of left matrix and number "
+ "of rows of right "
+ "matrix to be equal: MatrixTimesMatrix"));
}
TEST_F(ValidateArithmetics, OuterProduct2x2Success) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float matrix type as Result Type: "
- "OuterProduct"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected float matrix type as Result Type: "
+ "OuterProduct"));
}
TEST_F(ValidateArithmetics, OuterProductWrongLeftOperand) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected column type of Result Type to be equal to the type "
- "of the left operand: OuterProduct"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected column type of Result Type to be equal to the type "
+ "of the left operand: OuterProduct"));
}
TEST_F(ValidateArithmetics, OuterProductRightOperandNotFloatVector) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float vector type as right operand: OuterProduct"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected float vector type as right operand: OuterProduct"));
}
TEST_F(ValidateArithmetics, OuterProductRightOperandWrongComponent) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected component types of the operands to be equal: OuterProduct"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected component types of the operands to be equal: "
+ "OuterProduct"));
}
TEST_F(ValidateArithmetics, OuterProductRightOperandWrongDimension) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected number of columns of the matrix to be equal to the "
- "vector size of the right operand: OuterProduct"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected number of columns of the matrix to be equal to the "
+ "vector size of the right operand: OuterProduct"));
}
TEST_F(ValidateArithmetics, IAddCarrySuccess) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected a struct as Result Type: IAddCarry"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected a struct as Result Type: IAddCarry"));
}
TEST_F(ValidateArithmetics, IAddCarryResultTypeNotTwoMembers) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type struct to have two members: IAddCarry"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type struct to have two members: IAddCarry"));
}
TEST_F(ValidateArithmetics, IAddCarryResultTypeMemberNotUnsignedInt) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type struct member types to be unsigned integer scalar "
- "or vector: IAddCarry"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type struct member types to be "
+ "unsigned integer scalar "
+ "or vector: IAddCarry"));
}
TEST_F(ValidateArithmetics, IAddCarryWrongLeftOperand) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both operands to be of Result Type member type: IAddCarry"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected both operands to be of Result Type member "
+ "type: IAddCarry"));
}
TEST_F(ValidateArithmetics, IAddCarryWrongRightOperand) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both operands to be of Result Type member type: IAddCarry"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected both operands to be of Result Type member "
+ "type: IAddCarry"));
}
TEST_F(ValidateArithmetics, OpSMulExtendedSuccess) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type struct member types to be integer scalar "
- "or vector: SMulExtended"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type struct member types to be integer scalar "
+ "or vector: SMulExtended"));
}
TEST_F(ValidateArithmetics, SMulExtendedResultTypeMembersNotIdentical) {
CompileSuccessfully(GenerateCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type struct member types to be identical: "
- "SMulExtended"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type struct member types to be identical: "
+ "SMulExtended"));
}
} // anonymous namespace
const std::string& body,
const std::string& capabilities_and_extensions = "") {
const std::string capabilities =
-R"(
+ R"(
OpCapability Shader
OpCapability Int64
OpCapability Float64)";
const std::string after_extension_before_body =
-R"(
+ R"(
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
%void = OpTypeVoid
%main_entry = OpLabel)";
const std::string after_body =
-R"(
+ R"(
OpReturn
OpFunctionEnd)";
return capabilities + capabilities_and_extensions +
- after_extension_before_body + body + after_body;
+ after_extension_before_body + body + after_body;
}
TEST_F(ValidateBitwise, ShiftAllSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as Result Type: ShiftRightLogical"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector type as Result Type: "
+ "ShiftRightLogical"));
}
TEST_F(ValidateBitwise, OpShiftRightLogicalBaseNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Base to be int scalar or vector: ShiftRightLogical"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Base to be int scalar or vector: ShiftRightLogical"));
}
TEST_F(ValidateBitwise, OpShiftRightLogicalBaseWrongDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Base to have the same dimension as Result Type: "
- "ShiftRightLogical"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Base to have the same dimension as Result Type: "
+ "ShiftRightLogical"));
}
TEST_F(ValidateBitwise, OpShiftRightLogicalBaseWrongBitWidth) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Base to have the same bit width as Result Type: "
- "ShiftRightLogical"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Base to have the same bit width as Result Type: "
+ "ShiftRightLogical"));
}
TEST_F(ValidateBitwise, OpShiftRightLogicalShiftNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Shift to be int scalar or vector: ShiftRightLogical"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Shift to be int scalar or vector: ShiftRightLogical"));
}
TEST_F(ValidateBitwise, OpShiftRightLogicalShiftWrongDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Shift to have the same dimension as Result Type: "
- "ShiftRightLogical"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Shift to have the same dimension as Result Type: "
+ "ShiftRightLogical"));
}
TEST_F(ValidateBitwise, LogicAllSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as Result Type: BitwiseAnd"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected int scalar or vector type as Result Type: BitwiseAnd"));
}
TEST_F(ValidateBitwise, OpBitwiseAndLeftNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector as operand: BitwiseAnd "
- "operand index 2"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector as operand: BitwiseAnd "
+ "operand index 2"));
}
TEST_F(ValidateBitwise, OpBitwiseAndRightNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector as operand: BitwiseAnd "
- "operand index 3"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector as operand: BitwiseAnd "
+ "operand index 3"));
}
TEST_F(ValidateBitwise, OpBitwiseAndLeftWrongDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to have the same dimension as Result Type: "
- "BitwiseAnd operand index 2"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to have the same dimension as Result Type: "
+ "BitwiseAnd operand index 2"));
}
TEST_F(ValidateBitwise, OpBitwiseAndRightWrongDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to have the same dimension as Result Type: "
- "BitwiseAnd operand index 3"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to have the same dimension as Result Type: "
+ "BitwiseAnd operand index 3"));
}
TEST_F(ValidateBitwise, OpBitwiseAndLeftWrongBitWidth) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to have the same bit width as Result Type: "
- "BitwiseAnd operand index 2"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to have the same bit width as Result Type: "
+ "BitwiseAnd operand index 2"));
}
TEST_F(ValidateBitwise, OpBitwiseAndRightWrongBitWidth) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to have the same bit width as Result Type: "
- "BitwiseAnd operand index 3"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to have the same bit width as Result Type: "
+ "BitwiseAnd operand index 3"));
}
TEST_F(ValidateBitwise, OpBitFieldInsertSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as Result Type: BitFieldInsert"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected int scalar or vector type as Result Type: BitFieldInsert"));
}
TEST_F(ValidateBitwise, OpBitFieldInsertWrongBaseType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Base Type to be equal to Result Type: BitFieldInsert"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Base Type to be equal to Result Type: BitFieldInsert"));
}
TEST_F(ValidateBitwise, OpBitFieldInsertWrongInsertType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Insert Type to be equal to Result Type: BitFieldInsert"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Insert Type to be equal to Result Type: BitFieldInsert"));
}
TEST_F(ValidateBitwise, OpBitFieldInsertOffsetNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Offset Type to be int scalar: BitFieldInsert"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Offset Type to be int scalar: BitFieldInsert"));
}
TEST_F(ValidateBitwise, OpBitFieldInsertCountNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Count Type to be int scalar: BitFieldInsert"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Count Type to be int scalar: BitFieldInsert"));
}
TEST_F(ValidateBitwise, OpBitFieldSExtractSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as Result Type: BitFieldSExtract"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector type as Result Type: "
+ "BitFieldSExtract"));
}
TEST_F(ValidateBitwise, OpBitFieldSExtractWrongBaseType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Base Type to be equal to Result Type: BitFieldSExtract"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Base Type to be equal to Result Type: BitFieldSExtract"));
}
TEST_F(ValidateBitwise, OpBitFieldSExtractOffsetNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Offset Type to be int scalar: BitFieldSExtract"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Offset Type to be int scalar: BitFieldSExtract"));
}
TEST_F(ValidateBitwise, OpBitFieldSExtractCountNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Count Type to be int scalar: BitFieldSExtract"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Count Type to be int scalar: BitFieldSExtract"));
}
TEST_F(ValidateBitwise, OpBitReverseSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as Result Type: BitReverse"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected int scalar or vector type as Result Type: BitReverse"));
}
TEST_F(ValidateBitwise, OpBitReverseWrongBaseType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Base Type to be equal to Result Type: BitReverse"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Base Type to be equal to Result Type: BitReverse"));
}
TEST_F(ValidateBitwise, OpBitCountSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as Result Type: BitCount"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector type as Result Type: BitCount"));
}
TEST_F(ValidateBitwise, OpBitCountBaseNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Base Type to be int scalar or vector: BitCount"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Base Type to be int scalar or vector: BitCount"));
}
TEST_F(ValidateBitwise, OpBitCountBaseWrongDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Base dimension to be equal to Result Type dimension: "
- "BitCount"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Base dimension to be equal to Result Type dimension: "
+ "BitCount"));
}
} // anonymous namespace
// True if capability exists in env.
bool Exists(const std::string& capability, spv_target_env env) {
spv_operand_desc dummy;
- return SPV_SUCCESS ==
- libspirv::AssemblyGrammar(ScopedContext(env).context)
- .lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, capability.c_str(),
- capability.size(), &dummy);
+ return SPV_SUCCESS == libspirv::AssemblyGrammar(ScopedContext(env).context)
+ .lookupOperand(SPV_OPERAND_TYPE_CAPABILITY,
+ capability.c_str(),
+ capability.size(), &dummy);
}
TEST_P(ValidateCapability, Capability) {
HasSubstr("Capability value 4427 is not allowed by Vulkan 1.0"));
}
-} // namespace anonymous
+} // namespace
OpFunctionEnd
)";
CompileSuccessfully(str);
- ASSERT_EQ(SPV_SUCCESS, ValidateInstructions()) << str
- << getDiagnosticString();
+ ASSERT_EQ(SPV_SUCCESS, ValidateInstructions())
+ << str << getDiagnosticString();
}
TEST_P(ValidateCFG, Simple) {
loop.SetBody("OpLoopMerge %merge %cont None\n");
}
- string str = header(GetParam()) + nameOps("loop", "entry", "cont", "merge",
- make_pair("func", "Main")) +
- types_consts() + "%func = OpFunction %voidt None %funct\n";
+ string str =
+ header(GetParam()) +
+ nameOps("loop", "entry", "cont", "merge", make_pair("func", "Main")) +
+ types_consts() + "%func = OpFunction %voidt None %funct\n";
str += entry >> loop;
str += loop >> vector<Block>({cont, merge});
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";
+ 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 += "OpFunctionEnd";
CompileSuccessfully(str);
- EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << str
- << getDiagnosticString();
+ EXPECT_EQ(SPV_SUCCESS, ValidateInstructions())
+ << str << getDiagnosticString();
}
TEST_P(ValidateCFG, SingleLatchBlockHeaderContinueTargetIsItselfGood) {
str += "OpFunctionEnd";
CompileSuccessfully(str);
- EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << str
- << getDiagnosticString();
+ EXPECT_EQ(SPV_SUCCESS, ValidateInstructions())
+ << str << getDiagnosticString();
}
// Unit test to check the case where a basic block is the entry block of 2
/// TODO(umar): Switch instructions
/// TODO(umar): Nested CFG constructs
-} /// namespace
+} // namespace
const std::string& body,
const std::string& capabilities_and_extensions = "") {
const std::string capabilities =
-R"(
+ R"(
OpCapability Shader
OpCapability Int64
OpCapability Float64)";
const std::string after_extension_before_body =
-R"(
+ R"(
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
%void = OpTypeVoid
%main_entry = OpLabel)";
const std::string after_body =
-R"(
+ R"(
OpReturn
OpFunctionEnd)";
return capabilities + capabilities_and_extensions +
- after_extension_before_body + body + after_body;
+ after_extension_before_body + body + after_body;
}
std::string GenerateKernelCode(
const std::string& body,
const std::string& capabilities_and_extensions = "") {
const std::string capabilities =
-R"(
+ R"(
OpCapability Addresses
OpCapability Kernel
OpCapability Linkage
OpCapability Float64)";
const std::string after_extension_before_body =
-R"(
+ R"(
OpMemoryModel Physical32 OpenCL
%void = OpTypeVoid
%func = OpTypeFunction %void
%main_entry = OpLabel)";
const std::string after_body =
-R"(
+ R"(
OpReturn
OpFunctionEnd)";
return capabilities + capabilities_and_extensions +
- after_extension_before_body + body + after_body;
+ after_extension_before_body + body + after_body;
}
TEST_F(ValidateConversion, ConvertFToUSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected unsigned int scalar or vector type as Result Type: ConvertFToU"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected unsigned int scalar or vector type as Result "
+ "Type: ConvertFToU"));
}
TEST_F(ValidateConversion, ConvertFToUWrongInputType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be float scalar or vector: ConvertFToU"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected input to be float scalar or vector: ConvertFToU"));
}
TEST_F(ValidateConversion, ConvertFToUDifferentDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have the same dimension as Result Type: ConvertFToU"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have the same dimension as Result "
+ "Type: ConvertFToU"));
}
TEST_F(ValidateConversion, ConvertFToSSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as Result Type: ConvertFToS"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected int scalar or vector type as Result Type: ConvertFToS"));
}
TEST_F(ValidateConversion, ConvertFToSWrongInputType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be float scalar or vector: ConvertFToS"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected input to be float scalar or vector: ConvertFToS"));
}
TEST_F(ValidateConversion, ConvertFToSDifferentDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have the same dimension as Result Type: ConvertFToS"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have the same dimension as Result "
+ "Type: ConvertFToS"));
}
TEST_F(ValidateConversion, ConvertSToFSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float scalar or vector type as Result Type: ConvertSToF"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected float scalar or vector type as Result Type: ConvertSToF"));
}
TEST_F(ValidateConversion, ConvertSToFWrongInputType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be int scalar or vector: ConvertSToF"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected input to be int scalar or vector: ConvertSToF"));
}
TEST_F(ValidateConversion, ConvertSToFDifferentDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have the same dimension as Result Type: ConvertSToF"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have the same dimension as Result "
+ "Type: ConvertSToF"));
}
TEST_F(ValidateConversion, UConvertSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as Result Type: SConvert"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector type as Result Type: SConvert"));
}
TEST_F(ValidateConversion, SConvertWrongInputType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be int scalar or vector: SConvert"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to be int scalar or vector: SConvert"));
}
TEST_F(ValidateConversion, SConvertDifferentDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have the same dimension as Result Type: SConvert"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have the same dimension as Result "
+ "Type: SConvert"));
}
TEST_F(ValidateConversion, SConvertSameBitWidth) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have different bit width from Result Type: SConvert"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have different bit width from "
+ "Result Type: SConvert"));
}
TEST_F(ValidateConversion, FConvertSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected float scalar or vector type as Result Type: FConvert"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected float scalar or vector type as Result Type: FConvert"));
}
TEST_F(ValidateConversion, FConvertWrongInputType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be float scalar or vector: FConvert"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected input to be float scalar or vector: FConvert"));
}
TEST_F(ValidateConversion, FConvertDifferentDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have the same dimension as Result Type: FConvert"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have the same dimension as Result "
+ "Type: FConvert"));
}
TEST_F(ValidateConversion, FConvertSameBitWidth) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have different bit width from Result Type: FConvert"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have different bit width from "
+ "Result Type: FConvert"));
}
TEST_F(ValidateConversion, QuantizeToF16Success) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected 32-bit float scalar or vector type as Result Type: "
- "QuantizeToF16"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected 32-bit float scalar or vector type as Result Type: "
+ "QuantizeToF16"));
}
TEST_F(ValidateConversion, QuantizeToF16WrongResultTypeBitWidth) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected 32-bit float scalar or vector type as Result Type: "
- "QuantizeToF16"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected 32-bit float scalar or vector type as Result Type: "
+ "QuantizeToF16"));
}
TEST_F(ValidateConversion, QuantizeToF16WrongInputType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input type to be equal to Result Type: QuantizeToF16"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected input type to be equal to Result Type: QuantizeToF16"));
}
TEST_F(ValidateConversion, ConvertPtrToUSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected unsigned int scalar type as Result Type: "
- "ConvertPtrToU"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected unsigned int scalar type as Result Type: "
+ "ConvertPtrToU"));
}
TEST_F(ValidateConversion, ConvertPtrToUNotPointer) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be a pointer: ConvertPtrToU"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to be a pointer: ConvertPtrToU"));
}
TEST_F(ValidateConversion, SatConvertSToUSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector type as Result Type: "
- "SatConvertSToU"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector type as Result Type: "
+ "SatConvertSToU"));
}
TEST_F(ValidateConversion, SatConvertSToUWrongInputType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar or vector as input: SatConvertSToU"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected int scalar or vector as input: SatConvertSToU"));
}
TEST_F(ValidateConversion, SatConvertSToUDifferentDimension) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have the same dimension as Result Type: "
- "SatConvertSToU"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected input to have the same dimension as Result Type: "
+ "SatConvertSToU"));
}
TEST_F(ValidateConversion, ConvertUToPtrSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be a pointer: ConvertUToPtr"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be a pointer: ConvertUToPtr"));
}
TEST_F(ValidateConversion, ConvertUToPtrNotInt) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar as input: ConvertUToPtr"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected int scalar as input: ConvertUToPtr"));
}
TEST_F(ValidateConversion, ConvertUToPtrNotIntScalar) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected int scalar as input: ConvertUToPtr"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected int scalar as input: ConvertUToPtr"));
}
TEST_F(ValidateConversion, PtrCastToGenericSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be a pointer: PtrCastToGeneric"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type to be a pointer: PtrCastToGeneric"));
}
TEST_F(ValidateConversion, PtrCastToGenericWrongResultStorageClass) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to have storage class Generic: PtrCastToGeneric"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to have storage class Generic: "
+ "PtrCastToGeneric"));
}
TEST_F(ValidateConversion, PtrCastToGenericWrongInputType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be a pointer: PtrCastToGeneric"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to be a pointer: PtrCastToGeneric"));
}
TEST_F(ValidateConversion, PtrCastToGenericWrongInputStorageClass) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have storage class Workgroup, "
- "CrossWorkgroup or Function: PtrCastToGeneric"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have storage class Workgroup, "
+ "CrossWorkgroup or Function: PtrCastToGeneric"));
}
TEST_F(ValidateConversion, PtrCastToGenericPointToDifferentType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input and Result Type to point to the same type: "
- "PtrCastToGeneric"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected input and Result Type to point to the same type: "
+ "PtrCastToGeneric"));
}
TEST_F(ValidateConversion, GenericCastToPtrSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be a pointer: GenericCastToPtr"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type to be a pointer: GenericCastToPtr"));
}
TEST_F(ValidateConversion, GenericCastToPtrWrongResultStorageClass) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to have storage class Workgroup, "
- "CrossWorkgroup or Function: GenericCastToPtr"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to have storage class Workgroup, "
+ "CrossWorkgroup or Function: GenericCastToPtr"));
}
TEST_F(ValidateConversion, GenericCastToPtrWrongInputType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be a pointer: GenericCastToPtr"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to be a pointer: GenericCastToPtr"));
}
TEST_F(ValidateConversion, GenericCastToPtrWrongInputStorageClass) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have storage class Generic: "
- "GenericCastToPtr"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have storage class Generic: "
+ "GenericCastToPtr"));
}
TEST_F(ValidateConversion, GenericCastToPtrPointToDifferentType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input and Result Type to point to the same type: "
- "GenericCastToPtr"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected input and Result Type to point to the same type: "
+ "GenericCastToPtr"));
}
TEST_F(ValidateConversion, GenericCastToPtrExplicitSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be a pointer: GenericCastToPtrExplicit"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Result Type to be a pointer: GenericCastToPtrExplicit"));
}
TEST_F(ValidateConversion, GenericCastToPtrExplicitResultStorageClassDiffers) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be of target storage class: "
- "GenericCastToPtrExplicit"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be of target storage class: "
+ "GenericCastToPtrExplicit"));
}
TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongResultStorageClass) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected target storage class to be Workgroup, "
- "CrossWorkgroup or Function: GenericCastToPtrExplicit"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected target storage class to be Workgroup, "
+ "CrossWorkgroup or Function: GenericCastToPtrExplicit"));
}
TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongInputType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be a pointer: GenericCastToPtrExplicit"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected input to be a pointer: GenericCastToPtrExplicit"));
}
TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongInputStorageClass) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have storage class Generic: "
- "GenericCastToPtrExplicit"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have storage class Generic: "
+ "GenericCastToPtrExplicit"));
}
TEST_F(ValidateConversion, GenericCastToPtrExplicitPointToDifferentType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input and Result Type to point to the same type: "
- "GenericCastToPtrExplicit"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected input and Result Type to point to the same type: "
+ "GenericCastToPtrExplicit"));
}
TEST_F(ValidateConversion, BitcastSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have a type: Bitcast"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to have a type: Bitcast"));
}
TEST_F(ValidateConversion, BitcastWrongResultType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be a pointer or int or float vector "
- "or scalar type: Bitcast"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type to be a pointer or int or float vector "
+ "or scalar type: Bitcast"));
}
TEST_F(ValidateConversion, BitcastWrongInputType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be a pointer or int or float vector "
- "or scalar: Bitcast"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected input to be a pointer or int or float vector "
+ "or scalar: Bitcast"));
}
TEST_F(ValidateConversion, BitcastPtrWrongInputType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to be a pointer or int scalar if Result Type "
- "is pointer: Bitcast"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected input to be a pointer or int scalar if Result Type "
+ "is pointer: Bitcast"));
}
TEST_F(ValidateConversion, BitcastPtrWrongResultType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Pointer can only be converted to another pointer or int scalar: "
- "Bitcast"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Pointer can only be converted to another pointer or int scalar: "
+ "Bitcast"));
}
TEST_F(ValidateConversion, BitcastDifferentTotalBitWidth) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected input to have the same total bit width as Result Type: "
- "Bitcast"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected input to have the same total bit width as Result Type: "
+ "Bitcast"));
}
} // anonymous namespace
using ::testing::HasSubstr;
using ::testing::MatchesRegex;
-using std::string;
using std::pair;
+using std::string;
using std::stringstream;
using ValidateData = spvtest::ValidateBase<pair<string, bool>>;
}
TEST_F(ValidateData, storage_uniform_buffer_block_16_good) {
- string str = HeaderWith("StorageUniformBufferBlock16 "
- "OpExtension \"SPV_KHR_16bit_storage\"") +
- "%2 = OpTypeInt 16 1 %3 = OpTypeFloat 16";
+ string str = HeaderWith(
+ "StorageUniformBufferBlock16 "
+ "OpExtension \"SPV_KHR_16bit_storage\"") +
+ "%2 = OpTypeInt 16 1 %3 = OpTypeFloat 16";
CompileSuccessfully(str.c_str());
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
}
TEST_F(ValidateData, storage_push_constant_16_good) {
- string str = HeaderWith("StoragePushConstant16 "
- "OpExtension \"SPV_KHR_16bit_storage\"") +
- "%2 = OpTypeInt 16 1 %3 = OpTypeFloat 16";
+ string str = HeaderWith(
+ "StoragePushConstant16 "
+ "OpExtension \"SPV_KHR_16bit_storage\"") +
+ "%2 = OpTypeInt 16 1 %3 = OpTypeFloat 16";
CompileSuccessfully(str.c_str());
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateData, storage_input_output_16_good) {
- string str = HeaderWith("StorageInputOutput16 "
- "OpExtension \"SPV_KHR_16bit_storage\"") +
- "%2 = OpTypeInt 16 1 %3 = OpTypeFloat 16";
+ string str = HeaderWith(
+ "StorageInputOutput16 "
+ "OpExtension \"SPV_KHR_16bit_storage\"") +
+ "%2 = OpTypeInt 16 1 %3 = OpTypeFloat 16";
CompileSuccessfully(str.c_str());
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
}
TEST_F(ValidateData, default_disallow_free_fp_rounding_mode) {
- string str = R"(
+ string str = R"(
OpCapability Shader
OpCapability Linkage
OpMemoryModel Logical GLSL450
%1 = OpTypeFloat 32
%2 = OpConstant %1 1.25
)";
- CompileSuccessfully(str.c_str());
- ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(),
- HasSubstr("Operand 2 of Decorate requires one of these "
- "capabilities: Kernel"));
+ CompileSuccessfully(str.c_str());
+ ASSERT_EQ(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions());
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Operand 2 of Decorate requires one of these "
+ "capabilities: Kernel"));
}
} // anonymous namespace
// Common validation fixtures for unit tests
#include "gmock/gmock.h"
+#include "source/val/decoration.h"
#include "unit_spirv.h"
#include "val_fixtures.h"
-#include "source/val/decoration.h"
namespace {
+using libspirv::Decoration;
using std::string;
using std::vector;
-using ::testing::HasSubstr;
using ::testing::Eq;
-using libspirv::Decoration;
+using ::testing::HasSubstr;
using ValidateDecorations = spvtest::ValidateBase<bool>;
}
} // anonymous namespace
-
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be float scalar or vector type: "
- "DPdx"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type to be float scalar or vector type: "
+ "DPdx"));
}
TEST_F(ValidateDerivatives, OpDPdxWrongPType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected P type and Result Type to be the same: "
- "DPdx"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected P type and Result Type to be the same: "
+ "DPdx"));
}
TEST_F(ValidateDerivatives, OpDPdxWrongExecutionModel) {
CompileSuccessfully(GenerateShaderCode(body, "", "Vertex").c_str());
ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Derivative instructions require Fragment execution model: DPdx"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Derivative instructions require Fragment execution model: DPdx"));
}
} // anonymous namespace
return "Found unrecognized extension " + extension;
}
-INSTANTIATE_TEST_CASE_P(ExpectSuccess, ValidateKnownExtensions, Values(
- // Match the order as published on the SPIR-V Registry.
- "SPV_AMD_shader_explicit_vertex_parameter",
- "SPV_AMD_shader_trinary_minmax",
- "SPV_AMD_gcn_shader",
- "SPV_KHR_shader_ballot",
- "SPV_AMD_shader_ballot",
- "SPV_AMD_gpu_shader_half_float",
- "SPV_KHR_shader_draw_parameters",
- "SPV_KHR_subgroup_vote",
- "SPV_KHR_16bit_storage",
- "SPV_KHR_device_group",
- "SPV_KHR_multiview",
- "SPV_NVX_multiview_per_view_attributes",
- "SPV_NV_viewport_array2",
- "SPV_NV_stereo_view_rendering",
- "SPV_NV_sample_mask_override_coverage",
- "SPV_NV_geometry_shader_passthrough",
- "SPV_AMD_texture_gather_bias_lod",
- "SPV_KHR_storage_buffer_storage_class",
- "SPV_KHR_variable_pointers",
- "SPV_AMD_gpu_shader_int16",
- "SPV_KHR_post_depth_coverage",
- "SPV_KHR_shader_atomic_counter_ops",
- "SPV_EXT_shader_stencil_export",
- "SPV_EXT_shader_viewport_index_layer",
- "SPV_AMD_shader_image_load_store_lod",
- "SPV_AMD_shader_fragment_mask"
- ));
-
-INSTANTIATE_TEST_CASE_P(FailSilently, ValidateUnknownExtensions, Values(
- "ERROR_unknown_extension",
- "SPV_KHR_",
- "SPV_KHR_shader_ballot_ERROR"
- ));
+INSTANTIATE_TEST_CASE_P(
+ ExpectSuccess, ValidateKnownExtensions,
+ Values(
+ // Match the order as published on the SPIR-V Registry.
+ "SPV_AMD_shader_explicit_vertex_parameter",
+ "SPV_AMD_shader_trinary_minmax", "SPV_AMD_gcn_shader",
+ "SPV_KHR_shader_ballot", "SPV_AMD_shader_ballot",
+ "SPV_AMD_gpu_shader_half_float", "SPV_KHR_shader_draw_parameters",
+ "SPV_KHR_subgroup_vote", "SPV_KHR_16bit_storage",
+ "SPV_KHR_device_group", "SPV_KHR_multiview",
+ "SPV_NVX_multiview_per_view_attributes", "SPV_NV_viewport_array2",
+ "SPV_NV_stereo_view_rendering", "SPV_NV_sample_mask_override_coverage",
+ "SPV_NV_geometry_shader_passthrough", "SPV_AMD_texture_gather_bias_lod",
+ "SPV_KHR_storage_buffer_storage_class", "SPV_KHR_variable_pointers",
+ "SPV_AMD_gpu_shader_int16", "SPV_KHR_post_depth_coverage",
+ "SPV_KHR_shader_atomic_counter_ops", "SPV_EXT_shader_stencil_export",
+ "SPV_EXT_shader_viewport_index_layer",
+ "SPV_AMD_shader_image_load_store_lod", "SPV_AMD_shader_fragment_mask"));
+
+INSTANTIATE_TEST_CASE_P(FailSilently, ValidateUnknownExtensions,
+ Values("ERROR_unknown_extension", "SPV_KHR_",
+ "SPV_KHR_shader_ballot_ERROR"));
TEST_P(ValidateKnownExtensions, ExpectSuccess) {
const std::string extension = GetParam();
CompileSuccessfully(str.c_str());
ASSERT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(), HasSubstr("1st operand of Capability"));
- EXPECT_THAT(getDiagnosticString(), HasSubstr("requires one of these extensions"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("requires one of these extensions"));
EXPECT_THAT(getDiagnosticString(), HasSubstr("SPV_KHR_device_group"));
}
template <typename T>
std::string ValidateBase<T>::getDiagnosticString() {
- return diagnostic_ == nullptr ?
- std::string() : std::string(diagnostic_->error);
+ return diagnostic_ == nullptr ? std::string()
+ : std::string(diagnostic_->error);
}
template <typename T>
std::function<spv_result_t(int)>>>>;
template class spvtest::ValidateBase<SpvCapability>;
template class spvtest::ValidateBase<std::pair<std::string, std::string>>;
-}
+} // namespace spvtest
#ifndef LIBSPIRV_TEST_VALIDATE_FIXTURES_H_
#define LIBSPIRV_TEST_VALIDATE_FIXTURES_H_
-#include "unit_spirv.h"
#include "source/val/validation_state.h"
+#include "unit_spirv.h"
namespace spvtest {
spv_validator_options options_;
std::unique_ptr<libspirv::ValidationState_t> vstate_;
};
-}
+} // namespace spvtest
#endif
namespace {
-using ::testing::HasSubstr;
-using ::testing::ValuesIn;
using spvtest::ScopedContext;
using std::ostringstream;
using std::string;
using std::vector;
+using ::testing::HasSubstr;
+using ::testing::ValuesIn;
using ValidateIdWithMessage = spvtest::ValidateBase<bool>;
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(),
- HasSubstr("storage class is read-only"));
+ EXPECT_THAT(getDiagnosticString(), HasSubstr("storage class is read-only"));
}
TEST_F(ValidateIdWithMessage, OpCopyMemoryGood) {
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup +
"%float_entry = " + instr +
- R"( %_ptr_Private_float %my_matrix )" + elem +
- R"(%int_0 %int_1
+ R"( %_ptr_Private_float %my_matrix )" + elem +
+ R"(%int_0 %int_1
OpReturn
OpFunctionEnd
)";
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
%float_entry = )" +
- instr + " %_ptr_Private_float %void " + elem +
- R"(%int_0 %int_1
+ instr + " %_ptr_Private_float %void " + elem +
+ R"(%int_0 %int_1
OpReturn
OpFunctionEnd
)";
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%entry = )" +
- instr +
+%entry = )" + instr +
R"( %_ptr_Private_float %_ptr_Private_float )" + elem +
R"(%int_0 %int_1
OpReturn
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%entry = )" +
- instr +
+%entry = )" + instr +
R"( %_ptr_Function_float %my_matrix )" + elem +
R"(%int_0 %int_1
OpReturn
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%entry = )" +
- instr +
+%entry = )" + instr +
R"( %_ptr_Private_float %my_float_var )" + elem + R"(%int_0
OpReturn
OpFunctionEnd
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%entry = )" +
- instr +
+%entry = )" + instr +
R"( %_ptr_Private_float %my_float_var )" + elem + R"(
OpReturn
OpFunctionEnd
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%entry = )" +
- instr +
+%entry = )" + instr +
R"( %_ptr_Private_mat4x3 %my_float_var )" + elem + R"(
OpReturn
OpFunctionEnd
TEST_P(AccessChainInstructionTest, AccessChainUndefinedIndexBad) {
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
- string spirv =
- kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
+ string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
%entry = )" + instr +
- R"( %_ptr_Private_float %my_matrix )" + elem + R"(%float %int_1
+ R"( %_ptr_Private_float %my_matrix )" + elem + R"(%float %int_1
OpReturn
OpFunctionEnd
)";
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%f = )" +
- instr + R"( %_ptr_Uniform_float %blockName_var )" + elem +
- R"(%int_0 %spec_int %int_2
+%f = )" + instr + R"( %_ptr_Uniform_float %blockName_var )" +
+ elem +
+ R"(%int_0 %spec_int %int_2
OpReturn
OpFunctionEnd
)";
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%entry = )" +
- instr +
+%entry = )" + instr +
R"( %_ptr_Uniform_float %blockName_var )" + elem +
R"(%int_0 %int_1 %int_2
OpReturn
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%entry = )" +
- instr +
+%entry = )" + instr +
R"( %_ptr_Uniform_float %blockName_var )" + elem +
R"(%int_0 %int_2 %int_2
OpReturn
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%entry = )" +
- instr +
+%entry = )" + instr +
R"( %_ptr_Uniform_float %blockName_var )" + elem +
R"(%int_3 %int_2 %int_2
OpReturn
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%entry = )" +
- instr +
+%entry = )" + instr +
R"( %_ptr_Private_float %my_matrix )" + elem +
R"(%int_0 %int_1 %int_0
OpReturn
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
-%entry = )" +
- instr +
+%entry = )" + instr +
R"( %_ptr_Private_mat4x3 %my_matrix )" + elem +
R"(%int_0 %int_1
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
- EXPECT_THAT(
- getDiagnosticString(),
- HasSubstr("The Component Type of Vector 1 must be the same as "
- "ResultType."));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("The Component Type of Vector 1 must be the same as "
+ "ResultType."));
}
TEST_F(ValidateIdWithMessage, OpVectorShuffleVector2ComponentType) {
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
- EXPECT_THAT(
- getDiagnosticString(),
- HasSubstr("The Component Type of Vector 2 must be the same as "
- "ResultType."));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("The Component Type of Vector 2 must be the same as "
+ "ResultType."));
}
TEST_F(ValidateIdWithMessage, OpVectorShuffleLiterals) {
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
- HasSubstr("Condition operand for OpBranchConditional must be of boolean type"));
+ HasSubstr(
+ "Condition operand for OpBranchConditional must be of boolean type"));
}
TEST_F(ValidateIdWithMessage, OpBranchConditional_TrueTargetIsNotLabel) {
// EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
// EXPECT_THAT(
// getDiagnosticString(),
- // HasSubstr("The 'True Label' operand for OpBranchConditional must be the ID of an OpLabel instruction"));
+ // HasSubstr("The 'True Label' operand for OpBranchConditional must be the
+ // ID of an OpLabel instruction"));
// xxxnsubtil: this is actually caught by the ID validation instead
EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions());
- EXPECT_THAT(
- getDiagnosticString(),
- HasSubstr("are referenced but not defined in function"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("are referenced but not defined in function"));
}
TEST_F(ValidateIdWithMessage, OpBranchConditional_FalseTargetIsNotLabel) {
// EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
// EXPECT_THAT(
// getDiagnosticString(),
- // HasSubstr("The 'False Label' operand for OpBranchConditional must be the ID of an OpLabel instruction"));
+ // HasSubstr("The 'False Label' operand for OpBranchConditional must be
+ // the ID of an OpLabel instruction"));
// xxxnsubtil: this is actually caught by the ID validation
EXPECT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions());
- EXPECT_THAT(
- getDiagnosticString(),
- HasSubstr("are referenced but not defined in function"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("are referenced but not defined in function"));
}
TEST_F(ValidateIdWithMessage, OpBranchConditional_NotEnoughWeights) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be OpTypeSampledImage: SampledImage"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type to be OpTypeSampledImage: SampledImage"));
}
TEST_F(ValidateImage, SampledImageNotImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image to be of type OpTypeImage: SampledImage"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image to be of type OpTypeImage: SampledImage"));
}
TEST_F(ValidateImage, SampledImageImageNotForSampling) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled' parameter to be 0 or 1: SampledImage"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Image 'Sampled' parameter to be 0 or 1: SampledImage"));
}
TEST_F(ValidateImage, SampledImageImageDimSubpassData) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Dim' parameter to be not SubpassData"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Dim' parameter to be not SubpassData"));
}
TEST_F(ValidateImage, SampledImageNotSampler) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sampler to be of type OpTypeSampler: SampledImage"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Sampler to be of type OpTypeSampler: SampledImage"));
}
TEST_F(ValidateImage, SampleImplicitLodSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float vector type: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int or float vector type: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodWrongNumComponentsResultType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to have 4 components: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to have 4 components: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodNotSampledImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sampled Image to be of type OpTypeSampledImage: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodWrongSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type components: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as "
+ "Result Type components: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodVoidSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be float scalar or vector: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be float scalar or vector: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 2 components, but given only 1: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 2 components, "
+ "but given only 1: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodSuccessShader) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float vector type: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int or float vector type: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodWrongNumComponentsResultType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to have 4 components: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to have 4 components: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodNotSampledImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sampled Image to be of type OpTypeSampledImage: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodWrongSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type components: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as "
+ "Result Type components: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodVoidSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be float scalar or vector: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be float scalar or vector: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 2 components, but given only 1: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 2 components, "
+ "but given only 1: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodBias) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Bias can only be used with ImplicitLod opcodes: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Image Operand Bias can only be used with ImplicitLod opcodes: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, LodAndGrad) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand bits Lod and Grad cannot be set at the same time: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Image Operand bits Lod and Grad cannot be set at the same time: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, ImplicitLodWithLod) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Lod cannot be used with ImplicitLod opcodes: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Image Operand Lod cannot be used with ImplicitLod opcodes: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, LodWrongType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand Lod to be int or float scalar: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image Operand Lod to be int or float scalar: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, LodWrongDim) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Lod requires 'Dim' parameter to be 1D, 2D, 3D or Cube: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image Operand Lod requires 'Dim' parameter to be 1D, "
+ "2D, 3D or Cube: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, LodMultisampled) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Lod requires 'MS' parameter to be 0: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image Operand Lod requires 'MS' parameter to be 0: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, MinLodIncompatible) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand MinLod can only be used with ImplicitLod opcodes or "
- "together with Image Operand Grad: ImageSampleExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Image Operand MinLod can only be used with ImplicitLod opcodes or "
+ "together with Image Operand Grad: ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, ImplicitLodWithGrad) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Grad can only be used with ExplicitLod opcodes: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Image Operand Grad can only be used with ExplicitLod opcodes: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLod3DArrayedMultisampledSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand Bias to be float scalar: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image Operand Bias to be float scalar: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodBiasWrongDim) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Bias requires 'Dim' parameter to be 1D, 2D, 3D or Cube: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image Operand Bias requires 'Dim' parameter to be 1D, "
+ "2D, 3D or Cube: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodBiasMultisampled) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Bias requires 'MS' parameter to be 0: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image Operand Bias requires 'MS' parameter to be 0: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodGradDxWrongType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both Image Operand Grad ids to be float scalars or vectors: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected both Image Operand Grad ids to be float "
+ "scalars or vectors: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodGradDyWrongType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both Image Operand Grad ids to be float scalars or vectors: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected both Image Operand Grad ids to be float "
+ "scalars or vectors: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodGradDxWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand Grad dx to have 3 components, but given 2: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Image Operand Grad dx to have 3 components, but given 2: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodGradDyWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand Grad dy to have 3 components, but given 2: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Image Operand Grad dy to have 3 components, but given 2: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleExplicitLodGradMultisampled) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Grad requires 'MS' parameter to be 0: "
- "ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image Operand Grad requires 'MS' parameter to be 0: "
+ "ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodConstOffsetCubeDim) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand ConstOffset cannot be used with Cube Image 'Dim': "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Image Operand ConstOffset cannot be used with Cube Image 'Dim': "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodConstOffsetWrongType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand ConstOffset to be int scalar or vector: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Image Operand ConstOffset to be int scalar or vector: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodConstOffsetWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand ConstOffset to have 3 components, but given 2: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image Operand ConstOffset to have 3 "
+ "components, but given 2: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodConstOffsetNotConst) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand ConstOffset to be a const object: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image Operand ConstOffset to be a const object: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodOffsetCubeDim) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Offset cannot be used with Cube Image 'Dim': "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Image Operand Offset cannot be used with Cube Image 'Dim': "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodOffsetWrongType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand Offset to be int scalar or vector: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image Operand Offset to be int scalar or vector: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodOffsetWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand Offset to have 3 components, but given 2: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Image Operand Offset to have 3 components, but given 2: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodMoreThanOneOffset) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operands Offset, ConstOffset, ConstOffsets cannot be used together: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image Operands Offset, ConstOffset, ConstOffsets "
+ "cannot be used together: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodMinLodWrongType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand MinLod to be float scalar: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image Operand MinLod to be float scalar: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodMinLodWrongDim) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand MinLod requires 'Dim' parameter to be 1D, 2D, 3D or Cube: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image Operand MinLod requires 'Dim' parameter to be "
+ "1D, 2D, 3D or Cube: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleImplicitLodMinLodMultisampled) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand MinLod requires 'MS' parameter to be 0: "
- "ImageSampleImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image Operand MinLod requires 'MS' parameter to be 0: "
+ "ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, SampleProjExplicitLodSuccess2D) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float vector type: "
- "ImageSampleProjExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int or float vector type: "
+ "ImageSampleProjExplicitLod"));
}
TEST_F(ValidateImage, SampleProjExplicitLodWrongNumComponentsResultType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to have 4 components: "
- "ImageSampleProjExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to have 4 components: "
+ "ImageSampleProjExplicitLod"));
}
TEST_F(ValidateImage, SampleProjExplicitLodNotSampledImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sampled Image to be of type OpTypeSampledImage: "
- "ImageSampleProjExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage: "
+ "ImageSampleProjExplicitLod"));
}
TEST_F(ValidateImage, SampleProjExplicitLodWrongSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type components: "
- "ImageSampleProjExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as "
+ "Result Type components: "
+ "ImageSampleProjExplicitLod"));
}
TEST_F(ValidateImage, SampleProjExplicitLodVoidSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be float scalar or vector: "
- "ImageSampleProjExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be float scalar or vector: "
+ "ImageSampleProjExplicitLod"));
}
TEST_F(ValidateImage, SampleProjExplicitLodCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 3 components, but given only 2: "
- "ImageSampleProjExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 3 components, "
+ "but given only 2: "
+ "ImageSampleProjExplicitLod"));
}
TEST_F(ValidateImage, SampleProjImplicitLodSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float vector type: "
- "ImageSampleProjImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int or float vector type: "
+ "ImageSampleProjImplicitLod"));
}
TEST_F(ValidateImage, SampleProjImplicitLodWrongNumComponentsResultType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to have 4 components: "
- "ImageSampleProjImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to have 4 components: "
+ "ImageSampleProjImplicitLod"));
}
TEST_F(ValidateImage, SampleProjImplicitLodNotSampledImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sampled Image to be of type OpTypeSampledImage: "
- "ImageSampleProjImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage: "
+ "ImageSampleProjImplicitLod"));
}
TEST_F(ValidateImage, SampleProjImplicitLodWrongSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type components: "
- "ImageSampleProjImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as "
+ "Result Type components: "
+ "ImageSampleProjImplicitLod"));
}
TEST_F(ValidateImage, SampleProjImplicitLodVoidSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be float scalar or vector: "
- "ImageSampleProjImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be float scalar or vector: "
+ "ImageSampleProjImplicitLod"));
}
TEST_F(ValidateImage, SampleProjImplicitLodCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 3 components, but given only 2: "
- "ImageSampleProjImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 3 components, "
+ "but given only 2: "
+ "ImageSampleProjImplicitLod"));
}
TEST_F(ValidateImage, SampleDrefImplicitLodSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float scalar type: "
- "ImageSampleDrefImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int or float scalar type: "
+ "ImageSampleDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleDrefImplicitLodNotSampledImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sampled Image to be of type OpTypeSampledImage: "
- "ImageSampleDrefImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage: "
+ "ImageSampleDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleDrefImplicitLodWrongSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type: "
- "ImageSampleDrefImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type: "
+ "ImageSampleDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleDrefImplicitLodVoidSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type: "
- "ImageSampleDrefImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type: "
+ "ImageSampleDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleDrefImplicitLodWrongCoordinateType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be float scalar or vector: "
- "ImageSampleDrefImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be float scalar or vector: "
+ "ImageSampleDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleDrefImplicitLodCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 2 components, but given only 1: "
- "ImageSampleDrefImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 2 components, "
+ "but given only 1: "
+ "ImageSampleDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleDrefImplicitLodWrongDrefType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Dref to be of Image 'Sampled Type': "
- "ImageSampleDrefImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Dref to be of Image 'Sampled Type': "
+ "ImageSampleDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleDrefExplicitLodSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float scalar type: "
- "ImageSampleDrefExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int or float scalar type: "
+ "ImageSampleDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleDrefExplicitLodNotSampledImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sampled Image to be of type OpTypeSampledImage: "
- "ImageSampleDrefExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage: "
+ "ImageSampleDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleDrefExplicitLodWrongSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type: "
- "ImageSampleDrefExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type: "
+ "ImageSampleDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleDrefExplicitLodVoidSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type: "
- "ImageSampleDrefExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type: "
+ "ImageSampleDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleDrefExplicitLodWrongCoordinateType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be float scalar or vector: "
- "ImageSampleDrefExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be float scalar or vector: "
+ "ImageSampleDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleDrefExplicitLodCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 3 components, but given only 2: "
- "ImageSampleDrefExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 3 components, "
+ "but given only 2: "
+ "ImageSampleDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleDrefExplicitLodWrongDrefType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Dref to be of Image 'Sampled Type': "
- "ImageSampleDrefExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Dref to be of Image 'Sampled Type': "
+ "ImageSampleDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefImplicitLodSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float scalar type: "
- "ImageSampleProjDrefImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int or float scalar type: "
+ "ImageSampleProjDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefImplicitLodNotSampledImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sampled Image to be of type OpTypeSampledImage: "
- "ImageSampleProjDrefImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage: "
+ "ImageSampleProjDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefImplicitLodWrongSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type: "
- "ImageSampleProjDrefImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type: "
+ "ImageSampleProjDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefImplicitLodVoidSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type: "
- "ImageSampleProjDrefImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type: "
+ "ImageSampleProjDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefImplicitLodWrongCoordinateType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be float scalar or vector: "
- "ImageSampleProjDrefImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be float scalar or vector: "
+ "ImageSampleProjDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefImplicitLodCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 3 components, but given only 2: "
- "ImageSampleProjDrefImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 3 components, "
+ "but given only 2: "
+ "ImageSampleProjDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefImplicitLodWrongDrefType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Dref to be of Image 'Sampled Type': "
- "ImageSampleProjDrefImplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Dref to be of Image 'Sampled Type': "
+ "ImageSampleProjDrefImplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefExplicitLodSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float scalar type: "
- "ImageSampleProjDrefExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int or float scalar type: "
+ "ImageSampleProjDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefExplicitLodNotSampledImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sampled Image to be of type OpTypeSampledImage: "
- "ImageSampleProjDrefExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage: "
+ "ImageSampleProjDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefExplicitLodWrongSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type: "
- "ImageSampleProjDrefExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type: "
+ "ImageSampleProjDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefExplicitLodVoidSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type: "
- "ImageSampleProjDrefExplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as Result Type: "
+ "ImageSampleProjDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefExplicitLodWrongCoordinateType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be float scalar or vector: "
- "ImageSampleProjDrefExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be float scalar or vector: "
+ "ImageSampleProjDrefExplicitLod"));
}
TEST_F(ValidateImage, SampleProjDrefExplicitLodCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 2 components, but given only 1: "
- "ImageSampleProjDrefExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 2 components, "
+ "but given only 1: "
+ "ImageSampleProjDrefExplicitLod"));
}
TEST_F(ValidateImage, FetchSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float vector type: "
- "ImageFetch"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int or float vector type: "
+ "ImageFetch"));
}
TEST_F(ValidateImage, FetchWrongNumComponentsResultType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to have 4 components: ImageFetch"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type to have 4 components: ImageFetch"));
}
TEST_F(ValidateImage, FetchNotImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image to be of type OpTypeImage: ImageFetch"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image to be of type OpTypeImage: ImageFetch"));
}
TEST_F(ValidateImage, FetchNotSampled) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled' parameter to be 1: ImageFetch"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled' parameter to be 1: ImageFetch"));
}
TEST_F(ValidateImage, FetchCube) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image 'Dim' cannot be Cube: ImageFetch"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image 'Dim' cannot be Cube: ImageFetch"));
}
TEST_F(ValidateImage, FetchWrongSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type components: "
- "ImageFetch"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as "
+ "Result Type components: "
+ "ImageFetch"));
}
TEST_F(ValidateImage, FetchVoidSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be int scalar or vector: "
- "ImageFetch"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be int scalar or vector: "
+ "ImageFetch"));
}
TEST_F(ValidateImage, FetchCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 2 components, but given only 1: "
- "ImageFetch"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 2 components, "
+ "but given only 1: "
+ "ImageFetch"));
}
TEST_F(ValidateImage, GatherSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float vector type: "
- "ImageGather"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int or float vector type: "
+ "ImageGather"));
}
TEST_F(ValidateImage, GatherWrongNumComponentsResultType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to have 4 components: "
- "ImageGather"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to have 4 components: "
+ "ImageGather"));
}
TEST_F(ValidateImage, GatherNotSampledImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sampled Image to be of type OpTypeSampledImage: "
- "ImageGather"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Sampled Image to be of type OpTypeSampledImage: "
+ "ImageGather"));
}
TEST_F(ValidateImage, GatherWrongSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type components: "
- "ImageGather"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as "
+ "Result Type components: "
+ "ImageGather"));
}
TEST_F(ValidateImage, GatherVoidSampledType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be float scalar or vector: "
- "ImageGather"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be float scalar or vector: "
+ "ImageGather"));
}
TEST_F(ValidateImage, GatherCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 4 components, but given only 1: "
- "ImageGather"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 4 components, "
+ "but given only 1: "
+ "ImageGather"));
}
TEST_F(ValidateImage, GatherWrongComponentType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Component to be int scalar: ImageGather"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Component to be int scalar: ImageGather"));
}
TEST_F(ValidateImage, GatherDimCube) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand ConstOffsets cannot be used with Cube Image 'Dim': "
- "ImageGather"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Image Operand ConstOffsets cannot be used with Cube Image 'Dim': "
+ "ImageGather"));
}
TEST_F(ValidateImage, GatherConstOffsetsNotArray) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand ConstOffsets to be an array of size 4: "
- "ImageGather"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image Operand ConstOffsets to be an array of size 4: "
+ "ImageGather"));
}
TEST_F(ValidateImage, GatherConstOffsetsArrayWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand ConstOffsets to be an array of size 4: "
- "ImageGather"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image Operand ConstOffsets to be an array of size 4: "
+ "ImageGather"));
}
TEST_F(ValidateImage, GatherConstOffsetsArrayNotVector) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand ConstOffsets array componenets to be int vectors "
- "of size 2: ImageGather"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image Operand ConstOffsets array componenets "
+ "to be int vectors "
+ "of size 2: ImageGather"));
}
TEST_F(ValidateImage, GatherConstOffsetsArrayVectorWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand ConstOffsets array componenets to be int vectors "
- "of size 2: ImageGather"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image Operand ConstOffsets array componenets "
+ "to be int vectors "
+ "of size 2: ImageGather"));
}
TEST_F(ValidateImage, GatherConstOffsetsArrayNotConst) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand ConstOffsets to be a const object: "
- "ImageGather"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image Operand ConstOffsets to be a const object: "
+ "ImageGather"));
}
TEST_F(ValidateImage, NotGatherWithConstOffsets) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand ConstOffsets can only be used with OpImageGather "
- "and OpImageDrefGather: ImageSampleImplicitLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Image Operand ConstOffsets can only be used with OpImageGather "
+ "and OpImageDrefGather: ImageSampleImplicitLod"));
}
TEST_F(ValidateImage, DrefGatherSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type components: "
- "ImageDrefGather"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as "
+ "Result Type components: "
+ "ImageDrefGather"));
}
TEST_F(ValidateImage, DrefGatherWrongDrefType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Dref to be of Image 'Sampled Type': ImageDrefGather"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Dref to be of Image 'Sampled Type': ImageDrefGather"));
}
TEST_F(ValidateImage, ReadSuccess1) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Capability StorageImageReadWithoutFormat is required to read storage "
- "image: ImageRead"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Capability StorageImageReadWithoutFormat is required "
+ "to read storage "
+ "image: ImageRead"));
}
TEST_F(ValidateImage, ReadNeedCapabilityImage1D) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Capability Image1D is required to access storage image: ImageRead"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Capability Image1D is required to access storage image: ImageRead"));
}
TEST_F(ValidateImage, ReadNeedCapabilityImageCubeArray) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Capability ImageCubeArray is required to access storage image: "
- "ImageRead"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Capability ImageCubeArray is required to access storage image: "
+ "ImageRead"));
}
// TODO(atgoo@github.com) Disabled until the spec is clarified.
const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int or float vector type: ImageRead"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Result Type to be int or float vector type: ImageRead"));
}
// TODO(atgoo@github.com) Disabled until the spec is clarified.
const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to have 4 components: ImageRead"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type to have 4 components: ImageRead"));
}
TEST_F(ValidateImage, ReadNotImage) {
const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image to be of type OpTypeImage: ImageRead"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image to be of type OpTypeImage: ImageRead"));
}
TEST_F(ValidateImage, ReadImageSampled) {
const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled' parameter to be 0 or 2: ImageRead"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled' parameter to be 0 or 2: ImageRead"));
}
TEST_F(ValidateImage, ReadWrongSampledType) {
const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Result Type components: "
- "ImageRead"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled Type' to be the same as "
+ "Result Type components: "
+ "ImageRead"));
}
TEST_F(ValidateImage, ReadVoidSampledType) {
const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be int scalar or vector: ImageRead"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be int scalar or vector: ImageRead"));
}
TEST_F(ValidateImage, ReadCoordinateSizeTooSmall) {
const std::string extra = "\nOpCapability StorageImageReadWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 2 components, but given only 1: "
- "ImageRead"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 2 components, "
+ "but given only 1: "
+ "ImageRead"));
}
TEST_F(ValidateImage, WriteSuccess1) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image 'Dim' cannot be SubpassData: ImageWrite"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image 'Dim' cannot be SubpassData: ImageWrite"));
}
TEST_F(ValidateImage, WriteNeedCapabilityStorageImageWriteWithoutFormat) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Capability StorageImageWriteWithoutFormat is required to write to "
- "storage image: ImageWrite"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Capability StorageImageWriteWithoutFormat is required to write to "
+ "storage image: ImageWrite"));
}
TEST_F(ValidateImage, WriteNeedCapabilityImage1D) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Capability Image1D is required to access storage image: ImageWrite"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Capability Image1D is required to access storage "
+ "image: ImageWrite"));
}
TEST_F(ValidateImage, WriteNeedCapabilityImageCubeArray) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Capability ImageCubeArray is required to access storage image: "
- "ImageWrite"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Capability ImageCubeArray is required to access storage image: "
+ "ImageWrite"));
}
TEST_F(ValidateImage, WriteNotImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image to be of type OpTypeImage: ImageWrite"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image to be of type OpTypeImage: ImageWrite"));
}
TEST_F(ValidateImage, WriteImageSampled) {
const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled' parameter to be 0 or 2: ImageWrite"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image 'Sampled' parameter to be 0 or 2: ImageWrite"));
}
TEST_F(ValidateImage, WriteWrongCoordinateType) {
const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be int scalar or vector: ImageWrite"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Coordinate to be int scalar or vector: ImageWrite"));
}
TEST_F(ValidateImage, WriteCoordinateSizeTooSmall) {
const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 2 components, but given only 1: "
- "ImageWrite"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 2 components, "
+ "but given only 1: "
+ "ImageWrite"));
}
TEST_F(ValidateImage, WriteTexelWrongType) {
const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Texel to be int or float vector or scalar: ImageWrite"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Texel to be int or float vector or scalar: ImageWrite"));
}
TEST_F(ValidateImage, DISABLED_WriteTexelNotVector4) {
const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Texel to have 4 components: ImageWrite"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Texel to have 4 components: ImageWrite"));
}
TEST_F(ValidateImage, WriteTexelWrongComponentType) {
const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image 'Sampled Type' to be the same as Texel components: "
- "ImageWrite"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Image 'Sampled Type' to be the same as Texel components: "
+ "ImageWrite"));
}
TEST_F(ValidateImage, WriteSampleNotInteger) {
const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image Operand Sample to be int scalar: "
- "ImageWrite"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Image Operand Sample to be int scalar: "
+ "ImageWrite"));
}
TEST_F(ValidateImage, SampleNotMultisampled) {
const std::string extra = "\nOpCapability StorageImageWriteWithoutFormat\n";
CompileSuccessfully(GenerateShaderCode(body, extra).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Sample requires non-zero 'MS' parameter: ImageWrite"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Image Operand Sample requires non-zero 'MS' parameter: ImageWrite"));
}
TEST_F(ValidateImage, SampleWrongOpcode) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image Operand Sample can only be used with OpImageFetch, OpImageRead "
- "and OpImageWrite: ImageSampleExplicitLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image Operand Sample can only be used with "
+ "OpImageFetch, OpImageRead "
+ "and OpImageWrite: ImageSampleExplicitLod"));
}
TEST_F(ValidateImage, SampleImageToImageSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be OpTypeImage: Image"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be OpTypeImage: Image"));
}
TEST_F(ValidateImage, SampleImageToImageNotSampledImage) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sample Image to be of type OpTypeSampleImage: Image"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Sample Image to be of type OpTypeSampleImage: Image"));
}
TEST_F(ValidateImage, SampleImageToImageNotTheSameImageType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Sample Image image type to be equal to Result Type: Image"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Sample Image image type to be equal to "
+ "Result Type: Image"));
}
TEST_F(ValidateImage, QueryFormatSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int scalar type: ImageQueryFormat"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Result Type to be int scalar type: ImageQueryFormat"));
}
TEST_F(ValidateImage, QueryFormatNotImage) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operand to be of type OpTypeImage: ImageQueryFormat"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected operand to be of type OpTypeImage: ImageQueryFormat"));
}
TEST_F(ValidateImage, QueryOrderSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int scalar type: ImageQueryOrder"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int scalar type: ImageQueryOrder"));
}
TEST_F(ValidateImage, QueryOrderNotImage) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operand to be of type OpTypeImage: ImageQueryOrder"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operand to be of type OpTypeImage: ImageQueryOrder"));
}
TEST_F(ValidateImage, QuerySizeLodSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int scalar or vector type: "
- "ImageQuerySizeLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int scalar or vector type: "
+ "ImageQuerySizeLod"));
}
TEST_F(ValidateImage, QuerySizeLodResultTypeWrongSize) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Result Type has 1 components, but 2 expected: ImageQuerySizeLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Result Type has 1 components, but 2 expected: ImageQuerySizeLod"));
}
TEST_F(ValidateImage, QuerySizeLodNotImage) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image to be of type OpTypeImage: ImageQuerySizeLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image to be of type OpTypeImage: ImageQuerySizeLod"));
}
TEST_F(ValidateImage, QuerySizeLodWrongImageDim) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image 'Dim' must be 1D, 2D, 3D or Cube: ImageQuerySizeLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Image 'Dim' must be 1D, 2D, 3D or Cube: ImageQuerySizeLod"));
}
TEST_F(ValidateImage, QuerySizeLodMultisampled) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image 'MS' must be 0: ImageQuerySizeLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image 'MS' must be 0: ImageQuerySizeLod"));
}
TEST_F(ValidateImage, QuerySizeLodWrongLodType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Level of Detail to be int or float scalar: ImageQuerySizeLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Level of Detail to be int or float scalar: "
+ "ImageQuerySizeLod"));
}
TEST_F(ValidateImage, QuerySizeSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int scalar or vector type: "
- "ImageQuerySize"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Result Type to be int scalar or vector type: "
+ "ImageQuerySize"));
}
TEST_F(ValidateImage, QuerySizeNotImage) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image to be of type OpTypeImage: ImageQuerySize"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image to be of type OpTypeImage: ImageQuerySize"));
}
// TODO(atgoo@github.com) Add more tests for OpQuerySize.
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be float vector type: ImageQueryLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type to be float vector type: ImageQueryLod"));
}
TEST_F(ValidateImage, QueryLodResultTypeWrongSize) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to have 2 components: ImageQueryLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Result Type to have 2 components: ImageQueryLod"));
}
TEST_F(ValidateImage, QueryLodNotSampledImage) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image operand to be of type OpTypeSampledImage: "
- "ImageQueryLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image operand to be of type OpTypeSampledImage: "
+ "ImageQueryLod"));
}
TEST_F(ValidateImage, QueryLodWrongDim) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image 'Dim' must be 1D, 2D, 3D or Cube: ImageQueryLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Image 'Dim' must be 1D, 2D, 3D or Cube: ImageQueryLod"));
}
TEST_F(ValidateImage, QueryLodWrongCoordinateType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to be float scalar or vector: ImageQueryLod"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Coordinate to be float scalar or vector: ImageQueryLod"));
}
TEST_F(ValidateImage, QueryLodCoordinateSizeTooSmall) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Coordinate to have at least 2 components, but given only 1: "
- "ImageQueryLod"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected Coordinate to have at least 2 components, "
+ "but given only 1: "
+ "ImageQueryLod"));
}
TEST_F(ValidateImage, QueryLevelsSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Result Type to be int scalar type: ImageQueryLevels"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected Result Type to be int scalar type: ImageQueryLevels"));
}
TEST_F(ValidateImage, QueryLevelsNotImage) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected Image to be of type OpTypeImage: ImageQueryLevels"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected Image to be of type OpTypeImage: ImageQueryLevels"));
}
TEST_F(ValidateImage, QueryLevelsWrongDim) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image 'Dim' must be 1D, 2D, 3D or Cube: ImageQueryLevels"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Image 'Dim' must be 1D, 2D, 3D or Cube: ImageQueryLevels"));
}
TEST_F(ValidateImage, QuerySamplesSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image 'Dim' must be 2D: ImageQuerySamples"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image 'Dim' must be 2D: ImageQuerySamples"));
}
TEST_F(ValidateImage, QuerySamplesNotMultisampled) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Image 'MS' must be 1: ImageQuerySamples"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Image 'MS' must be 1: ImageQuerySamples"));
}
TEST_F(ValidateImage, QueryLodWrongExecutionModel) {
CompileSuccessfully(GenerateShaderCode(body, "", "Vertex").c_str());
ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "OpImageQueryLod requires Fragment execution model"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("OpImageQueryLod requires Fragment execution model"));
}
TEST_F(ValidateImage, QueryLodWrongExecutionModelWithFunc) {
CompileSuccessfully(GenerateShaderCode(body, "", "Vertex").c_str());
ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "OpImageQueryLod requires Fragment execution model"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("OpImageQueryLod requires Fragment execution model"));
}
TEST_F(ValidateImage, ImplicitLodWrongExecutionModel) {
CompileSuccessfully(GenerateShaderCode(body, "", "Vertex").c_str());
ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "ImplicitLod instructions require Fragment execution model"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("ImplicitLod instructions require Fragment execution model"));
}
} // anonymous namespace
CASE(DrefExplicitLod, "%float %img %coord %dref Lod %lod"),
}), );
#undef CASE
-}
+} // namespace
using std::ostream;
using std::ostream_iterator;
using std::pair;
-using std::stringstream;
using std::string;
+using std::stringstream;
using std::tie;
using std::tuple;
using std::vector;
+using libspirv::spvResultToString;
using ::testing::Eq;
using ::testing::HasSubstr;
using ::testing::StrEq;
-using libspirv::spvResultToString;
using pred_type = function<spv_result_t(int)>;
using ValidateLayout =
)";
CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1);
- ASSERT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0));
+ ASSERT_EQ(SPV_ERROR_INVALID_BINARY,
+ ValidateInstructions(SPV_ENV_UNIVERSAL_1_0));
// In a 1.0 environment the binary parse fails before we even get to
// validation. This occurs no matter where the OpModuleProcessed is placed.
EXPECT_THAT(getDiagnosticString(), HasSubstr("Invalid opcode: 330"));
)";
CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1);
- ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1));
+ ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT,
+ ValidateInstructions(SPV_ENV_UNIVERSAL_1_1));
// By the mechanics of the validator, we assume ModuleProcessed is in the
// right spot, but then that OpName is in the wrong spot.
EXPECT_THAT(getDiagnosticString(),
)";
CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1);
- ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1));
- EXPECT_THAT(getDiagnosticString(),
- HasSubstr("ModuleProcessed cannot appear in a function declaration"));
+ ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT,
+ ValidateInstructions(SPV_ENV_UNIVERSAL_1_1));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("ModuleProcessed cannot appear in a function declaration"));
}
TEST_F(ValidateLayout, ModuleProcessedInvalidInFunctionBeforeLabel) {
)";
CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1);
- ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1));
- EXPECT_THAT(getDiagnosticString(),
- HasSubstr("ModuleProcessed cannot appear in a function declaration"));
+ ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT,
+ ValidateInstructions(SPV_ENV_UNIVERSAL_1_1));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("ModuleProcessed cannot appear in a function declaration"));
}
TEST_F(ValidateLayout, ModuleProcessedInvalidInBasicBlock) {
)";
CompileSuccessfully(str, SPV_ENV_UNIVERSAL_1_1);
- ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT, ValidateInstructions(SPV_ENV_UNIVERSAL_1_1));
- EXPECT_THAT(getDiagnosticString(),
- HasSubstr("ModuleProcessed cannot appear in a function declaration"));
+ ASSERT_EQ(SPV_ERROR_INVALID_LAYOUT,
+ ValidateInstructions(SPV_ENV_UNIVERSAL_1_1));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("ModuleProcessed cannot appear in a function declaration"));
}
-
// TODO(umar): Test optional instructions
-}
+} // namespace
namespace {
+using std::string;
using ::testing::HasSubstr;
using ::testing::MatchesRegex;
-using std::string;
using ValidateLimits = spvtest::ValidateBase<bool>;
for (int i = 0; i < num_args; ++i) {
spirv << " %1";
}
- spvValidatorOptionsSetUniversalLimit(options_,
- spv_validator_limit_max_function_args, 100u);
+ spvValidatorOptionsSetUniversalLimit(
+ options_, spv_validator_limit_max_function_args, 100u);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
for (int i = 0; i < num_args; ++i) {
spirv << " %1";
}
- spvValidatorOptionsSetUniversalLimit(options_,
- spv_validator_limit_max_function_args, 100u);
+ spvValidatorOptionsSetUniversalLimit(
+ options_, spv_validator_limit_max_function_args, 100u);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
%int = OpTypeInt 32 0
%s_depth_1 = OpTypeStruct %int
)";
- for(auto i=2; i<=255; ++i) {
- spirv << "%s_depth_" << i << " = OpTypeStruct %int %s_depth_" << i-1;
+ for (auto i = 2; i <= 255; ++i) {
+ spirv << "%s_depth_" << i << " = OpTypeStruct %int %s_depth_" << i - 1;
spirv << "\n";
}
CompileSuccessfully(spirv.str());
%int = OpTypeInt 32 0
%s_depth_1 = OpTypeStruct %int
)";
- for(auto i=2; i<=256; ++i) {
- spirv << "%s_depth_" << i << " = OpTypeStruct %int %s_depth_" << i-1;
+ for (auto i = 2; i <= 256; ++i) {
+ spirv << "%s_depth_" << i << " = OpTypeStruct %int %s_depth_" << i - 1;
spirv << "\n";
}
CompileSuccessfully(spirv.str());
const std::string& body,
const std::string& capabilities_and_extensions = "") {
const std::string capabilities =
-R"(
+ R"(
OpCapability Shader
OpCapability Int64
OpCapability Float64)";
const std::string after_extension_before_body =
-R"(
+ R"(
%ext_inst = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
%main_entry = OpLabel)";
const std::string after_body =
-R"(
+ R"(
OpReturn
OpFunctionEnd)";
return capabilities + capabilities_and_extensions +
- after_extension_before_body + body + after_body;
+ after_extension_before_body + body + after_body;
}
std::string GenerateKernelCode(
const std::string& body,
const std::string& capabilities_and_extensions = "") {
const std::string capabilities =
-R"(
+ R"(
OpCapability Addresses
OpCapability Kernel
OpCapability Linkage
OpCapability Float64)";
const std::string after_extension_before_body =
-R"(
+ R"(
OpMemoryModel Physical32 OpenCL
%void = OpTypeVoid
%func = OpTypeFunction %void
%main_entry = OpLabel)";
const std::string after_body =
-R"(
+ R"(
OpReturn
OpFunctionEnd)";
return capabilities + capabilities_and_extensions +
- after_extension_before_body + body + after_body;
+ after_extension_before_body + body + after_body;
}
TEST_F(ValidateLogicals, OpAnySuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected bool scalar type as Result Type: Any"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected bool scalar type as Result Type: Any"));
}
TEST_F(ValidateLogicals, OpAnyWrongOperand) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operand to be vector bool: Any"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected operand to be vector bool: Any"));
}
TEST_F(ValidateLogicals, OpIsNanSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected bool scalar or vector type as Result Type: IsNan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected bool scalar or vector type as Result Type: IsNan"));
}
TEST_F(ValidateLogicals, OpIsNanOperandNotFloat) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operand to be scalar or vector float: IsNan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operand to be scalar or vector float: IsNan"));
}
TEST_F(ValidateLogicals, OpIsNanOperandWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected vector sizes of Result Type and the operand to be equal: "
- "IsNan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected vector sizes of Result Type and the operand to be equal: "
+ "IsNan"));
}
TEST_F(ValidateLogicals, OpLessOrGreaterSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected bool scalar or vector type as Result Type: LessOrGreater"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected bool scalar or vector type as Result Type: LessOrGreater"));
}
TEST_F(ValidateLogicals, OpLessOrGreaterLeftOperandNotFloat) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to be scalar or vector float: LessOrGreater"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected operands to be scalar or vector float: LessOrGreater"));
}
TEST_F(ValidateLogicals, OpLessOrGreaterLeftOperandWrongSize) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected vector sizes of Result Type and the operands to be equal: "
- "LessOrGreater"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected vector sizes of Result Type and the operands to be equal: "
+ "LessOrGreater"));
}
TEST_F(ValidateLogicals, OpLessOrGreaterOperandsDifferentType) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected left and right operands to have the same type: "
- "LessOrGreater"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected left and right operands to have the same type: "
+ "LessOrGreater"));
}
TEST_F(ValidateLogicals, OpFOrdEqualSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected bool scalar or vector type as Result Type: FOrdEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected bool scalar or vector type as Result Type: FOrdEqual"));
}
TEST_F(ValidateLogicals, OpFOrdEqualLeftOperandNotFloat) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to be scalar or vector float: FOrdEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to be scalar or vector float: FOrdEqual"));
}
TEST_F(ValidateLogicals, OpFOrdEqualLeftOperandWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected vector sizes of Result Type and the operands to be equal: "
- "FOrdEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected vector sizes of Result Type and the operands to be equal: "
+ "FOrdEqual"));
}
TEST_F(ValidateLogicals, OpFOrdEqualOperandsDifferentType) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected left and right operands to have the same type: "
- "FOrdEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected left and right operands to have the same type: "
+ "FOrdEqual"));
}
TEST_F(ValidateLogicals, OpLogicalEqualSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected bool scalar or vector type as Result Type: LogicalEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected bool scalar or vector type as Result Type: LogicalEqual"));
}
TEST_F(ValidateLogicals, OpLogicalEqualWrongLeftOperand) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both operands to be of Result Type: LogicalEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected both operands to be of Result Type: LogicalEqual"));
}
TEST_F(ValidateLogicals, OpLogicalEqualWrongRightOperand) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both operands to be of Result Type: LogicalEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected both operands to be of Result Type: LogicalEqual"));
}
TEST_F(ValidateLogicals, OpLogicalNotSuccess) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected bool scalar or vector type as Result Type: LogicalNot"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected bool scalar or vector type as Result Type: LogicalNot"));
}
TEST_F(ValidateLogicals, OpLogicalNotWrongOperand) {
CompileSuccessfully(GenerateKernelCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operand to be of Result Type: LogicalNot"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected operand to be of Result Type: LogicalNot"));
}
TEST_F(ValidateLogicals, OpSelectSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected scalar or vector type as Result Type: Select"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected scalar or vector type as Result Type: Select"));
}
TEST_F(ValidateLogicals, OpSelectPointerNoCapability) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Using pointers with OpSelect requires capability VariablePointers "
- "or VariablePointersStorageBuffer"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Using pointers with OpSelect requires capability VariablePointers "
+ "or VariablePointersStorageBuffer"));
}
TEST_F(ValidateLogicals, OpSelectPointerWithCapability1) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected bool scalar or vector type as condition: Select"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected bool scalar or vector type as condition: Select"));
}
TEST_F(ValidateLogicals, OpSelectWrongConditionDimension) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected vector sizes of Result Type and the condition to be equal: "
- "Select"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected vector sizes of Result Type and the condition to be equal: "
+ "Select"));
}
TEST_F(ValidateLogicals, OpSelectWrongLeftObject) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both objects to be of Result Type: Select"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected both objects to be of Result Type: Select"));
}
TEST_F(ValidateLogicals, OpSelectWrongRightObject) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both objects to be of Result Type: Select"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected both objects to be of Result Type: Select"));
}
TEST_F(ValidateLogicals, OpIEqualSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected bool scalar or vector type as Result Type: IEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected bool scalar or vector type as Result Type: IEqual"));
}
TEST_F(ValidateLogicals, OpIEqualLeftOperandNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to be scalar or vector int: IEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to be scalar or vector int: IEqual"));
}
TEST_F(ValidateLogicals, OpIEqualLeftOperandWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected vector sizes of Result Type and the operands to be equal: "
- "IEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected vector sizes of Result Type and the operands to be equal: "
+ "IEqual"));
}
TEST_F(ValidateLogicals, OpIEqualRightOperandNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to be scalar or vector int: IEqual"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to be scalar or vector int: IEqual"));
}
TEST_F(ValidateLogicals, OpIEqualDifferentBitWidth) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both operands to have the same component bit width: IEqual"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected both operands to have the same component bit "
+ "width: IEqual"));
}
TEST_F(ValidateLogicals, OpUGreaterThanSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected bool scalar or vector type as Result Type: UGreaterThan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected bool scalar or vector type as Result Type: UGreaterThan"));
}
TEST_F(ValidateLogicals, OpUGreaterThanLeftOperandNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to be scalar or vector int: UGreaterThan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to be scalar or vector int: UGreaterThan"));
}
TEST_F(ValidateLogicals, OpUGreaterThanLeftOperandWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected vector sizes of Result Type and the operands to be equal: "
- "UGreaterThan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected vector sizes of Result Type and the operands to be equal: "
+ "UGreaterThan"));
}
TEST_F(ValidateLogicals, OpUGreaterThanRightOperandNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to be scalar or vector int: UGreaterThan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to be scalar or vector int: UGreaterThan"));
}
TEST_F(ValidateLogicals, OpUGreaterThanDifferentBitWidth) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both operands to have the same component bit width: "
- "UGreaterThan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected both operands to have the same component bit width: "
+ "UGreaterThan"));
}
TEST_F(ValidateLogicals, OpSGreaterThanSuccess) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected bool scalar or vector type as Result Type: SGreaterThan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected bool scalar or vector type as Result Type: SGreaterThan"));
}
TEST_F(ValidateLogicals, OpSGreaterThanLeftOperandNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to be scalar or vector int: SGreaterThan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to be scalar or vector int: SGreaterThan"));
}
TEST_F(ValidateLogicals, OpSGreaterThanLeftOperandWrongSize) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected vector sizes of Result Type and the operands to be equal: "
- "SGreaterThan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr(
+ "Expected vector sizes of Result Type and the operands to be equal: "
+ "SGreaterThan"));
}
TEST_F(ValidateLogicals, OpSGreaterThanRightOperandNotInt) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected operands to be scalar or vector int: SGreaterThan"));
+ EXPECT_THAT(
+ getDiagnosticString(),
+ HasSubstr("Expected operands to be scalar or vector int: SGreaterThan"));
}
TEST_F(ValidateLogicals, OpSGreaterThanDifferentBitWidth) {
CompileSuccessfully(GenerateShaderCode(body).c_str());
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
- EXPECT_THAT(getDiagnosticString(), HasSubstr(
- "Expected both operands to have the same component bit width: SGreaterThan"));
+ EXPECT_THAT(getDiagnosticString(),
+ HasSubstr("Expected both operands to have the same component bit "
+ "width: SGreaterThan"));
}
} // anonymous namespace
using ::testing::HasSubstr;
using ::testing::MatchesRegex;
-using std::string;
using std::pair;
+using std::string;
using std::stringstream;
namespace {
spvContextDestroy(context_);
spvValidatorOptionsDestroy(options_);
}
+
protected:
spv_context context_;
spv_validator_options options_;
}
TEST_F(ValidationState_HasAnyOfExtensions, MultiCapMask) {
- const auto set1 = ExtensionSet {
- Extension::kSPV_KHR_multiview,
- Extension::kSPV_KHR_16bit_storage
- };
- const auto set2 = ExtensionSet {
- Extension::kSPV_KHR_shader_draw_parameters,
- Extension::kSPV_NV_stereo_view_rendering,
- Extension::kSPV_KHR_shader_ballot
- };
+ const auto set1 = ExtensionSet{Extension::kSPV_KHR_multiview,
+ Extension::kSPV_KHR_16bit_storage};
+ const auto set2 = ExtensionSet{Extension::kSPV_KHR_shader_draw_parameters,
+ Extension::kSPV_NV_stereo_view_rendering,
+ Extension::kSPV_KHR_shader_ballot};
EXPECT_FALSE(state_.HasAnyOfExtensions(set1));
EXPECT_FALSE(state_.HasAnyOfExtensions(set2));
state_.RegisterExtension(Extension::kSPV_KHR_multiview);
EXPECT_TRUE(state_.HasAnyOfExtensions(set1));
EXPECT_FALSE(state_.HasAnyOfExtensions(set2));
}
-
-}
+} // namespace
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpVariable storage class cannot be Generic"));
}
-}
+} // namespace
// Returns expected error string if |opcode| produces a duplicate type
// declaration.
string GetErrorString(SpvOp opcode) {
- return "Duplicate non-aggregate type declarations are not allowed. Opcode: "
- + std::string(spvOpcodeString(opcode));
+ return "Duplicate non-aggregate type declarations are not allowed. Opcode: " +
+ std::string(spvOpcodeString(opcode));
}
TEST_F(ValidateTypeUnique, success) {
projects / platform / upstream / SPIRV-Tools.git / commitdiff