name string | code string | asm string | file string |
|---|---|---|---|
spvDiagnosticCreate | spv_diagnostic spvDiagnosticCreate(const spv_position position,
const char* message) {
spv_diagnostic diagnostic = new spv_diagnostic_t;
if (!diagnostic) return nullptr;
size_t length = strlen(message) + 1;
diagnostic->error = new char[length];
if (!diagnostic->error) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x28, %edi
callq 0xdb140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9d1222
movq $0x0, -0x8(%rbp)
jmp 0x9d12ca
movq -0x18(%rbp), %rdi
callq 0xd7700
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/diagnostic.cpp |
spvtools::DiagnosticStream::~DiagnosticStream() | DiagnosticStream::~DiagnosticStream() {
if (error_ != SPV_FAILED_MATCH && consumer_ != nullptr) {
auto level = SPV_MSG_ERROR;
switch (error_) {
case SPV_SUCCESS:
case SPV_REQUESTED_TERMINATION: // Essentially success.
level = SPV_MSG_INFO;
break;
case SPV_WARNING:
le... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x4, 0x1d0(%rax)
je 0x9d1687
movq -0x38(%rbp), %rdi
addq $0x190, %rdi # imm = 0x190
xorl %eax, %eax
movl %eax, %esi
callq 0x73e310
testb $0x1, %al
jne 0x9d157e
jmp 0x9d1687
movq -0x38(%rbp), %... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/diagnostic.cpp |
spvtools::disassemble::InstructionDisassembler::EmitHeaderGenerator(unsigned int) | void InstructionDisassembler::EmitHeaderGenerator(uint32_t generator) {
const char* generator_tool =
spvGeneratorStr(SPV_GENERATOR_TOOL_PART(generator));
stream_ << "; Generator: " << generator_tool;
// For unknown tools, print the numeric tool value.
if (0 == strcmp("Unknown", generator_tool)) {
stre... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
shrl $0x10, %edi
callq 0x9e2d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rdi
leaq 0x234202(%rip), %rsi # 0xc0615a
callq 0xdc... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/disassemble.cpp |
spvtools::(anonymous namespace)::Disassembler::SaveTextResult(spv_text_t**) const | spv_result_t Disassembler::SaveTextResult(spv_text* text_result) const {
if (!print_) {
size_t length = text_.str().size();
char* str = new char[length + 1];
if (!str) return SPV_ERROR_OUT_OF_MEMORY;
strncpy(str, text_.str().c_str(), length + 1);
spv_text text = new spv_text_t();
if (!text) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
testb $0x1, (%rax)
jne 0x9d3fd6
movq -0x78(%rbp), %rsi
addq $0x8, %rsi
leaq -0x40(%rbp), %rdi
callq 0xdd5c0
leaq -0x40(%rbp), %rdi
callq 0xdbe00
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp)... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/disassemble.cpp |
spvtools::(anonymous namespace)::Disassembler::HandleHeader(spv_endianness_t, unsigned int, unsigned int, unsigned int, unsigned int) | spv_result_t Disassembler::HandleHeader(spv_endianness_t endian,
uint32_t version, uint32_t generator,
uint32_t id_bound, uint32_t schema) {
endian_ = endian;
if (header_) {
instruction_disassembler_.EmitHeaderSpirv();
instruct... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
testb $0x1, 0x220(%rax)
je 0x9d44d0
movq -0x28(%rbp)... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/disassemble.cpp |
spvtools::(anonymous namespace)::ParsedInstruction::ParsedInstruction(spv_parsed_instruction_t const*) | ParsedInstruction(const spv_parsed_instruction_t* instruction) {
// Make a copy of the parsed instruction, including stable memory for its
// operands.
instruction_ = *instruction;
operands_ =
std::make_unique<spv_parsed_operand_t[]>(instruction->num_operands);
memcpy(operands_.get(), instru... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x28, %rdi
callq 0x9d94c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x28, %edx
callq 0xdafb0
movq -0x10(%rbp), %rax
movzwl 0x20(%rax), %eax
movl %eax, %esi
leaq -0x18(%rb... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/disassemble.cpp |
spvtools::(anonymous namespace)::ParsedInstruction::ParsedInstruction(spvtools::(anonymous namespace)::ParsedInstruction&&) | ParsedInstruction(const spv_parsed_instruction_t* instruction) {
// Make a copy of the parsed instruction, including stable memory for its
// operands.
instruction_ = *instruction;
operands_ =
std::make_unique<spv_parsed_operand_t[]>(instruction->num_operands);
memcpy(operands_.get(), instru... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl $0x28, %edx
callq 0xdafb0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x9d9aa0
addq $0x20, %rsp
popq %rbp
retq
nopw ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/disassemble.cpp |
spvtools::(anonymous namespace)::BuildControlFlowGraph(spvtools::(anonymous namespace)::ControlFlowGraph&) | std::unordered_map<uint32_t, uint32_t> BuildControlFlowGraph(
ControlFlowGraph& cfg) {
std::unordered_map<uint32_t, uint32_t> id_to_index;
for (size_t index = 0; index < cfg.blocks.size(); ++index) {
SingleBlock& block = cfg.blocks[index];
// For future use, build the ID->index map
assert(static_c... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3940c0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9d5d30
movq %rax, %rcx
movq -0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/disassemble.cpp |
spvExtInstTableGet(spv_ext_inst_table_t const**, spv_target_env) | spv_result_t spvExtInstTableGet(spv_ext_inst_table* pExtInstTable,
spv_target_env env) {
if (!pExtInstTable) return SPV_ERROR_INVALID_POINTER;
switch (env) {
// The extended instruction sets are all version 1.0 so far.
case SPV_ENV_UNIVERSAL_1_0:
case SPV_ENV_VULKAN_1_0:... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9de6cb
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x9de703
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x13, %eax
jb 0x9de6e5
jmp 0x9de6d8
movl -0x18(%rbp), %eax
addl $-0x14, %eax
subl $0x6, %eax
ja 0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/ext_inst.cpp |
spvExtInstImportTypeGet(char const*) | spv_ext_inst_type_t spvExtInstImportTypeGet(const char* name) {
// The names are specified by the respective extension instruction
// specifications.
if (!strcmp("GLSL.std.450", name)) {
return SPV_EXT_INST_TYPE_GLSL_STD_450;
}
if (!strcmp("OpenCL.std", name)) {
return SPV_EXT_INST_TYPE_OPENCL_STD;
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x175970(%rip), %rdi # 0xb54097
callq 0xdda70
cmpl $0x0, %eax
jne 0x9de73d
movl $0x1, -0x4(%rbp)
jmp 0x9de8b2
movq -0x10(%rbp), %rsi
leaq 0x22a212(%rip), %rdi # 0xc0895a
callq 0xdda70
cmpl $0x0, %eax
jne 0x9de75e
movl $... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/ext_inst.cpp |
spvtools::SpirvTools::Assemble(char const*, unsigned long, std::vector<unsigned int, std::allocator<unsigned int>>*, unsigned int) const | bool SpirvTools::Assemble(const char* text, const size_t text_size,
std::vector<uint32_t>* binary,
uint32_t options) const {
spv_binary spvbinary = nullptr;
spv_result_t status = spvTextToBinaryWithOptions(
impl_->context, text, text_size, options, &spvbinar... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq $0x0, -0x30(%rbp)
callq 0x9df370
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x30(%rbp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/libspirv.cpp |
spvtools::SpirvTools::Disassemble(unsigned int const*, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, unsigned int) const | bool SpirvTools::Disassemble(const uint32_t* binary, const size_t binary_size,
std::string* text, uint32_t options) const {
spv_text spvtext = nullptr;
spv_result_t status = spvBinaryToText(impl_->context, binary, binary_size,
options, &spvtext, n... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq $0x0, -0x30(%rbp)
callq 0x9df370
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x30(%rbp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/libspirv.cpp |
spvtools::FriendlyNameMapper::SaveBuiltInName(unsigned int, unsigned int) | void FriendlyNameMapper::SaveBuiltInName(uint32_t target_id,
uint32_t built_in) {
#define GLCASE(name) \
case spv::BuiltIn::name: \
SaveName(target_id, "gl_" #name); \
return;
#define GLCASE2(name, suggested) \
case spv::BuiltIn:... | pushq %rbp
movq %rsp, %rbp
subq $0x830, %rsp # imm = 0x830
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x770(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x768(%rbp)
testl %eax, %eax
je 0x9e0040
jmp 0x9dfd23
movl -0x768(%rbp), %eax
subl $0x1, %eax
je 0x9e0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/name_mapper.cpp |
spvOpcodeString | const char* spvOpcodeString(const uint32_t opcode) {
const auto beg = kOpcodeTableEntries;
const auto end = kOpcodeTableEntries + ARRAY_SIZE(kOpcodeTableEntries);
spv_opcode_desc_t needle = {"", static_cast<spv::Op>(opcode),
0, nullptr,
0, {},... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
leaq 0x61faeb(%rip), %rax # 0x1002f00
movq %rax, -0x10(%rbp)
leaq 0x61fae0(%rip), %rax # 0x1002f00
addq $0x1a218, %rax # imm = 0x1A218
movq %rax, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x88, %edx
callq 0xd7340
leaq 0x152d... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opcode.cpp |
spvOpcodeIsScalarSpecConstant(spv::Op) | bool spvOpcodeIsScalarSpecConstant(const spv::Op opcode) {
switch (opcode) {
case spv::Op::OpSpecConstantTrue:
case spv::Op::OpSpecConstantFalse:
case spv::Op::OpSpecConstant:
return true;
default:
return false;
}
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x30, %eax
subl $0x2, %eax
ja 0x9e369a
jmp 0x9e3694
movb $0x1, -0x1(%rbp)
jmp 0x9e369e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opcode.cpp |
spvOpcodeReturnsLogicalVariablePointer(spv::Op) | bool spvOpcodeReturnsLogicalVariablePointer(const spv::Op opcode) {
switch (opcode) {
case spv::Op::OpVariable:
case spv::Op::OpUntypedVariableKHR:
case spv::Op::OpAccessChain:
case spv::Op::OpInBoundsAccessChain:
case spv::Op::OpUntypedAccessChainKHR:
case spv::Op::OpUntypedInBoundsAccessChai... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2e, %eax
je 0x9e37ab
jmp 0x9e3728
movl -0xc(%rbp), %eax
subl $0x37, %eax
je 0x9e37ab
jmp 0x9e3732
movl -0xc(%rbp), %eax
subl $0x39, %eax
je 0x9e37ab
jmp 0x9e373c
movl -0xc(%rbp), %eax
addl $-0x3b, %eax
subl $0x3, %eax
j... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opcode.cpp |
spvOpcodeGeneratesType(spv::Op) | int32_t spvOpcodeGeneratesType(spv::Op op) {
switch (op) {
case spv::Op::OpTypeVoid:
case spv::Op::OpTypeBool:
case spv::Op::OpTypeInt:
case spv::Op::OpTypeFloat:
case spv::Op::OpTypeVector:
case spv::Op::OpTypeMatrix:
case spv::Op::OpTypeImage:
case spv::Op::OpTypeSampler:
case sp... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x13, %eax
subl $0x14, %eax
jb 0x9e38e2
jmp 0x9e385b
movl -0xc(%rbp), %eax
subl $0x142, %eax # imm = 0x142
je 0x9e38e2
jmp 0x9e3867
movl -0xc(%rbp), %eax
subl $0x147, %eax # imm = 0x147
je 0x9e38e2
... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opcode.cpp |
spvOpcodeIsReturn(spv::Op) | bool spvOpcodeIsReturn(spv::Op opcode) {
switch (opcode) {
case spv::Op::OpReturn:
case spv::Op::OpReturnValue:
return true;
default:
return false;
}
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0xffffff03, %eax # imm = 0xFFFFFF03
subl $0x1, %eax
ja 0x9e3acc
jmp 0x9e3ac6
movb $0x1, -0x1(%rbp)
jmp 0x9e3ad0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
| /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opcode.cpp |
spvOpcodeIsCommutativeBinaryOperator(spv::Op) | bool spvOpcodeIsCommutativeBinaryOperator(spv::Op opcode) {
switch (opcode) {
case spv::Op::OpPtrEqual:
case spv::Op::OpPtrNotEqual:
case spv::Op::OpIAdd:
case spv::Op::OpFAdd:
case spv::Op::OpIMul:
case spv::Op::OpFMul:
case spv::Op::OpDot:
case spv::Op::OpIAddCarry:
case spv::Op:... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x80, %eax
subl $0x2, %eax
jb 0x9e3d7f
jmp 0x9e3d07
movl -0xc(%rbp), %eax
addl $0xffffff7c, %eax # imm = 0xFFFFFF7C
subl $0x2, %eax
jb 0x9e3d7f
jmp 0x9e3d16
movl -0xc(%rbp), %eax
addl $0xffffff6c, %eax # imm ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opcode.cpp |
spvOpcodeIsAccessChain(spv::Op) | bool spvOpcodeIsAccessChain(spv::Op opcode) {
switch (opcode) {
case spv::Op::OpAccessChain:
case spv::Op::OpInBoundsAccessChain:
case spv::Op::OpPtrAccessChain:
case spv::Op::OpInBoundsPtrAccessChain:
case spv::Op::OpRawAccessChainNV:
return true;
default:
return false;
}
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x41, %eax
subl $0x3, %eax
jb 0x9e40ad
jmp 0x9e4097
movl -0xc(%rbp), %eax
subl $0x46, %eax
je 0x9e40ad
jmp 0x9e40a1
movl -0xc(%rbp), %eax
subl $0x1516, %eax # imm = 0x1516
jne 0x9e40b3
jmp 0x9e40ad
movb $0x1, -... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opcode.cpp |
spvOperandTableNameLookup(spv_target_env, spv_operand_table_t const*, spv_operand_type_t, char const*, unsigned long, spv_operand_desc_t const**) | spv_result_t spvOperandTableNameLookup(spv_target_env,
const spv_operand_table table,
const spv_operand_type_t type,
const char* name,
const size_t nameLength,
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9e47d1
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x9e495d
cmpq $0x0, -0x20(%rbp)
je 0x9e47df
cmpq $0x0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/operand.cpp |
spvOperandIsOptional(spv_operand_type_t) | bool spvOperandIsOptional(spv_operand_type_t type) {
switch (type) {
case SPV_OPERAND_TYPE_OPTIONAL_ID:
case SPV_OPERAND_TYPE_OPTIONAL_IMAGE:
case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS:
case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER:
case SPV_OPERAND_TYPE_OPTIONAL_LITERAL_NUMBER:
case SPV_OP... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x2a, %eax
subl $0xa, %eax
jb 0x9e5283
jmp 0x9e525b
movl -0xc(%rbp), %eax
subl $0x4c, %eax
je 0x9e5283
jmp 0x9e5265
movl -0xc(%rbp), %eax
subl $0x4e, %eax
je 0x9e5283
jmp 0x9e526f
movl -0xc(%rbp), %eax
s... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/operand.cpp |
spvExpandOperandSequenceOnce(spv_operand_type_t, std::vector<spv_operand_type_t, std::allocator<spv_operand_type_t>>*) | bool spvExpandOperandSequenceOnce(spv_operand_type_t type,
spv_operand_pattern_t* pattern) {
switch (type) {
case SPV_OPERAND_TYPE_VARIABLE_ID:
pattern->push_back(type);
pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_ID);
return true;
case SPV_OPERAND_TYPE_VAR... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $-0x34, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0x9e53df
movq -0x30(%rbp), %rax
leaq 0x229131(%rip), %rcx # 0xc0e440
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/operand.cpp |
spvAlternatePatternFollowingImmediate(std::vector<spv_operand_type_t, std::allocator<spv_operand_type_t>> const&) | spv_operand_pattern_t spvAlternatePatternFollowingImmediate(
const spv_operand_pattern_t& pattern) {
auto it =
std::find(pattern.crbegin(), pattern.crend(), SPV_OPERAND_TYPE_RESULT_ID);
if (it != pattern.crend()) {
spv_operand_pattern_t alternatePattern(it - pattern.crbegin() + 2,
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x9eac60
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x9eaca0
movl $0x3, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
l... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/operand.cpp |
std::ostream& spvtools::utils::operator<<<double>(std::ostream&, spvtools::utils::FloatProxy<double> const&) | std::ostream& operator<<(std::ostream& os, const FloatProxy<T>& value) {
auto float_val = value.getAsFloat();
switch (std::fpclassify(float_val)) {
case FP_ZERO:
case FP_NORMAL: {
auto saved_precision = os.precision();
os.precision(std::numeric_limits<T>::max_digits10);
os << float_val;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x85ac70
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0xdd760
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
subl $0x2, %eax
je 0x9ebeae
jmp 0x9ebea4
movl -0x34(%rbp), %eax
subl $0x4, %eax
jne 0x9ebe... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/util/hex_float.h |
std::ostream& spvtools::utils::operator<<<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>(std::ostream&, spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>> const&) | std::ostream& operator<<(std::ostream& os, const HexFloat<T, Traits>& value) {
using HF = HexFloat<T, Traits>;
using uint_type = typename HF::uint_type;
using int_type = typename HF::int_type;
static_assert(HF::num_used_bits != 0,
"num_used_bits must be non-zero for a valid float");
static_as... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8534d0
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x850d90
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
andl $0x80000000, %edx # imm = 0x80000000
leaq 0x149f58(%rip), %rax # 0xb361e... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/util/hex_float.h |
spvIsOpenCLEnv(spv_target_env) | bool spvIsOpenCLEnv(spv_target_env env) {
switch (env) {
case SPV_ENV_UNIVERSAL_1_0:
case SPV_ENV_VULKAN_1_0:
case SPV_ENV_UNIVERSAL_1_1:
case SPV_ENV_OPENGL_4_0:
case SPV_ENV_OPENGL_4_1:
case SPV_ENV_OPENGL_4_2:
case SPV_ENV_OPENGL_4_3:
case SPV_ENV_OPENGL_4_5:
case SPV_ENV_UNIVER... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x1b, %rax
ja 0x9ed4e6
movq -0x10(%rbp), %rax
leaq 0x22435d(%rip), %rcx # 0xc117f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rbp)
jmp 0x9ed4ea
movb $0x1, -0x1(%rbp)
jmp 0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/spirv_target_env.cpp |
spvParseUniversalLimitsOptions(char const*, spv_validator_limit*)::$_0::operator()(char const*) const | bool spvParseUniversalLimitsOptions(const char* s, spv_validator_limit* type) {
auto match = [s](const char* b) {
return s && (0 == strncmp(s, b, strlen(b)));
};
if (match("--max-struct-members")) {
*type = spv_validator_limit_max_struct_members;
} else if (match("--max-struct_depth")) {
*type = spv... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x9edb6b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/spirv_validator_options.cpp |
spvIsValidID(char const*) | bool spvIsValidID(const char* textValue) {
const char* c = textValue;
for (; *c != '\0'; ++c) {
if (!spvIsValidIDCharacter(*c)) {
return false;
}
}
// If the string was empty, then the ID also is not valid.
return c != textValue;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9edff6
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x9edf70
testb $0x1, %al
jne 0x9edfe6
movb $0x0, -0x1(%rbp)
jmp 0x9ee006
jmp 0x9edfe8
m... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/text.cpp |
(anonymous namespace)::GetNumericIds(spvtools::AssemblyGrammar const&, std::function<void (spv_message_level_t, char const*, spv_position_t const&, char const*)> const&, spv_text_t*, std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int>>*) | spv_result_t GetNumericIds(const spvtools::AssemblyGrammar& grammar,
const spvtools::MessageConsumer& consumer,
const spv_text text,
std::set<uint32_t>* numeric_ids) {
spvtools::AssemblyContext context(text, consumer);
if (!text->str)... | pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp # imm = 0x400
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x3f8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x3f0(%rbp)
leaq -0x1b0(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/text.cpp |
spvtools::(anonymous namespace)::startsWithOp(spv_text_t*, spv_position_t*) | bool startsWithOp(spv_text text, spv_position position) {
if (text->length < position->index + 3) return false;
char ch0 = text->str[position->index];
char ch1 = text->str[position->index + 1];
char ch2 = text->str[position->index + 2];
return ('O' == ch0 && 'p' == ch1 && ('A' <= ch2 && ch2 <= 'Z'));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
addq $0x3, %rcx
cmpq %rcx, %rax
jae 0x9f2c8e
movb $0x0, -0x1(%rbp)
jmp 0x9f2d20
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/text_handler.cpp |
spvtools::AssemblyContext::binaryEncodeNumericLiteral(char const*, spv_result_t, spvtools::IdType const&, spv_instruction_t*) | spv_result_t AssemblyContext::binaryEncodeNumericLiteral(
const char* val, spv_result_t error_code, const IdType& type,
spv_instruction_t* pInst) {
using spvtools::utils::EncodeNumberStatus;
// Populate the NumberType from the IdType for parsing.
spvtools::utils::NumberType number_type;
switch (type.typ... | pushq %rbp
movq %rsp, %rbp
subq $0xa40, %rsp # imm = 0xA40
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa18(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0xa10(%rbp)
subq $0x3, %rax
ja 0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/text_handler.cpp |
spvtools::val::(anonymous namespace)::ValidateForwardDecls(spvtools::val::ValidationState_t&) | spv_result_t ValidateForwardDecls(ValidationState_t& _) {
if (_.unresolved_forward_id_count() == 0) return SPV_SUCCESS;
std::stringstream ss;
std::vector<uint32_t> ids = _.UnresolvedForwardIds();
std::transform(
std::begin(ids), std::end(ids),
std::ostream_iterator<std::string>(ss, " "),
bin... | pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp # imm = 0x440
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaecea0
cmpq $0x0, %rax
jne 0x9f82ba
movl $0x0, -0x4(%rbp)
jmp 0x9f8459
leaq -0x198(%rbp), %rdi
callq 0xd7a60
movq -0x10(%rbp), %rsi
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x438(%rbp)
callq 0xaecec0
m... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate.cpp |
(anonymous namespace)::IsStorageClassAllowedByUniversalRules(spv::StorageClass) | bool IsStorageClassAllowedByUniversalRules(spv::StorageClass storage_class) {
switch (storage_class) {
case spv::StorageClass::Uniform:
case spv::StorageClass::StorageBuffer:
case spv::StorageClass::Workgroup:
case spv::StorageClass::CrossWorkgroup:
case spv::StorageClass::Generic:
case spv::S... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2, %eax
je 0xa10963
jmp 0xa10924
movl -0xc(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0xa10963
jmp 0xa10931
movl -0xc(%rbp), %eax
addl $-0x7, %eax
subl $0x2, %eax
jb 0xa10963
jmp 0xa1093e
movl -0xc(%rbp), %eax
addl... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_atomics.cpp |
spvtools::val::ValidateBaseType(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*, unsigned int) | spv_result_t ValidateBaseType(ValidationState_t& _, const Instruction* inst,
const uint32_t base_type) {
const spv::Op opcode = inst->opcode();
if (!_.IsIntScalarType(base_type) && !_.IsIntVectorType(base_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected... | pushq %rbp
movq %rsp, %rbp
subq $0x600, %rsp # imm = 0x600
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xaf56f0
testb $0x1, %al
jne 0xa11b87
movq -0x10(%rbp), %rdi
movl -0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_bitwise.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateSingleBuiltInAtDefinition(spvtools::val::Decoration const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateSingleBuiltInAtDefinition(
const Decoration& decoration, const Instruction& inst) {
const spv::BuiltIn label = decoration.builtin();
// Universial checks
if (label == spv::BuiltIn::WorkgroupSize) {
return ValidateWorkgroupSizeAtDefinition(decoration, inst);
}
i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa3b0c0
movl %eax, -0x24(%rbp)
cmpl $0x19, -0x24(%rbp)
jne 0xa13244
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp),... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateWorkgroupSizeAtDefinition(spvtools::val::Decoration const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateWorkgroupSizeAtDefinition(
const Decoration& decoration, const Instruction& inst) {
// Vulkan requires 32-bit int, but Universal has no restrictions
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateI32Vec(
decoration, inst, 3... | pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp # imm = 0x4C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x470(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa132ca
jmp 0xa1334e
movq -0x470(%rbp), %rax
mo... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateI32Vec(spvtools::val::Decoration const&, spvtools::val::Instruction const&, unsigned int, std::function<spv_result_t (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)> const&) | spv_result_t BuiltInsValidator::ValidateI32Vec(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &... | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x400(%rbp)
movl $0x0, -0x34(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
le... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateFragDepthAtDefinition(spvtools::val::Decoration const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateFragDepthAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateF32(
decoration, inst,
[this, &inst](const std::string& message) -> spv_result_t {
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa15b34
jmp 0xa15b98
movq -0x60(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateFragmentShaderF32Vec3InputAtDefinition(spvtools::val::Decoration const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateFragmentShaderF32Vec3InputAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const spv::BuiltIn builtin = decoration.builtin();
if (spv_result_t error = ValidateF32Vec(
decoration, inst, ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa15d94
jmp 0xa15e11
movq -0x18(%rbp), %rdi
callq 0xa3b0c0
movl %eax, %ecx... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateInvocationIdAtDefinition(spvtools::val::Decoration const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateInvocationIdAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateI32(
decoration, inst,
[this, &inst](const std::string& message) -> spv_result_t {
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa15f34
jmp 0xa15f98
movq -0x60(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateLayerOrViewportIndexAtDefinition(spvtools::val::Decoration const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateLayerOrViewportIndexAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
// This can be a per-primitive variable for mesh shader stage.
// In such cases variable will have an array of 32-bit integers.
... | pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2b0(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa160ba
jmp 0xa16392
movq -0x18(%rbp), %rdi
cal... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateI32InputAtDefinition(spvtools::val::Decoration const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateI32InputAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const spv::BuiltIn builtin = decoration.builtin();
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
return _.diag... | pushq %rbp
movq %rsp, %rbp
subq $0x500, %rsp # imm = 0x500
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x4b8(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa16caa
jmp 0xa17006
movq -0x18(%rbp), %rdi
cal... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateNVSMOrARMCoreBuiltinsAtDefinition(spvtools::val::Decoration const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateNVSMOrARMCoreBuiltinsAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateI32(
decoration, inst,
[this, &inst,
&decoration](const std::... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa17814
jmp 0xa17880
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateDeviceIndexAtDefinition(spvtools::val::Decoration const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateDeviceIndexAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateI32(
decoration, inst,
[this, &inst,
&decoration](const std::string& me... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa17b54
jmp 0xa17bc0
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateFragSizeAtDefinition(spvtools::val::Decoration const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateFragSizeAtDefinition(const Decoration& decoration,
const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const spv::BuiltIn builtin = decoration.builtin();
if (spv_result_t error = ValidateI32Vec(
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa17d04
jmp 0xa17d83
movq -0x18(%rbp), %rdi
callq 0xa3b0c0
movl %eax, %ecx... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateF32ArrHelper(spvtools::val::Decoration const&, spvtools::val::Instruction const&, unsigned int, std::function<spv_result_t (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)> const&, unsigned int) | spv_result_t BuiltInsValidator::ValidateF32ArrHelper(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type) {
const Instruction* const type_inst = _.FindDef(underlying_type);
if (... | pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x450(%rbp)
movq (%rax), %rdi
movl -0x34(%rbp), %esi
callq 0xaed030
movq %rax,... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateF32VecHelper(spvtools::val::Decoration const&, spvtools::val::Instruction const&, unsigned int, std::function<spv_result_t (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)> const&, unsigned int) | spv_result_t BuiltInsValidator::ValidateF32VecHelper(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type) {
if (!_.IsFloatVectorType(underlying_type)) {
return diag(GetDefinit... | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x400(%rbp)
movq (%rax), %rdi
movl -0x34(%rbp), %esi
callq 0xaf5520
testb $0x1... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateBool(spvtools::val::Decoration const&, spvtools::val::Instruction const&, std::function<spv_result_t (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)> const&) | spv_result_t BuiltInsValidator::ValidateBool(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x2c(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
callq 0xa145a0
movl %eax, -0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateComputeShaderI32Vec3InputAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateComputeShaderI32Vec3InputAtReference(
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 = decor... | pushq %rbp
movq %rsp, %rbp
subq $0x700, %rsp # imm = 0x700
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x6a0(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateHelperInvocationAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateHelperInvocationAtReference(
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 = Get... | pushq %rbp
movq %rsp, %rbp
subq $0x670, %rsp # imm = 0x670
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x640(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateSampleIdAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateSampleIdAtReference(
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 = GetStorageC... | pushq %rbp
movq %rsp, %rbp
subq $0x670, %rsp # imm = 0x670
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x640(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateNVSMOrARMCoreBuiltinsAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateNVSMOrARMCoreBuiltinsAtReference(
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
movq %rsp, %rbp
subq $0x450, %rsp # imm = 0x450
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x410(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateFragInvocationCountAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateFragInvocationCountAtReference(
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... | pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp # imm = 0x6F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x698(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa... | /DiligentGraphics[P]DiligentCore/ThirdParty/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
movq %rsp, %rbp
subq $0x6f0, %rsp # imm = 0x6F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x698(%rbp)
movq (%rax), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xa... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_builtins.cpp |
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
movq %rsp, %rbp
subq $0xc90, %rsp # imm = 0xC90
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
cmpl $0x11, %eax
je 0xa41ccd
movl $0x0, -0x4(%rbp)
jmp 0xa424a2
movq -0x18(%rbp), %rdi
callq 0x9f91d0
movq %rax, %rdi
callq 0x9cd910
cmpq $0x1, %rax
jne 0xa41ce6
jmp ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_capability.cpp |
spvtools::val::(anonymous namespace)::IsSupportOptionalOpenCL_1_2(unsigned int) | bool IsSupportOptionalOpenCL_1_2(uint32_t capability) {
switch (spv::Capability(capability)) {
case spv::Capability::ImageBasic:
case spv::Capability::Float64:
return true;
default:
break;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0xa, %eax
je 0xa4294e
jmp 0xa42944
movl -0xc(%rbp), %eax
subl $0xd, %eax
jne 0xa42954
jmp 0xa4294e
movb $0x1, -0x1(%rbp)
jmp 0xa4295a
jmp 0xa42956
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
n... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_capability.cpp |
spvtools::val::(anonymous namespace)::IsSupportGuaranteedOpenCL_2_0(unsigned int, bool) | bool IsSupportGuaranteedOpenCL_2_0(uint32_t capability, bool embedded_profile) {
if (IsSupportGuaranteedOpenCL_1_2(capability, embedded_profile)) return true;
switch (spv::Capability(capability)) {
case spv::Capability::DeviceEnqueue:
case spv::Capability::GenericPointer:
case spv::Capability::Groups:
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl -0x8(%rbp), %edi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xa428d0
testb $0x1, %al
jne 0xa42a09
jmp 0xa42a0f
movb $0x1, -0x1(%rbp)
jmp 0xa42a35
movl -0x8(%rbp), %eax
movl %eax, -0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_capability.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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xadd250
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa4b4b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa4b4e0
movq %rax, -0x30(%rbp)
lea... | /DiligentGraphics[P]DiligentCore/ThirdParty/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
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x3c0(%rbp)
subl $0xf6, %eax
je 0xa47b41
jmp 0xa47a05
movl -0x3c0(%rbp), %eax
subl $0xf7, %eax
je 0xa47bb2
j... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::(anonymous namespace)::ValidateReturnValue(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateReturnValue(ValidationState_t& _,
const Instruction* inst) {
const auto value_id = inst->GetOperandAs<uint32_t>(0);
const auto value = _.FindDef(value_id);
if (!value || !value->type_id()) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "OpReturn... | pushq %rbp
movq %rsp, %rbp
subq $0x870, %rsp # imm = 0x870
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9f9020
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xaed030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::(anonymous namespace)::ValidateLoopMerge(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateLoopMerge(ValidationState_t& _, const Instruction* inst) {
const auto merge_id = inst->GetOperandAs<uint32_t>(0);
const auto merge = _.FindDef(merge_id);
if (!merge || merge->opcode() != spv::Op::OpLabel) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Merge Block " << _.getIdN... | pushq %rbp
movq %rsp, %rbp
subq $0xfa0, %rsp # imm = 0xFA0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9f9020
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xaed030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_cfg.cpp |
spvtools::val::(anonymous namespace)::ValidateSpecConstant(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateSpecConstant(ValidationState_t& _,
const Instruction* inst) {
// Operand 0 is the <id> of the type that we're specializing to.
auto type_id = inst->GetOperandAs<const uint32_t>(0);
auto type_instruction = _.FindDef(type_id);
auto type_opcode = type_instruct... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa10a40
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xaed030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
call... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_constants.cpp |
spvtools::val::(anonymous namespace)::ValidateMemberName(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateMemberName(ValidationState_t& _, const Instruction* inst) {
const auto type_id = inst->GetOperandAs<uint32_t>(0);
const auto type = _.FindDef(type_id);
if (!type || spv::Op::OpTypeStruct != type->opcode()) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "OpMemberName Type <id> "... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9f9020
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xaed030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_debug.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
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0xaed030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa076a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
movl %eax, %ecx
movl %ecx, %eax
addl $-0x15, %eax... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_decorations.cpp |
spvtools::val::(anonymous namespace)::CheckIntegerWrapDecoration(spvtools::val::ValidationState_t&, spvtools::val::Instruction const&, spvtools::val::Decoration const&) | spv_result_t CheckIntegerWrapDecoration(ValidationState_t& vstate,
const Instruction& inst,
const Decoration& decoration) {
switch (inst.opcode()) {
case spv::Op::OpIAdd:
case spv::Op::OpISub:
case spv::Op::OpIMul:
case sp... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
movl %eax, %ecx
movl %ecx, -0x20c(%rbp)
subl $0xc, %eax
je 0xa70043
jmp 0xa6ffdf
movl -0x20c(%rbp), %eax
subl $0x7e, %eax
je 0xa70037
jmp 0xa6f... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_decorations.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
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa04620
cmpl $0xa, (%rax)
jne 0xa89d9b
leaq -0x58(%rbp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::(anonymous namespace)::DoesDebugInfoOperandMatchExpectation(spvtools::val::ValidationState_t const&, std::function<bool (CommonDebugInfoInstructions)> const&, spvtools::val::Instruction const*, unsigned int) | bool DoesDebugInfoOperandMatchExpectation(
const ValidationState_t& _,
const std::function<bool(CommonDebugInfoInstructions)>& expectation,
const Instruction* inst, uint32_t word_index) {
if (inst->words().size() <= word_index) return false;
auto* debug_inst = _.FindDef(inst->word(word_index));
if (!s... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa076a0
movq %rax, %rdi
callq 0xe8df0
movl -0x24(%rbp), %ecx
cmpq %rcx, %rax
ja 0xa8a1b9
movb $0x0, -0x1(%rbp)
jmp 0xa8a23f
movq -0x10(%rbp), %rax
movq %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/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
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x400(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa075d0
movq -0x400(%rbp), %rdi
movl %eax, %esi
callq 0xaf5410
testb $0x1, %al
jne 0xa8a884
movq -0x10(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_extensions.cpp |
spvtools::val::(anonymous namespace)::ValidateImageLod(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateImageLod(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
uint32_t actual_result_type = 0;
if (spv_result_t error = GetActualResultType(_, inst, &actual_result_type)) {
return error;
}
if (!_.IsIntVectorType(actual_result_type) &&
!_.IsFlo... | pushq %rbp
movq %rsp, %rbp
subq $0x1330, %rsp # imm = 0x1330
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xa9be70
movl %eax, -0x24(%rbp)
cmpl $0x0, -... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::ValidateImageQueryLevelsOrSamples(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateImageQueryLevelsOrSamples(ValidationState_t& _,
const Instruction* inst) {
if (!_.IsIntScalarType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Result Type to be int scalar type";
}
const uint32_t im... | pushq %rbp
movq %rsp, %rbp
subq $0xd60, %rsp # imm = 0xD60
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd60(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa075d0
movq -0xd60(%rbp), %rdi
movl %eax, %esi
callq 0xaf56f0
testb $0x1, %al
jne 0xa9b251
movq -0x10(%rbp), %rsi
movq -0x18(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_image.cpp |
spvtools::val::(anonymous namespace)::IsValidLodOperand(spvtools::val::ValidationState_t const&, spv::Op) | bool IsValidLodOperand(const ValidationState_t& _, spv::Op opcode) {
switch (opcode) {
case spv::Op::OpImageRead:
case spv::Op::OpImageWrite:
case spv::Op::OpImageSparseRead:
return _.HasCapability(spv::Capability::ImageReadWriteLodAMD);
default:
return IsExplicitLod(opcode);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
addl $-0x62, %eax
subl $0x2, %eax
jb 0xa9dcdb
jmp 0xa9dccf
movl -0x18(%rbp), %eax
subl $0x140, %eax # imm = 0x140
jne 0xa9dcf0
jmp 0xa9dcdb
movq -0x10(%rbp), %rdi
movl $0x13... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_image.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
movq %rsp, %rbp
subq $0x7e0, %rsp # imm = 0x7E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
movl %eax, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jne 0xaa4cf7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaa5150
jmp 0xaa5048
cmpl $0x11, -0x1c(%rbp)
jne 0xaa4... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_instruction.cpp |
spvtools::val::(anonymous namespace)::ReservedCheck(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ReservedCheck(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
switch (opcode) {
// These instructions are enabled by a capability, but should never
// be used anyway.
case spv::Op::OpImageSparseSampleProjImplicitLod:
case spv::Op::OpImageSparseSam... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0xfffffecb, %eax # imm = 0xFFFFFECB
subl $0x3, %eax
ja 0xaa5436
jmp 0xaa53be
movq -0x10(%rbp), %rdi
callq 0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_instruction.cpp |
spvtools::val::(anonymous namespace)::EnablingCapabilitiesForOp(spvtools::val::ValidationState_t const&, spv::Op) | CapabilitySet EnablingCapabilitiesForOp(const ValidationState_t& state,
spv::Op opcode) {
// Exceptions for SPV_AMD_shader_ballot
switch (opcode) {
// Normally these would require Group capability
case spv::Op::OpGroupIAddNonUniformAMD:
case spv::Op::OpGroupFAddNo... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0xffffec78, %eax # imm = 0xFFFFEC78
subl $0x7, %eax
ja 0xaa618e
jmp 0xaa616d
movq -0x10(%rbp), %rdi
movl $0x5, ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_instruction.cpp |
spvtools::val::(anonymous namespace)::ValidateCopyMemory(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateCopyMemory(ValidationState_t& _, const Instruction* inst) {
const auto target_index = 0;
const auto target_id = inst->GetOperandAs<uint32_t>(target_index);
const auto target = _.FindDef(target_id);
if (!target) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Target operand <i... | pushq %rbp
movq %rsp, %rbp
subq $0x20f0, %rsp # imm = 0x20F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9f9020
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0xaed030
movq %rax, -0x28(%rbp)
cmp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_memory.cpp |
spvtools::val::(anonymous namespace)::ValidateCooperativeMatrixLoadStoreKHR(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateCooperativeMatrixLoadStoreKHR(ValidationState_t& _,
const Instruction* inst) {
uint32_t type_id;
const char* opname;
if (inst->opcode() == spv::Op::OpCooperativeMatrixLoadKHR) {
type_id = inst->type_id();
opname = "spv::Op::OpCooperat... | pushq %rbp
movq %rsp, %rbp
subq $0x12d0, %rsp # imm = 0x12D0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
cmpl $0x1169, %eax # imm = 0x1169
jne 0xab3bcc
movq -0x18(%rbp), %rdi
callq 0xa075d0
movl %eax, -0x1c(%rbp)
leaq 0x17534c(%rip), %rax # 0xc28f12
movq %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_memory.cpp |
spvtools::val::(anonymous namespace)::ValidatePtrComparison(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidatePtrComparison(ValidationState_t& _,
const Instruction* inst) {
if (_.addressing_model() == spv::AddressingModel::Logical &&
!_.features().variable_pointers) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Instruction cannot for logical addre... | pushq %rbp
movq %rsp, %rbp
subq $0x14e0, %rsp # imm = 0x14E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaeddc0
cmpl $0x0, %eax
jne 0xab69c8
movq -0x10(%rbp), %rdi
callq 0xa4f0c0
testb $0x1, 0x3(%rax)
jne 0xab69c8
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x1f0(%rbp)... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_memory.cpp |
spvtools::val::(anonymous namespace)::DoesStructContainRTA(spvtools::val::ValidationState_t const&, spvtools::val::Instruction const*) | bool DoesStructContainRTA(const ValidationState_t& _, const Instruction* inst) {
for (size_t member_index = 1; member_index < inst->operands().size();
++member_index) {
const auto member_id = inst->GetOperandAs<uint32_t>(member_index);
const auto member_type = _.FindDef(member_id);
if (member_type-... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f91d0
movq %rax, %rdi
callq 0x9cd910
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xab7301
movq -0x18(%rbp), %rdi
m... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_memory.cpp |
spvtools::val::(anonymous namespace)::GetStorageClass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | std::pair<spv::StorageClass, spv::StorageClass> GetStorageClass(
ValidationState_t& _, const Instruction* inst) {
spv::StorageClass dst_sc = spv::StorageClass::Max;
spv::StorageClass src_sc = spv::StorageClass::Max;
switch (inst->opcode()) {
case spv::Op::OpCooperativeMatrixLoadNV:
case spv::Op::OpCoo... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x7fffffff, -0x1c(%rbp) # imm = 0x7FFFFFFF
movl $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
movq -0x18(%rbp), %rdi
callq 0x9f9000
movl %eax, %ecx
movl %ecx, -0x64(%rbp)
subl $0x3d, %eax
je 0xab80f4
jmp 0xab806a
movl -0x64(%r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_memory.cpp |
spvtools::val::(anonymous namespace)::ValidateCopyMemoryMemoryAccess(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateCopyMemoryMemoryAccess(ValidationState_t& _,
const Instruction* inst) {
assert(inst->opcode() == spv::Op::OpCopyMemory ||
inst->opcode() == spv::Op::OpCopyMemorySized);
const uint32_t first_access_index =
inst->opcode() == spv::Op::OpCo... | pushq %rbp
movq %rsp, %rbp
subq $0x5d0, %rsp # imm = 0x5D0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
movl %eax, %ecx
movb $0x1, %al
cmpl $0x3f, %ecx
movb %al, -0x5c9(%rbp)
je 0xab9350
movq -0x18(%rbp), %rdi
callq 0x9f9000
cmpl $0x40, %eax
sete %al
movb %al, -0x5c9(%r... | /DiligentGraphics[P]DiligentCore/ThirdParty/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
movq %rsp, %rbp
subq $0x1190, %rsp # imm = 0x1190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9f9000
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x115c(%rbp)
subl $0x3b, %eax
je 0xabbe5a
jmp 0xabb9b3
movl -0x115c(%rbp), %eax
subl $0x14ae, %eax ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_mesh_shading.cpp |
spvtools::val::(anonymous namespace)::ValidateUndef(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateUndef(ValidationState_t& _, const Instruction* inst) {
if (_.IsVoidType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Cannot create undefined values with void type";
}
if (_.HasCapability(spv::Capability::Shader) &&
_.ContainsLimitedUseIntOrFloatType(i... | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3d0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa075d0
movq -0x3d0(%rbp), %rdi
movl %eax, %esi
callq 0xaf5410
testb $0x1, %al
jne 0xabcc2b
jmp 0xabcc73
movq -0x10(%rbp), %rsi... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_misc.cpp |
spvtools::val::(anonymous namespace)::ValidateAssumeTrue(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateAssumeTrue(ValidationState_t& _, const Instruction* inst) {
const auto operand_type_id = _.GetOperandTypeId(inst, 0);
if (!operand_type_id || !_.IsBoolScalarType(operand_type_id)) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Value operand of OpAssumeTrueKHR must be a boolean s... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xaf7390
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xabd01d
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_misc.cpp |
spvtools::val::ValidateFloatControls2(spvtools::val::ValidationState_t&) | spv_result_t ValidateFloatControls2(ValidationState_t& _) {
std::unordered_set<uint32_t> fp_fast_math_default_entry_points;
for (auto entry_point : _.entry_points()) {
const auto* exec_modes = _.GetExecutionModes(entry_point);
if (exec_modes &&
exec_modes->count(spv::ExecutionMode::FPFastMathDefault... | pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp # imm = 0x440
movq %rdi, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x218880
movq -0x10(%rbp), %rdi
callq 0x9fe220
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0xf1bb0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0xf1be0
movq %rax, -0x60(%rbp)
leaq -0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_mode_setting.cpp |
spvtools::val::(anonymous namespace)::ValidateGroupNonUniformBroadcastShuffle(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateGroupNonUniformBroadcastShuffle(ValidationState_t& _,
const Instruction* inst) {
const auto type_id = inst->type_id();
if (!_.IsFloatScalarOrVectorType(type_id) &&
!_.IsIntScalarOrVectorType(type_id) &&
!_.IsBoolScalarOrVectorType... | pushq %rbp
movq %rsp, %rbp
subq $0x7f0, %rsp # imm = 0x7F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa075d0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xaf5670
testb $0x1, %al
jne 0xac7a77
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_non_uniform.cpp |
spvtools::val::(anonymous namespace)::ValidateTypeVector(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t ValidateTypeVector(ValidationState_t& _, const Instruction* inst) {
const auto component_index = 1;
const auto component_id = inst->GetOperandAs<uint32_t>(component_index);
const auto component_type = _.FindDef(component_id);
if (!component_type || !spvOpcodeIsScalarType(component_type->opcode())) ... | pushq %rbp
movq %rsp, %rbp
subq $0x600, %rsp # imm = 0x600
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x9f9020
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0xaed030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rb... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validate_type.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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movl -0x18(%rbp), %eax
movl %eax, 0x4(%rdi)
movl -0x10(%rbp), %eax
movl %eax, ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/function.cpp |
spvtools::val::Function::AddConstruct(spvtools::val::Construct const&) | Construct& Function::AddConstruct(const Construct& new_construct) {
cfg_constructs_.push_back(new_construct);
auto& result = cfg_constructs_.back();
entry_block_to_construct_[std::make_pair(new_construct.entry_block(),
new_construct.type())] = &result;
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x290, %rdi # imm = 0x290
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rsi
callq 0xae0a60
movq -0x68(%rbp), %rdi
callq 0xae0aa0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/function.cpp |
spvtools::CFA<spvtools::val::BasicBlock>::TraversalRoots(std::vector<spvtools::val::BasicBlock*, std::allocator<spvtools::val::BasicBlock*>> const&, std::function<std::vector<spvtools::val::BasicBlock*, std::allocator<spvtools::val::BasicBlock*>> const* (spvtools::val::BasicBlock const*)>, std::function<std::vector<spv... | std::vector<BB*> CFA<BB>::TraversalRoots(const std::vector<BB*>& blocks,
get_blocks_func succ_func,
get_blocks_func pred_func) {
// The set of nodes which have been visited from any of the roots so far.
std::unordered_set<const BB*> v... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rcx, -0xf0(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa4b9a0
movq -0xe0(%r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/cfa.h |
spvtools::val::Instruction::Instruction(spv_parsed_instruction_t const*) | Instruction::Instruction(const spv_parsed_instruction_t* inst)
: words_(inst->words, inst->words + inst->num_words),
operands_(inst->operands, inst->operands + inst->num_operands),
inst_({words_.data(), inst->num_words, inst->opcode, inst->ext_inst_type,
inst->type_id, inst->result_id, oper... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
a... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/instruction.cpp |
spvtools::val::(anonymous namespace)::setHeader(void*, spv_endianness_t, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int) | spv_result_t setHeader(void* user_data, spv_endianness_t, uint32_t,
uint32_t version, uint32_t generator, uint32_t id_bound,
uint32_t) {
ValidationState_t& vstate =
*(reinterpret_cast<ValidationState_t*>(user_data));
vstate.setIdBound(id_bound);
vstate.setGenera... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xaf4e20
movq -0x28(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x190, %rdi # imm = 0x190
movl -0xc(%rbp), %esi
callq 0x7b4240
testb $0x1, %al
jne 0xaedc7c
jmp 0xaedc7e
jmp 0xaedce3
movq -0x38(%rbp), %rsi
addq $0x190, %rsi ... | /DiligentGraphics[P]DiligentCore/ThirdParty/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xaed830
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
jne 0xaede9c
movb... | /DiligentGraphics[P]DiligentCore/ThirdParty/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
callq 0xaecfb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xaf56a0
movb $0x0, -0x1(%rbp)
jmp 0xaf56e4
movq -0x20(%rbp), %rdi
callq 0x9f9000
cmpl $0x16, %e... | /DiligentGraphics[P]DiligentCore/ThirdParty/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
callq 0xaecfb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xaf57e0
movb $0x0, -0x1(%rbp)
jmp 0xaf5810
movq -0x20(%rbp), %rdi
callq 0x9f9000
cmpl $0x17, %e... | /DiligentGraphics[P]DiligentCore/ThirdParty/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
callq 0xaecfb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xaf5940
movb $0x0, -0x1(%rbp)
jmp 0xaf5970
movq -0x20(%rbp), %rdi
callq 0x9f9000
cmpl $0x17, %e... | /DiligentGraphics[P]DiligentCore/ThirdParty/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xaf5ce6
movb $0x0, -0x1(%rbp)
jmp 0xaf5e07
movq -0x58(%rbp), %rdi
... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::CooperativeVectorDimensionsMatch(spvtools::val::Instruction const*, unsigned int, unsigned int) | spv_result_t ValidationState_t::CooperativeVectorDimensionsMatch(
const Instruction* inst, uint32_t v1, uint32_t v2) {
const auto v1_type = FindDef(v1);
const auto v2_type = FindDef(v2);
if (v1_type->opcode() != v2_type->opcode()) {
return diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected cooper... | pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp # imm = 0x450
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x448(%rbp)
movl -0x1c(%rbp), %esi
callq 0xaed030
movq -0x448(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %esi
cal... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validation_state.cpp |
spvtools::val::ValidationState_t::IsValidStorageClass(spv::StorageClass) const | bool ValidationState_t::IsValidStorageClass(
spv::StorageClass storage_class) const {
if (spvIsVulkanEnv(context()->target_env)) {
switch (storage_class) {
case spv::StorageClass::UniformConstant:
case spv::StorageClass::Uniform:
case spv::StorageClass::StorageBuffer:
case spv::Storage... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9fe300
movl (%rax), %edi
callq 0x9ed3e0
testb $0x1, %al
jne 0xaf8868
jmp 0xaf8916
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x5, %eax
jb 0xaf890a
jmp 0xaf8879
movl -0x18(%rbp), %eax
addl $-... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/val/validation_state.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.