name string | code string | asm string | file string |
|---|---|---|---|
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateDeviceIndexAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateDeviceIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
uint32_t operand = (uint32_t)decoration.builtin();
if (spvIsVulkanEnv(_.context()->target_env)) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x90e9c
movl %eax, %r14d
movq (%r12), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateFragSizeAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateFragSizeAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const spv::BuiltIn builtin = decoration.builtin();... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, %rbx
movq %rcx, 0x28(%rsp)
movq %rdx, %r13
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x8e441
movq 0x10(%rsp), %rdi
call... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateFullyCoveredAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateFullyCoveredAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const spv::BuiltIn builtin = decoration.builti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, %rbx
movq %rcx, 0x28(%rsp)
movq %rdx, %r13
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x8ee01
movq 0x10(%rsp), %rdi
call... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const spv::BuiltIn builtin = decorati... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, %rbx
movq %rcx, 0x28(%rsp)
movq %rdx, %r13
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x8fee4
movq 0x10(%rsp), %rdi
call... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidatePrimitiveShadingRateAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidatePrimitiveShadingRateAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const spv::StorageClass storage_class =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %r8, %rbx
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x9069e
movq %rbx, %rdi
callq 0x8424f
cm... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::ValidationState_t::GetExecutionModels(unsigned int) const | const std::set<spv::ExecutionModel>* GetExecutionModels(
uint32_t entry_point) const {
const auto it = entry_point_to_execution_models_.find(entry_point);
if (it == entry_point_to_execution_models_.end()) {
assert(0);
return nullptr;
}
return &it->second;
} | pushq %rax
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
addq $0x4b0, %rdi # imm = 0x4B0
movq %rax, %rsi
callq 0x91be8
testq %rax, %rax
je 0x91ba2
addq $0x10, %rax
popq %rcx
retq
leaq 0x209844(%rip), %rdi # 0x29b3ed
leaq 0x1c70eb(%rip), %rsi # 0x258c9b
leaq 0x1c715e(%rip), %rcx # 0x258d15
movl $0xff, %edx
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.h |
spvtools::val::CapabilityPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t CapabilityPass(ValidationState_t& _, const Instruction* inst) {
if (inst->opcode() != spv::Op::OpCapability) return SPV_SUCCESS;
assert(inst->operands().size() == 1);
const spv_parsed_operand_t& operand = inst->operand(0);
assert(operand.num_words == 1);
assert(operand.offset < inst->words().s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
xorl %ebx, %ebx
cmpw $0x11, 0x3a(%rsi)
jne 0x9225f
movq %rsi, %r14
movq 0x18(%rsi), %rax
movq 0x20(%rsi), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jne 0x9232d
cmpw $0x1, 0x2(%rax)
jne 0x9234c
movzwl (%rax), %eax
mo... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_capability.cpp |
spvtools::val::(anonymous namespace)::IsEnabledByExtension(spvtools::val::ValidationState_t&, unsigned int) | bool IsEnabledByExtension(ValidationState_t& _, uint32_t capability) {
spv_operand_desc operand_desc = nullptr;
_.grammar().lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, capability,
&operand_desc);
// operand_desc is expected to be not null, otherwise validator would have
// failed at ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %edx
movq %rdi, %rbx
movq %rsp, %r14
andq $0x0, (%r14)
addq $0x438, %rdi # imm = 0x438
pushq $0x21
popq %rsi
movq %r14, %rcx
callq 0xda054
movq (%r14), %rax
testq %rax, %rax
je 0x923f9
movl 0x18(%rax), %esi
movq 0x20(%rax), %rdx
leaq 0x8(%rsp), %r14
movq %r14... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_capability.cpp |
spvtools::val::(anonymous namespace)::IsEnabledByCapabilityOpenCL_2_0(spvtools::val::ValidationState_t&, unsigned int) | bool IsEnabledByCapabilityOpenCL_2_0(ValidationState_t& _,
uint32_t capability) {
if (_.HasCapability(spv::Capability::ImageBasic)) {
switch (spv::Capability(capability)) {
case spv::Capability::ImageReadWrite:
case spv::Capability::LiteralSampler:
case spv::... | pushq %rbx
movl %esi, %ebx
addq $0x170, %rdi # imm = 0x170
pushq $0xd
popq %rsi
callq 0x7b28c
xorb $0x1, %al
cmpl $0x30, %ebx
setae %cl
orb %al, %cl
jne 0x924de
movabsq $0xd80000104000, %rax # imm = 0xD80000104000
movl %ebx, %ecx
shrq %cl, %rax
jmp 0x924e0
xorl %eax, %eax
andb $0x1, %al
popq %rbx
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_capability.cpp |
spvtools::EnumSet<spvtools::Extension>::insert(spvtools::Extension const&) | std::pair<iterator, bool> insert(const T& value) {
const size_t index = FindBucketForValue(value);
const ElementType offset = ComputeBucketOffset(value);
if (index >= buckets_.size() ||
buckets_[index].start != ComputeBucketStart(value)) {
size_ += 1;
InsertBucketFor(index, value);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %esi
movq %r14, %rdi
callq 0x92702
movq %rax, %r15
movl (%r12), %edx
movl %edx, %r12d
andl $0x3f, %r12d
movq (%r14), %rsi
movq 0x8(%r14), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
cmpq %rcx, %rax
jae 0x925ae
s... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::EnumSet<spvtools::Extension>::InsertBucketFor(unsigned long, spvtools::Extension) | void InsertBucketFor(size_t index, T value) {
const T bucket_start = ComputeBucketStart(value);
Bucket bucket = {1ULL << ComputeBucketOffset(value), bucket_start};
auto it = buckets_.emplace(buckets_.begin() + index, std::move(bucket));
#if defined(NDEBUG)
(void)it; // Silencing unused variable warning... | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edx, %ecx
movq %rdi, %rbx
pushq $0x1
popq %rax
shlq %cl, %rax
movl %edx, %ebp
andl $-0x40, %ebp
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl %ebp, 0x8(%rdx)
shlq $0x4, %rsi
addq (%rdi), %rsi
callq 0x927d6
movq %rax, %rcx
addq $0x10, %rcx
cmpq 0x8(%rbx), %rcx
je 0x92787
cmpl %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::val::FirstBlockAssert(spvtools::val::ValidationState_t&, unsigned int) | spv_result_t FirstBlockAssert(ValidationState_t& _, uint32_t target) {
if (_.current_function().IsFirstBlock(target)) {
return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(_.current_function().id()))
<< "First block " << _.getIdName(target) << " of function "
<< _.getIdName(_.current_function().i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd1224
movq %rax, %rdi
movl %ebp, %esi
callq 0xccb7a
xorl %r13d, %r13d
testb %al, %al
je 0x92af8
movq %rbx, %rdi
callq 0xd1224
movl (%rax), %esi
movq %rbx, %rdi
callq 0xd0e... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::MergeBlockAssert(spvtools::val::ValidationState_t&, unsigned int) | spv_result_t MergeBlockAssert(ValidationState_t& _, uint32_t merge_block) {
if (_.current_function().IsBlockType(merge_block, kBlockTypeMerge)) {
return _.diag(SPV_ERROR_INVALID_CFG, _.FindDef(_.current_function().id()))
<< "Block " << _.getIdName(merge_block)
<< " is already a merge block f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp # imm = 0x200
movl %esi, %ebx
movq %rdi, %r14
callq 0xd1224
pushq $0x3
popq %rdx
movq %rax, %rdi
movl %ebx, %esi
callq 0xcd5b0
xorl %ebp, %ebp
testb %al, %al
je 0x92bb3
movq %r14, %rdi
callq 0xd1224
movl (%rax), %esi
movq %r14, %rdi
cal... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::UpdateContinueConstructExitBlocks(spvtools::val::Function&, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>> const&) | void UpdateContinueConstructExitBlocks(
Function& function,
const std::vector<std::pair<uint32_t, uint32_t>>& back_edges) {
auto& constructs = function.constructs();
// TODO(umar): Think of a faster way to do this
for (auto& edge : back_edges) {
uint32_t back_edge_block_id;
uint32_t loop_header_bl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, 0x20(%rsp)
callq 0xcd596
movq %rax, %rbp
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x30(%rsp), %r15
leaq 0x28(%rsp), %r12
cmpq 0x10(%rsp), %rax
je 0x92c90
movl (%rax), %ecx
movl %ecx, 0x... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::ConstructErrorString(spvtools::val::Construct const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>... | std::string ConstructErrorString(const Construct& construct,
const std::string& header_string,
const std::string& exit_string,
const std::string& dominate_text) {
std::string construct_name, header_name, exit_name;
st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %r8, %r12
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, 0x8(%rsp)
xorl %ecx, %ecx
leaq 0x48(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::FindCaseFallThrough(spvtools::val::ValidationState_t&, spvtools::val::BasicBlock*, unsigned int*, spvtools::val::BasicBlock const*, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>> const&, spvtools::val::Function*) | spv_result_t FindCaseFallThrough(
ValidationState_t& _, BasicBlock* target_block, uint32_t* case_fall_through,
const BasicBlock* merge, const std::unordered_set<uint32_t>& case_targets,
Function* function) {
std::vector<BasicBlock*> stack;
stack.push_back(target_block);
std::unordered_set<const BasicB... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %r9, %r14
movq %r8, 0x38(%rsp)
movq %rcx, %r13
movq %rdx, 0x18(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x10(%rsp), %rbx
movq %rsi, (%rbx)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rbp
movaps %xmm0, (%rbp)
andq $0x0, 0x... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::StructuredSwitchChecks(spvtools::val::ValidationState_t&, spvtools::val::Function*, spvtools::val::Instruction const*, spvtools::val::BasicBlock const*, spvtools::val::BasicBlock const*) | spv_result_t StructuredSwitchChecks(ValidationState_t& _, Function* function,
const Instruction* switch_inst,
const BasicBlock* header,
const BasicBlock* merge) {
std::unordered_set<uint32_t> case_targets;
fo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %r8, %r12
movq %rcx, 0x20(%rsp)
movq %rdx, %r15
movq %rsi, 0x30(%rsp)
movq %rdi, 0x18(%rsp)
leaq 0xf8(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
m... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::ValidateStructuredSelections(spvtools::val::ValidationState_t&, std::vector<spvtools::val::BasicBlock const*, std::allocator<spvtools::val::BasicBlock const*>> const&) | spv_result_t ValidateStructuredSelections(
ValidationState_t& _, const std::vector<const BasicBlock*>& postorder) {
std::unordered_set<uint32_t> seen;
for (auto iter = postorder.rbegin(); iter != postorder.rend(); ++iter) {
const auto* block = *iter;
const auto* terminator = block->terminator();
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdi, 0x8(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
mov... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::MaximalReconvergenceChecks(spvtools::val::ValidationState_t&) | spv_result_t StructuredSwitchChecks(ValidationState_t& _, Function* function,
const Instruction* switch_inst,
const BasicBlock* header,
const BasicBlock* merge) {
std::unordered_set<uint32_t> case_targets;
fo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
leaq 0x90(%rsp), %rax
movq %rax, -0x30(%rax)
pushq $0x1
popq %rcx
movq %rcx, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, %edx # imm = 0x3F800000
movl %edx, -0x10(%rax)
movups... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::CfgPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t CfgPass(ValidationState_t& _, const Instruction* inst) {
spv::Op opcode = inst->opcode();
switch (opcode) {
case spv::Op::OpLabel:
if (auto error = _.current_function().RegisterBlock(inst->id()))
return error;
// TODO(github:1661) This should be done in the
// ValidationS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rdi, %rbx
movzwl 0x3a(%rsi), %r15d
leal -0xf6(%r15), %eax
cmpl $0x9, %eax
ja 0x957c3
movq %rsi, %r14
leaq 0x1c3b63(%rip), %rcx # 0x2592d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::CFA<spvtools::val::BasicBlock>::DepthFirstTraversal(spvtools::val::BasicBlock const*, std::function<std::vector<spvtools::val::BasicBlock*, std::allocator<spvtools::val::BasicBlock*>> const* (spvtools::val::BasicBlock const*)>, std::function<void (spvtools::val::BasicBlock const*)>, std::function<void (spvtoo... | void CFA<BB>::DepthFirstTraversal(const BB* entry,
get_blocks_func successor_func,
std::function<void(cbb_ptr)> preorder,
std::function<void(cbb_ptr)> postorder,
std::function<bool(cbb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %rdi
callq 0x9857c
leaq 0x68(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x985b0
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x985b0
xorps %x... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/cfa.h |
spvtools::CFA<spvtools::val::BasicBlock>::CalculateDominators(std::vector<spvtools::val::BasicBlock const*, std::allocator<spvtools::val::BasicBlock const*>> const&, std::function<std::vector<spvtools::val::BasicBlock*, std::allocator<spvtools::val::BasicBlock*>> const* (spvtools::val::BasicBlock const*)>) | std::vector<std::pair<BB*, BB*>> CFA<BB>::CalculateDominators(
const std::vector<cbb_ptr>& postorder, get_blocks_func predecessor_func) {
struct block_detail {
size_t dominator; ///< The index of blocks's dominator in post order array
size_t postorder_index; ///< The index of the block in the post order... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r13
movq (%rsi), %rsi
movq 0x8(%r14), %rax
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x3, %rcx
movq %rcx, (%rsp)
leaq 0x70(%rsp), %rcx
movq %rcx, -0x30(%rcx)
movq $0x1, -0x28(%rcx)
xorps %xmm... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/cfa.h |
spv::LoopControlShift spvtools::val::Instruction::GetOperandAs<spv::LoopControlShift>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0x97a9c
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0x97ab5
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x1bb58d(%rip), %rdi # 0x253030
leaq 0x1bb5a3(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
spvtools::val::(anonymous namespace)::IsTypeNullable(std::vector<unsigned int, std::allocator<unsigned int>> const&, spvtools::val::ValidationState_t const&) | bool IsTypeNullable(const std::vector<uint32_t>& instruction,
const ValidationState_t& _) {
uint16_t opcode;
uint16_t word_count;
spvOpcodeSplit(instruction[0], &word_count, &opcode);
switch (static_cast<spv::Op>(opcode)) {
case spv::Op::OpTypeBool:
case spv::Op::OpTypeInt:
case ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl (%rax), %edi
leaq 0x4(%rsp), %rsi
leaq 0x6(%rsp), %r15
movq %r15, %rdx
callq 0xe194d
movzwl (%r15), %eax
leal -0x14(%rax), %ecx
cmpl $0x11, %ecx
ja 0x9c510
movb $0x1, %bpl
leaq 0x1bf379(%rip), %rax # 0x25b84... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_constants.cpp |
spvtools::EnumSet<spvtools::Extension>::contains(spvtools::Extension) const | bool contains(T value) const {
const size_t index = FindBucketForValue(value);
if (index >= buckets_.size() ||
buckets_[index].start != ComputeBucketStart(value)) {
return false;
}
auto& bucket = buckets_[index];
return bucket.data & ComputeMaskForValue(value);
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x92702
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rdx, %rax
jae 0x9dbbd
shlq $0x4, %rax
movl %ebx, %edx
andl $-0x40, %edx
cmpl %edx, 0x8(%rcx,%rax)
jne 0x9dbbd
addq %rax, %rcx
movq (%rcx), %rax
btq %rbx, %rax
setb ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::val::DebugPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t DebugPass(ValidationState_t& _, const Instruction* inst) {
switch (inst->opcode()) {
case spv::Op::OpMemberName:
if (auto error = ValidateMemberName(_, inst)) return error;
break;
case spv::Op::OpLine:
if (auto error = ValidateLine(_, inst)) return error;
break;
defaul... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x3a(%rsi), %eax
cmpl $0x8, %eax
je 0x9dce2
cmpl $0x6, %eax
jne 0x9ddbf
movq %r14, %rdi
xorl %esi, %esi
callq 0x7a018
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0xd0e80
tes... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_debug.cpp |
spvtools::val::(anonymous namespace)::hasImportLinkageAttribute(unsigned int, spvtools::val::ValidationState_t&) | bool hasImportLinkageAttribute(uint32_t id, ValidationState_t& vstate) {
const auto& decorations = vstate.id_decorations(id);
return std::any_of(
decorations.begin(), decorations.end(), [](const Decoration& d) {
return spv::Decoration::LinkageAttributes == d.dec_type() &&
d.params().siz... | pushq %rbx
movl %edi, %eax
movq %rsi, %rdi
movl %eax, %esi
callq 0x7d860
movq %rax, %rbx
movq 0x18(%rax), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
je 0xa1881
cmpl $0x29, 0x20(%rax)
jne 0xa1877
movq 0x30(%rax), %rcx
movq %rcx, %rdx
subq 0x28(%rax), %rdx
cmpq $0x5, %rdx
jb 0xa1877
cmpl $0x1, -0x4(%rcx)
je 0xa1881
movq %rax, ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_decorations.cpp |
spvtools::val::(anonymous namespace)::getStructMembers(unsigned int, spv::Op, spvtools::val::ValidationState_t&) | std::vector<uint32_t> getStructMembers(uint32_t struct_id, spv::Op type,
ValidationState_t& vstate) {
std::vector<uint32_t> members;
for (auto id : getStructMembers(struct_id, vstate)) {
if (type == vstate.FindDef(id)->opcode()) {
members.push_back(id);
}
}
r... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xa19b5
movq (%r15), %r12
movq 0x8(%r15), %r13
leaq 0x4(%rsp), %r15
cmpq %r13, %r12
je 0xa199a
movl (%r12), %es... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_decorations.cpp |
spvtools::val::(anonymous namespace)::ComputeMemberConstraintsForStruct(std::unordered_map<std::pair<unsigned int, unsigned int>, spvtools::val::(anonymous namespace)::LayoutConstraints, spvtools::val::(anonymous namespace)::PairHash, std::equal_to<std::pair<unsigned int, unsigned int>>, std::allocator<std::pair<std::p... | void ComputeMemberConstraintsForStruct(MemberConstraints* constraints,
uint32_t struct_id,
const LayoutConstraints& inherited,
ValidationState_t& vstate) {
assert(constraints);
const auto& members = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, (%rsp)
testq %rdi, %rdi
je 0xa1b52
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r15
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rdx
callq 0xa19b5
movq 0x8(%r12), %rax
subq (%r12), %rax
shrq $0x2, %rax
movl %ebp, %ecx
movq... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_decorations.cpp |
spvtools::val::(anonymous namespace)::isMissingOffsetInStruct(unsigned int, spvtools::val::ValidationState_t&) | bool isMissingOffsetInStruct(uint32_t struct_id, ValidationState_t& vstate) {
const auto* inst = vstate.FindDef(struct_id);
std::vector<bool> hasOffset;
std::vector<uint32_t> struct_members;
if (inst->opcode() == spv::Op::OpTypeStruct) {
// Check offsets of member decorations.
struct_members = getStruct... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, %rdi
movl %ebp, %esi
callq 0xd0e80
andq $0x0, 0x20(%rsp)
andl $0x0, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
andl $0x0, 0x38(%rsp)
movq %rax, %r14
andq $0x0, 0x40(%rsp)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rsp)
mov... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_decorations.cpp |
spvtools::val::(anonymous namespace)::checkForRequiredDecoration(unsigned int, std::function<bool (spv::Decoration)>, spv::Op, spvtools::val::ValidationState_t&) | bool checkForRequiredDecoration(uint32_t struct_id,
std::function<bool(spv::Decoration)> checker,
spv::Op type, ValidationState_t& vstate) {
const auto& members = getStructMembers(struct_id, vstate);
for (size_t memberIdx = 0; memberIdx < members.size(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movl %edx, %r12d
movq %rsi, %r14
movl %edi, %esi
leaq 0x18(%rsp), %rdi
movl %esi, 0x10(%rsp)
movq %rcx, %rdx
callq 0xa19b5
xorl %ebp, %ebp
pushq $0x1
popq %r13
movl %r12d, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_decorations.cpp |
spvtools::val::(anonymous namespace)::checkLayout(unsigned int, char const*, char const*, bool, bool, unsigned int, std::unordered_map<std::pair<unsigned int, unsigned int>, spvtools::val::(anonymous namespace)::LayoutConstraints, spvtools::val::(anonymous namespace)::PairHash, std::equal_to<std::pair<unsigned int, uns... | spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str,
const char* decoration_str, bool blockRules,
bool scalar_block_layout,
uint32_t incoming_offset,
MemberConstraints& constraints,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movl %r9d, 0x30(%rsp)
movq %rdx, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x308(%rsp), %r13
movl %edi, 0x40(%rsp)
movq 0x8(%r13), %rsi
xorl %eax, %eax
cmpb $0x0, 0x2a(%rsi)
jne 0xa28ff
movl %r8d, %r15d
movl %edi, %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_decorations.cpp |
spvtools::val::(anonymous namespace)::ComputeMemberConstraintsForArray(std::unordered_map<std::pair<unsigned int, unsigned int>, spvtools::val::(anonymous namespace)::LayoutConstraints, spvtools::val::(anonymous namespace)::PairHash, std::equal_to<std::pair<unsigned int, unsigned int>>, std::allocator<std::pair<std::pa... | void ComputeMemberConstraintsForArray(MemberConstraints* constraints,
uint32_t array_id,
const LayoutConstraints& inherited,
ValidationState_t& vstate) {
assert(constraints);
auto elem_type_id = vstate.... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd0e80
movq (%rax), %rax
movl 0x8(%rax), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd0e80
movzwl 0x3a(%rax), %eax
leal -0x1c(%rax), %ecx
cmpl $0x2, %ecx
jb 0xa2... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_decorations.cpp |
spvtools::val::(anonymous namespace)::getScalarAlignment(unsigned int, spvtools::val::ValidationState_t&) | uint32_t getScalarAlignment(uint32_t type_id, ValidationState_t& vstate) {
const auto inst = vstate.FindDef(type_id);
const auto& words = inst->words();
switch (inst->opcode()) {
case spv::Op::OpTypeSampledImage:
case spv::Op::OpTypeSampler:
case spv::Op::OpTypeImage:
if (vstate.HasCapability(sp... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1b9752(%rip), %r14 # 0x25c6b0
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd0e80
movzwl 0x3a(%rax), %edx
leal -0x15(%rdx), %ecx
cmpl $0xb, %ecx
ja 0xa2fb5
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
movq (%rax), ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_decorations.cpp |
spvtools::val::(anonymous namespace)::getBaseAlignment(unsigned int, bool, spvtools::val::(anonymous namespace)::LayoutConstraints const&, std::unordered_map<std::pair<unsigned int, unsigned int>, spvtools::val::(anonymous namespace)::LayoutConstraints, spvtools::val::(anonymous namespace)::PairHash, std::equal_to<std:... | uint32_t getBaseAlignment(uint32_t member_id, bool roundUp,
const LayoutConstraints& inherited,
MemberConstraints& constraints,
ValidationState_t& vstate) {
const auto inst = vstate.FindDef(member_id);
const auto& words = inst->words();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movl %esi, 0x4(%rsp)
movl %edi, %ebp
pushq $0x1
popq %r13
leaq 0x1b965b(%rip), %rbx # 0x25c6e0
pushq $0x4
popq %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0xd0e80
movzwl 0x3a(%rax), %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_decorations.cpp |
spvtools::val::(anonymous namespace)::getSize(unsigned int, spvtools::val::(anonymous namespace)::LayoutConstraints const&, std::unordered_map<std::pair<unsigned int, unsigned int>, spvtools::val::(anonymous namespace)::LayoutConstraints, spvtools::val::(anonymous namespace)::PairHash, std::equal_to<std::pair<unsigned ... | uint32_t getSize(uint32_t member_id, const LayoutConstraints& inherited,
MemberConstraints& constraints, ValidationState_t& vstate) {
const auto inst = vstate.FindDef(member_id);
const auto& words = inst->words();
switch (inst->opcode()) {
case spv::Op::OpTypeSampledImage:
case spv::Op::O... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movl %edi, %ebp
pushq $0x1
popq %r14
leaq 0x1b9433(%rip), %r12 # 0x25c710
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd0e80
movq %rax, %r13
movzwl 0x3a(%rax), %ecx
leal -0x15(%rcx), %ea... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_decorations.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> spvtools::utils::MakeString<__gnu_cxx::__normal_iterator<unsigned int const*, std::vector<unsigned int, std::allocator<unsigned int>>>>(__gnu_cxx::__normal_iterator<unsigned int const*, std::vector<unsigned int, std::allocator<unsigned int>>... | inline std::string MakeString(InputIt first, InputIt last,
bool assert_found_terminating_null = true) {
std::string result;
constexpr size_t kCharsPerWord = sizeof(*first);
static_assert(kCharsPerWord == 4, "expect 4-byte word");
for (InputIt pos = first; pos != last; ++pos) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq %r14, %r15
je 0xa49a2
movl (%r15), %r13d
xorl %r12d, %r12d
cmpq $0x20, %r12
je 0xa499c
movl... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/string_utils.h |
spvtools::val::ValidationState_t::id_member_decorations(unsigned int, unsigned int) | FieldDecorationsIter id_member_decorations(uint32_t id,
uint32_t member_index) {
const auto& decorations = id_decorations_[id];
// The decorations are sorted by member_index, so this look up will give the
// exact range of decorations for this member index.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %edx, %ebp
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0x3d8, %rdi # imm = 0x3D8
movq %rax, %rsi
callq 0x7dade
movq %rax, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
leaq 0x40(%rsp), %rb... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.h |
spvtools::val::ValidateExtInstImport(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateExtInstImport(ValidationState_t& _,
const Instruction* inst) {
const auto name_id = 1;
if (_.version() <= SPV_SPIRV_VERSION_WORD(1, 5) &&
!_.HasExtension(kSPV_KHR_non_semantic_info)) {
const std::string name = inst->GetOperandAs<std::string>(name_id)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp # imm = 0x200
cmpl $0x10500, 0x24(%rdi) # imm = 0x10500
ja 0xa5fc0
movq %rsi, %rbx
movq %rdi, %r14
addq $0x190, %rdi # imm = 0x190
pushq $0x5d
popq %rsi
callq 0x9db7e
testb %al, %al
jne 0xa5fc0
leaq 0x8(%rsp), %r15
pushq $... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::(anonymous namespace)::ValidateDebugInfoOperand(spvtools::val::ValidationState_t&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, CommonDebugInfoInstructions, spvtools::val::Instruction const*, unsigned int, std::function<std::__cxx11::basic_string<char, std::char_... | spv_result_t ValidateDebugInfoOperand(
ValidationState_t& _, const std::string& debug_inst_name,
CommonDebugInfoInstructions expected_debug_inst, const Instruction* inst,
uint32_t word_index, const std::function<std::string()>& ext_inst_name) {
std::function<bool(CommonDebugInfoInstructions)> expectation ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %r9, %r14
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r13
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movl %edx, (%rsi)
leaq 0x1799(%rip), %rax # 0xb0bdc
movq %rax, 0... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::(anonymous namespace)::ValidateUint32ConstantOperandForDebugInfo(spvtools::val::ValidationState_t&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spvtools::val::Instruction const*, unsigned int, std::function<std::__cxx11::basic_string<char, std::char_traits<char>... | spv_result_t ValidateUint32ConstantOperandForDebugInfo(
ValidationState_t& _, const std::string& operand_name,
const Instruction* inst, uint32_t word_index,
const std::function<std::string()>& ext_inst_name) {
if (!IsUint32Constant(_, inst->word(word_index))) {
return _.diag(SPV_ERROR_INVALID_DATA, in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %r8, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movl %ecx, %eax
movq (%rdx), %rcx
movl (%rcx,%rax,4), %esi
callq 0xafa60
xorl %ebp, %ebp
testb %al, %al
jne 0xaf6a8
leaq 0x20(%rsp), %r14
pushq $-0x... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::(anonymous namespace)::ValidateOperandDebugType(spvtools::val::ValidationState_t&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spvtools::val::Instruction const*, unsigned int, std::function<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<... | spv_result_t ValidateOperandDebugType(
ValidationState_t& _, const std::string& debug_inst_name,
const Instruction* inst, uint32_t word_index,
const std::function<std::string()>& ext_inst_name,
bool allow_template_param) {
// Check for NonSemanticShaderDebugInfo100 specific types.
if (inst->ext_inst... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movb %r9b, 0xf(%rsp)
cmpl $0xa, 0x3c(%rdx)
jne 0xaf916
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
leaq 0x1381(%rip), %rax # 0x... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::(anonymous namespace)::ValidateOperandLexicalScope(spvtools::val::ValidationState_t&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spvtools::val::Instruction const*, unsigned int, std::function<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocat... | spv_result_t ValidateOperandLexicalScope(
ValidationState_t& _, const std::string& debug_inst_name,
const Instruction* inst, uint32_t word_index,
const std::function<std::string()>& ext_inst_name) {
std::function<bool(CommonDebugInfoInstructions)> expectation =
[](CommonDebugInfoInstructions dbg_ins... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %r8, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x119b(%rip), %rax # 0xb0c60
movq %rax, 0x18(%rsi)
leaq 0x11a2(%rip), %rax # ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::(anonymous namespace)::ValidateClspvReflectionInstruction(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int) | spv_result_t ValidateClspvReflectionInstruction(ValidationState_t& _,
const Instruction* inst,
uint32_t version) {
if (!_.IsVoidType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Return T... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl 0x40(%rsi), %esi
callq 0xd34c8
testb %al, %al
je 0xafd1b
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xb1064
decl %eax
xorl %r13d, %r13d
cmpl $0x27, %eax
ja 0... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::(anonymous namespace)::ReflectionInstructionName[abi:cxx11](spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | std::string ReflectionInstructionName(ValidationState_t& _,
const Instruction* inst) {
spv_ext_inst_desc desc = nullptr;
if (_.grammar().lookupExtInst(SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION,
inst->word(4), &desc) != SPV_SUCCESS ||
!d... | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
leaq 0x8(%rsp), %rcx
andq $0x0, (%rcx)
movq %rdi, %rbx
leaq 0x438(%rsi), %rdi
movq (%rdx), %rax
movl 0x10(%rax), %edx
pushq $0x9
popq %rsi
callq 0xda2b4
testl %eax, %eax
jne 0xb0cee
cmpq $0x0, 0x8(%rsp)
je 0xb0cee
leaq 0x10(%rsp), %r14
movq %r14, %rdi
cal... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::(anonymous namespace)::ValidateKernelDecl(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateKernelDecl(ValidationState_t& _, const Instruction* inst) {
const auto decl_id = inst->GetOperandAs<uint32_t>(4);
const auto decl = _.FindDef(decl_id);
if (!decl || !spvIsExtendedInstruction(decl->opcode())) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Kernel must be a Kerne... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x7a018
movq %r14, %rdi
movl %eax, %esi
callq 0xd0e80
testq %rax, %rax
je 0xb0d81
movq %rax, %r15
movzwl 0x3a(%rax), %edi
callq 0xe1f68
testb %al, ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::(anonymous namespace)::ValidateArgInfo(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int) | spv_result_t ValidateArgInfo(ValidationState_t& _, const Instruction* inst,
uint32_t info_index) {
auto info = _.FindDef(inst->GetOperandAs<uint32_t>(info_index));
if (!info || !spvIsExtendedInstruction(info->opcode())) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "ArgI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
movq %rbx, %rdi
callq 0x7a018
movq %r14, %rdi
movl %eax, %esi
callq 0xd0e80
testq %rax, %rax
je 0xb0e56
movq %rax, %r15
movzwl 0x3a(%rax), %edi
callq 0xe1f68
testb %al, %al
j... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::ValidateExecutionLimitations(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateExecutionLimitations(ValidationState_t& _,
const Instruction* inst) {
if (inst->opcode() != spv::Op::OpFunction) {
return SPV_SUCCESS;
}
const auto func = _.function(inst->id());
if (!func) {
return _.diag(SPV_ERROR_INTERNAL, inst)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
cmpw $0x36, 0x3a(%rsi)
jne 0xb13b3
movq %rsi, %r15
movq %rdi, %r14
movl 0x44(%rsi), %esi
callq 0xd12c2
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0xb13bd
movl 0x44(%r15), %esi
movq %r14, %rdi
callq 0xd4664
movq (... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_execution_limitations.cpp |
spvtools::val::FunctionPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t FunctionPass(ValidationState_t& _, const Instruction* inst) {
switch (inst->opcode()) {
case spv::Op::OpFunction:
if (auto error = ValidateFunction(_, inst)) return error;
break;
case spv::Op::OpFunctionParameter:
if (auto error = ValidateFunctionParameter(_, inst)) return error... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x3a(%rsi), %eax
cmpl $0x39, %eax
je 0xb15e0
cmpl $0x37, %eax
je 0xb157e
cmpl $0x36, %eax
jne 0xb1d73
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x7a018
movl %eax, %ebp
mov... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_function.cpp |
spvtools::val::UpdateIdUse(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t UpdateIdUse(ValidationState_t& _, const Instruction* inst) {
for (auto& operand : inst->operands()) {
const spv_operand_type_t& type = operand.type;
const uint32_t operand_id = inst->word(operand.offset);
if (spvIsIdType(type) && type != SPV_OPERAND_TYPE_RESULT_ID) {
if (auto def = _.Fi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
movq 0x20(%rsi), %r12
cmpq %r12, %r15
je 0xb2425
movzwl (%r15), %eax
movq (%rbx), %rcx
movl (%rcx,%rax,4), %ebp
movl 0x4(%r15), %edi
callq 0xe22f3
testb %al, %al
je 0xb241f
cmpl $0x3, 0x4(%r15)
je 0xb241f
movq %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_id.cpp |
spvtools::val::CheckIdDefinitionDominateUse(spvtools::val::ValidationState_t&) | spv_result_t CheckIdDefinitionDominateUse(ValidationState_t& _) {
std::vector<const Instruction*> phi_instructions;
std::unordered_set<uint32_t> phi_ids;
for (const auto& inst : _.ordered_instructions()) {
if (inst.id() == 0) continue;
if (const Function* func = inst.function()) {
if (const BasicBlo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0xb8(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_id.cpp |
spvtools::val::IdPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction*) | spv_result_t IdPass(ValidationState_t& _, Instruction* inst) {
auto can_have_forward_declared_ids =
spvIsExtendedInstruction(inst->opcode()) &&
spvExtInstIsDebugInfo(inst->ext_inst_type())
? spvDbgInfoExtOperandCanBeForwardDeclaredFunction(
inst->opcode(), inst->ext_inst_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x3a(%rsi), %edi
callq 0xe1f68
testb %al, %al
je 0xb2888
movl 0x3c(%r14), %edi
callq 0xe059b
testb %al, %al
je 0xb2888
movzwl 0x3a(%r14), %esi
movl 0x3c(%r14), %edx
movq (%... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_id.cpp |
spvtools::val::ImagePass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ImagePass(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
if (IsImplicitLod(opcode)) {
_.function(inst->function()->id())
->RegisterExecutionModelLimitation([opcode](spv::ExecutionModel model,
std::s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x3a(%rsi), %r15d
movl %r15d, %edi
callq 0xb60bb
testb %al, %al
je 0xb312a
movq 0x60(%rbx), %rax
movl (%rax), %esi
movq %r14, %rdi
callq 0xd12c2
xorps %xmm0, %xmm0
leaq 0x2... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::IsImageInstruction(spv::Op) | bool IsImageInstruction(const spv::Op opcode) {
switch (opcode) {
case spv::Op::OpImageSampleImplicitLod:
case spv::Op::OpImageSampleDrefImplicitLod:
case spv::Op::OpImageSampleProjImplicitLod:
case spv::Op::OpImageSampleProjDrefImplicitLod:
case spv::Op::OpImageSparseSampleImplicitLod:
case s... | movb $0x1, %al
leal -0x57(%rdi), %ecx
cmpl $0x15, %ecx
jb 0xb6102
leal -0x131(%rdi), %ecx
cmpl $0xf, %ecx
ja 0xb6103
movl $0x87ff, %edx # imm = 0x87FF
btl %ecx, %edx
jae 0xb6103
retq
addl $0xffffee80, %edi # imm = 0xFFFFEE80
cmpl $0x17, %edi
ja 0xb6118
movl $0xf0000f, %ecx # imm = 0xF0000F
btl %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::GetImageTypeInfo(spvtools::val::ValidationState_t const&, unsigned int, spvtools::val::(anonymous namespace)::ImageTypeInfo*) | bool GetImageTypeInfo(const ValidationState_t& _, uint32_t id,
ImageTypeInfo* info) {
if (!id || !info) return false;
const Instruction* inst = _.FindDef(id);
assert(inst);
if (inst->opcode() == spv::Op::OpTypeSampledImage) {
inst = _.FindDef(inst->word(2));
assert(inst);
}
... | pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0xb62b6
movq %rdx, %rbx
movq %rdi, %r14
callq 0xd0e5a
testq %rax, %rax
je 0xb62c0
movzwl 0x3a(%rax), %ecx
cmpw $0x1b, %cx
jne 0xb625e
movq (%rax), %rax
movl 0x8(%rax), %esi
movq %r14, %rdi
callq 0xd0e5a
testq %rax, %ra... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::GetPlaneCoordSize(spvtools::val::(anonymous namespace)::ImageTypeInfo const&) | uint32_t GetPlaneCoordSize(const ImageTypeInfo& info) {
uint32_t plane_size = 0;
// If this switch breaks your build, please add new values below.
switch (info.dim) {
case spv::Dim::Dim1D:
case spv::Dim::Buffer:
plane_size = 1;
break;
case spv::Dim::Dim2D:
case spv::Dim::Rect:
case... | movl 0x4(%rdi), %eax
cmpl $0x6, %eax
ja 0xb6316
pushq $0x52
popq %rcx
btl %eax, %ecx
jb 0xb631d
pushq $0xc
popq %rcx
btl %eax, %ecx
jae 0xb6312
pushq $0x3
jmp 0xb631f
pushq $0x1
jmp 0xb631f
cmpl $0x104d, %eax # imm = 0x104D
jne 0xb6321
pushq $0x2
popq %rax
retq
pushq %rax
leaq 0x1e50c4(%rip), %rdi # 0x29b3... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::GetActualResultType(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int*) | spv_result_t GetActualResultType(ValidationState_t& _, const Instruction* inst,
uint32_t* actual_result_type) {
const spv::Op opcode = inst->opcode();
if (IsSparse(opcode)) {
const Instruction* const type_inst = _.FindDef(inst->type_id());
assert(type_inst);
if (!type_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdx, %r15
movq %rsi, %rbx
movzwl 0x3a(%rsi), %eax
addl $0xfffffecf, %eax # imm = 0xFFFFFECF
cmpl $0xf, %eax
ja 0xb641d
movl $0x8fff, %ecx # imm = 0x8FFF
btl %eax, %ecx
jae 0xb641d
movq %rdi, %r14
movl 0x40(%rbx)... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::IsProj(spv::Op) | bool IsProj(spv::Op opcode) {
switch (opcode) {
case spv::Op::OpImageSampleProjImplicitLod:
case spv::Op::OpImageSampleProjDrefImplicitLod:
case spv::Op::OpImageSparseSampleProjImplicitLod:
case spv::Op::OpImageSparseSampleProjDrefImplicitLod:
case spv::Op::OpImageSampleProjExplicitLod:
case s... | movb $0x1, %al
leal -0x5b(%rdi), %ecx
cmpl $0x4, %ecx
jb 0xb645b
addl $0xfffffecb, %edi # imm = 0xFFFFFECB
cmpl $0x4, %edi
jae 0xb645c
retq
xorl %eax, %eax
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::GetMinCoordSize(spv::Op, spvtools::val::(anonymous namespace)::ImageTypeInfo const&) | uint32_t GetMinCoordSize(spv::Op opcode, const ImageTypeInfo& info) {
if (info.dim == spv::Dim::Cube &&
(opcode == spv::Op::OpImageRead || opcode == spv::Op::OpImageWrite ||
opcode == spv::Op::OpImageSparseRead)) {
// These opcodes use UV for Cube, not direction vector.
return 3;
}
return Ge... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
cmpl $0x3, 0x4(%rsi)
jne 0xb6515
pushq $0x3
popq %rax
leal -0x62(%rbx), %ecx
cmpl $0x2, %ecx
jb 0xb652f
cmpl $0x140, %ebx # imm = 0x140
je 0xb652f
movq %r14, %rdi
callq 0xb62f6
movl %eax, %ebp
addl 0xc(%r14), %ebp
movl %ebx, %edi
callq 0xb6446
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::ValidateImageOperands(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, spvtools::val::(anonymous namespace)::ImageTypeInfo const&, unsigned int) | spv_result_t ValidateImageOperands(ValidationState_t& _,
const Instruction* inst,
const ImageTypeInfo& info,
uint32_t word_index) {
static const bool kAllImageOperandsHandled = CheckAllImageOperandsHandled();
(v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movl %ecx, %r12d
movq %rsi, %rbx
movq %rdi, %rsi
movb 0x3358bc(%rip), %al # 0x3ebe10
testb %al, %al
je 0xb7374
movzwl 0x3a(%rbx), %r13d
movq (%rbx), %rax
movq 0x8(%rbx), %rbp
subq %rax, %rbp
sarq $0x2, %rbp
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::IsExplicitLod(spv::Op) | bool IsExplicitLod(spv::Op opcode) {
switch (opcode) {
case spv::Op::OpImageSampleExplicitLod:
case spv::Op::OpImageSampleDrefExplicitLod:
case spv::Op::OpImageSampleProjExplicitLod:
case spv::Op::OpImageSampleProjDrefExplicitLod:
case spv::Op::OpImageSparseSampleExplicitLod:
case spv::Op::OpI... | movb $0x1, %al
leal -0x58(%rdi), %edx
pushq $0x55
popq %rcx
cmpl $0x6, %edx
jbe 0xb740e
addl $0xfffffece, %edi # imm = 0xFFFFFECE
cmpl $0x6, %edi
ja 0xb7415
btl %edi, %ecx
jae 0xb7415
retq
btl %edx, %ecx
jb 0xb740d
jmp 0xb73fd
xorl %eax, %eax
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::ValidateImageReadWrite(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, spvtools::val::(anonymous namespace)::ImageTypeInfo const&) | spv_result_t ValidateImageReadWrite(ValidationState_t& _,
const Instruction* inst,
const ImageTypeInfo& info) {
if (info.sampled == 2) {
if (info.dim == spv::Dim::Dim1D &&
!_.HasCapability(spv::Capability::Image1D)) {
return _.d... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movl 0x14(%rdx), %ebp
testl %ebp, %ebp
je 0xb764f
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2, %ebp
jne 0xb761d
movq %rdx, %r15
movl 0x4(%rdx), %eax
testl %eax, %eax
jne 0xb755e
leaq 0x170(%r14), %rdi
pushq $0x2c
popq %rsi
callq 0x7b28... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::ValidateImageProcessingQCOMDecoration(spvtools::val::ValidationState_t&, int, spv::Decoration) | spv_result_t ValidateImageProcessingQCOMDecoration(ValidationState_t& _, int id,
spv::Decoration decor) {
const Instruction* si_inst = nullptr;
const Instruction* ld_inst = _.FindDef(id);
bool is_intf_obj = (ld_inst->opcode() == spv::Op::OpSampledImage);
if (is... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp # imm = 0x200
movl %edx, %ebp
movq %rdi, %rbx
callq 0xd0e80
movq %rax, %r14
movzwl 0x3a(%rax), %eax
cmpw $0x56, %ax
jne 0xb7873
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0xb7ce0
movq %rbx, %rdi
movl %eax, %esi
callq 0xd0e80
movq %rax, ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_image.cpp |
int spvtools::val::Instruction::GetOperandAs<int>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0xb7d0a
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0xb7d23
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x19b31f(%rip), %rdi # 0x253030
leaq 0x19b335(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
unsigned long spvtools::utils::CountSetBits<unsigned int>(unsigned int) | size_t CountSetBits(T word) {
static_assert(std::is_integral<T>::value,
"CountSetBits requires integer type");
uint32_t count = 0;
while (word) {
word &= word - 1;
++count;
}
return count;
} | xorl %eax, %eax
testl %edi, %edi
je 0xb7d70
leal -0x1(%rdi), %ecx
andl %edi, %ecx
incl %eax
movl %ecx, %edi
jmp 0xb7d61
movl %eax, %eax
retq
nop
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/bitutils.h |
spvtools::val::(anonymous namespace)::NumConsumedLocations(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int*) | spv_result_t NumConsumedLocations(ValidationState_t& _, const Instruction* type,
uint32_t* num_locations) {
*num_locations = 0;
switch (type->opcode()) {
case spv::Op::OpTypeInt:
case spv::Op::OpTypeFloat:
// Scalars always consume a single location.
*num_locati... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rsi, %r14
andl $0x0, (%rdx)
movq %rdi, %r15
movzwl 0x3a(%rsi), %eax
addl $-0x15, %eax
cmpl $0xb, %eax
ja 0xb94e8
movq %rdx, %rbx
leaq 0x1abcb9(%rip), %rcx # 0x2650fc
movslq (%rcx,%rax,4), %rax
addq %rcx... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_interfaces.cpp |
spvtools::val::(anonymous namespace)::NumConsumedComponents(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | uint32_t NumConsumedComponents(ValidationState_t& _, const Instruction* type) {
uint32_t num_components = 0;
switch (type->opcode()) {
case spv::Op::OpTypeInt:
case spv::Op::OpTypeFloat:
// 64-bit types consume two components.
if (type->GetOperandAs<uint32_t>(1) == 64) {
num_components =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1abaa8(%rip), %r12 # 0x26512c
pushq $0x1
popq %r15
movzwl 0x3a(%rbx), %eax
addl $-0x15, %eax
cmpl $0xb, %eax
ja 0xb9736
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7a018
mov... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_interfaces.cpp |
spvtools::val::InstructionPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t InstructionPass(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
if (opcode == spv::Op::OpExtension) {
CheckIfKnownExtension(_, inst);
} else if (opcode == spv::Op::OpCapability) {
_.RegisterCapability(inst->GetOperandAs<spv::Capability>(0));
} else if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x3a(%rsi), %eax
leal -0xa(%rax), %ecx
cmpl $0x7, %ecx
ja 0xb9afa
leaq 0x1aba96(%rip), %rax # 0x26551c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x30(%r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_instruction.cpp |
spvtools::val::(anonymous namespace)::ToString[abi:cxx11](spvtools::EnumSet<spv::Capability> const&, spvtools::AssemblyGrammar const&) | std::string ToString(const CapabilitySet& capabilities,
const AssemblyGrammar& grammar) {
std::stringstream ss;
for (auto capability : capabilities) {
spv_operand_desc desc;
if (SPV_SUCCESS == grammar.lookupOperand(SPV_OPERAND_TYPE_CAPABILITY,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x29410
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xbb35a
movq 0x8(%r15), %rbx
subq (%r15), %rbx
sarq $0x4, %rbx... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_instruction.cpp |
spvtools::val::(anonymous namespace)::CheckRequiredCapabilities(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned long, spv_parsed_operand_t const&, unsigned int) | spv_result_t CheckRequiredCapabilities(ValidationState_t& state,
const Instruction* inst,
size_t which_operand,
const spv_parsed_operand_t& operand,
uint32_t word) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movl %r8d, %ebx
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl 0x4(%rcx), %eax
cmpl $0x18, %eax
je 0xba6a5
cmpl $0x1e, %eax
je 0xba68e
cmpl $0x1d, %eax
jne 0xba6b0
cmpl $0x4, %ebx
ja 0xba6b0
pushq $0x1a
po... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_instruction.cpp |
spv::Capability spvtools::val::Instruction::GetOperandAs<spv::Capability>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0xbac4a
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0xbac63
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x1983df(%rip), %rdi # 0x253030
leaq 0x1983f5(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
spv::AddressingModel spvtools::val::Instruction::GetOperandAs<spv::AddressingModel>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0xbacaa
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0xbacc3
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x19837f(%rip), %rdi # 0x253030
leaq 0x198395(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
spv::MemoryModel spvtools::val::Instruction::GetOperandAs<spv::MemoryModel>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0xbad0a
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0xbad23
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x19831f(%rip), %rdi # 0x253030
leaq 0x198335(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
spvtools::EnumSet<spv::Capability>::Iterator::operator*() const | T operator*() const {
assert(set_->HasEnumAt(bucketIndex_, bucketOffset_) &&
"operator*() called on an invalid iterator.");
return GetValueFromBucket(set_->buckets_[bucketIndex_], bucketOffset_);
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movl 0x10(%rbx), %edx
callq 0xbb390
testb %al, %al
je 0xbb2ec
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq (%rax), %rax
shlq $0x4, %rcx
movl 0x8(%rax,%rcx), %eax
addl 0x10(%rbx), %eax
popq %rbx
retq
leaq 0x1aa4ed(%rip), %rdi # 0x2657e0
leaq 0x19de82(%r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::EnumSet<spv::Capability>::Iterator::operator++() | Iterator& operator++() {
do {
if (bucketIndex_ >= set_->buckets_.size()) {
bucketIndex_ = set_->buckets_.size();
bucketOffset_ = 0;
break;
}
if (bucketOffset_ + 1 == kBucketSize) {
bucketOffset_ = 0;
++bucketIndex_;
} else {
... | pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x4, %rax
cmpq %rax, %rsi
jae 0xbb34d
movl 0x10(%rbx), %ecx
incl %ecx
cmpl $0x40, %ecx
jne 0xbb338
incq %rsi
movq %rsi, 0x8(%rbx)
xorl %ecx, %ecx
movl %ecx, 0x10(%rbx)
cmpq %rax, %rsi
jae 0xbb355
movl %ecx, %e... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::EnumSet<spv::Capability>::cbegin() const | iterator cbegin() const noexcept {
auto it = iterator(this, /* bucketIndex= */ 0, /* bucketOffset= */ 0);
if (buckets_.size() == 0) {
return it;
}
// The iterator has the logic to find the next valid bit. If the value 0
// is not stored, use it to find the next valid bit.
if (!HasEnumAt(i... | pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
andq $0x0, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0xbb38b
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xbb390
testb %al, %al
jne 0xbb38b
movq %rbx, %rdi
callq 0xbb30a
movq %rbx, %rax
popq %rbx
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::EnumSet<spv::Capability>::HasEnumAt(unsigned long, unsigned long) const | bool HasEnumAt(size_t bucketIndex, BucketType bucketOffset) const {
assert(bucketIndex < buckets_.size());
assert(bucketOffset < kBucketSize);
return buckets_[bucketIndex].data & (1ULL << bucketOffset);
} | pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rsi, %rcx
jbe 0xbb3bb
cmpq $0x40, %rdx
jae 0xbb3da
shlq $0x4, %rsi
movq (%rax,%rsi), %rax
btq %rdx, %rax
setb %al
popq %rcx
retq
leaq 0x1aa382(%rip), %rdi # 0x265744
leaq 0x19ddb3(%rip), %rsi # 0x25917c
leaq 0x1aa392(%rip), %r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::EnumSet<spv::Capability>::insert(spv::Capability const&) | std::pair<iterator, bool> insert(const T& value) {
const size_t index = FindBucketForValue(value);
const ElementType offset = ComputeBucketOffset(value);
if (index >= buckets_.size() ||
buckets_[index].start != ComputeBucketStart(value)) {
size_ += 1;
InsertBucketFor(index, value);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %esi
movq %r14, %rdi
callq 0x7b2d6
movq %rax, %r15
movl (%r12), %edx
movl %edx, %r12d
andl $0x3f, %r12d
movq (%r14), %rsi
movq 0x8(%r14), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
cmpq %rcx, %rax
jae 0xbb45e
s... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::EnumSet<spv::Capability>::InsertBucketFor(unsigned long, spv::Capability) | void InsertBucketFor(size_t index, T value) {
const T bucket_start = ComputeBucketStart(value);
Bucket bucket = {1ULL << ComputeBucketOffset(value), bucket_start};
auto it = buckets_.emplace(buckets_.begin() + index, std::move(bucket));
#if defined(NDEBUG)
(void)it; // Silencing unused variable warning... | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edx, %ecx
movq %rdi, %rbx
pushq $0x1
popq %rax
shlq %cl, %rax
movl %edx, %ebp
andl $-0x40, %ebp
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl %ebp, 0x8(%rdx)
shlq $0x4, %rsi
addq (%rdi), %rsi
callq 0xbb548
movq %rax, %rcx
addq $0x10, %rcx
cmpq 0x8(%rbx), %rcx
je 0xbb4f9
cmpl %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::val::ModuleLayoutPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ModuleLayoutPass(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
switch (_.current_layout_section()) {
case kLayoutCapabilities:
case kLayoutExtensions:
case kLayoutExtInstImport:
case kLayoutMemoryModel:
case kLayoutSamplerImageAddressMode:
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x3a(%rsi), %ebp
callq 0xd0ea6
cmpl $0xc, %eax
jae 0xbb9ab
cmpl $0x1151, %ebp # imm = 0x1151
je 0xbb91e
cmpl $0xc, %ebp
jne 0xbba3e
movl 0x3c(%rbx), %edi
callq 0xe059b
testb %al, %al
j... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_layout.cpp |
spvtools::val::(anonymous namespace)::FunctionScopedInstructions(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, spv::Op) | spv_result_t FunctionScopedInstructions(ValidationState_t& _,
const Instruction* inst,
spv::Op opcode) {
// Make sure we advance into the function definitions when we hit
// non-function declaration instructions.
if (_.current_layout_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd0ea6
cmpl $0xc, %eax
jne 0xbbc3b
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd0fe0
testb %al, %al
jne 0xbbc3b
movq %rbx, %rdi
callq 0xd0eae
movq %rbx, %rdi
callq 0xd125c... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_layout.cpp |
spv::FunctionControlMask spvtools::val::Instruction::GetOperandAs<spv::FunctionControlMask>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0xbc1d2
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0xbc1eb
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x196e57(%rip), %rdi # 0x253030
leaq 0x196e6d(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
spvtools::val::LiteralsPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t LiteralsPass(ValidationState_t& _, const Instruction* inst) {
// For every operand that is a literal number
for (size_t i = 0; i < inst->operands().size(); i++) {
const spv_parsed_operand_t& operand = inst->operand(i);
if (!IsLiteralNumber(operand)) continue;
// The upper bits are always i... | pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %rbx
movq %rdi, %rsi
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
pushq $-0x1
popq %rdi
subq $0x1, %rdx
jb 0xbc299
movl 0x8(%rax), %r8d
leal -0x1(%r8), %ecx
cmpl $0x2, %ecx
ja 0xbc293
movl 0xc(%rax), %ecx
andl $0x... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_literals.cpp |
spvtools::val::(anonymous namespace)::ValidateAccessChain(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateAccessChain(ValidationState_t& _,
const Instruction* inst) {
std::string instr_name =
"Op" + std::string(spvOpcodeString(static_cast<spv::Op>(inst->opcode())));
const bool untyped_pointer = spvOpcodeGeneratesUntypedPointer(inst->opcode());
// The resul... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x3a(%rsi), %edi
callq 0xe1bee
leaq 0x60(%rsp), %r15
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x765ea
leaq 0x1a3366(%rip), %rsi # 0x264257
leaq 0x18(%... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_memory.cpp |
spvtools::val::(anonymous namespace)::ContainsInvalidBool(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, bool) | bool ContainsInvalidBool(ValidationState_t& _, const Instruction* storage,
bool skip_builtin) {
if (skip_builtin) {
for (const Decoration& decoration : _.id_decorations(storage->id())) {
if (decoration.dec_type() == spv::Decoration::BuiltIn) return false;
}
}
const size_t e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x31800000, %r13d # imm = 0x31800000
pushq $0x1
popq %r14
testb %bpl, %bpl
je 0xc168b
movl 0x44(%r15), %esi
movq %rbx, %rdi
callq 0x7d860
movq %rax, %r12
movq 0x18(%rax), %rax
addq $0x... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_memory.cpp |
spvtools::val::(anonymous namespace)::IsAllowedTypeOrArrayOfSame(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, std::initializer_list<spv::Op>) | bool IsAllowedTypeOrArrayOfSame(ValidationState_t& _, const Instruction* type,
std::initializer_list<spv::Op> allowed) {
if (std::find(allowed.begin(), allowed.end(), type->opcode()) !=
allowed.end()) {
return true;
}
if (type->opcode() == spv::Op::OpTypeArray ||
ty... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq (%rdx,%rcx,4), %rbx
movzwl 0x3a(%rsi), %eax
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc204c
movq %rax, %rcx
movb $0x1, %al
cmpq %rbx, %rcx
jne 0xc178d
movzwl 0x3a(%r12), %eax
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_memory.cpp |
spvtools::val::MeshShadingPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t MeshShadingPass(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
switch (opcode) {
case spv::Op::OpEmitMeshTasksEXT: {
_.function(inst->function()->id())
->RegisterExecutionModelLimitation(
[](spv::ExecutionModel model, std::strin... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x3a(%rsi), %eax
cmpl $0x14af, %eax # imm = 0x14AF
je 0xc2adc
cmpl $0x14ae, %eax # imm = 0x14AE
jne 0xc2b8e
movq 0x60(%rbx), %rax
movl (%rax), %esi
movq %r14, %rdi
callq 0xd1... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_mesh_shading.cpp |
spvtools::val::MiscPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t MiscPass(ValidationState_t& _, const Instruction* inst) {
switch (inst->opcode()) {
case spv::Op::OpUndef:
if (auto error = ValidateUndef(_, inst)) return error;
break;
default:
break;
}
switch (inst->opcode()) {
case spv::Op::OpBeginInvocationInterlockEXT:
case spv:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x3a(%rsi), %eax
cmpw $0x1, %ax
jne 0xc2da5
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0xd34c8
testb %al, %al
je 0xc2d6c
leaq 0x48(%rsp), %r15
pushq $-0xa
popq %rdx
movq %r15, %rdi
m... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_misc.cpp |
spvtools::val::ModeSettingPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ModeSettingPass(ValidationState_t& _, const Instruction* inst) {
switch (inst->opcode()) {
case spv::Op::OpEntryPoint:
if (auto error = ValidateEntryPoint(_, inst)) return error;
break;
case spv::Op::OpExecutionMode:
case spv::Op::OpExecutionModeId:
if (auto error = Validate... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x3a(%rsi), %eax
cmpl $0xe, %eax
je 0xc37e4
cmpl $0x14b, %eax # imm = 0x14B
je 0xc36b3
cmpl $0x10, %eax
je 0xc36b3
cmpl $0xf, %eax
jne 0xc4284
pushq $0x1
popq %r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_mode_setting.cpp |
spvtools::val::PrimitivesPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t PrimitivesPass(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
switch (opcode) {
case spv::Op::OpEmitVertex:
case spv::Op::OpEndPrimitive:
case spv::Op::OpEmitStreamVertex:
case spv::Op::OpEndStreamPrimitive:
_.function(inst->function()->id... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rsi, %r14
movq %rdi, %r15
movzwl 0x3a(%rsi), %ebx
leal -0xda(%rbx), %eax
cmpl $0x3, %eax
ja 0xc6048
movq 0x60(%r14), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0xd12c2
movq %rax, %r12
movl %ebx, %edi
cal... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_primitives.cpp |
spvtools::val::RayQueryPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t RayQueryPass(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
const uint32_t result_type = inst->type_id();
switch (opcode) {
case spv::Op::OpRayQueryInitializeKHR: {
if (auto error = ValidateRayQueryPointer(_, inst, 0)) return error;
if (_.Get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x3a(%rsi), %r12d
movl 0x40(%rsi), %ebp
leal -0x1780(%r12), %eax
cmpl $0x10, %eax
ja 0xc61a3
leaq 0x1a53fb(%rip), %rcx # 0x26b548
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_ray_query.cpp |
spvtools::val::(anonymous namespace)::ValidateRayQueryPointer(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int) | spv_result_t ValidateRayQueryPointer(ValidationState_t& _,
const Instruction* inst,
uint32_t ray_query_index) {
const uint32_t ray_query_id = inst->GetOperandAs<uint32_t>(ray_query_index);
auto variable = _.FindDef(ray_query_id);
const auto... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
movq %rbx, %rdi
callq 0x7a018
movq %r14, %rdi
movl %eax, %esi
callq 0xd0e80
movzwl 0x3a(%rax), %ecx
addl $-0x37, %ecx
cmpl $0xa, %ecx
ja 0xc6888
movl $0x411, %edx # imm = 0x4... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_ray_query.cpp |
spvtools::val::(anonymous namespace)::ValidateIntersectionId(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int) | spv_result_t ValidateIntersectionId(ValidationState_t& _,
const Instruction* inst,
uint32_t intersection_index) {
const uint32_t intersection_id =
inst->GetOperandAs<uint32_t>(intersection_index);
const uint32_t intersection_type = _.GetT... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x7a018
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
callq 0xd3300
movl %eax, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0xd3314
movl %eax, %ebp
movq %r14... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_ray_query.cpp |
spvtools::val::RayTracingPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t RayTracingPass(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
const uint32_t result_type = inst->type_id();
switch (opcode) {
case spv::Op::OpTraceRayKHR: {
_.function(inst->function()->id())
->RegisterExecutionModelLimitation(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x240, %rsp # imm = 0x240
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x3a(%rsi), %eax
xorl %ebp, %ebp
cmpl $0x14d6, %eax # imm = 0x14D6
je 0xc6d95
cmpl $0x115e, %eax # imm = 0x115E
je 0xc6c9d
cmpl $0x115d, %eax # imm = 0x1... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_ray_tracing.cpp |
spvtools::val::ValidateHitObjectPointer(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int) | spv_result_t ValidateHitObjectPointer(ValidationState_t& _,
const Instruction* inst,
uint32_t hit_object_index) {
const uint32_t hit_object_id = inst->GetOperandAs<uint32_t>(hit_object_index);
auto variable = _.FindDef(hit_object_id);
con... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
movq %rbx, %rdi
callq 0x7a018
movq %r14, %rdi
movl %eax, %esi
callq 0xd0e80
movzwl 0x3a(%rax), %ecx
addl $-0x37, %ecx
cmpl $0xa, %ecx
ja 0xc7257
movl $0x411, %edx # imm = 0x4... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_ray_tracing_reorder.cpp |
spvtools::val::ValidateHitObjectInstructionCommonParameters(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned... | spv_result_t ValidateHitObjectInstructionCommonParameters(
ValidationState_t& _, const Instruction* inst,
uint32_t acceleration_struct_index, uint32_t instance_id_index,
uint32_t primtive_id_index, uint32_t geometry_index,
uint32_t ray_flags_index, uint32_t cull_mask_index, uint32_t hit_kind_index,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
cmpl $-0x1, %edx
je 0xc72de
movl %edx, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd41f2
movq %r14, %rdi
movl %eax, %esi
callq 0xd3314
cmpl... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_ray_tracing_reorder.cpp |
spvtools::val::IsValidScope(unsigned int) | bool IsValidScope(uint32_t scope) {
// Deliberately avoid a default case so we have to update the list when the
// scopes list changes.
switch (static_cast<spv::Scope>(scope)) {
case spv::Scope::CrossDevice:
case spv::Scope::Device:
case spv::Scope::Workgroup:
case spv::Scope::Subgroup:
case s... | cmpl $0x7, %edi
setb %al
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_scopes.cpp |
spvtools::val::ValidateScope(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int) | spv_result_t ValidateScope(ValidationState_t& _, const Instruction* inst,
uint32_t scope) {
spv::Op opcode = inst->opcode();
bool is_int32 = false, is_const_int32 = false;
uint32_t value = 0;
std::tie(is_int32, is_const_int32, value) = _.EvalInt32IfConst(scope);
if (!is_int32) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp # imm = 0x200
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x3a(%rsi), %r15d
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xd40ec
cmpb $0x0, 0x5(%r12)
je 0xc8abb
cmpb $0x0, 0x2c(%rsp)
je 0xc8b16
xorl %r15d, %r15... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_scopes.cpp |
spvtools::val::ValidateExecutionScope(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int) | spv_result_t ValidateExecutionScope(ValidationState_t& _,
const Instruction* inst, uint32_t scope) {
spv::Op opcode = inst->opcode();
bool is_int32 = false, is_const_int32 = false;
uint32_t tmp_value = 0;
std::tie(is_int32, is_const_int32, tmp_value) = _.EvalInt32IfConst(scop... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movzwl 0x3a(%rsi), %ebx
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xd40ec
movb 0x4(%r12), %r13b
movl (%r12), %r12d
movq %r14, %rdi
movq %r15, %rs... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_scopes.cpp |
spvtools::val::ValidateMemoryScope(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int) | spv_result_t ValidateMemoryScope(ValidationState_t& _, const Instruction* inst,
uint32_t scope) {
const spv::Op opcode = inst->opcode();
bool is_int32 = false, is_const_int32 = false;
uint32_t tmp_value = 0;
std::tie(is_int32, is_const_int32, tmp_value) = _.EvalInt32IfConst(scop... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r13
movzwl 0x3a(%rsi), %r14d
leaq 0x90(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xd40ec
movb 0x4(%r12), %bpl
movl (%r12), %r12d
movq %r13, %rdi
movq %rbx, %r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_scopes.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.