name string | code string | asm string | file string |
|---|---|---|---|
spvtools::opt::PrivateToLocalPass::GetNewType(unsigned int) | uint32_t PrivateToLocalPass::GetNewType(uint32_t old_type_id) {
auto type_mgr = context()->get_type_mgr();
Instruction* old_type_inst = get_def_use_mgr()->GetDef(old_type_id);
uint32_t pointee_type_id =
old_type_inst->GetSingleWordInOperand(kSpvTypePointerTypeIdInIdx);
uint32_t new_type_id =
type_mg... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x76b110
movq %rax, %rdi
callq 0x76b2c0
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x76b080
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x895fb0
movq %rax, -0x20(%rbp)
movq... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/private_to_local_pass.cpp |
spvtools::opt::RemoveUnusedInterfaceVariablesContext::processFunction(spvtools::opt::Function*) | bool processFunction(Function* func) {
for (const auto& basic_block : *func)
for (const auto& instruction : basic_block)
instruction.ForEachInId([&](const uint32_t* id) {
if (used_variables_.count(*id)) return;
auto* var = parent_.get_def_use_mgr()->GetDef(*id);
if (!var ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x76f940
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x76f990
movq %rax, -0x38(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/remove_unused_interface_variables_pass.cpp |
spvtools::opt::ReplaceDescArrayAccessUsingVarIndex::IsConcreteType(unsigned int) const | bool ReplaceDescArrayAccessUsingVarIndex::IsConcreteType(
uint32_t type_id) const {
Instruction* type_inst = get_def_use_mgr()->GetDef(type_id);
if (type_inst->opcode() == spv::Op::OpTypeInt ||
type_inst->opcode() == spv::Op::OpTypeFloat) {
return true;
}
if (type_inst->opcode() == spv::Op::OpType... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x76b080
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x895fb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x76b0f0
cmpl $0x15, %eax
je 0x786637
movq -0x20(%rbp), %rdi
ca... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/replace_desc_array_access_using_var_index.cpp |
spvtools::opt::ReplaceDescArrayAccessUsingVarIndex::CreateCaseBlock(spvtools::opt::Instruction*, unsigned int, std::deque<spvtools::opt::Instruction*, std::allocator<spvtools::opt::Instruction*>> const&, unsigned int, std::unordered_map<unsigned int, unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, s... | BasicBlock* ReplaceDescArrayAccessUsingVarIndex::CreateCaseBlock(
Instruction* access_chain, uint32_t element_index,
const std::deque<Instruction*>& insts_to_be_cloned,
uint32_t branch_target_id,
std::unordered_map<uint32_t, uint32_t>* old_ids_to_new_ids) const {
auto* case_block = CreateNewBlock();
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x786790
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq -0x10(... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/replace_desc_array_access_using_var_index.cpp |
spvtools::opt::ReplaceDescArrayAccessUsingVarIndex::CreateNewBlock() const | BasicBlock* ReplaceDescArrayAccessUsingVarIndex::CreateNewBlock() const {
auto* new_block = new BasicBlock(std::unique_ptr<Instruction>(new Instruction(
context(), spv::Op::OpLabel, 0, context()->TakeNextId(), {})));
get_def_use_mgr()->AnalyzeInstDefUse(new_block->GetLabelInst());
context()->set_instr_block... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x88, %edi
callq 0xdb140
movq %rax, -0x50(%rbp)
movl $0x70, %edi
callq 0xdb140
movq -0x40(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x76b110
movq -0x40(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x76b110
mo... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/replace_desc_array_access_using_var_index.cpp |
spvtools::opt::ReplaceDescArrayAccessUsingVarIndex::AddConstElementAccessToCaseBlock(spvtools::opt::BasicBlock*, spvtools::opt::Instruction*, unsigned int, std::unordered_map<unsigned int, unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>*) ... | void ReplaceDescArrayAccessUsingVarIndex::AddConstElementAccessToCaseBlock(
BasicBlock* case_block, Instruction* access_chain,
uint32_t const_element_idx,
std::unordered_map<uint32_t, uint32_t>* old_ids_to_new_ids) const {
std::unique_ptr<Instruction> access_clone(access_chain->Clone(context()));
UseCon... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x76b110
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x8f6f50
mov... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/replace_desc_array_access_using_var_index.cpp |
spvtools::opt::ReplaceDescArrayAccessUsingVarIndex::CloneInstsToBlock(spvtools::opt::BasicBlock*, spvtools::opt::Instruction*, std::deque<spvtools::opt::Instruction*, std::allocator<spvtools::opt::Instruction*>> const&, std::unordered_map<unsigned int, unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>,... | void ReplaceDescArrayAccessUsingVarIndex::CloneInstsToBlock(
BasicBlock* block, Instruction* inst_to_skip_cloning,
const std::deque<Instruction*>& insts_to_be_cloned,
std::unordered_map<uint32_t, uint32_t>* old_ids_to_new_ids) const {
for (auto* inst_to_be_cloned : insts_to_be_cloned) {
if (inst_to_be... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x7888e0
movq -0x30(... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/replace_desc_array_access_using_var_index.cpp |
spvtools::opt::InstructionBuilder::AddSelectionMerge(unsigned int, unsigned int) | Instruction* AddSelectionMerge(
uint32_t merge_id, uint32_t selection_control = static_cast<uint32_t>(
spv::SelectionControlMask::MaskNone)) {
std::unique_ptr<Instruction> new_branch_merge(new Instruction(
GetContext(), spv::Op::OpSelectionMerge, 0, 0,
{{spv_operan... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movl $0x70, %edi
callq 0xdb140
movq -0x150(%rbp), %rdi
movq %rax, -0x138(%rbp)
callq 0x7720d0
movq %rax, -0x140(%rbp)
movl -0xc(%rbp), %e... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/ir_builder.h |
spvtools::opt::InstructionBuilder::AddNaryOp(unsigned int, spv::Op, std::vector<unsigned int, std::allocator<unsigned int>> const&, unsigned int) | Instruction* AddNaryOp(uint32_t type_id, spv::Op opcode,
const std::vector<uint32_t>& operands,
uint32_t result = 0) {
std::vector<Operand> ops;
for (size_t i = 0; i < operands.size(); i++) {
ops.push_back({SPV_OPERAND_TYPE_ID, {operands[i]}});
}
/... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x772080
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/ir_builder.h |
spvtools::opt::ScalarReplacementPass::GetOrCreatePointerType(unsigned int) | uint32_t ScalarReplacementPass::GetOrCreatePointerType(uint32_t id) {
auto iter = pointee_to_pointer_.find(id);
if (iter != pointee_to_pointer_.end()) return iter->second;
analysis::TypeManager* type_mgr = context()->get_type_mgr();
uint32_t ptr_type_id =
type_mgr->FindPointerToType(id, spv::StorageClass... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0xe0, %rdi
leaq -0x14(%rbp), %rsi
callq 0x3941c0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xe0, %rdi
callq 0x395030
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/scalar_replacement_pass.cpp |
spvtools::opt::ScalarReplacementPass::CheckUsesRelaxed(spvtools::opt::Instruction const*) const | bool ScalarReplacementPass::CheckUsesRelaxed(const Instruction* inst) const {
bool ok = true;
get_def_use_mgr()->ForEachUse(
inst, [this, &ok](const Instruction* user, uint32_t index) {
switch (user->opcode()) {
case spv::Op::OpAccessChain:
case spv::Op::OpInBoundsAccessChain:
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movb $0x1, -0x11(%rbp)
callq 0x76b080
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
leaq -0x11(%rbp),... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/scalar_replacement_pass.cpp |
spvtools::opt::ScalarReplacementPass::CheckStore(spvtools::opt::Instruction const*, unsigned int) const | bool ScalarReplacementPass::CheckStore(const Instruction* inst,
uint32_t index) const {
if (index != 0u) return false;
if (inst->NumInOperands() >= 3 &&
inst->GetSingleWordInOperand(2u) &
uint32_t(spv::MemoryAccessMask::Volatile))
return false;
return tru... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x79044f
movb $0x0, -0x1(%rbp)
jmp 0x79047d
movq -0x18(%rbp), %rdi
callq 0x76b860
cmpl $0x3, %eax
jb 0x790479
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x76b0b0
andl $0x1, %eax
c... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/scalar_replacement_pass.cpp |
spvtools::opt::SSARewriter::ReplacePhiUsersWith(spvtools::opt::SSARewriter::PhiCandidate const&, unsigned int) | void SSARewriter::ReplacePhiUsersWith(const PhiCandidate& phi_to_remove,
uint32_t repl_id) {
for (uint32_t user_id : phi_to_remove.users()) {
PhiCandidate* user_phi = GetPhiCandidate(user_id);
BasicBlock* bb = pass_->context()->get_instr_block(user_id);
if (user_phi) ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7a1d60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf1bb0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf1be0
movq ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/ssa_rewrite_pass.cpp |
spvtools::opt::StrengthReductionPass::Process() | Pass::Status StrengthReductionPass::Process() {
// Initialize the member variables on a per module basis.
bool modified = false;
int32_type_id_ = 0;
uint32_type_id_ = 0;
std::memset(constant_ids_, 0, sizeof(constant_ids_));
FindIntTypesAndConstants();
modified = ScanFunctions();
return (modified ? Stat... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
movl $0x0, 0x34(%rdi)
movl $0x0, 0x38(%rdi)
addq $0x3c, %rdi
xorl %esi, %esi
movl $0x84, %edx
callq 0xd7340
movq -0x18(%rbp), %rdi
callq 0x7a9250
movq -0x18(%rbp), %rdi
callq 0x7a93d0
and... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/strength_reduction_pass.cpp |
spvtools::opt::StrengthReductionPass::ReplaceMultiplyByPowerOf2(spvtools::opt::InstructionList::iterator*) | bool StrengthReductionPass::ReplaceMultiplyByPowerOf2(
BasicBlock::iterator* inst) {
assert((*inst)->opcode() == spv::Op::OpIMul &&
"Only works for multiplication of integers.");
bool modified = false;
// Currently only works on 32-bit integers.
if ((*inst)->type_id() != int32_type_id_ &&
(*... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7754f0
movq %rax, %rdi
callq 0x76b0f0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x84, %ecx
movb %al, -0xe1(%rbp)
jne 0x7a957b
movb ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/strength_reduction_pass.cpp |
spvtools::opt::isPackingScalar(spvtools::opt::StructPackingPass::PackingRules) | static bool isPackingScalar(StructPackingPass::PackingRules rules) {
switch (rules) {
case StructPackingPass::PackingRules::Scalar:
case StructPackingPass::PackingRules::ScalarEnhancedLayout:
return true;
default:
return false;
}
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x7, %eax
subl $0x1, %eax
ja 0x7ad52a
jmp 0x7ad524
movb $0x1, -0x1(%rbp)
jmp 0x7ad52e
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/opt/struct_packing_pass.cpp |
spvtools::opt::isPackingHlsl(spvtools::opt::StructPackingPass::PackingRules) | static bool isPackingHlsl(StructPackingPass::PackingRules rules) {
switch (rules) {
case StructPackingPass::PackingRules::HlslCbuffer:
case StructPackingPass::PackingRules::HlslCbufferPackOffset:
return true;
default:
return false;
}
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x5, %eax
subl $0x1, %eax
ja 0x7ad9aa
jmp 0x7ad9a4
movb $0x1, -0x1(%rbp)
jmp 0x7ad9ae
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/opt/struct_packing_pass.cpp |
spvtools::opt::StructPackingPass::StructPackingPass(char const*, spvtools::opt::StructPackingPass::PackingRules) | StructPackingPass::StructPackingPass(const char* structToPack,
PackingRules rules)
: structToPack_{structToPack != nullptr ? structToPack : ""},
packingRules_{rules} {} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x76a7e0
movq -0x28(%rbp), %rax
leaq 0x83885d(%rip), %rcx # 0xfe65d8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x38, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0,... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/struct_packing_pass.cpp |
spvtools::opt::StructPackingPass::findStructMemberTypes(spvtools::opt::Instruction const&) const | std::vector<const analysis::Type*> StructPackingPass::findStructMemberTypes(
const Instruction& structDef) const {
// Found struct type to pack, now collect all types of its members
assert(structDef.NumOperands() > 0 &&
"Number of operands in OpTypeStruct instruction must not be zero");
const uint32_... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x797420
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/struct_packing_pass.cpp |
spvtools::opt::StructPackingPass::GetPreservedAnalyses() | IRContext::Analysis GetPreservedAnalyses() override {
return IRContext::kAnalysisCombinators | IRContext::kAnalysisCFG |
IRContext::kAnalysisDominatorAnalysis |
IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisNameMap |
IRContext::kAnalysisScalarEvolution |
IRContex... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, %edi
movl $0x10, %esi
callq 0x76b3b0
movl %eax, %edi
movl $0x20, %esi
callq 0x76b3b0
movl %eax, %edi
movl $0x40, %esi
callq 0x76b3b0
movl %eax, %edi
movl $0x80, %esi
callq 0x76b3b0
movl %eax, %edi
movl $0x100, %esi # imm = 0x100
cal... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/struct_packing_pass.h |
spvtools::opt::TrimCapabilitiesPass::addInstructionRequirementsForOpcode(spv::Op, spvtools::EnumSet<spv::Capability>*, spvtools::EnumSet<spvtools::Extension>*) const | void TrimCapabilitiesPass::addInstructionRequirementsForOpcode(
spv::Op opcode, CapabilitySet* capabilities,
ExtensionSet* extensions) const {
if (hasOpcodeConflictingCapabilities(opcode)) {
return;
}
const spv_opcode_desc_t* desc = {};
auto result = context()->grammar().lookupOpcode(opcode, &desc)... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %edi
callq 0x7b0780
testb $0x1, %al
jne 0x7b071d
jmp 0x7b071f
jmp 0x7b0774
movq -0x38(%rbp), %rdi
movq $0x0, -0x28(%rbp)
cal... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/trim_capabilities_pass.cpp |
spvtools::opt::TrimCapabilitiesPass::TrimUnrequiredCapabilities(spvtools::EnumSet<spv::Capability> const&) const | Pass::Status TrimCapabilitiesPass::TrimUnrequiredCapabilities(
const CapabilitySet& required_capabilities) const {
const FeatureManager* feature_manager = context()->get_feature_mgr();
CapabilitySet capabilities_to_trim;
for (auto capability : feature_manager->GetCapabilities()) {
// Some capabilities can... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x76b110
movq %rax, %rdi
callq 0x76c140
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x76c6b0
movq -0x18(%rbp), %rdi
callq 0x7b40b0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/trim_capabilities_pass.cpp |
spvtools::opt::TrimCapabilitiesPass::Process() | Pass::Status TrimCapabilitiesPass::Process() {
if (HasForbiddenCapabilities()) {
return Status::SuccessWithoutChange;
}
auto[required_capabilities, required_extensions] =
DetermineRequiredCapabilitiesAndExtensions();
Pass::Status capStatus = TrimUnrequiredCapabilities(required_capabilities);
Pass:... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7b13d0
testb $0x1, %al
jne 0x7b1462
jmp 0x7b146b
movl $0x11, -0x4(%rbp)
jmp 0x7b14e6
movq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x7b0d50
leaq -0x50(%rbp), %rdi
callq 0x7b4550
movq %rax, -0x5... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/trim_capabilities_pass.cpp |
spvtools::opt::Handler_OpImageRead_StorageImageReadWithoutFormat(spvtools::opt::Instruction const*) | static std::optional<spv::Capability>
Handler_OpImageRead_StorageImageReadWithoutFormat(
const Instruction* instruction) {
assert(instruction->opcode() == spv::Op::OpImageRead &&
"This handler only support OpImageRead opcodes.");
const auto* def_use_mgr = instruction->context()->get_def_use_mgr();
c... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76b0f0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x62, %ecx
movb %al, -0x3a(%rbp)
jne 0x7b1528
movb $0x1, %al
movb %al, -0x3a(%rbp)
jmp 0x7b1528
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x7b1531
jmp 0x7b1533
jmp 0x7b1552
leaq... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/trim_capabilities_pass.cpp |
void spvtools::opt::(anonymous namespace)::DFSWhile<bool spvtools::opt::(anonymous namespace)::AnyTypeOf<bool (*)(spvtools::opt::Instruction const*)>(spvtools::opt::Instruction const*, bool (*)(spvtools::opt::Instruction const*))::'lambda'(spvtools::opt::Instruction const*)>(spvtools::opt::Instruction const*, bool (*)(... | static void DFSWhile(const Instruction* instruction, UnaryPredicate condition) {
std::stack<uint32_t> instructions_to_visit;
instructions_to_visit.push(instruction->result_id());
const auto* def_use_mgr = instruction->context()->get_def_use_mgr();
while (!instructions_to_visit.empty()) {
const Instruction*... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x512c10
movq -0x18(%rbp), %rdi
callq 0x76b360
movl %eax, -0x6c(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
callq 0x7b48a0
movq -0x18(%rbp), %rdi
callq 0x779a10
movq %rax,... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/trim_capabilities_pass.cpp |
void spvtools::opt::(anonymous namespace)::DFSWhile<spvtools::opt::Handler_OpTypePointer_StorageUniform16(spvtools::opt::Instruction const*)::$_0>(spvtools::opt::Instruction const*, spvtools::opt::Handler_OpTypePointer_StorageUniform16(spvtools::opt::Instruction const*)::$_0) | static void DFSWhile(const Instruction* instruction, UnaryPredicate condition) {
std::stack<uint32_t> instructions_to_visit;
instructions_to_visit.push(instruction->result_id());
const auto* def_use_mgr = instruction->context()->get_def_use_mgr();
while (!instructions_to_visit.empty()) {
const Instruction*... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x512c10
movq -0x8(%rbp), %rdi
callq 0x76b360
movl %eax, -0x5c(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x7b48a0
movq -0x8(%rbp), %rdi
callq 0x779a10
movq %rax, %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/trim_capabilities_pass.cpp |
void spvtools::opt::TrimCapabilitiesPass::addSupportedCapabilitiesToSet<spv_opcode_desc_t>(spv_opcode_desc_t const*, spvtools::EnumSet<spv::Capability>*) const | inline void addSupportedCapabilitiesToSet(const Descriptor* const descriptor,
CapabilitySet* output) const {
const uint32_t capabilityCount = descriptor->numCapabilities;
for (uint32_t i = 0; i < capabilityCount; ++i) {
const auto capability = descriptor->capabi... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x7b38da
movq -0x50(%r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/trim_capabilities_pass.h |
void spvtools::opt::TrimCapabilitiesPass::addSupportedCapabilitiesToSet<spv_operand_desc_t>(spv_operand_desc_t const*, spvtools::EnumSet<spv::Capability>*) const | inline void addSupportedCapabilitiesToSet(const Descriptor* const descriptor,
CapabilitySet* output) const {
const uint32_t capabilityCount = descriptor->numCapabilities;
for (uint32_t i = 0; i < capabilityCount; ++i) {
const auto capability = descriptor->capabi... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x7b3bea
movq -0x50(%r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/trim_capabilities_pass.h |
spvtools::EnumSet<spv::Capability>::Iterator::operator++() | Iterator& operator++() {
do {
if (bucketIndex_ >= set_->buckets_.size()) {
bucketIndex_ = set_->buckets_.size();
bucketOffset_ = 0;
break;
}
if (bucketOffset_ + 1 == kBucketSize) {
bucketOffset_ = 0;
++bucketIndex_;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x76d700
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jb 0x7b3fd7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
c... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/enum_set.h |
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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x7b56d0
movq -0x18(%rbp), %rdi
callq 0x7b5460
cmpq $0x0, %rax
jne 0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/enum_set.h |
spvtools::opt::analysis::TypeManager::RecordIfTypeDefinition(spvtools::opt::Instruction const&) | Type* TypeManager::RecordIfTypeDefinition(const Instruction& inst) {
if (!IsTypeInst(inst.opcode())) return nullptr;
Type* type = nullptr;
switch (inst.opcode()) {
case spv::Op::OpTypeVoid:
type = new Void();
break;
case spv::Op::OpTypeBool:
type = new Bool();
break;
case spv:... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x528, %rsp # imm = 0x528
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x280(%rbp)
movq -0x20(%rbp), %rdi
callq 0x76b0f0
movl %eax, %edi
callq 0x7b4860
testb $0x1, %al
jne 0x7ba090
movq $0x0, -0x10(%rbp)
jmp 0x7bb9e7
movq $0x0, -... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/type_manager.cpp |
spvtools::opt::analysis::TypeManager::AttachDecoration(spvtools::opt::Instruction const&, spvtools::opt::analysis::Type*) | void TypeManager::AttachDecoration(const Instruction& inst, Type* type) {
const spv::Op opcode = inst.opcode();
if (!IsAnnotationInst(opcode)) return;
switch (opcode) {
case spv::Op::OpDecorate:
case spv::Op::OpDecorateId: {
const auto count = inst.NumOperands();
std::vector<uint32_t> data;
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76b0f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x7939d0
testb $0x1, %al
jne 0x7bc0e4
jmp 0x7bc21f
movl -0x1c(%rbp), %eax
movl %eax, -0x74(%rbp)
subl $0x47, %eax
je 0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/type_manager.cpp |
spvtools::opt::analysis::TypeManager::GetTypeInstruction(spvtools::opt::analysis::Type const*) | uint32_t TypeManager::GetTypeInstruction(const Type* type) {
uint32_t id = GetId(type);
if (id != 0) return id;
std::unique_ptr<Instruction> typeInst;
// TODO(1841): Handle id overflow.
id = context()->TakeNextId();
if (id == 0) {
return 0;
}
RegisterType(id, *type);
switch (type->kind()) {
#def... | pushq %rbp
movq %rsp, %rbp
subq $0x1c60, %rsp # imm = 0x1C60
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1a00(%rbp)
movq -0x18(%rbp), %rsi
callq 0x7b9fe0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7bc49b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7bf642
l... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/type_manager.cpp |
spvtools::utils::AppendToVector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned int, std::allocator<unsigned int>>*) | inline void AppendToVector(const std::string& input,
std::vector<uint32_t>* result) {
uint32_t word = 0;
size_t num_bytes = input.size();
// SPIR-V strings are null-terminated. The byte_index == num_bytes
// case is used to push the terminating null byte.
for (size_t byte_index = 0... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdbe00
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x7c5b62
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x7c5b04
movq -0x8... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/util/string_utils.h |
spvtools::opt::analysis::(anonymous namespace)::CompareTwoVectors(std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>>, std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, s... | bool CompareTwoVectors(const U32VecVec a, const U32VecVec b) {
const auto size = a.size();
if (size != b.size()) return false;
if (size == 0) return true;
if (size == 1) return a.front() == b.front();
std::vector<const std::vector<uint32_t>*> a_ptrs, b_ptrs;
a_ptrs.reserve(size);
a_ptrs.reserve(size);
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rsi, -0xb8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x1b4e00
movq -0xb8(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x1b4e00
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
je 0x7d... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/types.cpp |
spvtools::opt::analysis::Type::IsUniqueType() const | bool Type::IsUniqueType() const {
switch (kind_) {
case kPointer:
case kStruct:
case kArray:
case kRuntimeArray:
case kNodePayloadArrayAMDX:
return false;
default:
return true;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
addl $-0x9, %eax
subl $0x4, %eax
jb 0x7d07d6
jmp 0x7d07cc
movl -0x14(%rbp), %eax
subl $0xe, %eax
jne 0x7d07dc
jmp 0x7d07d6
movb $0x0, -0x1(%rbp)
jmp 0x7d07e0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
a... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/types.cpp |
spvtools::opt::analysis::Vector::IsSameImpl(spvtools::opt::analysis::Type const*, std::set<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>, std::less<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>>, std::allocator<std::pair<spvtool... | bool Vector::IsSameImpl(const Type* that, IsSameCache* seen) const {
const Vector* vt = that->AsVector();
if (!vt) return false;
return count_ == vt->count_ &&
element_type_->IsSameImpl(vt->element_type_, seen) &&
HasSameDecorations(that);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %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
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7d2167
movb $0x0, -0x1(%rbp)
jmp 0x7d21bc
movq -0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/types.cpp |
spvtools::opt::analysis::Image::str[abi:cxx11]() const | std::string Image::str() const {
std::ostringstream oss;
oss << "image(" << sampled_type_->str() << ", " << uint32_t(dim_) << ", "
<< depth_ << ", " << arrayed_ << ", " << ms_ << ", " << sampled_ << ", "
<< uint32_t(format_) << ", " << uint32_t(access_qualifier_) << ")";
return oss.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xd9cc0
leaq -0x188(%rbp), %rdi
leaq 0x409ac6(%rip), %rsi # 0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/types.cpp |
spvtools::opt::analysis::Pointer::IsSameImpl(spvtools::opt::analysis::Type const*, std::set<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>, std::less<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>>, std::allocator<std::pair<spvtoo... | bool Pointer::IsSameImpl(const Type* that, IsSameCache* seen) const {
const Pointer* pt = that->AsPointer();
if (!pt) return false;
if (storage_class_ != pt->storage_class_) return false;
auto p = seen->insert(std::make_pair(this, that->AsPointer()));
if (!p.second) {
return true;
}
bool same_pointee ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x110(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7d3c53
movb $0x0, -0x1(%rbp)
jmp 0x7d3d3b
movq -0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/types.cpp |
spvtools::opt::analysis::Function::IsSameImpl(spvtools::opt::analysis::Type const*, std::set<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>, std::less<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>>, std::allocator<std::pair<spvto... | bool Function::IsSameImpl(const Type* that, IsSameCache* seen) const {
const Function* ft = that->AsFunction();
if (!ft) return false;
if (!return_type_->IsSameImpl(ft->return_type_, seen)) return false;
if (param_types_.size() != ft->param_types_.size()) return false;
for (size_t i = 0; i < param_types_.size... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x120(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7d3fad
movb $0x0, -0x1(%rbp)
jmp 0x7d4096
movq -0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/types.cpp |
spvtools::opt::analysis::ForwardPointer::IsSameImpl(spvtools::opt::analysis::Type const*, std::set<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>, std::less<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>>, std::allocator<std::pair... | bool ForwardPointer::IsSameImpl(const Type* that, IsSameCache*) const {
const ForwardPointer* fpt = that->AsForwardPointer();
if (!fpt) return false;
return (pointer_ && fpt->pointer_ ? *pointer_ == *fpt->pointer_
: target_id_ == fpt->target_id_) &&
storage_class_ == f... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %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
movq (%rdi), %rax
callq *0x180(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7d449a
movb $0x0, -0x1(%rbp)
jmp 0x7d4515
movq -0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/types.cpp |
spvtools::opt::analysis::CooperativeMatrixNV::IsSameImpl(spvtools::opt::analysis::Type const*, std::set<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>, std::less<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>>, std::allocator<std:... | bool CooperativeMatrixNV::IsSameImpl(const Type* that,
IsSameCache* seen) const {
const CooperativeMatrixNV* mt = that->AsCooperativeMatrixNV();
if (!mt) return false;
return component_type_->IsSameImpl(mt->component_type_, seen) &&
scope_id_ == mt->scope_id_ && rows_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %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
movq (%rdi), %rax
callq *0x1c0(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7d494a
movb $0x0, -0x1(%rbp)
jmp 0x7d49c9
movq -0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/types.cpp |
spvtools::opt::analysis::CooperativeVectorNV::IsSameImpl(spvtools::opt::analysis::Type const*, std::set<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>, std::less<std::pair<spvtools::opt::analysis::Pointer const*, spvtools::opt::analysis::Pointer const*>>, std::allocator<std:... | bool CooperativeVectorNV::IsSameImpl(const Type* that,
IsSameCache* seen) const {
const CooperativeVectorNV* mt = that->AsCooperativeVectorNV();
if (!mt) return false;
return component_type_->IsSameImpl(mt->component_type_, seen) &&
components_ == mt->components_ && H... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %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
movq (%rdi), %rax
callq *0x1e0(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7d540a
movb $0x0, -0x1(%rbp)
jmp 0x7d545f
movq -0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/types.cpp |
spvtools::opt::VectorDCE::RewriteInstructions(spvtools::opt::Function*, std::unordered_map<unsigned int, spvtools::utils::BitVector, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, spvtools::utils::BitVector>>> const&) | bool VectorDCE::RewriteInstructions(
Function* function, const VectorDCE::LiveComponentMap& live_components) {
bool modified = false;
// Kill DebugValue in the middle of the instruction iteration will result
// in accessing a dangling pointer. We keep dead DebugValue instructions
// in |dead_dbg_value| to ... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x757ad0
movq -0xd8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0xd0(%rbp)
leaq -0x19(%rbp), %rcx
movq %rcx,... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/vector_dce.cpp |
spvtools::opt::AggressiveDCEPass::MarkBlockAsLive(spvtools::opt::Instruction*) | void AggressiveDCEPass::MarkBlockAsLive(Instruction* inst) {
BasicBlock* basic_block = context()->get_instr_block(inst);
if (basic_block == nullptr) {
return;
}
// If we intend to keep this instruction, we need the block label and
// block terminator to have a valid block for the instruction.
AddToWork... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x76b110
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x76f450
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7fdc49
jmp 0x7fdd3c
movq -0x18(%rbp), %rdi
callq 0x788bd0
movq -0... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/aggressive_dead_code_elim_pass.cpp |
spvtools::opt::AggressiveDCEPass::AddDebugInstructionsToWorkList(spvtools::opt::Instruction const*) | void AggressiveDCEPass::AddDebugInstructionsToWorkList(
const Instruction* inst) {
for (auto& line_inst : inst->dbg_line_insts()) {
if (line_inst.IsDebugLineInst()) {
AddOperandsToWorkList(&line_inst);
}
AddDebugScopeToWorkList(&line_inst);
}
AddDebugScopeToWorkList(inst);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x804fa0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7ac010
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7ac040
movq %rax, -0x28(%rbp)
lea... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/aggressive_dead_code_elim_pass.cpp |
spvtools::opt::AmdExtensionToKhrPass::Process() | Pass::Status AmdExtensionToKhrPass::Process() {
bool changed = false;
// Traverse the body of the functions to replace instructions that require
// the extensions.
InstructionFolder folder(
context(),
std::unique_ptr<AmdExtFoldingRules>(new AmdExtFoldingRules(context())),
MakeUnique<AmdExtCon... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x250(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x76b110
movq %rax, -0x258(%rbp)
movl $0x90, %edi
callq 0xdb140
movq -0x250(%rbp), %rdi
movq %rax, -0x260(%rbp)
callq 0x76b110
movq -0x260(%rbp), %rdi
mov... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/amd_ext_to_khr.cpp |
bool spvtools::opt::(anonymous namespace)::ReplaceGroupNonuniformOperationOpCode<(spv::Op)356>(spvtools::opt::IRContext*, spvtools::opt::Instruction*, std::vector<spvtools::opt::analysis::Constant const*, std::allocator<spvtools::opt::analysis::Constant const*>> const&) | bool ReplaceGroupNonuniformOperationOpCode(
IRContext* ctx, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
switch (new_opcode) {
case spv::Op::OpGroupNonUniformIAdd:
case spv::Op::OpGroupNonUniformFAdd:
case spv::Op::OpGroupNonUniformUMin:
case spv::Op::OpGroupNonUniformSM... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76b0f0
addl $0xffffec78, %eax # imm = 0xFFFFEC78
subl $0x7, %eax
ja 0x8085cb
jmp 0x8085c9
jmp 0x8085ea
leaq 0x3d6194(%rip), %rdi # 0xbde766
leaq 0x3d61d6(%rip), %rsi ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/amd_ext_to_khr.cpp |
spvtools::opt::(anonymous namespace)::ReplaceCubeFaceIndex(spvtools::opt::IRContext*, spvtools::opt::Instruction*, std::vector<spvtools::opt::analysis::Constant const*, std::allocator<spvtools::opt::analysis::Constant const*>> const&) | bool ReplaceCubeFaceIndex(IRContext* ctx, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
analysis::TypeManager* type_mgr = ctx->get_type_mgr();
analysis::ConstantManager* const_mgr = ctx->get_constant_mgr();
uint32_t float_type_id = type_mgr->GetFloatTypeId();
uin... | pushq %rbp
movq %rsp, %rbp
subq $0x4a0, %rsp # imm = 0x4A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x76b2c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x76b310
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x813b40
movl %eax, -0x2c(%rbp)
m... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/amd_ext_to_khr.cpp |
spvtools::opt::InstructionBuilder::AddNaryExtendedInstruction(unsigned int, unsigned int, unsigned int, std::vector<unsigned int, std::allocator<unsigned int>> const&) | Instruction* AddNaryExtendedInstruction(
uint32_t result_type, uint32_t set, uint32_t instruction,
const std::vector<uint32_t>& ext_operands) {
std::vector<Operand> operands;
operands.push_back({SPV_OPERAND_TYPE_ID, {set}});
operands.push_back(
{SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUM... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x772080
movl -0x18(%rbp), %eax
movl %eax, -0xac(%rbp)
leaq ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/ir_builder.h |
spvtools::opt::InstructionBuilder::AddSelect(unsigned int, unsigned int, unsigned int, unsigned int) | Instruction* AddSelect(uint32_t type, uint32_t cond, uint32_t true_value,
uint32_t false_value) {
// TODO(1841): Handle id overflow.
std::unique_ptr<Instruction> select(new Instruction(
GetContext(), spv::Op::OpSelect, type, GetContext()->TakeNextId(),
std::initializer_l... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movl $0x70, %edi
callq 0xdb140
movq -0x1d8(%rbp), %rdi
movq %rax, -0x1b0(%rbp)
callq 0x7720... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/ir_builder.h |
spvtools::opt::BasicBlock::Clone(spvtools::opt::IRContext*) const | BasicBlock* BasicBlock::Clone(IRContext* context) const {
BasicBlock* clone = new BasicBlock(
std::unique_ptr<Instruction>(GetLabelInst()->Clone(context)));
for (const auto& inst : insts_) {
// Use the incoming context
clone->AddInstruction(std::unique_ptr<Instruction>(inst.Clone(context)));
}
if... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x88, %edi
callq 0xdb140
movq -0x70(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x818ce0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x8f6f50
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
c... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/basic_block.cpp |
spvtools::opt::BasicBlock::ForMergeAndContinueLabel(std::function<void (unsigned int)> const&) | void BasicBlock::ForMergeAndContinueLabel(
const std::function<void(const uint32_t)>& f) {
auto ii = insts_.end();
--ii;
if (ii == insts_.begin()) return;
--ii;
if (ii->opcode() == spv::Op::OpSelectionMerge ||
ii->opcode() == spv::Op::OpLoopMerge) {
ii->ForEachInId([&f](const uint32_t* idp) { f(... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x50(%rbp)
addq $0x10, %rsi
leaq -0x18(%rbp), %rdi
callq 0x775920
leaq -0x18(%rbp), %rdi
callq 0x792d30
movq -0x50(%rbp), %rsi
addq $0x10, %rsi
leaq -0x20(%rbp), %rdi
callq 0x7758e0
leaq -0x18(%rbp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/basic_block.cpp |
spvtools::opt::BasicBlock::MergeBlockIdIfAny() const | uint32_t BasicBlock::MergeBlockIdIfAny() const {
auto merge_ii = cend();
--merge_ii;
uint32_t mbid = 0;
if (merge_ii != cbegin()) {
--merge_ii;
if (merge_ii->opcode() == spv::Op::OpLoopMerge) {
mbid = merge_ii->GetSingleWordInOperand(kLoopMergeMergeBlockIdInIdx);
} else if (merge_ii->opcode() ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x818fa0
leaq -0x10(%rbp), %rdi
callq 0x818e20
movq -0x28(%rbp), %rsi
movl $0x0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x818df0
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
cal... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/basic_block.cpp |
spvtools::opt::blockmergeutil::(anonymous namespace)::EliminateOpPhiInstructions(spvtools::opt::IRContext*, spvtools::opt::BasicBlock*)::$_0::operator()(spvtools::opt::Instruction*) const | void EliminateOpPhiInstructions(IRContext* context, BasicBlock* block) {
block->ForEachPhiInst([context](Instruction* phi) {
assert(2 == phi->NumInOperands() &&
"A block can only have one predecessor for block merging to make "
"sense.");
context->ReplaceAllUsesWith(phi->result_id(),
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76b860
movl %eax, %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x81b958
movb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x81b958... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/block_merge_util.cpp |
spvtools::opt::IRContext::IRContext(spv_target_env, std::function<void (spv_message_level_t, char const*, spv_position_t const&, char const*)>) | IRContext(spv_target_env env, MessageConsumer c)
: syntax_context_(spvContextCreate(env)),
grammar_(syntax_context_),
unique_id_(0),
module_(new Module()),
consumer_(std::move(c)),
def_use_mgr_(nullptr),
feature_mgr_(nullptr),
valid_analyses_(kAnalysisNone),... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %edi
callq 0x9ede50
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq %rax, %rdi
addq $0x8, %rdi
movq (%rax), %r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/ir_context.h |
spvtools::opt::CCPPass::VisitPhi(spvtools::opt::Instruction*) | SSAPropagator::PropStatus CCPPass::VisitPhi(Instruction* phi) {
uint32_t meet_val_id = 0;
// Implement the lattice meet operation. The result of this Phi instruction is
// interesting only if the meet operation over arguments coming through
// executable edges yields the same constant value.
for (uint32_t i ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x2, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x797420
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/ccp_pass.cpp |
spvtools::opt::CFG::ComputeStructuredOrder(spvtools::opt::Function*, spvtools::opt::BasicBlock*, spvtools::opt::BasicBlock*, std::__cxx11::list<spvtools::opt::BasicBlock*, std::allocator<spvtools::opt::BasicBlock*>>*) | void CFG::ComputeStructuredOrder(Function* func, BasicBlock* root,
BasicBlock* end,
std::list<BasicBlock*>* order) {
assert(module_->context()->get_feature_mgr()->HasCapability(
spv::Capability::Shader) &&
"This only works on stru... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq (%rax), %rdi
callq 0x82a910
movq %rax, %rdi
callq 0x76c140
movq %rax, %rdi
movl $0x1, %esi
callq 0x76c180
movb %a... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/cfg.cpp |
spvtools::opt::CFG::ComputeStructuredSuccessors(spvtools::opt::Function*) | void CFG::ComputeStructuredSuccessors(Function* func) {
block2structured_succs_.clear();
for (auto& blk : *func) {
// If no predecessors in function, make successor to pseudo entry.
if (label2preds_[blk.id()].size() == 0)
block2structured_succs_[&pseudo_entry_block_].push_back(&blk);
// If header... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
addq $0x8, %rdi
callq 0x82afb0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x76f940
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
ca... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/cfg.cpp |
spvtools::opt::CFG::SplitLoopHeader(spvtools::opt::BasicBlock*) | BasicBlock* CFG::SplitLoopHeader(BasicBlock* bb) {
assert(bb->GetLoopMergeInst() && "Expecting bb to be the header of a loop.");
Function* fn = bb->GetParent();
IRContext* context = module_->context();
// Get the new header id up front. If we are out of ids, then we cannot split
// the loop.
uint32_t new... | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x318(%rbp)
movq -0x18(%rbp), %rdi
callq 0x815780
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x309(%rbp)
je 0x8268c2
movb $0x1, %al
movb %al, -0x309(%rbp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/cfg.cpp |
spvtools::opt::CodeSinkingPass::SinkInstruction(spvtools::opt::Instruction*) | bool CodeSinkingPass::SinkInstruction(Instruction* inst) {
if (inst->opcode() != spv::Op::OpLoad &&
inst->opcode() != spv::Op::OpAccessChain) {
return false;
}
if (ReferencesMutableMemory(inst)) {
return false;
}
if (BasicBlock* target_bb = FindNewBasicBlockFor(inst)) {
Instruction* pos = ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x76b0f0
cmpl $0x3d, %eax
je 0x83216d
movq -0x18(%rbp), %rdi
callq 0x76b0f0
cmpl $0x41, %eax
je 0x83216d
movb $0x0, -0x1(%rbp)
jmp 0x83220a
movq -0x38(%rbp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/code_sink.cpp |
spvtools::opt::CodeSinkingPass::FindNewBasicBlockFor(spvtools::opt::Instruction*) | BasicBlock* CodeSinkingPass::FindNewBasicBlockFor(Instruction* inst) {
assert(inst->result_id() != 0 && "Instruction should have a result.");
BasicBlock* original_bb = context()->get_instr_block(inst);
BasicBlock* bb = original_bb;
std::unordered_set<uint32_t> bbs_with_uses;
get_def_use_mgr()->ForEachUse(
... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76b360
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xe9(%rbp)
je 0x832310
movb $0x1, %al
movb %al, -0xe9(%rbp)
jmp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/code_sink.cpp |
spvtools::opt::(anonymous namespace)::FoldBinaryOp(std::function<spvtools::opt::analysis::Constant const* (spvtools::opt::analysis::Type const*, spvtools::opt::analysis::Constant const*, spvtools::opt::analysis::Constant const*, spvtools::opt::analysis::ConstantManager*)>) | ConstantFoldingRule FoldBinaryOp(BinaryScalarFoldingRule scalar_rule) {
return [scalar_rule](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants)
-> const analysis::Constant* {
assert(constants.size() == inst->NumInOperands());
ass... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8538b0
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x849420
leaq -0x30(%rbp), %rdi
callq 0x8494a0
movq -0x38(%rbp), %rax
addq $0x4... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/const_folding_rules.cpp |
spvtools::opt::(anonymous namespace)::FoldMin(spvtools::opt::analysis::Type const*, spvtools::opt::analysis::Constant const*, spvtools::opt::analysis::Constant const*, spvtools::opt::analysis::ConstantManager*) | const analysis::Constant* FoldMin(const analysis::Type* result_type,
const analysis::Constant* a,
const analysis::Constant* b,
analysis::ConstantManager*) {
if (const analysis::Integer* int_type = result_type->AsInte... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x83a2d5
movq -0x30(%rbp), %rdi
callq 0x797ae0
cmpl $0x20, %eax
jne 0x83a215... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/const_folding_rules.cpp |
spvtools::opt::(anonymous namespace)::FoldClamp1(spvtools::opt::IRContext*, spvtools::opt::Instruction*, std::vector<spvtools::opt::analysis::Constant const*, std::allocator<spvtools::opt::analysis::Constant const*>> const&) | const analysis::Constant* FoldClamp1(
IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
assert(inst->opcode() == spv::Op::OpExtInst &&
"Expecting an extended instruction.");
assert(inst->GetSingleWordInOperand(0) ==
context->get_feature_m... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x76b0f0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0xc, %ecx
movb %al, -0xea(%rbp)
jne 0x83a699
movb $0x1, %al
movb %al, -0xea(%rbp)
jmp 0x83a699
movb -0xea... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/const_folding_rules.cpp |
spvtools::opt::(anonymous namespace)::FoldUnaryOp(std::function<spvtools::opt::analysis::Constant const* (spvtools::opt::analysis::Type const*, spvtools::opt::analysis::Constant const*, spvtools::opt::analysis::ConstantManager*)>)::$_0::~$_0() | ConstantFoldingRule FoldUnaryOp(UnaryScalarFoldingRule scalar_rule) {
return [scalar_rule](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants)
-> const analysis::Constant* {
analysis::ConstantManager* const_mgr = context->get_constant... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x84ebc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/const_folding_rules.cpp |
spvtools::opt::(anonymous namespace)::FoldBinaryOp(std::function<spvtools::opt::analysis::Constant const* (spvtools::opt::analysis::Type const*, spvtools::opt::analysis::Constant const*, spvtools::opt::analysis::Constant const*, spvtools::opt::analysis::ConstantManager*)>)::$_0::operator()(spvtools::opt::IRContext*, sp... | ConstantFoldingRule FoldBinaryOp(BinaryScalarFoldingRule scalar_rule) {
return [scalar_rule](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants)
-> const analysis::Constant* {
assert(constants.size() == inst->NumInOperands());
ass... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x28(%rbp), %rdi
callq 0x84f770
movq %rax, -0x130(%rbp)
movq -0x20(%rbp), %rdi
callq 0x76b860
movl %eax, ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/const_folding_rules.cpp |
spvtools::utils::FloatProxy<float>::GetWords() const | std::vector<uint32_t> GetWords() const {
std::vector<uint32_t> words;
if (FloatProxyTraits<T>::width() == 64) {
FloatProxyTraits<double>::uint_type d = data();
words.push_back(static_cast<uint32_t>(d));
words.push_back(static_cast<uint32_t>(d >> 32));
} else {
words.push_back(static_... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xe8dd0
callq 0x851910
cmpl $0x40, %eax
jne 0x8518d3
movq -0x38(%rbp), %rdi
callq 0x850d90
mov... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/util/hex_float.h |
void spvtools::utils::HexFloat<spvtools::utils::FloatProxy<spvtools::utils::Float16>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<spvtools::utils::Float16>>>::castTo<spvtools::utils::HexFloat<spvtools::utils::FloatProxy<float>, spvtools::utils::HexFloatTraits<spvtools::utils::FloatProxy<float>>>>(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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x1c(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x850d60
movl -0x1c(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x8528e0
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax... | /DiligentGraphics[P]DiligentCore/ThirdParty/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>>>::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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x8537e0
movq -0x18(%rbp), %rdi
movw %ax, -0xa(%rbp)
callq 0x853520
movw %ax, -0xc(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %eax
cmpl $-0xf, %eax
jg 0x8537c3
movzwl -0xc(%rbp), ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/util/hex_float.h |
spvtools::opt::analysis::ConstantManager::GetConstantsFromIds(std::vector<unsigned int, std::allocator<unsigned int>> const&) const | std::vector<const Constant*> ConstantManager::GetConstantsFromIds(
const std::vector<uint32_t>& ids) const {
std::vector<const Constant*> constants;
for (uint32_t id : ids) {
if (const Constant* c = FindDeclaredConstant(id)) {
constants.push_back(c);
} else {
return {};
}
}
return co... | 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 %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x850040
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp)... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/constants.cpp |
spvtools::opt::analysis::ConstantManager::CreateInstruction(unsigned int, spvtools::opt::analysis::Constant const*, unsigned int) const | std::unique_ptr<Instruction> ConstantManager::CreateInstruction(
uint32_t id, const Constant* c, uint32_t type_id) const {
uint32_t type =
(type_id == 0) ? context()->get_type_mgr()->GetId(c->type()) : type_id;
if (c->AsNullConstant()) {
return MakeUnique<Instruction>(context(), spv::Op::OpConstantNul... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x190(%rbp)
movq %rdi, %rax
movq %rax, -0x188(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x180(%rbp)
cmpl $0x0, -0x24(%rbp)
jn... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/constants.cpp |
spvtools::opt::ConvertToSampledImagePass::UpdateImageVariableToSampledImage(spvtools::opt::Instruction*, spvtools::opt::DescriptorSetAndBinding const&) | Pass::Status ConvertToSampledImagePass::UpdateImageVariableToSampledImage(
Instruction* image_variable,
const DescriptorSetAndBinding& descriptor_set_binding) {
std::vector<Instruction*> image_variable_loads;
FindUses(image_variable, &image_variable_loads, spv::Op::OpLoad);
if (image_variable_loads.empty(... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x757ad0
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0x3d, %ecx
callq 0x8635a0
leaq -0x38(%rbp), %rdi... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/convert_to_sampled_image_pass.cpp |
spvtools::opt::ConvertToSampledImagePass::GetSampledImageTypeForImage(spvtools::opt::Instruction*) | uint32_t ConvertToSampledImagePass::GetSampledImageTypeForImage(
Instruction* image_variable) {
const auto* variable_type = GetVariableType(*image_variable);
if (variable_type == nullptr) return 0;
const auto* image_type = variable_type->AsImage();
if (image_type == nullptr) return 0;
analysis::Image ima... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq -0x18(%rbp), %rsi
callq 0x862c70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8638eb
movl $0x0, -0x4(%rbp)
jmp 0x863964
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x90... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/convert_to_sampled_image_pass.cpp |
spvtools::opt::ConvertToSampledImagePass::IsSamplerOfSampledImageDecoratedByDescriptorSetBinding(spvtools::opt::Instruction*, spvtools::opt::DescriptorSetAndBinding const&) | bool ConvertToSampledImagePass::
IsSamplerOfSampledImageDecoratedByDescriptorSetBinding(
Instruction* sampled_image_inst,
const DescriptorSetAndBinding& descriptor_set_binding) {
auto* def_use_mgr = context()->get_def_use_mgr();
uint32_t sampler_id = sampled_image_inst->GetSingleWordInOperand(1u... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x76b110
movq %rax, %rdi
callq 0x76b8a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x76b0b0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/convert_to_sampled_image_pass.cpp |
spvtools::opt::ConvertToHalfPass::IsArithmetic(spvtools::opt::Instruction*) | bool ConvertToHalfPass::IsArithmetic(Instruction* inst) {
return target_ops_core_.count(inst->opcode()) != 0 ||
(inst->opcode() == spv::Op::OpExtInst &&
inst->GetSingleWordInOperand(0) ==
context()->get_feature_mgr()->GetExtInstImportId_GLSLstd450() &&
target_ops_450_.count(... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76b0f0
movq -0x28(%rbp), %rdi
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x86baa0
movq %rax, %rcx
movb $0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/convert_to_half_pass.cpp |
spvtools::opt::ConvertToHalfPass::EquivFloatTypeId(unsigned int, unsigned int) | uint32_t ConvertToHalfPass::EquivFloatTypeId(uint32_t ty_id, uint32_t width) {
analysis::Type* reg_equiv_ty;
Instruction* ty_inst = get_def_use_mgr()->GetDef(ty_id);
if (ty_inst->opcode() == spv::Op::OpTypeMatrix)
reg_equiv_ty = FloatMatrixType(ty_inst->GetSingleWordInOperand(1),
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x76b080
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x895fb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x76b0f0
cmpl $0x18, %eax
jne 0x86766f
movq ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/convert_to_half_pass.cpp |
spvtools::opt::ConvertToHalfPass::ProcessConvert(spvtools::opt::Instruction*) | bool ConvertToHalfPass::ProcessConvert(Instruction* inst) {
// If float32 and relaxed, change to float16 convert
if (IsFloat(inst, 32) && IsRelaxed(inst->result_id())) {
inst->SetResultType(EquivFloatTypeId(inst->type_id(), 16));
get_def_use_mgr()->AnalyzeInstUse(inst);
converted_ids_.insert(inst->resul... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movl $0x20, %edx
callq 0x867220
testb $0x1, %al
jne 0x8680ff
jmp 0x868188
movq -0x10(%rbp), %rdi
callq 0x76b360
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x8673... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/convert_to_half_pass.cpp |
spvtools::opt::CopyPropagateArrays::MemoryObject::Contains(spvtools::opt::CopyPropagateArrays::MemoryObject*) | bool CopyPropagateArrays::MemoryObject::Contains(
CopyPropagateArrays::MemoryObject* other) {
if (this->GetVariable() != other->GetVariable()) {
return false;
}
if (AccessChain().size() > other->AccessChain().size()) {
return false;
}
for (uint32_t i = 0; i < AccessChain().size(); i++) {
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x871dd0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x871dd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x86f5ef
movb $0x0, -0x1(%rbp)
jmp 0x86f6ae
movq -... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/copy_prop_arrays.cpp |
spvtools::opt::DeadBranchElimPass::AddBlocksWithBackEdge(unsigned int, unsigned int, unsigned int, std::unordered_set<spvtools::opt::BasicBlock*, std::hash<spvtools::opt::BasicBlock*>, std::equal_to<spvtools::opt::BasicBlock*>, std::allocator<spvtools::opt::BasicBlock*>>*) | void DeadBranchElimPass::AddBlocksWithBackEdge(
uint32_t cont_id, uint32_t header_id, uint32_t merge_id,
std::unordered_set<BasicBlock*>* blocks_with_back_edges) {
std::unordered_set<uint32_t> visited;
visited.insert(cont_id);
visited.insert(header_id);
visited.insert(merge_id);
std::vector<uint32_t>... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x218880
leaq -0x58(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x3... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/dead_branch_elim_pass.cpp |
spvtools::opt::DeadBranchElimPass::SwitchHasNestedBreak(unsigned int) | bool DeadBranchElimPass::SwitchHasNestedBreak(uint32_t switch_header_id) {
std::vector<BasicBlock*> block_in_construct;
BasicBlock* start_block = context()->get_instr_block(switch_header_id);
uint32_t merge_block_id = start_block->MergeBlockIdIfAny();
StructuredCFGAnalysis* cfg_analysis = context()->GetStructu... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x82ac30
movq -0x90(%rbp), %rdi
callq 0x76b110
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x7a1e00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x815f... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/dead_branch_elim_pass.cpp |
spvtools::opt::DeadBranchElimPass::FixBlockOrder() | void DeadBranchElimPass::FixBlockOrder() {
context()->BuildInvalidAnalyses(IRContext::kAnalysisCFG |
IRContext::kAnalysisDominatorAnalysis);
// Reorders blocks according to DFS of dominator tree.
ProcessFunction reorder_dominators = [this](Function* function) {
DominatorAnaly... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x76b110
movq %rax, -0x68(%rbp)
movl $0x10, %edi
movl $0x20, %esi
callq 0x76b3b0
movq -0x68(%rbp), %rdi
movl %eax, %esi
callq 0x9122a0
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/dead_branch_elim_pass.cpp |
spvtools::opt::DeadInsertElimPass::MarkInsertChain(spvtools::opt::Instruction*, std::vector<unsigned int, std::allocator<unsigned int>>*, unsigned int, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>>*) | void DeadInsertElimPass::MarkInsertChain(
Instruction* insertChain, std::vector<uint32_t>* pExtIndices,
uint32_t extOffset, std::unordered_set<uint32_t>* visited_phis) {
// Not currently optimizing array inserts.
Instruction* typeInst = get_def_use_mgr()->GetDef(insertChain->type_id());
if (typeInst->opco... | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x76b080
movq %rax, -0x260(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76b040
movq -0x260(%r... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/dead_insert_elim_pass.cpp |
spvtools::opt::DeadInsertElimPass::GetPreservedAnalyses() | IRContext::Analysis GetPreservedAnalyses() override {
return IRContext::kAnalysisDefUse |
IRContext::kAnalysisInstrToBlockMapping |
IRContext::kAnalysisDecorations | IRContext::kAnalysisCombinators |
IRContext::kAnalysisCFG | IRContext::kAnalysisDominatorAnalysis |
IRCont... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x2, %esi
callq 0x76b3b0
movl %eax, %edi
movl $0x4, %esi
callq 0x76b3b0
movl %eax, %edi
movl $0x8, %esi
callq 0x76b3b0
movl %eax, %edi
movl $0x10, %esi
callq 0x76b3b0
movl %eax, %edi
movl $0x20, %esi
callq 0x76b3b0
movl %eax, %edi
m... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/dead_insert_elim_pass.h |
spvtools::opt::analysis::(anonymous namespace)::IsSubset(std::set<std::__cxx11::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>, std::less<std::__cxx11::basic_string<char32_t, std::char_traits<char32_t>, std::allocator<char32_t>>>, std::allocator<std::__cxx11::basic_string<char32_t, std::ch... | bool IsSubset(const DecorationSet& a, const DecorationSet& b) {
auto it1 = a.begin();
auto it2 = b.begin();
while (it1 != a.end()) {
if (it2 == b.end() || *it1 < *it2) {
// |*it1| is in |a|, but not in |b|.
return false;
}
if (*it1 == *it2) {
// Found the element move to the next on... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x888c20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x888c20
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x888c80
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
c... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/decoration_manager.cpp |
spvtools::opt::analysis::DecorationManager::AreDecorationsTheSame(spvtools::opt::Instruction const*, spvtools::opt::Instruction const*, bool) const | bool DecorationManager::AreDecorationsTheSame(const Instruction* inst1,
const Instruction* inst2,
bool ignore_target) const {
switch (inst1->opcode()) {
case spv::Op::OpDecorate:
case spv::Op::OpMemberDecorate:
cas... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0x76b0f0
movl %eax, %ecx
movl %ecx, %eax
addl $-0x47, %eax
movl %ecx, -0x2c(%rbp)
subl $0x2, %eax
jb 0x884d7d
jmp 0x884d65
movl... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/decoration_manager.cpp |
spvtools::opt::analysis::DecorationManager::AddMemberDecoration(unsigned int, unsigned int, unsigned int, unsigned int) | void DecorationManager::AddMemberDecoration(uint32_t inst_id, uint32_t member,
uint32_t decoration,
uint32_t decoration_value) {
AddDecoration(
spv::Op::OpMemberDecorate,
{{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {ins... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x218(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x13c(%rbp)
leaq -0x13c(%rbp), %rax
movq %rax, -0x138(%rb... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/decoration_manager.cpp |
spvtools::opt::analysis::DecorationManager::RemoveDecoration(spvtools::opt::Instruction*)::$_0::operator()(std::vector<spvtools::opt::Instruction*, std::allocator<spvtools::opt::Instruction*>>&) const | void DecorationManager::RemoveDecoration(Instruction* inst) {
const auto remove_from_container = [inst](std::vector<Instruction*>& v) {
v.erase(std::remove(v.begin(), v.end(), inst), v.end());
};
switch (inst->opcode()) {
case spv::Op::OpDecorate:
case spv::Op::OpDecorateId:
case spv::Op::OpDecor... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7755b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7755e0
movq -0x58(%rbp), %rdx
movq %rax, -0x30(%... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/decoration_manager.cpp |
spvtools::opt::analysis::operator==(spvtools::opt::analysis::DecorationManager::TargetData const&, spvtools::opt::analysis::DecorationManager::TargetData const&) | bool operator==(const TargetData& lhs, const TargetData& rhs) {
if (!std::is_permutation(lhs.direct_decorations.begin(),
lhs.direct_decorations.end(),
rhs.direct_decorations.begin())) {
return false;
}
if (!std::is_permutation(lhs.indirect_deco... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x792800
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x792830
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x792800
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
m... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/decoration_manager.h |
spvtools::opt::analysis::DebugInfoManager::AnalyzeDebugInsts(spvtools::opt::Module&) | void DebugInfoManager::AnalyzeDebugInsts(Module& module) {
deref_operation_ = nullptr;
debug_info_none_inst_ = nullptr;
empty_debug_expr_inst_ = nullptr;
module.ForEachInst([this](Instruction* cpi) { AnalyzeDebugInst(cpi); });
// Move |empty_debug_expr_inst_| to the beginning of the debug instruction
// li... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, 0x120(%rax)
movq $0x0, 0x128(%rax)
movq $0x0, 0x130(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
ca... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.cpp |
spvtools::opt::analysis::DebugInfoManager::GetDbgSetImportId() | uint32_t DebugInfoManager::GetDbgSetImportId() {
uint32_t setId =
context()->get_feature_mgr()->GetExtInstImportId_OpenCL100DebugInfo();
if (setId == 0) {
setId =
context()->get_feature_mgr()->GetExtInstImportId_Shader100DebugInfo();
}
return setId;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x890380
movq %rax, %rdi
callq 0x76c140
movq %rax, %rdi
callq 0x8903a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x88bdee
movq -0x18(%rbp), %rdi
callq 0x890380
movq %rax, %rdi
callq 0x76c140
movq %... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.cpp |
spvtools::opt::analysis::DebugInfoManager::RegisterDbgDeclare(unsigned int, spvtools::opt::Instruction*) | void DebugInfoManager::RegisterDbgDeclare(uint32_t var_id,
Instruction* dbg_declare) {
assert(dbg_declare->GetCommonDebugOpcode() == CommonDebugInfoDebugDeclare ||
dbg_declare->GetCommonDebugOpcode() == CommonDebugInfoDebugValue);
auto dbg_decl_itr = var_id_to_dbg_... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8f8a90
movl %eax, %ecx
movb $0x1, %al
cmpl $0x1c, %ecx
movb %al, -0x51(%rbp)
je 0x88c202
movq -0x18(%rbp), %rdi
callq 0x8f8a90
cmpl $... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.cpp |
spvtools::opt::analysis::DebugInfoManager::BuildDebugInlinedAtChain(unsigned int, spvtools::opt::analysis::DebugInlinedAtContext*) | uint32_t DebugInfoManager::BuildDebugInlinedAtChain(
uint32_t callee_inlined_at, DebugInlinedAtContext* inlined_at_ctx) {
if (inlined_at_ctx->GetScopeOfCallInstruction().GetLexicalScope() ==
kNoDebugScope)
return kNoInlinedAt;
// Reuse the already generated DebugInlinedAt chain if exists.
uint32_t ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8906c0
movq %rax, %rdi
callq 0x804f10
cmpl $0x0, %eax
jne 0x88cc3d
movl $0x0, -0x4(%rbp)
jmp 0x88cd7c
movq -0x20(%rbp), %rdi
movl ... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.cpp |
spvtools::opt::analysis::(anonymous namespace)::SetInlinedOperand(spvtools::opt::Instruction*, unsigned int) | void SetInlinedOperand(Instruction* dbg_inlined_at, uint32_t inlined_operand) {
assert(dbg_inlined_at);
assert(dbg_inlined_at->GetCommonDebugOpcode() ==
CommonDebugInfoDebugInlinedAt);
if (dbg_inlined_at->NumOperands() <= kDebugInlinedAtOperandInlinedIndex) {
dbg_inlined_at->AddOperand(
{spv_... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x88cf0b
jmp 0x88cf2a
leaq 0x35df3a(%rip), %rdi # 0xbeae4c
leaq 0x35d279(%rip), %rsi # 0xbea192
movl $0x34, %edx
leaq 0x35df36(%rip), %rcx # 0xbeae5b
callq 0xd6a00
movq -0x8(%rbp), %rdi
callq 0x8f8a... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.cpp |
spvtools::opt::analysis::DebugInfoManager::GetDebugOperationWithDeref() | Instruction* DebugInfoManager::GetDebugOperationWithDeref() {
if (deref_operation_ != nullptr) return deref_operation_;
uint32_t result_id = context()->TakeNextId();
std::unique_ptr<Instruction> deref_operation;
if (context()->get_feature_mgr()->GetExtInstImportId_OpenCL100DebugInfo()) {
deref_operation =... | pushq %rbp
movq %rsp, %rbp
subq $0x3c0, %rsp # imm = 0x3C0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x338(%rbp)
cmpq $0x0, 0x120(%rax)
je 0x88d12b
movq -0x338(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x88d77c
movq -0x338(%rbp), %rdi
callq 0x890380
movq %rax, %rdi
callq 0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.cpp |
spvtools::opt::analysis::DebugInfoManager::KillDebugDeclares(unsigned int) | bool DebugInfoManager::KillDebugDeclares(uint32_t variable_id) {
bool modified = false;
auto dbg_decl_itr = var_id_to_dbg_decl_.find(variable_id);
if (dbg_decl_itr != var_id_to_dbg_decl_.end()) {
// We intentionally copy the list of DebugDeclare instructions because
// context()->KillInst(dbg_decl) will u... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movb $0x0, -0xd(%rbp)
addq $0x78, %rdi
leaq -0xc(%rbp), %rsi
callq 0x8904a0
movq -0x88(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x78, %rdi
callq 0x890500
movq %rax, -0x20(%rbp)
leaq -0x18... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.cpp |
spvtools::opt::analysis::DebugInfoManager::GetParentScope(unsigned int) | uint32_t DebugInfoManager::GetParentScope(uint32_t child_scope) {
auto dbg_scope_itr = id_to_dbg_inst_.find(child_scope);
assert(dbg_scope_itr != id_to_dbg_inst_.end());
CommonDebugInfoInstructions debug_opcode =
dbg_scope_itr->second->GetCommonDebugOpcode();
uint32_t parent_scope = kNoDebugScope;
switc... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
leaq -0xc(%rbp), %rsi
callq 0x8903e0
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0x890440
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.cpp |
spvtools::opt::analysis::DebugInfoManager::IsAncestorOfScope(unsigned int, unsigned int) | bool DebugInfoManager::IsAncestorOfScope(uint32_t scope, uint32_t ancestor) {
uint32_t ancestor_scope_itr = scope;
while (ancestor_scope_itr != kNoDebugScope) {
if (ancestor == ancestor_scope_itr) return true;
ancestor_scope_itr = GetParentScope(ancestor_scope_itr);
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x88e555
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x88e544
movb $0x1, -0x1(%rbp)... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.cpp |
spvtools::opt::analysis::DebugInfoManager::GetVulkanDebugOperation(spvtools::opt::Instruction*) | uint32_t DebugInfoManager::GetVulkanDebugOperation(Instruction* inst) {
assert(inst->GetShader100DebugOpcode() ==
NonSemanticShaderDebugInfo100DebugOperation &&
"inst must be Vulkan DebugOperation");
return context()
->get_constant_mgr()
->GetConstantFromInst(context()->get_def_use... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f8500
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1e, %ecx
movb %al, -0x11(%rbp)
jne 0x88ed54
movb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x88ed54
movb -0x11(%rb... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.cpp |
spvtools::opt::analysis::DebugInfoManager::ClearDebugInfo(spvtools::opt::Instruction*) | void DebugInfoManager::ClearDebugInfo(Instruction* instr) {
auto scope_id_to_users_itr =
scope_id_to_users_.find(instr->GetDebugScope().GetLexicalScope());
if (scope_id_to_users_itr != scope_id_to_users_.end()) {
scope_id_to_users_itr->second.erase(instr);
}
auto inlinedat_id_to_users_itr =
inli... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
addq $0xb0, %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7a2680
movq %rax, %rdi
callq 0x804f10
movq -0xa8(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/opt/debug_info_manager.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.