name string | code string | asm string | file string |
|---|---|---|---|
spvtools::val::ValidateSmallTypeUses(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateSmallTypeUses(ValidationState_t& _,
const Instruction* inst) {
if (!_.HasCapability(spv::Capability::Shader) || inst->type_id() == 0 ||
!_.ContainsLimitedUseIntOrFloatType(inst->type_id())) {
return SPV_SUCCESS;
}
if (_.IsPointerType(inst->type_id... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rsi, %r15
movq %rdi, %r14
addq $0x170, %rdi # imm = 0x170
pushq $0x1
popq %rsi
callq 0x7b28c
xorl %ebx, %ebx
testb %al, %al
je 0xc9a4b
movl 0x40(%r15), %esi
testl %esi, %esi
je 0xc9a4b
movq %r14, %rdi
callq 0xd4bb2
testb %al, %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_small_type_uses.cpp |
spvtools::val::TypePass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t TypePass(ValidationState_t& _, const Instruction* inst) {
if (!spvOpcodeGeneratesType(inst->opcode()) &&
inst->opcode() != spv::Op::OpTypeForwardPointer) {
return SPV_SUCCESS;
}
if (auto error = ValidateUniqueness(_, inst)) return error;
switch (inst->opcode()) {
case spv::Op::OpTyp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x3a(%rsi), %edi
callq 0xe1cfe
testl %eax, %eax
jne 0xc9afe
xorl %ebp, %ebp
cmpw $0x27, 0x3a(%r14)
jne 0xcb0c3
leaq 0x190(%rbx), %rdi
movl $0x8a, %esi
callq 0x9db7e
testb %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_type.cpp |
spvtools::val::BasicBlock::RegisterSuccessors(std::vector<spvtools::val::BasicBlock*, std::allocator<spvtools::val::BasicBlock*>> const&) | void BasicBlock::RegisterSuccessors(
const std::vector<BasicBlock*>& next_blocks) {
for (auto& block : next_blocks) {
block->predecessors_.push_back(this);
successors_.push_back(block);
// Register structural successors/predecessors too.
block->structural_predecessors_.push_back(this);
struct... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %rbp
leaq 0x38(%rdi), %r15
leaq 0x88(%rdi), %r12
movq %rsp, %r13
cmpq %rbp, %r14
je 0xcb932
movq (%r14), %rdi
addq $0x20, %rdi
movq %rbx, (%rsp)
movq %r13, %rsi
callq 0xcbfb6
movq %r15, %rdi
mo... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/basic_block.cpp |
spvtools::val::BasicBlock::dominates(spvtools::val::BasicBlock const&) const | bool BasicBlock::dominates(const BasicBlock& other) const {
return (this == &other) ||
!(other.dom_end() ==
std::find(other.dom_begin(), other.dom_end(), this));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
cmpq %rsi, %rdi
je 0xcb9e0
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xcba10
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
andq $0x0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x8(%rsp), %rcx
movq %rbx, (%rcx)
leaq 0x68(%rsp), %r15
movq ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/basic_block.cpp |
spvtools::val::BasicBlock::dom_begin() const | const BasicBlock::DominatorIterator BasicBlock::dom_begin() const {
return DominatorIterator(
this, [](const BasicBlock* b) { return b->immediate_dominator(); });
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x421(%rip), %rax # 0xcbe4c
movq %rax, 0x18(%r14)
leaq 0x41e(%rip), %rax # 0xcbe54
movq %rax, 0x10(%r14)
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %r14, %rsi
callq 0xcbf68
movq 0x10(%r14), %rax
t... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/basic_block.cpp |
spvtools::val::BasicBlock::structurally_dominates(spvtools::val::BasicBlock const&) const | bool BasicBlock::structurally_dominates(const BasicBlock& other) const {
return (this == &other) || !(other.structural_dom_end() ==
std::find(other.structural_dom_begin(),
other.structural_dom_end(), this));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
cmpq %rsi, %rdi
je 0xcbb06
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xcbb2c
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
andq $0x0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x8(%rsp), %rcx
movq %rbx, (%rcx)
leaq 0x68(%rsp), %r15
movq ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/basic_block.cpp |
spvtools::val::BasicBlock::structural_dom_begin() const | const BasicBlock::DominatorIterator BasicBlock::structural_dom_begin() const {
return DominatorIterator(this, [](const BasicBlock* b) {
return b->immediate_structural_dominator();
});
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x339(%rip), %rax # 0xcbe80
movq %rax, 0x18(%r14)
leaq 0x336(%rip), %rax # 0xcbe88
movq %rax, 0x10(%r14)
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %r14, %rsi
callq 0xcbf68
movq 0x10(%r14), %rax
t... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/basic_block.cpp |
spvtools::val::BasicBlock::structurally_postdominates(spvtools::val::BasicBlock const&) const | bool BasicBlock::structurally_postdominates(const BasicBlock& other) const {
return (this == &other) || !(other.structural_pdom_end() ==
std::find(other.structural_pdom_begin(),
other.structural_pdom_end(), this));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
cmpq %rsi, %rdi
je 0xcbc22
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xcbc48
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
andq $0x0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x8(%rsp), %rcx
movq %rbx, (%rcx)
leaq 0x68(%rsp), %r15
movq ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/basic_block.cpp |
spvtools::val::BasicBlock::structural_pdom_begin() const | const BasicBlock::DominatorIterator BasicBlock::structural_pdom_begin() const {
return DominatorIterator(this, [](const BasicBlock* b) {
return b->immediate_structural_post_dominator();
});
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x251(%rip), %rax # 0xcbeb4
movq %rax, 0x18(%r14)
leaq 0x24e(%rip), %rax # 0xcbebc
movq %rax, 0x10(%r14)
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %r14, %rsi
callq 0xcbf68
movq 0x10(%r14), %rax
t... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/basic_block.cpp |
spvtools::val::BasicBlock::dom_begin() | BasicBlock::DominatorIterator BasicBlock::dom_begin() {
return DominatorIterator(
this, [](const BasicBlock* b) { return b->immediate_dominator(); });
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x151(%rip), %rax # 0xcbe66
movq %rax, 0x18(%r14)
leaq 0x14e(%rip), %rax # 0xcbe6e
movq %rax, 0x10(%r14)
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %r14, %rsi
callq 0xcbf68
movq 0x10(%r14), %rax
t... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/basic_block.cpp |
spvtools::val::BasicBlock::structural_dom_begin() | BasicBlock::DominatorIterator BasicBlock::structural_dom_begin() {
return DominatorIterator(this, [](const BasicBlock* b) {
return b->immediate_structural_dominator();
});
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x119(%rip), %rax # 0xcbe9a
movq %rax, 0x18(%r14)
leaq 0x116(%rip), %rax # 0xcbea2
movq %rax, 0x10(%r14)
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %r14, %rsi
callq 0xcbf68
movq 0x10(%r14), %rax
t... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/basic_block.cpp |
spvtools::val::BasicBlock::structural_pdom_begin() | BasicBlock::DominatorIterator BasicBlock::structural_pdom_begin() {
return DominatorIterator(this, [](const BasicBlock* b) {
return b->immediate_structural_post_dominator();
});
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0xe1(%rip), %rax # 0xcbece
movq %rax, 0x18(%r14)
leaq 0xde(%rip), %rax # 0xcbed6
movq %rax, 0x10(%r14)
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %r14, %rsi
callq 0xcbf68
movq 0x10(%r14), %rax
t... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/basic_block.cpp |
spvtools::val::ValidateConstructSize(spvtools::val::ConstructType, unsigned long) | bool ValidateConstructSize(ConstructType type, size_t size) {
switch (type) {
case ConstructType::kSelection:
return size == 0;
case ConstructType::kContinue:
return size == 1;
case ConstructType::kLoop:
return size == 1;
case ConstructType::kCase:
return size >= 1;
default... | decl %edi
cmpl $0x3, %edi
ja 0xcc274
leaq 0x1a1225(%rip), %rax # 0x26d47c
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpq $0x1, %rsi
jmp 0xcc269
testq %rsi, %rsi
sete %al
retq
testq %rsi, %rsi
setne %al
retq
pushq %rax
leaq 0x1a1220(%rip), %rdi # 0x26d49c
leaq 0x1a1236(%rip), %rsi # 0x26d4b9
leaq 0x... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/construct.cpp |
spvtools::val::Construct::blocks(spvtools::val::Function*) const | Construct::ConstructBlockSet Construct::blocks(Function* /*function*/) const {
const auto header = entry_block();
const auto exit = exit_block();
const bool is_continue = type() == ConstructType::kContinue;
const bool is_loop = type() == ConstructType::kLoop;
const BasicBlock* continue_header = nullptr;
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq 0x20(%rsi), %r14
movl (%rsi), %ebp
cmpl $0x3, %ebp
je 0xcc32d
movq $0x0, 0x18(%rsp)
jmp 0xcc33d
movq 0x8(%rsi), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsi), %rax
movq %rax... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/construct.cpp |
spvtools::val::Construct::IsStructuredExit(spvtools::val::ValidationState_t&, spvtools::val::BasicBlock*) const | ConstructType Construct::type() const { return type_; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0xcc639
movq %rdx, %r12
leaq 0x1a0ffd(%rip), %rcx # 0x26d48c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %al
movl %eax, 0xc(%rsp)
cmpq %r12, 0x28(%rdi)
je 0xcc607
mov... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/construct.cpp |
spvtools::val::Function::Function(unsigned int, unsigned int, spv::FunctionControlMask, unsigned int) | Function::Function(uint32_t function_id, uint32_t result_type_id,
spv::FunctionControlMask function_control,
uint32_t function_type_id)
: id_(function_id),
function_type_id_(function_type_id),
result_type_id_(result_type_id),
function_control_(function_control... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, (%rdi)
movl %r8d, 0x4(%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
andl $0x0, 0x10(%rdi)
movb $0x0, 0x14(%rdi)
andq $0x0, 0x38(%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x18(%rdi)
pushq $0x1
popq %r14
movq %r14, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/function.cpp |
spvtools::val::Function::RegisterFunctionParameter(unsigned int, unsigned int) | spv_result_t Function::RegisterFunctionParameter(uint32_t parameter_id,
uint32_t type_id) {
assert(current_block_ == nullptr &&
"RegisterFunctionParameter can only be called when parsing the binary "
"outside of a block");
// TODO(umar): Validate fu... | cmpq $0x0, 0xa0(%rdi)
jne 0xccbaf
xorl %eax, %eax
retq
pushq %rax
leaq 0x1a0aed(%rip), %rdi # 0x26d6a4
leaq 0x1a0b60(%rip), %rsi # 0x26d71e
leaq 0x1a0bcd(%rip), %rcx # 0x26d792
pushq $0x3b
popq %rdx
callq 0x293b0
nop
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/function.cpp |
spvtools::val::Function::RegisterLoopMerge(unsigned int, unsigned int) | spv_result_t Function::RegisterLoopMerge(uint32_t merge_id,
uint32_t continue_id) {
RegisterBlock(merge_id, false);
RegisterBlock(continue_id, false);
BasicBlock& merge_block = blocks_.at(merge_id);
BasicBlock& continue_target_block = blocks_.at(continue_id);
assert(cu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x44(%rsp), %r14
movl %esi, (%r14)
leaq 0x40(%rsp), %r15
movl %edx, (%r15)
xorl %edx, %edx
callq 0xcce64
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xcce64
leaq 0x18(%rbx), %r13
movq %r13, ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/function.cpp |
spvtools::val::Function::RegisterBlock(unsigned int, bool) | spv_result_t Function::RegisterBlock(uint32_t block_id, bool is_definition) {
assert(
declaration_type_ == FunctionDecl::kFunctionDeclDefinition &&
"RegisterBlocks can only be called after declaration_type_ is defined");
std::unordered_map<uint32_t, BasicBlock>::iterator inserted_block;
bool success ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movl %esi, 0xc(%rsp)
cmpl $0x2, 0x10(%rdi)
jne 0xccff7
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
leaq 0xb8(%rsp), %r14
movq %r14, %rdi
callq 0xcb85c
leaq 0x18(%rsp), %r12
movl %r13d,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/function.cpp |
spvtools::val::Function::RegisterSelectionMerge(unsigned int) | spv_result_t Function::RegisterSelectionMerge(uint32_t merge_id) {
RegisterBlock(merge_id, false);
BasicBlock& merge_block = blocks_.at(merge_id);
current_block_->set_type(kBlockTypeSelection);
merge_block.set_type(kBlockTypeMerge);
merge_block_header_[&merge_block] = current_block_;
current_block_->Registe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl %esi, (%r14)
xorl %edx, %edx
callq 0xcce64
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xce6f2
movq %rax, %r14
movq 0xa0(%rbx), %rdi
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0xcde08
pushq $0x3
popq %rsi
m... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/function.cpp |
spvtools::val::Function::RegisterBlockEnd(std::vector<unsigned int, std::allocator<unsigned int>>) | void Function::RegisterBlockEnd(std::vector<uint32_t> next_list) {
assert(
current_block_ &&
"RegisterBlockEnd can only be called when parsing a binary in a block");
std::vector<BasicBlock*> next_blocks;
next_blocks.reserve(next_list.size());
std::unordered_map<uint32_t, BasicBlock>::iterator inser... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
cmpq $0x0, 0xa0(%rdi)
je 0xcd428
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa0(%rdi), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/function.cpp |
spvtools::val::Function::FindConstructForEntryBlock(spvtools::val::BasicBlock const*, spvtools::val::ConstructType) | Construct& Function::FindConstructForEntryBlock(const BasicBlock* entry_block,
ConstructType type) {
auto where =
entry_block_to_construct_.find(std::make_pair(entry_block, type));
assert(where != entry_block_to_construct_.end());
auto construct_ptr = (*where)... | subq $0x18, %rsp
addq $0x2d8, %rdi # imm = 0x2D8
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movl %edx, 0x8(%rax)
movq %rax, %rsi
callq 0xcfdd6
testq %rax, %rax
je 0xcd479
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xcd498
addq $0x18, %rsp
retq
leaq 0x1a0664(%rip), %rdi # 0x26dae4
leaq 0x1a0297(%rip), %rsi #... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/function.cpp |
spvtools::val::Function::IsBlockType(unsigned int, spvtools::val::BlockType) const | bool Function::IsBlockType(uint32_t merge_block_id, BlockType type) const {
bool ret = false;
const BasicBlock* block;
std::tie(block, std::ignore) = GetBlock(merge_block_id);
if (block) {
ret = block->is_type(type);
}
return ret;
} | pushq %rbx
movl %edx, %ebx
callq 0xcd5cc
testq %rax, %rax
je 0xcd5c8
movq %rax, %rdi
movl %ebx, %esi
popq %rbx
jmp 0xcdeb6
xorl %eax, %eax
popq %rbx
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/function.cpp |
spvtools::val::Function::CheckLimitations(spvtools::val::ValidationState_t const&, spvtools::val::Function const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const | bool Function::CheckLimitations(const ValidationState_t& _,
const Function* entry_point,
std::string* reason) const {
bool return_value = true;
std::stringstream ss_reason;
for (const auto& is_compatible : limitations_) {
std::string message;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rcx, %rbp
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x29410
addq $0x3d0, %rbx # imm = 0x3D0
movb $0x1, %al
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %r1... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/function.cpp |
spvtools::val::(anonymous namespace)::InstructionLayoutSection(spvtools::val::ModuleLayoutSection, spv::Op) | ModuleLayoutSection InstructionLayoutSection(
ModuleLayoutSection current_section, spv::Op op) {
// See Section 2.4
if (spvOpcodeGeneratesType(op) || spvOpcodeIsConstant(op))
return kLayoutTypes;
switch (op) {
case spv::Op::OpCapability:
return kLayoutCapabilities;
case spv::Op::OpExtension... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movl %edi, %ebp
movl %esi, %edi
callq 0xe1cfe
pushq $0xb
popq %rbx
testl %eax, %eax
jne 0xd0fd8
movl %r14d, %edi
callq 0xe1c16
testl %eax, %eax
jne 0xd0fd8
leal -0x1(%r14), %eax
cmpl $0x26, %eax
jbe 0xd0f7f
leal -0x47(%r14), %eax
cmpl $0x5, %eax
jb 0xd0f93
leal -0x36(%r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::diag(spv_result_t, spvtools::val::Instruction const*) | DiagnosticStream ValidationState_t::diag(spv_result_t error_code,
const Instruction* inst) {
if (error_code == SPV_WARNING) {
if (num_of_warnings_ == max_num_of_warnings_) {
DiagnosticStream({0, 0, 0}, context_->consumer, "", error_code)
<< "Other warnings ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x3, %edx
jne 0xd10d1
movl 0x6b0(%r14), %eax
movl 0x6b4(%r14), %ecx
cmpl %ecx, %eax
jne 0xd10c0
andq $0x0, 0x70(%rsp)
xorps %xmm0, %xmm0
mova... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::in_block() const | bool ValidationState_t::in_block() const {
return module_functions_.empty() == false &&
module_functions_.back().current_block() != nullptr;
} | movq %rdi, %rax
movq 0x160(%rdi), %rdi
cmpq %rdi, 0x158(%rax)
je 0xd1313
pushq %rax
addq $-0x418, %rdi # imm = 0xFBE8
callq 0xcd586
testq %rax, %rax
setne %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::RegisterExtension(spvtools::Extension) | void ValidationState_t::RegisterExtension(Extension ext) {
if (module_extensions_.contains(ext)) return;
module_extensions_.insert(ext);
switch (ext) {
case kSPV_AMD_gpu_shader_half_float:
case kSPV_AMD_gpu_shader_half_float_fetch:
// SPV_AMD_gpu_shader_half_float enables float16 type.
// ht... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
leaq 0x190(%rdi), %r14
movq %r14, %rdi
callq 0x9db7e
testb %al, %al
jne 0xd14c2
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x9254a
movl (%r15), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0xd14c2
mo... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::set_addressing_model(spv::AddressingModel) | void ValidationState_t::set_addressing_model(spv::AddressingModel am) {
addressing_model_ = am;
switch (am) {
case spv::AddressingModel::Physical32:
pointer_size_and_alignment_ = 4;
break;
default:
// fall through
case spv::AddressingModel::Physical64:
case spv::AddressingModel::Phys... | movl %esi, 0x458(%rdi)
xorl %eax, %eax
cmpl $0x1, %esi
setne %al
leal 0x4(,%rax,4), %eax
movl %eax, 0x460(%rdi)
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::RegisterFunction(unsigned int, unsigned int, spv::FunctionControlMask, unsigned int) | spv_result_t ValidationState_t::RegisterFunction(
uint32_t id, uint32_t ret_type_id,
spv::FunctionControlMask function_control, uint32_t function_type_id) {
assert(in_function_body() == false &&
"RegisterFunction can only be called when parsing the binary outside "
"of another function");
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
cmpb $0x1, 0x468(%rdi)
je 0xd15a6
movq %rdi, %rbx
movb $0x1, 0x468(%rdi)
addq $0x158, %rdi # imm = 0x158
leaq 0x14(%rsp), %r14
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
lea... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::RegisterFunctionEnd() | spv_result_t ValidationState_t::RegisterFunctionEnd() {
assert(in_function_body() == true &&
"RegisterFunctionEnd can only be called when parsing the binary "
"inside of another function");
assert(in_block() == false &&
"RegisterFunctionParameter can only be called when parsing the binary... | pushq %rbx
cmpb $0x0, 0x468(%rdi)
je 0xd15f7
movq %rdi, %rbx
callq 0xd12e8
testb %al, %al
jne 0xd1616
movq %rbx, %rdi
callq 0xd1224
movq %rax, %rdi
callq 0xcd4b8
movb $0x0, 0x468(%rbx)
xorl %eax, %eax
popq %rbx
retq
leaq 0x19d6af(%rip), %rdi # 0x26ecad
leaq 0x19d3cf(%rip), %rsi # 0x26e9d4
leaq 0x19d71e(%rip), %rc... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::AddOrderedInstruction(spv_parsed_instruction_t const*) | Instruction* ValidationState_t::AddOrderedInstruction(
const spv_parsed_instruction_t* inst) {
ordered_instructions_.emplace_back(inst);
ordered_instructions_.back().SetLineNum(ordered_instructions_.size());
return &ordered_instructions_.back();
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
addq $0x1b0, %rdi # imm = 0x1B0
movq %rax, %rsi
callq 0xd5916
movq 0x1b8(%rbx), %rsi
movq %rsi, %rax
subq 0x1b0(%rbx), %rax
leaq -0x88(%rsi), %rcx
movl $0x88, %edi
cqto
idivq %rdi
movq %rax, -0x30(%rsi)
movq %rcx, %rax
addq $0... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::RegisterStorageClassConsumer(spv::StorageClass, spvtools::val::Instruction*) | void ValidationState_t::RegisterStorageClassConsumer(
spv::StorageClass storage_class, Instruction* consumer) {
if (spvIsVulkanEnv(context()->target_env)) {
if (storage_class == spv::StorageClass::Output) {
std::string errorVUID = VkErrorID(4644);
function(consumer->function()->id())
->R... | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdi), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0xd192b
leal -0x14da(%r15), %eax
cmpl $0x5, %eax
jbe 0xd19ed
cmpl $0x151a, %r15d # imm = 0x151A
je 0xd1c07
cmpl $0x4, ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::getSampledImageConsumers(unsigned int) const | std::vector<Instruction*> ValidationState_t::getSampledImageConsumers(
uint32_t sampled_image_id) const {
std::vector<Instruction*> result;
auto iter = sampled_image_consumers_.find(sampled_image_id);
if (iter != sampled_image_consumers_.end()) {
result = iter->second;
}
return result;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %edx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0xa8(%rsi), %rdi
movq %rax, %rsi
callq 0xd6fe6
testq %rax, %rax
je 0xd20e7
addq $0x10, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd5958
movq %rbx, %rax
addq $0x10, %rsp... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::RegisterQCOMImageProcessingTextureConsumer(unsigned int, spvtools::val::Instruction const*, spvtools::val::Instruction const*) | void ValidationState_t::RegisterQCOMImageProcessingTextureConsumer(
uint32_t texture_id, const Instruction* consumer0,
const Instruction* consumer1) {
if (HasDecoration(texture_id, spv::Decoration::WeightTextureQCOM) ||
HasDecoration(texture_id, spv::Decoration::BlockMatchTextureQCOM) ||
HasDecora... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1187, %edx # imm = 0x1187
callq 0x7d602
testb %al, %al
jne 0xd2136
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1188, %edx # imm = 0x1188
callq 0x7d602
testb %al, %al
jne 0xd2136... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::RegisterUniqueTypeDeclaration(spvtools::val::Instruction const*) | bool ValidationState_t::RegisterUniqueTypeDeclaration(const Instruction* inst) {
std::vector<uint32_t> key;
key.push_back(static_cast<uint32_t>(inst->opcode()));
for (size_t index = 0; index < inst->operands().size(); ++index) {
const spv_parsed_operand_t& operand = inst->operand(index);
if (operand.type... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
movzwl 0x3a(%rsi), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x7a212
pushq $0x4
popq %r12
xorl %r13d, %r13d
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::GetComponentType(unsigned int) const | uint32_t ValidationState_t::GetComponentType(uint32_t id) const {
const Instruction* inst = FindDef(id);
assert(inst);
switch (inst->opcode()) {
case spv::Op::OpTypeFloat:
case spv::Op::OpTypeInt:
case spv::Op::OpTypeBool:
return id;
case spv::Op::OpTypeArray:
return inst->word(2);
... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x19b5ca(%rip), %r14 # 0x26e904
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd0e5a
testq %rax, %rax
je 0xd33a9
movzwl 0x3a(%rax), %ecx
leal -0x14(%rcx), %edx
cmpl $0x8, %edx
ja 0xd3366
movslq (%r14,%rdx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
movq (%rax), ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::GetDimension(unsigned int) const | uint32_t ValidationState_t::GetDimension(uint32_t id) const {
const Instruction* inst = FindDef(id);
assert(inst);
switch (inst->opcode()) {
case spv::Op::OpTypeFloat:
case spv::Op::OpTypeInt:
case spv::Op::OpTypeBool:
return 1;
case spv::Op::OpTypeVector:
case spv::Op::OpTypeMatrix:
... | pushq %rbx
movq %rdi, %rbx
movq %rbx, %rdi
callq 0xd0e5a
testq %rax, %rax
je 0xd3434
movzwl 0x3a(%rax), %ecx
leal -0x14(%rcx), %edx
cmpl $0x3, %edx
jb 0xd3423
leal -0x17(%rcx), %edx
cmpl $0x2, %edx
jb 0xd342c
cmpl $0x1168, %ecx # imm = 0x1168
je 0xd3428
cmpl $0x14ee, %ecx # imm = 0x14EE
je 0xd3428
m... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::GetBitWidth(unsigned int) const | uint32_t ValidationState_t::GetBitWidth(uint32_t id) const {
const uint32_t component_type_id = GetComponentType(id);
const Instruction* inst = FindDef(component_type_id);
assert(inst);
if (inst->opcode() == spv::Op::OpTypeFloat ||
inst->opcode() == spv::Op::OpTypeInt)
return inst->word(2);
if (in... | pushq %rbx
movq %rdi, %rbx
callq 0xd332a
movq %rbx, %rdi
movl %eax, %esi
callq 0xd0e5a
testq %rax, %rax
je 0xd348a
movzwl 0x3a(%rax), %ecx
leal -0x15(%rcx), %edx
cmpl $0x2, %edx
jae 0xd3480
movq (%rax), %rax
movl 0x8(%rax), %eax
jmp 0xd3488
cmpl $0x14, %ecx
jne 0xd34a9
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0x19bb90(... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::IsFloatVectorType(unsigned int) const | bool ValidationState_t::IsFloatVectorType(uint32_t id) const {
const Instruction* inst = FindDef(id);
if (!inst) {
return false;
}
if (inst->opcode() == spv::Op::OpTypeVector) {
return IsFloatScalarType(GetComponentType(id));
}
return false;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd0e5a
testq %rax, %rax
je 0xd352f
cmpw $0x17, 0x3a(%rax)
jne 0xd352f
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd332a
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd34e2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::IsFloat16Vector2Or4Type(unsigned int) const | bool ValidationState_t::IsFloat16Vector2Or4Type(uint32_t id) const {
const Instruction* inst = FindDef(id);
assert(inst);
if (inst->opcode() == spv::Op::OpTypeVector) {
uint32_t vectorDim = GetDimension(id);
return IsFloatScalarType(GetComponentType(id)) &&
(vectorDim == 2 || vectorDim == 4) &... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd0e5a
testq %rax, %rax
je 0xd35a6
cmpw $0x17, 0x3a(%rax)
jne 0xd359f
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd33c8
movl %eax, %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd332a
movq %rbx, %rdi
movl %eax, %esi
callq 0xd34e2
testb %al, %al
je 0xd35... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::IsFloatScalarOrVectorType(unsigned int) const | bool ValidationState_t::IsFloatScalarOrVectorType(uint32_t id) const {
const Instruction* inst = FindDef(id);
if (!inst) {
return false;
}
if (inst->opcode() == spv::Op::OpTypeFloat) {
return true;
}
if (inst->opcode() == spv::Op::OpTypeVector) {
return IsFloatScalarType(GetComponentType(id));... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd0e5a
testq %rax, %rax
je 0xd3600
movzwl 0x3a(%rax), %eax
cmpl $0x16, %eax
je 0xd3604
cmpl $0x17, %eax
jne 0xd3600
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd332a
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd34e2
xorl %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::IsIntArrayType(unsigned int) const | bool ValidationState_t::IsIntArrayType(uint32_t id) const {
const Instruction* inst = FindDef(id);
if (!inst) {
return false;
}
if (inst->opcode() == spv::Op::OpTypeArray) {
return IsIntScalarType(GetComponentType(id));
}
return false;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd0e5a
testq %rax, %rax
je 0xd365b
cmpw $0x1c, 0x3a(%rax)
jne 0xd365b
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd332a
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd360e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::IsIntVectorType(unsigned int) const | bool ValidationState_t::IsIntVectorType(uint32_t id) const {
const Instruction* inst = FindDef(id);
if (!inst) {
return false;
}
if (inst->opcode() == spv::Op::OpTypeVector) {
return IsIntScalarType(GetComponentType(id));
}
return false;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd0e5a
testq %rax, %rax
je 0xd3697
cmpw $0x17, 0x3a(%rax)
jne 0xd3697
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd332a
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd360e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::IsIntScalarOrVectorType(unsigned int) const | bool ValidationState_t::IsIntScalarOrVectorType(uint32_t id) const {
const Instruction* inst = FindDef(id);
if (!inst) {
return false;
}
if (inst->opcode() == spv::Op::OpTypeInt) {
return true;
}
if (inst->opcode() == spv::Op::OpTypeVector) {
return IsIntScalarType(GetComponentType(id));
}
... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd0e5a
testq %rax, %rax
je 0xd36da
movzwl 0x3a(%rax), %eax
cmpl $0x15, %eax
je 0xd36de
cmpl $0x17, %eax
jne 0xd36da
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd332a
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd360e
xorl %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::IsUnsignedIntVectorType(unsigned int) const | bool ValidationState_t::IsUnsignedIntVectorType(uint32_t id) const {
const Instruction* inst = FindDef(id);
if (!inst) {
return false;
}
if (inst->opcode() == spv::Op::OpTypeVector) {
return IsUnsignedIntScalarType(GetComponentType(id));
}
return false;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd0e5a
testq %rax, %rax
je 0xd373d
cmpw $0x17, 0x3a(%rax)
jne 0xd373d
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd332a
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd36e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::IsUnsignedIntScalarOrVectorType(unsigned int) const | bool ValidationState_t::IsUnsignedIntScalarOrVectorType(uint32_t id) const {
const Instruction* inst = FindDef(id);
if (!inst) {
return false;
}
if (inst->opcode() == spv::Op::OpTypeInt) {
return inst->GetOperandAs<uint32_t>(2) == 0;
}
if (inst->opcode() == spv::Op::OpTypeVector) {
return IsUn... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd0e5a
testq %rax, %rax
je 0xd3778
movzwl 0x3a(%rax), %ecx
cmpl $0x17, %ecx
je 0xd3781
cmpl $0x15, %ecx
jne 0xd3778
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0x7a018
testl %eax, %eax
sete %al
jmp 0xd377a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
p... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::IsSignedIntVectorType(unsigned int) const | bool ValidationState_t::IsSignedIntVectorType(uint32_t id) const {
const Instruction* inst = FindDef(id);
if (!inst) {
return false;
}
if (inst->opcode() == spv::Op::OpTypeVector) {
return IsSignedIntScalarType(GetComponentType(id));
}
return false;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd0e5a
testq %rax, %rax
je 0xd37f1
cmpw $0x17, 0x3a(%rax)
jne 0xd37f1
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd332a
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd379c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::GetMatrixTypeInfo(unsigned int, unsigned int*, unsigned int*, unsigned int*, unsigned int*) const | bool ValidationState_t::GetMatrixTypeInfo(uint32_t id, uint32_t* num_rows,
uint32_t* num_cols,
uint32_t* column_type,
uint32_t* component_type) const {
if (!id) return false;
const Instruct... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
je 0xd3944
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %rbp
callq 0xd0e5a
testq %rax, %rax
je 0xd3955
movq %rax, %r13
cmpw $0x18, 0x3a(%rax)
jne 0xd3944
movq (%r13), %rax
movl 0x8(%rax), %esi
movq ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::GetStructMemberTypes(unsigned int, std::vector<unsigned int, std::allocator<unsigned int>>*) const | bool ValidationState_t::GetStructMemberTypes(
uint32_t struct_type_id, std::vector<uint32_t>* member_types) const {
member_types->clear();
if (!struct_type_id) return false;
const Instruction* inst = FindDef(struct_type_id);
assert(inst);
if (inst->opcode() != spv::Op::OpTypeStruct) return false;
*mem... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0xd39c9
movq %rax, 0x8(%rbx)
testl %esi, %esi
je 0xd3a1f
callq 0xd0e5a
testq %rax, %rax
je 0xd3a29
cmpw $0x1e, 0x3a(%rax)
jne 0xd3a1f
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq $0x8, %rsi
xorps %xmm0, %xmm0
movq %rsp, %r14... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::GetPointerTypeInfo(unsigned int, unsigned int*, spv::StorageClass*) const | bool ValidationState_t::GetPointerTypeInfo(
uint32_t id, uint32_t* data_type, spv::StorageClass* storage_class) const {
*storage_class = spv::StorageClass::Max;
if (!id) return false;
const Instruction* inst = FindDef(id);
assert(inst);
if (inst->opcode() == spv::Op::OpTypeUntypedPointerKHR) {
*stora... | pushq %r14
pushq %rbx
pushq %rax
movl $0x7fffffff, (%rcx) # imm = 0x7FFFFFFF
testl %esi, %esi
je 0xd3ac4
movq %rcx, %r14
movq %rdx, %rbx
callq 0xd0e5a
testq %rax, %rax
je 0xd3ae0
movzwl 0x3a(%rax), %ecx
cmpl $0x20, %ecx
je 0xd3ac8
cmpl $0x1141, %ecx # imm = 0x1141
jne 0xd3ac4
movq (%rax), %rax
movl 0x8(%r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::EvalConstantValUint64(unsigned int, unsigned long*) const | bool ValidationState_t::EvalConstantValUint64(uint32_t id,
uint64_t* val) const {
const Instruction* inst = FindDef(id);
if (!inst) {
assert(0 && "Instruction not found");
return false;
}
if (!IsIntScalarType(inst->type_id())) return false;
if (inst->opc... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
callq 0xd0e5a
testq %rax, %rax
je 0xd3c30
movq %rax, %r14
movl 0x40(%rax), %esi
movq %r15, %rdi
callq 0xd360e
testb %al, %al
je 0xd3c1d
movzwl 0x3a(%r14), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
je 0xd3c25
cmpl $0x2b, %ecx
jne 0xd3c2a
movq (%r14), %rax
movq... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::CooperativeMatrixShapesMatch(spvtools::val::Instruction const*, unsigned int, unsigned int) | spv_result_t ValidationState_t::CooperativeMatrixShapesMatch(
const Instruction* inst, uint32_t m1, uint32_t m2) {
const auto m1_type = FindDef(m1);
const auto m2_type = FindDef(m2);
if (m1_type->opcode() != m2_type->opcode()) {
return diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected cooperativ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movl %ecx, %ebx
movq %rsi, %r13
movq %rdi, %r14
movl %edx, %esi
callq 0xd0e80
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
callq 0xd0e80
movq %rax, %r12
movzwl 0x3a(%r15), %eax
cmpw 0x3a(%r12), %ax
jne 0xd3f4... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::EvalConstantValInt64(unsigned int, long*) const | bool ValidationState_t::EvalConstantValInt64(uint32_t id, int64_t* val) const {
const Instruction* inst = FindDef(id);
if (!inst) {
assert(0 && "Instruction not found");
return false;
}
if (!IsIntScalarType(inst->type_id())) return false;
if (inst->opcode() == spv::Op::OpConstantNull) {
*val = 0... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
callq 0xd0e5a
testq %rax, %rax
je 0xd4277
movq %rax, %r14
movl 0x40(%rax), %esi
movq %r15, %rdi
callq 0xd360e
testb %al, %al
je 0xd4264
movzwl 0x3a(%r14), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
je 0xd426c
cmpl $0x2b, %ecx
jne 0xd4271
movq (%r14), %rax
movq... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::ContainsLimitedUseIntOrFloatType(unsigned int) const | bool ValidationState_t::ContainsLimitedUseIntOrFloatType(uint32_t id) const {
if ((!HasCapability(spv::Capability::Int16) &&
ContainsSizedIntOrFloatType(id, spv::Op::OpTypeInt, 16)) ||
(!HasCapability(spv::Capability::Int8) &&
ContainsSizedIntOrFloatType(id, spv::Op::OpTypeInt, 8)) ||
(!HasC... | pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x170(%rdi), %r15
pushq $0x16
popq %rsi
movq %r15, %rdi
callq 0x7b28c
testb %al, %al
jne 0xd4bea
pushq $0x15
popq %rdx
pushq $0x10
popq %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0xd4b46
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xd4c3a
pushq... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.cpp |
bool spvtools::utils::ParseNumber<spvtools::utils::HexFloat<spvtools::utils::FloatProxy<spvtools::utils::Float16>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<spvtools::utils::Float16>>>>(char const*, spvtools::utils::HexFloat<spvtools::utils::FloatProxy<spvtools::utils::Float16>, spvtools::utils::HexFl... | bool ParseNumber(const char* text, T* value_pointer) {
// C++11 doesn't define std::istringstream(int8_t&), so calling this method
// with a single-byte type leads to implementation-defined behaviour.
// Similarly for uint8_t.
static_assert(sizeof(T) > 1,
"Single-byte types are not supported in ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
testq %rdi, %rdi
je 0xd86b9
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x765ea
leaq 0x28(%rsp), %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x29... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/parse_number.h |
bool spvtools::utils::ParseNumber<spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>>(char const*, spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>*) | bool ParseNumber(const char* text, T* value_pointer) {
// C++11 doesn't define std::istringstream(int8_t&), so calling this method
// with a single-byte type leads to implementation-defined behaviour.
// Similarly for uint8_t.
static_assert(sizeof(T) > 1,
"Single-byte types are not supported in ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
testq %rdi, %rdi
je 0xd875e
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x765ea
leaq 0x28(%rsp), %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x29... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/parse_number.h |
bool spvtools::utils::ParseNumber<spvtools::utils::HexFloat<spvtools::utils::FloatProxy<double>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<double>>>>(char const*, spvtools::utils::HexFloat<spvtools::utils::FloatProxy<double>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<double>>>*) | bool ParseNumber(const char* text, T* value_pointer) {
// C++11 doesn't define std::istringstream(int8_t&), so calling this method
// with a single-byte type leads to implementation-defined behaviour.
// Similarly for uint8_t.
static_assert(sizeof(T) > 1,
"Single-byte types are not supported in ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
testq %rdi, %rdi
je 0xd8803
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x765ea
leaq 0x28(%rsp), %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x29... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/parse_number.h |
spvtools::utils::get_nibble_from_character(int) | inline uint8_t get_nibble_from_character(int character) {
const char* dec = "0123456789";
const char* lower = "abcdef";
const char* upper = "ABCDEF";
const char* p = nullptr;
if ((p = strchr(dec, character))) {
return static_cast<uint8_t>(p - dec);
} else if ((p = strchr(lower, character))) {
return... | pushq %rbx
movl %edi, %ebx
leaq 0x19f0d8(%rip), %rdi # 0x277e95
pushq $0xb
popq %rdx
movl %ebx, %esi
callq 0x29690
testq %rax, %rax
je 0xd8dd7
leaq 0x19f0c2(%rip), %rcx # 0x277e95
subb %cl, %al
jmp 0xd8e17
leaq 0x19a178(%rip), %rdi # 0x272f56
pushq $0x7
popq %rdx
movl %ebx, %esi
callq 0x29690
testq %rax, %rax
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/hex_float.h |
std::istream& spvtools::utils::ParseNormalFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>(std::istream&, bool, spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>&) | inline std::istream& ParseNormalFloat(std::istream& is, bool negate_value,
HexFloat<T, Traits>& value) {
if (RejectParseDueToLeadingSign(is, negate_value, value)) {
return is;
}
T val;
is >> val;
if (negate_value) {
val = -val;
}
value.set_value(val);
// In ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd8ffa
testb %al, %al
jne 0xd8ecd
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd9047
movl (%r15), %ecx
testb %bpl, %bpl
je 0xd8e72
addl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x4(... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/hex_float.h |
void spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>::castTo<spvtools::utils::HexFloat<spvtools::utils::FloatProxy<spvtools::utils::Float16>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<spvtools::utils::Float16>>>>(spvtoo... | void castTo(other_T& other, round_direction round_dir) {
other = other_T(static_cast<typename other_T::native_type>(0));
bool negate = isNegative();
if (getUnsignedBits() == 0) {
if (negate) {
other.set_value(-other.value());
}
return;
}
uint_type significand = getSignifica... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
andw $0x0, (%rsi)
movl (%rdi), %ebp
testl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
je 0xd8f2d
movl %edx, %r14d
movq %rdi, %r15
movl %ebp, %r12d
andl $0x7fffff, %r12d # imm = 0x7FFFFF
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
m... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/hex_float.h |
bool spvtools::utils::RejectParseDueToLeadingSign<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>(std::istream&, bool, spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>&) | inline bool RejectParseDueToLeadingSign(std::istream& is, bool negate_value,
HexFloat<T, Traits>& value) {
if (negate_value) {
auto next_char = is.peek();
if (next_char == '-' || next_char == '+') {
// Fail the parse. Emulate standard behaviour by setting the val... | testl %esi, %esi
je 0xd903d
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x291d0
movl %eax, %ebp
cmpl $0x2d, %eax
je 0xd9019
cmpl $0x2b, %ebp
jne 0xd9040
andl $0x0, (%r14)
movq (%rbx), %rax
addq -0x18(%rax), %rbx
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x29380
addl $-0x2b, %ebp
testl $0xfff... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/hex_float.h |
spvtools::utils::HexFloat<spvtools::utils::FloatProxy<spvtools::utils::Float16>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<spvtools::utils::Float16>>>::uint_type spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>::getRound... | typename other_T::uint_type getRoundedNormalizedSignificand(
round_direction dir, bool* carry_bit) {
using other_uint_type = typename other_T::uint_type;
static const int_type num_throwaway_bits =
static_cast<int_type>(num_fraction_bits) -
static_cast<int_type>(other_T::num_fraction_bits);... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movb 0x312d94(%rip), %al # 0x3ebe20
testb %al, %al
je 0xd910d
movb 0x312d9a(%rip), %al # 0x3ebe30
testb %al, %al
je 0xd913c
movb $0x0, (%rbx)
movq %r14, %rdi
callq 0xd91f8
movl %eax, %ecx
andl $0x1fff, %ecx # imm = 0x1FFF... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/hex_float.h |
spvtools::utils::HexFloat<spvtools::utils::FloatProxy<spvtools::utils::Float16>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<spvtools::utils::Float16>>>::setFromSignUnbiasedExponentAndNormalizedSignificand(bool, short, unsigned short, bool) | void setFromSignUnbiasedExponentAndNormalizedSignificand(
bool negative, int_type exponent, uint_type significand,
bool round_denorm_up) {
bool significand_is_zero = significand == 0;
if (exponent <= min_exponent) {
// If this was denormalized, then we have to shift the bit on, meaning
... | movl %ecx, %eax
shrl %eax
orl $0x200, %eax # imm = 0x200
cmpw $-0xe, %dx
cmovgel %ecx, %eax
movl %edx, %ecx
cmpw $-0x10, %cx
jg 0xd918d
movzwl %ax, %eax
shrl %eax
incl %ecx
jmp 0xd917e
cmpw $-0xe, %dx
movl $0xfff1, %ecx # imm = 0xFFF1
cmovgel %edx, %ecx
addw $0xf, %cx
js 0xd91d7
movzbl %sil, %esi
s... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/hex_float.h |
spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>::getNormalizedSignificand() const | const uint_type getNormalizedSignificand() const {
int_type unbiased_exponent = getUnbiasedNormalizedExponent();
uint_type significand = getSignificandBits();
for (int_type i = unbiased_exponent; i <= min_exponent; ++i) {
significand = static_cast<uint_type>(significand << 1);
}
significand &=... | pushq %rbx
movq %rdi, %rbx
callq 0xd9218
movl %eax, %ecx
movl (%rbx), %eax
cmpl $-0x7e, %ecx
jge 0xd9210
addl %eax, %eax
incl %ecx
jmp 0xd9205
andl $0x7fffff, %eax # imm = 0x7FFFFF
popq %rbx
retq
nop
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/hex_float.h |
spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>::getUnbiasedNormalizedExponent() const | uint_type data() const { return data_; } | movl (%rdi), %ecx
testl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
je 0xd9232
movl %ecx, %eax
shrl $0x17, %eax
movzbl %al, %eax
testl %eax, %eax
je 0xd9235
addl $-0x7f, %eax
retq
xorl %eax, %eax
retq
pushq $-0x7f
popq %rax
btl $0x16, %ecx
jb 0xd9234
addl %ecx, %ecx
decl %eax
jmp 0xd9238
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/hex_float.h |
std::istream& spvtools::utils::operator>><spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>(std::istream&, spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>&) | std::istream& operator>>(std::istream& is, HexFloat<T, Traits>& value) {
using HF = HexFloat<T, Traits>;
using uint_type = typename HF::uint_type;
using int_type = typename HF::int_type;
value.set_value(static_cast<typename HF::native_type>(0.f));
if (is.flags() & std::ios::skipws) {
// If the user want... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andl $0x0, (%rsi)
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x10, 0x19(%rdi,%rax)
jne 0xd93e5
movq %rbx, %rdi
callq 0x291d0
movl %eax, %ebp
cmpl $0x2d, %eax
je 0xd9285
cmpl $0x30, %ebp
jne 0xd9414
mo... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/hex_float.h |
std::istream& spvtools::utils::ParseNormalFloat<spvtools::utils::FloatProxy<double>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<double>>>(std::istream&, bool, spvtools::utils::HexFloat<spvtools::utils::FloatProxy<double>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<double>>>&) | inline std::istream& ParseNormalFloat(std::istream& is, bool negate_value,
HexFloat<T, Traits>& value) {
if (RejectParseDueToLeadingSign(is, negate_value, value)) {
return is;
}
T val;
is >> val;
if (negate_value) {
val = -val;
}
value.set_value(val);
// In ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd9cac
testb %al, %al
jne 0xd9c9c
movabsq $0x7fffffffffffffff, %r12 # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd9cf9
movq (%r15), %rcx
testb %bpl, %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/hex_float.h |
spvtools::utils::CardinalToOrdinal[abi:cxx11](unsigned long) | std::string CardinalToOrdinal(size_t cardinal) {
const size_t mod10 = cardinal % 10;
const size_t mod100 = cardinal % 100;
std::string suffix;
if (mod10 == 1 && mod100 != 11)
suffix = "st";
else if (mod10 == 2 && mod100 != 12)
suffix = "nd";
else if (mod10 == 3 && mod100 != 13)
suffix = "rd";
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
pushq $0xa
popq %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rcx
pushq $0x64
popq %rsi
movq %rbx, %rax
xorl %edx, %edx
divq %rsi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/string_utils.cpp |
spvtools::EnumSet<spvtools::Extension>::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 0xe0927
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe092c
testb %al, %al
jne 0xe0927
movq %rbx, %rdi
callq 0xe08a6
movq %rbx, %rax
popq %rbx
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::EnumSet<spvtools::Extension>::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 0xe0957
cmpq $0x40, %rdx
jae 0xe0976
shlq $0x4, %rsi
movq (%rax,%rsi), %rax
btq %rdx, %rax
setb %al
popq %rcx
retq
leaq 0x184de6(%rip), %rdi # 0x265744
leaq 0x178817(%rip), %rsi # 0x25917c
leaq 0x197295(%rip), %r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::FriendlyNameMapper::FriendlyNameMapper(spv_context_t const*, unsigned int const*, unsigned long) | FriendlyNameMapper::FriendlyNameMapper(const spv_const_context context,
const uint32_t* code,
const size_t wordCount)
: grammar_(AssemblyGrammar(context)) {
spv_diagnostic diag = nullptr;
// We don't care if the parse fails.
spvBina... | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rsi
addq $0x30, %rdi
movq %rdi, (%rsi)
pushq $0x1
popq %rdi
movq %rdi, 0x8(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movl $0x3f800000, %r8d # imm = 0x3F800000
movl %r8d, 0x20(%rsi)
movups %xmm0, 0x28(%rsi)
leaq 0x68(%rsi), %r9
movq %r9, 0x38(%rsi)
mo... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/name_mapper.cpp |
spvtools::FriendlyNameMapper::NameForId[abi:cxx11](unsigned int) | std::string FriendlyNameMapper::NameForId(uint32_t id) {
auto iter = name_for_id_.find(id);
if (iter == name_for_id_.end()) {
// It must have been an invalid module, so just return a trivial mapping.
// We don't care about uniqueness.
return to_string(id);
} else {
return iter->second;
}
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movl %edx, (%rsi)
movq %rax, %rdi
callq 0xe17e0
testq %rax, %rax
je 0xe0ad2
addq $0x10, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29840
jmp 0xe0ade
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0xe09c1
movq %rbx, %rax
addq $0x10, %rsp
popq... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/name_mapper.cpp |
spvtools::FriendlyNameMapper::Sanitize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string FriendlyNameMapper::Sanitize(const std::string& suggested_name) {
if (suggested_name.empty()) return "_";
// Otherwise, replace invalid characters by '_'.
std::string result;
std::string valid =
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"_0123456789";
std::transfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdx)
je 0xe0b72
movq %rdx, %r15
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x197346(%rip), %rsi # 0x277e60
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/name_mapper.cpp |
spvtools::FriendlyNameMapper::SaveName(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void FriendlyNameMapper::SaveName(uint32_t id,
const std::string& suggested_name) {
if (name_for_id_.find(id) != name_for_id_.end()) return;
const std::string sanitized_suggested_name = Sanitize(suggested_name);
std::string name = sanitized_suggested_name;
auto inserted = used... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rdi, %r12
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movq %rax, %rsi
callq 0xe17e0
testq %rax, %rax
jne 0xe0cbd
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xe0ae8
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
m... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/name_mapper.cpp |
spvtools::EmitNumericLiteral(std::ostream*, spv_parsed_instruction_t const&, spv_parsed_operand_t const&) | void EmitNumericLiteral(std::ostream* out, const spv_parsed_instruction_t& inst,
const spv_parsed_operand_t& operand) {
if (operand.type != SPV_OPERAND_TYPE_LITERAL_INTEGER &&
operand.type != SPV_OPERAND_TYPE_LITERAL_FLOAT &&
operand.type != SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER &&... | subq $0x18, %rsp
movl 0x4(%rdx), %eax
cmpq $0x2f, %rax
ja 0xe2bea
movabsq $0xa00000000640, %rcx # imm = 0xA00000000640
btq %rax, %rcx
jae 0xe2bea
movzwl 0x2(%rdx), %eax
leal -0x3(%rax), %ecx
cmpw $-0x2, %cx
jae 0xe2bef
addq $0x18, %rsp
retq
movq (%rsi), %rcx
movzwl (%rdx), %r8d
movl (%rcx,%r8,4), %esi
cmpw $0x1, %ax
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/parsed_operand.cpp |
spvc_msl_shader_interface_var_init_2 | void spvc_msl_shader_interface_var_init_2(spvc_msl_shader_interface_var_2 *var)
{
#if SPIRV_CROSS_C_API_MSL
MSLShaderInterfaceVariable var_default;
var->location = var_default.location;
var->format = static_cast<spvc_msl_shader_variable_format>(var_default.format);
var->builtin = static_cast<SpvBuiltIn>(var_default... | movaps 0x197d58(%rip), %xmm0 # 0x280910
movups %xmm0, (%rdi)
andl $0x0, 0x10(%rdi)
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross_c.cpp |
mz_zip_array_ensure_capacity | static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing)
{
void *pNew_p;
size_t new_capacity = min_new_capacity;
MZ_ASSERT(pArray->m_element_size);
if (pArray->m_capacity >= min_new_capacity)
return MZ_TRUE;
if (growing... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r8
movl 0x18(%rsi), %edx
testq %rdx, %rdx
je 0xf8df8
movq %rsi, %r14
movq 0x10(%rsi), %rsi
pushq $0x1
popq %rbx
cmpq %r8, %rsi
jae 0xf8df0
movq %rdi, %rax
testl %ecx, %ecx
je 0xf8dd0
cmpq $0x1, %rsi
adcq $0x0, %rsi
movq %rsi, %r15
addq %rsi, %rsi
cmpq %r8, %r15
jb 0xf8dc3
jm... | /ValveSoftware[P]Fossilize/miniz/miniz.c |
volkGenLoadLoader | static void volkGenLoadLoader(void* context, PFN_vkVoidFunction (*load)(void*, const char*))
{
/* VOLK_GENERATE_LOAD_LOADER */
#if defined(VK_VERSION_1_0)
vkCreateInstance = (PFN_vkCreateInstance)load(context, "vkCreateInstance");
vkEnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)l... | pushq %rax
leaq 0x189ac7(%rip), %rsi # 0x282934
xorl %edi, %edi
callq *0x2f2fcb(%rip) # 0x3ebe40
movq %rax, 0x2f2fd4(%rip) # 0x3ebe50
leaq 0x189ac2(%rip), %rsi # 0x282945
xorl %edi, %edi
callq *0x2f2fb5(%rip) # 0x3ebe40
movq %rax, 0x2f32c6(%rip) # 0x3ec158
leaq 0x189ad3(%rip), %rsi # 0x28... | /ValveSoftware[P]Fossilize/cli/volk/volk.c |
volkGetInstanceVersion | uint32_t volkGetInstanceVersion(void)
{
#if defined(VK_VERSION_1_1)
uint32_t apiVersion = 0;
if (vkEnumerateInstanceVersion && vkEnumerateInstanceVersion(&apiVersion) == VK_SUCCESS)
return apiVersion;
#endif
if (vkCreateInstance)
return VK_API_VERSION_1_0;
return 0;
} | pushq %rax
andl $0x0, 0x4(%rsp)
movq 0x2f2f72(%rip), %rax # 0x3ebe48
testq %rax, %rax
je 0xf8ee6
leaq 0x4(%rsp), %rdi
callq *%rax
testl %eax, %eax
je 0xf8ef8
xorl %eax, %eax
cmpq $0x0, 0x2f2f60(%rip) # 0x3ebe50
setne %al
shll $0x16, %eax
jmp 0xf8efc
movl 0x4(%rsp), %eax
popq %rcx
retq
| /ValveSoftware[P]Fossilize/cli/volk/volk.c |
void spirv_cross::CompilerGLSL::statement<char const (&) [5]>(char const (&) [5]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x11b948
movq 0x1dc0(%rbx), %r15
testq %r15, %r15
je 0x11b95b
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x12817c
movq %r15, %rdi
movq %r12, %rsi
callq 0x11cc18
movq %r12,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<char const (&) [29], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [11], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [14], std::__cxx11::basic_string<char, std::char_traits<cha... | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x28(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x30(... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<char const (&) [10]>(char const (&) [10]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x11bb82
movq 0x1dc0(%rbx), %r15
testq %r15, %r15
je 0x11bb95
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x128a7a
movq %r15, %rdi
movq %r12, %rsi
callq 0x11cc18
movq %r12,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<char const (&) [23]>(char const (&) [23]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x11bc26
movq 0x1dc0(%rbx), %r15
testq %r15, %r15
je 0x11bc39
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x128af0
movq %r15, %rdi
movq %r12, %rsi
callq 0x11cc18
movq %r12,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<char const (&) [64]>(char const (&) [64]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x11d1d8
movq 0x1dc0(%rbx), %r15
testq %r15, %r15
je 0x11d1eb
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x12fe92
movq %r15, %rdi
movq %r12, %rsi
callq 0x11cc18
movq %r12,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<char const (&) [9], unsigned int&, char const (&) [5], unsigned int&, char const (&) [9]>(char const (&) [9], unsigned int&, char const (&) [5], unsigned int&, char const (&) [9]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x11d4e8
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq 0x1dc0(%rbx), %r14
testq %r14, %r14
je 0x11d4fd
leaq 0x1... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
spirv_cross::SmallVector<bool, 8ul>::reserve(unsigned long) | void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
{
if ((count > (std::numeric_limits<size_t>::max)() / sizeof(T)) ||
(count > (std::numeric_limits<size_t>::max)() / 2))
{
// Only way this should ever happen is with garbage input, terminate.
std::terminate();
}
if (count > buffer_capacity)
{
si... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
js 0x120f34
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
cmpq %rsi, %rcx
jae 0x120f71
cmpq $0x9, %rcx
pushq $0x8
popq %rax
cmovaeq %rcx, %rax
movq %rax, %r14
addq %rax, %rax
cmpq %rsi, %r14
jb 0x120f13
cmpq $0x8, %r14
jbe 0x120f39
movq %r14, %rdi
callq 0x297f0
movq %rax, %r15
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross_containers.hpp |
spirv_cross::SmallVector<spirv_cross::SPIRType*, 0ul>::reserve(unsigned long) | void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
{
if ((count > (std::numeric_limits<size_t>::max)() / sizeof(T)) ||
(count > (std::numeric_limits<size_t>::max)() / 2))
{
// Only way this should ever happen is with garbage input, terminate.
std::terminate();
}
if (count > buffer_capacity)
{
si... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
shrq $0x3d, %rax
jne 0x1212c8
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
jae 0x1212c2
cmpq $0x1, %rax
adcq $0x0, %rax
movq %rax, %r15
addq %rax, %rax
cmpq %rsi, %r15
jb 0x121276
leaq (,%r15,8), %rdi
callq 0x297f0
testq %rax, %rax
je 0x1212c8
movq %rax, %r14
mo... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross_containers.hpp |
spirv_cross::SmallVector<std::unique_ptr<spirv_cross::SPIRType, spirv_cross::ObjectPool<spirv_cross::SPIRType>::MallocDeleter>, 8ul>::reserve(unsigned long) | void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
{
if ((count > (std::numeric_limits<size_t>::max)() / sizeof(T)) ||
(count > (std::numeric_limits<size_t>::max)() / 2))
{
// Only way this should ever happen is with garbage input, terminate.
std::terminate();
}
if (count > buffer_capacity)
{
si... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rax
shrq $0x3d, %rax
jne 0x12139b
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
cmpq %rsi, %rcx
jae 0x1213f4
cmpq $0x9, %rcx
pushq $0x8
popq %rax
cmovaeq %rcx, %rax
movq %rax, %r15
addq %rax, %rax
cmpq %rsi, %r15
jb 0x121375
cmpq $0x8, %r15
jbe 0x1213a0
leaq (,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross_containers.hpp |
spirv_cross::SmallVector<std::unique_ptr<spirv_cross::SPIRAccessChain, spirv_cross::ObjectPool<spirv_cross::SPIRAccessChain>::MallocDeleter>, 8ul>::reserve(unsigned long) | void reserve(size_t count) SPIRV_CROSS_NOEXCEPT
{
if ((count > (std::numeric_limits<size_t>::max)() / sizeof(T)) ||
(count > (std::numeric_limits<size_t>::max)() / 2))
{
// Only way this should ever happen is with garbage input, terminate.
std::terminate();
}
if (count > buffer_capacity)
{
si... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rax
shrq $0x3d, %rax
jne 0x121f3d
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
cmpq %rsi, %rcx
jae 0x121f96
cmpq $0x9, %rcx
pushq $0x8
popq %rax
cmovaeq %rcx, %rax
movq %rax, %r15
addq %rax, %rax
cmpq %rsi, %r15
jb 0x121f17
cmpq $0x8, %r15
jbe 0x121f42
leaq (,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross_containers.hpp |
spirv_cross::SmallVector<spirv_cross::SPIRCombinedImageSampler*, 0ul>::resize(unsigned long) | void resize(size_t new_size) SPIRV_CROSS_NOEXCEPT
{
if (new_size < this->buffer_size)
{
for (size_t i = new_size; i < this->buffer_size; i++)
this->ptr[i].~T();
}
else if (new_size > this->buffer_size)
{
reserve(new_size);
for (size_t i = this->buffer_size; i < new_size; i++)
new (&this->ptr... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
jae 0x12b949
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12b75c
movq 0x8(%r14), %rax
cmpq %rbx, %rax
jae 0x12b949
movq (%r14), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x12b937
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross_containers.hpp |
void spirv_cross::CompilerGLSL::statement<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [16], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [2]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<cha... | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x12c287
movq %r14, 0x8(%rsp)
movq 0x1dc0(%rbx), %r14
testq %r14, %r14
je 0x12c29c
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
mov... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [20], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [34]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<ch... | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x12c515
movq %r14, 0x8(%rsp)
movq 0x1dc0(%rbx), %r14
testq %r14, %r14
je 0x12c52a
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
mov... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [20], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [28]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<ch... | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x12c6c9
movq %r14, 0x8(%rsp)
movq 0x1dc0(%rbx), %r14
testq %r14, %r14
je 0x12c6de
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
mov... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [27]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [27]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x12c920
movq 0x1dc0(%rbx), %r12
testq %r12, %r12
je 0x12c935
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12dcbe
movq %r12... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [29]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [29]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x12ca8c
movq 0x1dc0(%rbx), %r12
testq %r12, %r12
je 0x12caa1
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12de06
movq %r12... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<char const (&) [45]>(char const (&) [45]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x12cc12
movq 0x1dc0(%rbx), %r15
testq %r15, %r15
je 0x12cc25
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x12e01c
movq %r15, %rdi
movq %r12, %rsi
callq 0x11cc18
movq %r12,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<char const (&) [78]>(char const (&) [78]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23119e
testb %al, %al
jne 0x12cd5a
movq 0x1dc0(%rbx), %r15
testq %r15, %r15
je 0x12cd6d
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x12e108
movq %r15, %rdi
movq %r12, %rsi
callq 0x11cc18
movq %r12,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<char const (&) [17], unsigned int&, char const (&) [32], unsigned int, char const (&) [2], char const&, char const (&) [2]>(char const (&) [17], unsigned int&, char const (&) [32], unsigned int&&, char const (&) [2], char const&, char const (&) [2]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, %r15
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %r14
callq 0x23119e
testb %al, %al
jne 0x12ceeb
movq %r15, (%rsp)
movq %r14,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [16], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<cha... | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r15
movq %rdx, 0x18(%rsp)
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x80(%rsp), %r12
callq 0x23119e
testb %al, %al
jne 0x12e682
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq 0x1dc0(%rbx), %r14
testq... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
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.