name string | code string | asm string | file string |
|---|---|---|---|
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkBlendOverlapEXT>, rapidjson::internal::IsGenericValue<VkBlendOverlapEXT>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllo... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5ada2
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkConservativeRasterizationModeEXT>, rapidjson::internal::IsGenericValue<VkConservativeRasterizationModeEXT>>)>::Type, rapidjson::GenericValue<rapidjson::UTF... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5ae08
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<unsigned short>, rapidjson::internal::IsGenericValue<unsigned short>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5aed4
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkImageLayout>, rapidjson::internal::IsGenericValue<VkImageLayout>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<ra... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5af60
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkResolveModeFlagBits>, rapidjson::internal::IsGenericValue<VkResolveModeFlagBits>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::Memory... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5afc6
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkSampleCountFlagBits>, rapidjson::internal::IsGenericValue<VkSampleCountFlagBits>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::Memory... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b02c
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkProvokingVertexModeEXT>, rapidjson::internal::IsGenericValue<VkProvokingVertexModeEXT>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b092
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkFormat>, rapidjson::internal::IsGenericValue<VkFormat>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::C... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b0f8
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkSamplerReductionMode>, rapidjson::internal::IsGenericValue<VkSamplerReductionMode>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::Memo... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b15e
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkDiscardRectangleModeEXT>, rapidjson::internal::IsGenericValue<VkDiscardRectangleModeEXT>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b1c4
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkSamplerYcbcrModelConversion>, rapidjson::internal::IsGenericValue<VkSamplerYcbcrModelConversion>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, r... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b2ee
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkChromaLocation>, rapidjson::internal::IsGenericValue<VkChromaLocation>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAlloca... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b35e
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkDepthBiasRepresentationEXT>, rapidjson::internal::IsGenericValue<VkDepthBiasRepresentationEXT>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rap... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b42a
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkPipelineRobustnessBufferBehavior>, rapidjson::internal::IsGenericValue<VkPipelineRobustnessBufferBehavior>>)>::Type, rapidjson::GenericValue<rapidjson::UTF... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b4be
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkPipelineRobustnessImageBehavior>, rapidjson::internal::IsGenericValue<VkPipelineRobustnessImageBehavior>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b4f6
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkDepthClampModeEXT>, rapidjson::internal::IsGenericValue<VkDepthClampModeEXT>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPool... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b55c
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkDescriptorType>, rapidjson::internal::IsGenericValue<VkDescriptorType>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAlloca... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b5c2
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkPolygonMode>, rapidjson::internal::IsGenericValue<VkPolygonMode>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<ra... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b906
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkLogicOp>, rapidjson::internal::IsGenericValue<VkLogicOp>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson:... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b9ae
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkBlendFactor>, rapidjson::internal::IsGenericValue<VkBlendFactor>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<ra... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5b9e6
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkStencilOp>, rapidjson::internal::IsGenericValue<VkStencilOp>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidj... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5ba84
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkShaderStageFlagBits>, rapidjson::internal::IsGenericValue<VkShaderStageFlagBits>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::Memory... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5bb18
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkRayTracingShaderGroupTypeKHR>, rapidjson::internal::IsGenericValue<VkRayTracingShaderGroupTypeKHR>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>,... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x18, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
callq 0x5bc12
addq $0x18, %rsp
retq
nop
| /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
Fossilize::add_application_filters(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Fossilize::AppInfo, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std:... | static bool add_application_filters(std::unordered_map<std::string, AppInfo> &output, const Value *filters)
{
if (!filters->IsObject())
{
LOGE("Not an object.\n");
return false;
}
for (auto itr = filters->MemberBegin(); itr != filters->MemberEnd(); ++itr)
{
if (!itr->value.IsObject())
{
LOGE("Not an ob... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, 0x18(%rsp)
cmpw $0x3, 0xe(%rsi)
jne 0x5d51b
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x4af56
movq %rax, %r15
xorl %r13d, %r13d
leaq 0x28(%rsp), %r14
leaq 0x1f1ae7(%rip), %rbp # 0x24ec63
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
ca... | /ValveSoftware[P]Fossilize/fossilize_application_filter.cpp |
Fossilize::create_concurrent_database_with_encoded_extra_paths(char const*, Fossilize::DatabaseMode, char const*) | DatabaseInterface *create_concurrent_database_with_encoded_extra_paths(const char *base_path, DatabaseMode mode,
const char *encoded_extra_paths)
{
if (!encoded_extra_paths)
return create_concurrent_database(base_path, mode, nullptr, 0);
#ifdef ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
testq %rdx, %rdx
je 0x5f513
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x291e0
leaq 0x1efb7f(%rip), %rdx # 0x24efed
leaq 0x30(%rsp), %r13
movq %r13,... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::merge_concurrent_databases_last_use(char const*, char const* const*, unsigned long, bool) | bool merge_concurrent_databases_last_use(const char *append_archive, const char * const *source_paths, size_t num_source_paths,
bool skip_missing_inputs)
{
std::unordered_map<Hash, uint64_t> timestamps[RESOURCE_COUNT];
for (size_t source = 0; source < num_source_paths + 1; so... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rdx, %r13
movq %rsi, 0x40(%rsp)
movq %rdi, %r14
movl $0x230, %eax # imm = 0x230
leaq 0x90(%rsp), %rdx
xorps %xmm0, %xmm0
movq %rdx, -0x30(%rdx)
movq $0x1, -0x28(%rdx)
movups %xmm0, -0x20(%rdx)
m... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::merge_concurrent_databases(char const*, char const* const*, unsigned long, bool) | bool merge_concurrent_databases(const char *append_archive, const char * const *source_paths, size_t num_source_paths,
bool skip_missing_inputs)
{
auto append_db = std::unique_ptr<DatabaseInterface>(create_stream_archive_database(append_archive, DatabaseMode::Append));
if (!append_db->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %ebx
movq %rdx, %r13
movq %rsi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x5ea98
movq %rax, %rdi
movq (%rax), %rax
movq %rdi, 0x10(%rsp)
callq *0x10(%rax)
testb %al, %al
je 0x5fa0f
movl %ebx, 0xc(%rsp)
pushq $0x1
popq %rbp
m... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::DumbDirectoryDatabase::DumbDirectoryDatabase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Fossilize::DatabaseMode) | DumbDirectoryDatabase(const string &base, DatabaseMode mode_)
: DatabaseInterface(mode_), base_directory(base), mode(mode_)
{
if (mode == DatabaseMode::ExclusiveOverWrite)
mode = DatabaseMode::OverWrite;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
callq 0x5e988
leaq 0x33fcac(%rip), %rax # 0x39f7e0
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x29840
movl %ebp, 0x30(%rbx)
leaq 0x68(%rbx), %rax
movl $0x230, %ecx # imm = 0x230
xorps %xmm0,... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::ZipDatabase::ZipDatabase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Fossilize::DatabaseMode) | ZipDatabase(const string &path_, DatabaseMode mode_)
: DatabaseInterface(mode_), path(path_), mode(mode_)
{
if (mode == DatabaseMode::ExclusiveOverWrite)
mode = DatabaseMode::OverWrite;
mz_zip_zero_struct(&mz);
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
callq 0x5e988
leaq 0x33fcd4(%rip), %rax # 0x39f878
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x29840
leaq 0xd0(%rbx), %rax
movl $0x230, %ecx # imm = 0x230
xorps %xmm0, %xmm0
movq %rax, -0x3... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::StreamArchive::StreamArchive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Fossilize::DatabaseMode) | StreamArchive(const string &path_, DatabaseMode mode_)
: DatabaseInterface(mode_), path(path_), mode(mode_)
{
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
callq 0x5e988
leaq 0x33fce2(%rip), %rax # 0x39f910
movq %rax, (%rbx)
leaq 0x20(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq %r14, %rsi
callq 0x29840
xorps %xmm0, %xmm0
leaq 0x70(%rbx), %rax
movl $0x230, %... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::ConcurrentDatabase::ConcurrentDatabase(char const*, Fossilize::DatabaseMode, char const* const*, unsigned long) | explicit ConcurrentDatabase(const char *base_path_, DatabaseMode mode_,
const char * const *extra_paths, size_t num_extra_paths)
: DatabaseInterface(mode_), base_path(base_path_ ? base_path_ : ""), mode(mode_)
{
// Normalize this mode. The concurrent database is always "exclusive write... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movl %edx, %esi
callq 0x5e988
leaq 0x33fcd6(%rip), %rax # 0x39f9a8
movq %rax, (%r12)
leaq 0x10(%r12), %r13
testq %r15, %r15
leaq 0x222234(%rip), %rsi # ... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::DumbDirectoryDatabase::write_entry(Fossilize::ResourceTag, unsigned long, void const*, unsigned long, unsigned int) | bool write_entry(ResourceTag tag, Hash hash, const void *blob, size_t size, PayloadWriteFlags flags) override
{
if ((flags & PAYLOAD_WRITE_RAW_FOSSILIZE_DB_BIT) != 0)
return false;
if (mode == DatabaseMode::ReadOnly)
return false;
if (has_entry(tag, hash))
return true;
char filename[25]; // 2 digit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
xorl %ebp, %ebp
testb $0x1, %r9b
jne 0x60434
movq %rdi, %r15
cmpl $0x1, 0x30(%rdi)
je 0x60434
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movl %esi, %r13d
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movb $0x1, %bpl
testb %al, ... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::DumbDirectoryDatabase::get_hash_list_for_resource_tag(Fossilize::ResourceTag, unsigned long*, unsigned long*) | bool get_hash_list_for_resource_tag(ResourceTag tag, size_t *hash_count, Hash *hashes) override
{
size_t size = seen_blobs[tag].size();
if (hashes)
{
if (size != *hash_count)
return false;
}
else
*hash_count = size;
if (hashes)
{
Hash *iter = hashes;
for (auto &blob : seen_blobs[tag])
... | movl %esi, %eax
imulq $0x38, %rax, %rsi
movq 0x50(%rdi,%rsi), %rax
testq %rcx, %rcx
je 0x604da
cmpq (%rdx), %rax
jne 0x604e0
pushq %rax
leaq (%rdi,%rsi), %rdx
addq $0x38, %rdx
addq $0x10, %rdx
movq %rcx, %rsi
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x604e3
movq 0x8(%rdx), %rdi
movq %rdi, (%rsi)
addq $0x8, %rsi
jmp 0x604c... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::ZipDatabase::~ZipDatabase() | ~ZipDatabase()
{
if (alive)
{
if (mode != DatabaseMode::ReadOnly)
{
if (!mz_zip_writer_finalize_archive(&mz))
LOGE_LEVEL("Failed to finalize archive.\n");
}
if (!mz_zip_end(&mz))
LOGE_LEVEL("mz_zip_end failed!\n");
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x33ef34(%rip), %rax # 0x39f878
movq %rax, (%rdi)
cmpb $0x1, 0x2d4(%rdi)
jne 0x609b1
cmpl $0x1, 0x2d0(%rbx)
je 0x60985
leaq 0x30(%rbx), %rdi
callq 0xf7381
testl %eax, %eax
jne 0x60985
callq 0x35b3b
cmpl $0x2, %eax
jg 0x60985
leaq 0x1ee7bb(%rip), %rsi # 0x24f13... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::ZipDatabase::~ZipDatabase() | ~ZipDatabase()
{
if (alive)
{
if (mode != DatabaseMode::ReadOnly)
{
if (!mz_zip_writer_finalize_archive(&mz))
LOGE_LEVEL("Failed to finalize archive.\n");
}
if (!mz_zip_end(&mz))
LOGE_LEVEL("mz_zip_end failed!\n");
}
} | pushq %rbx
movq %rdi, %rbx
callq 0x60936
movl $0x2d8, %esi # imm = 0x2D8
movq %rbx, %rdi
popq %rbx
jmp 0x295f0
nop
| /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::StreamArchive::prepare() | bool prepare() override
{
if (!impl->imported_metadata.empty() && mode != DatabaseMode::ReadOnly)
return false;
if (impl->imported_metadata.size() > 1)
return false;
switch (mode)
{
case DatabaseMode::ReadOnly:
#if _WIN32
{
file = nullptr;
int fd = _open(path.c_str(), _O_BINARY | _O_RDONLY ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x8(%rdi), %rax
movq 0x270(%rax), %rcx
subq 0x268(%rax), %rcx
setne %dl
movl 0x270(%rdi), %eax
cmpl $0x1, %eax
setne %sil
andb %dl, %sil
cmpq $0x9, %rcx
setae %cl
orb %sil, %cl
jne 0x61633
movq %rdi, %rbx
cmpl $0x4, %eax
ja 0x614ad
... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::StreamArchive::get_hash_list_for_resource_tag(Fossilize::ResourceTag, unsigned long*, unsigned long*) | bool get_hash_list_for_resource_tag(ResourceTag tag, size_t *hash_count, Hash *hashes) override
{
if (imported_metadata)
{
size_t size = imported_metadata->lists[tag].count;
if (hashes)
{
if (size != *hash_count)
return false;
}
else
*hash_count = size;
if (hashes)
{
const au... | pushq %rax
movq 0x10(%rdi), %rax
movl %esi, %r8d
testq %rax, %rax
je 0x61c7f
shlq $0x4, %r8
movq 0x18(%rax,%r8), %rsi
testq %rcx, %rcx
je 0x61cba
cmpq (%rdx), %rsi
jne 0x61cb6
leaq 0x10(%rax), %rdx
addq (%rdx,%r8), %rax
xorl %edx, %edx
cmpq %rdx, %rsi
je 0x61cd0
movq (%rax), %rdi
movq %rdi, (%rcx,%rdx,8)
incq %rdx
addq... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::StreamArchive::write_exported_metadata(void*, unsigned long) const | bool write_exported_metadata(void *data_, size_t size) const override
{
auto *data = static_cast<uint8_t *>(data_);
auto *header = static_cast<ExportedMetadataHeader *>(data_);
if (size < sizeof(*header))
return false;
header->magic = ExportedMetadataMagic;
header->size = size;
size_t offset = sizeof(... | cmpq $0xb0, %rdx
jae 0x61d36
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movabsq $0xb10bf05511153, %rax # imm = 0xB10BF05511153
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq 0x10(%rsi), %r14
leaq 0x40(%rdi), %r15
addq $0x58, %rdi
movl $0xb0, %eax
pushq $0x18
popq %rcx
cmpq... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::StreamArchive::convert_from_le(unsigned int*, unsigned char const*, unsigned int) | static void convert_from_le(uint32_t *output, const uint8_t *le_input, unsigned word_count)
{
for (unsigned i = 0; i < word_count; i++)
{
uint32_t v =
(uint32_t(le_input[0]) << 0) |
(uint32_t(le_input[1]) << 8) |
(uint32_t(le_input[2]) << 16) |
(uint32_t(le_input[3]) << 24);
*output++ = ... | movl %edx, %eax
xorl %ecx, %ecx
cmpl %ecx, %eax
je 0x61ee5
movl (%rsi,%rcx,4), %edx
movl %edx, (%rdi,%rcx,4)
incq %rcx
jmp 0x61ed6
retq
| /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Fossilize::StreamArchive::decode_payload_uncompressed(void*, unsigned long, Fossilize::StreamArchive::Entry const&, bool) | bool decode_payload_uncompressed(void *blob, size_t blob_size, const Entry &entry, bool concurrent)
{
if (entry.header.uncompressed_size != blob_size || entry.header.payload_size != blob_size)
return false;
{
ConditionalLockGuard holder(read_lock, concurrent);
if (fseek(file, entry.offset, SEEK_SET) < 0)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x14(%rcx), %eax
xorl %ebp, %ebp
cmpq %rdx, %rax
jne 0x62415
movq %rcx, %rbx
movq %rdx, %r14
movl 0x8(%rcx), %eax
cmpq %rdx, %rax
jne 0x62415
movq %rsi, %r15
movq %rdi, %r12
addq $0x290, %rdi # imm = 0x290
movq %rdi, 0x8(... | /ValveSoftware[P]Fossilize/fossilize_db.cpp |
Path::strip_whitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string strip_whitespace(const string &str)
{
string ret;
auto index = str.find_first_not_of(" \t");
if (index == string::npos)
return "";
ret = str.substr(index, string::npos);
index = ret.find_last_not_of(" \t");
if (index != string::npos)
return ret.substr(0, index + 1);
else
return ret;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
andq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x1eab2a(%rip), %rsi # 0x24f46c
movq %r14, %rdi
xorl %edx, %edx
callq 0x29340
cmpq $-0x1, %rax
je 0x649af
leaq 0x20(%rsp), ... | /ValveSoftware[P]Fossilize/path.cpp |
Path::join(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string join(const string &base, const string &path)
{
if (base.empty())
return path;
if (path.empty())
return base;
if (is_abspath(path))
return path;
auto index = find_last_slash(base);
bool need_slash = index != base.size() - 1;
return Util::join(base, need_slash ? "/" : "", path);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x64ca5
movq %rsi, %r15
cmpq $0x0, 0x8(%r14)
je 0x64cad
movq %r14, %rdi
callq 0x64bf3
testb %al, %al
je 0x64cc5
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x64cb3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29840
movq %rbx, %... | /ValveSoftware[P]Fossilize/path.cpp |
Path::basename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string basename(const string &path)
{
if (path.empty())
return "";
auto index = find_last_slash(path);
if (index == string::npos)
return path;
auto base = path.substr(index + 1, string::npos);
return base;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x64ddf
movq %rsi, %r14
movq %rsi, %rdi
callq 0x64d01
cmpq $-0x1, %rax
je 0x64df5
incq %rax
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x29630
jmp 0x64e00
leaq 0x21d133(%rip), %rsi # 0x281f19
leaq 0x7(%rsp), %rd... | /ValveSoftware[P]Fossilize/path.cpp |
Path::protocol_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | pair<string, string> protocol_split(const string &path)
{
if (path.empty())
return make_pair(string(""), string(""));
auto index = path.find("://");
if (index == string::npos)
return make_pair(string(""), path);
return make_pair(path.substr(0, index), path.substr(index + 3, string::npos));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x6501e
movq %rsi, %r14
leaq 0x1ea4b6(%rip), %rsi # 0x24f473
movq %r14, %rdi
xorl %edx, %edx
callq 0x29bb0
cmpq $-0x1, %rax
je 0x65067
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
... | /ValveSoftware[P]Fossilize/path.cpp |
Path::mkdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool mkdir(const std::string &path)
{
#ifdef _WIN32
if (!CreateDirectoryA(path.c_str(), nullptr))
{
if (GetLastError() != ERROR_ALREADY_EXISTS)
return false;
if (!is_directory(path))
return false;
}
return true;
#else
int ret = ::mkdir(path.c_str(), 0750);
if (ret == 0)
return true;
if (ret < 0 && er... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1e8, %esi # imm = 0x1E8
callq 0x29240
testl %eax, %eax
je 0x65171
jns 0x6513f
callq 0x29060
cmpl $0x11, (%rax)
jne 0x65175
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x29320
movq (%rbx), %rdi
mov... | /ValveSoftware[P]Fossilize/path.cpp |
Path::get_mtime_us(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&) | bool get_mtime_us(const std::string &path, uint64_t &mtime_us)
{
#ifdef _WIN32
HANDLE h = CreateFileA(path.c_str(), GENERIC_READ, FILE_SHARE_READ,
nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
INVALID_HANDLE_VALUE);
if (h == INVALID_HANDLE_VALUE)
return false;
FILE... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movl $0x90, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x29320
movq (%r14), %rdi
movq %r15, %rsi
callq 0x29500
movl %eax, %ecx
testl %eax, %eax
jne 0x652bc
imulq $0xf4240, 0x58(%rsp), %rsi # imm = 0xF4240
movq 0x60(%rsp), ... | /ValveSoftware[P]Fossilize/path.cpp |
Fossilize::CLIParser::next_uint() | unsigned CLIParser::next_uint()
{
if (!argc)
{
LOGE("Tried to parse uint, but nothing left in arguments.\n");
exit(EXIT_FAILURE);
}
auto val = stoul(*argv);
if (val > numeric_limits<unsigned>::max())
{
LOGE("next_uint() out of range.\n");
exit(EXIT_FAILURE);
}
argc--;
argv++;
return unsigned(val);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x0, 0x78(%rdi)
je 0x658db
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movq (%rax), %rsi
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x291e0
pushq $0xa
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x65a4f
movq %rax, %r14
movq %r15, %rdi
callq 0x2... | /ValveSoftware[P]Fossilize/cli/cli_parser.cpp |
Fossilize::CLIParser::next_string() | const char *CLIParser::next_string()
{
if (!argc)
{
LOGE("Tried to parse string, but nothing left in arguments.\n");
exit(EXIT_FAILURE);
}
const char *ret = *argv;
argc--;
argv++;
return ret;
} | movl 0x78(%rdi), %ecx
testl %ecx, %ecx
je 0x659c8
movq 0x80(%rdi), %rdx
movq (%rdx), %rax
decl %ecx
movl %ecx, 0x78(%rdi)
addq $0x8, %rdx
movq %rdx, 0x80(%rdi)
retq
pushq %rbx
movq 0x3855f8(%rip), %rbx # 0x3eafc8
movq (%rbx), %rcx
leaq 0x1e9c26(%rip), %rdi # 0x24f600
pushq $0x47
popq %rsi
pushq $0x1
popq %rdx
cal... | /ValveSoftware[P]Fossilize/cli/cli_parser.cpp |
Fossilize::VulkanDevice::init_null_device() | void VulkanDevice::init_null_device()
{
LOGI("Creating null device.\n");
device = reinterpret_cast<VkDevice>(uintptr_t(1));
gpu = reinterpret_cast<VkPhysicalDevice>(uintptr_t(2));
api_version = VK_API_VERSION_1_1;
vkCreateSampler = create_sampler;
vkDestroySampler = destroy_sampler;
vkCreateDescriptorSetLayout ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3840d4(%rip), %r14 # 0x3eafc8
movq (%r14), %rcx
leaq 0x1e8b94(%rip), %rdi # 0x24fa92
pushq $0x26
popq %rsi
pushq $0x1
popq %rdx
callq 0x29b70
movq (%r14), %rdi
callq 0x296f0
movq $0x1, 0x18(%rbx)
movq $0x2, 0x10(%rbx)
movl $0x401000, 0x360(%rbx) # imm = 0x4... | /ValveSoftware[P]Fossilize/cli/device.cpp |
Fossilize::write_string_to_file(char const*, char const*) | bool write_string_to_file(const char *path, const char *text)
{
FILE *file = fopen(path, "w");
if (!file)
return false;
if (fputs(text, file) == EOF)
{
fclose(file);
return false;
}
fclose(file);
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x221ae9(%rip), %rsi # 0x289d49
callq 0x29700
testq %rax, %rax
je 0x68288
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x296b0
cmpl $-0x1, %eax
setne %bl
movq %r14, %rdi
callq 0x295d0
jmp 0x6828a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
... | /ValveSoftware[P]Fossilize/cli/file.cpp |
Fossilize::filter_feature_enablement(VkPhysicalDeviceFeatures2&, Fossilize::VulkanFeatures&, VkPhysicalDeviceFeatures2 const*, char const**, unsigned long*) | void filter_feature_enablement(VkPhysicalDeviceFeatures2 &pdf,
VulkanFeatures &features,
const VkPhysicalDeviceFeatures2 *target_features,
const char **active_extensions, size_t *out_extension_count)
{
filter_feature_enablement(pdf, features, targ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl 0x1e8(%rsi), %r9d
movl 0x1ec(%rsi), %r8d
cmpl $0x1, %r9d
sete %al
movl 0x1f0(%rsi), %ecx
cmpl $0x1, %ecx
sete %r10b
orb %al, %r10b
cmpl $0x1, %r8d
sete %al
orb %r10b, %al
cmpb $0x1, %al
jne 0x6adbe
andq $0x0... | /ValveSoftware[P]Fossilize/cli/fossilize_feature_filter.cpp |
Fossilize::FeatureFilter::Impl::init_features(void const*) | void FeatureFilter::Impl::init_features(const void *pNext)
{
while (pNext)
{
auto *base = static_cast<const VkBaseInStructure *>(pNext);
#define F(struct_type, member, ...) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_##struct_type##_FEATURES: \
memcpy(&features.member, base, sizeof(features.member)); \
features.mem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe50(%rdi), %rax
movq %rax, 0x150(%rsp)
leaq 0xff0(%rdi), %rax
movq %rax, 0x148(%rsp)
leaq 0xfd0(%rdi), %rax
movq %rax, 0x2f0(%rsp)
leaq 0xfb8(%rdi), %rax
movq %rax, 0x140(%... | /ValveSoftware[P]Fossilize/cli/fossilize_feature_filter.cpp |
Fossilize::FeatureFilter::Impl::pnext_chain_is_supported(void const*) const | bool FeatureFilter::Impl::pnext_chain_is_supported(const void *pNext) const
{
while (pNext)
{
auto *base = static_cast<const VkBaseInStructure *>(pNext);
// These are the currently pNext structs which Fossilize serialize.
switch (base->sType)
{
case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_ST... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rsp), %r12
testq %rbx, %rbx
sete %bpl
je 0x6ef54
movl (%rbx), %edx
leal -0x3b9d2b60(%rdx), %eax
cmpl $0x2, %eax
jb 0x6e46c
leal -0x3b9e5441(%rdx), %eax
cmpl $0x2, %eax
... | /ValveSoftware[P]Fossilize/cli/fossilize_feature_filter.cpp |
Fossilize::FeatureFilter::Impl::descriptor_set_layout_is_supported(VkDescriptorSetLayoutCreateInfo const*) const | bool FeatureFilter::Impl::descriptor_set_layout_is_supported(const VkDescriptorSetLayoutCreateInfo *info) const
{
bool must_check_set_layout_before_accept = false;
// Only allow flags we recognize and validate.
constexpr VkDescriptorSetLayoutCreateFlags supported_flags =
VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESC... | movl 0x10(%rsi), %ecx
testl $0xffffff0c, %ecx # imm = 0xFFFFFF0C
je 0x6f2f8
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movb $0x1, %al
cmpb $0x0, 0x13f8(%rdi)
jne 0x6f3f7
movq %rsi, %r14
testb $0x1, %cl
je 0x6f36d
leaq 0x1e1b49(%rip), %rs... | /ValveSoftware[P]Fossilize/cli/fossilize_feature_filter.cpp |
Fossilize::extract_string[abi:cxx11](unsigned int const*, unsigned int) | static std::string extract_string(const uint32_t *words, uint32_t num_words)
{
std::string ret;
for (uint32_t i = 0; i < num_words; i++)
{
uint32_t w = words[i];
for (uint32_t j = 0; j < 4; j++, w >>= 8)
{
auto c = char(w & 0xff);
if (c == '\0')
return ret;
ret += c;
}
}
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl %edx, %r15d
xorl %r12d, %r12d
cmpq %r15, %r12
je 0x70f19
movl (%r14,%r12,4), %r13d
pushq $0x4
popq %rbp
subl $0x1, %ebp
jb ... | /ValveSoftware[P]Fossilize/cli/fossilize_feature_filter.cpp |
Fossilize::FeatureFilter::Impl::raytracing_pipeline_is_supported(VkRayTracingPipelineCreateInfoKHR const*) const | bool FeatureFilter::Impl::raytracing_pipeline_is_supported(const VkRayTracingPipelineCreateInfoKHR *info) const
{
// Only allow flags we recognize and validate.
constexpr VkPipelineCreateFlags2KHR supported_flags =
VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT |
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT |
VK_PI... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
callq 0x739a8
testq %rax, %rax
je 0x73511
movq 0x10(%rax), %r13
jmp 0x73515
movl 0x10(%r14), %r13d
testq $-0x6913f8c8, %r13 # imm = 0x96EC0738
je 0x7352e
xorl %eax, %eax
addq $0x30, %rsp
pop... | /ValveSoftware[P]Fossilize/cli/fossilize_feature_filter.cpp |
(anonymous namespace)::encodeImmediate(spvtools::AssemblyContext*, char const*, spv_instruction_t*) | spv_result_t encodeImmediate(spvtools::AssemblyContext* context,
const char* text, spv_instruction_t* pInst) {
assert(*text == '!');
uint32_t parse_result;
if (!spvtools::utils::ParseNumber(text + 1, &parse_result)) {
return context->diagnostic(SPV_ERROR_INVALID_TEXT)
<... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
cmpb $0x21, (%rsi)
jne 0x755c0
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1(%rsi), %r14
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x76537
testb %al, %al
je 0x75573
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movq %r12, %rdx
cal... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/text.cpp |
(anonymous namespace)::spvTextEncodeOpcode(spvtools::AssemblyGrammar const&, spvtools::AssemblyContext*, spv_instruction_t*) | spv_result_t spvTextEncodeOpcode(const spvtools::AssemblyGrammar& grammar,
spvtools::AssemblyContext* context,
spv_instruction_t* pInst) {
// Check for !<integer> first.
if ('!' == context->peek()) {
return encodeInstructionStartingWithImmediate(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
callq 0x7756e
leaq 0xa0(%rsp), %rcx
leaq 0x90(%rsp), %rsi
cmpb $0x21, %al
jne 0x75b0d
movq %rcx, (%rsi)
andq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/text.cpp |
spvtools::AssemblyContext::AssemblyContext(spv_text_t*, std::function<void (spv_message_level_t, char const*, spv_position_t const&, char const*)> const&, std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int>>&&) | AssemblyContext(spv_text text, const MessageConsumer& consumer,
std::set<uint32_t>&& ids_to_preserve = std::set<uint32_t>())
: current_position_({}),
consumer_(consumer),
text_(text),
bound_(1),
next_id_(1),
ids_to_preserve_(std::move(ids_to_preserve)) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
pushq $0x1
popq %rax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, %ecx # imm = 0x3F800000
movl %ecx, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
leaq 0x68(%rdi), %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/text_handler.h |
spvtools::AssemblyContext::spvNamedIdAssignOrGet(char const*) | uint32_t AssemblyContext::spvNamedIdAssignOrGet(const char* textValue) {
if (!ids_to_preserve_.empty()) {
uint32_t id = 0;
if (spvtools::utils::ParseNumber(textValue, &id)) {
if (ids_to_preserve_.find(id) != ids_to_preserve_.end()) {
bound_ = std::max(bound_, id + 1);
return id;
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x30(%rsp)
leaq 0x128(%rdi), %r14
cmpq $0x0, 0x150(%rdi)
je 0x771cd
leaq 0x10(%rsp), %rsi
andl $0x0, (%rsi)
movq %r15, %rdi
callq 0x76537
testb %al, %al
je 0x771cd
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x77d98
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/text_handler.cpp |
spvtools::(anonymous namespace)::getWord(spv_text_t*, spv_position_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | spv_result_t getWord(spv_text text, spv_position position, std::string* word) {
if (!text->str || !text->length) return SPV_ERROR_INVALID_TEXT;
if (!position) return SPV_ERROR_INVALID_POINTER;
const size_t start_index = position->index;
bool quoting = false;
bool escaping = false;
// NOTE: Assumes first ... | pushq %rbx
movq (%rdi), %r8
pushq $-0x5
popq %rbx
testq %r8, %r8
je 0x77408
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x77408
movq %rsi, %rcx
testq %rsi, %rsi
je 0x773dd
movq 0x10(%rcx), %rsi
xorl %r9d, %r9d
movabsq $0x800000100002600, %r10 # imm = 0x800000100002600
movq %rsi, %rax
xorl %r11d, %r11d
cmpq %rdi, %rax
jae ... | /ValveSoftware[P]Fossilize/cli/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %r8, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rcx), %eax
cmpq $0x3, %rax
ja 0x776b4
movq %rcx, %r12
leaq 0x1db6d9(%rip), %rcx # 0x252ce0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
j... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/text_handler.cpp |
spvtools::AssemblyContext::recordTypeIdForValue(unsigned int, unsigned int) | spv_result_t AssemblyContext::recordTypeIdForValue(uint32_t value,
uint32_t type) {
bool successfully_inserted = false;
std::tie(std::ignore, successfully_inserted) =
value_types_.insert(std::make_pair(value, type));
if (!successfully_inserted)
return d... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, %rbx
addq $0x70, %rdi
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
callq 0x78550
xorl %ebp, %ebp
testb $0x1, %dl
jne 0x77abb
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x76460... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/text_handler.cpp |
spvtools::AssemblyContext::recordIdAsExtInstImport(unsigned int, spv_ext_inst_type_t) | spv_result_t AssemblyContext::recordIdAsExtInstImport(
uint32_t id, spv_ext_inst_type_t type) {
bool successfully_inserted = false;
std::tie(std::ignore, successfully_inserted) =
import_id_to_ext_inst_type_.insert(std::make_pair(id, type));
if (!successfully_inserted)
return diagnostic() << "Import ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, %rbx
addq $0xa8, %rdi
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
callq 0x787ba
xorl %ebp, %ebp
testb $0x1, %dl
jne 0x77b2a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x76460... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/text_handler.cpp |
spvtools::AssemblyContext::GetNumericIds() const | std::set<uint32_t> AssemblyContext::GetNumericIds() const {
std::set<uint32_t> ids;
for (const auto& kv : named_ids_) {
uint32_t id;
if (spvtools::utils::ParseNumber(kv.first.c_str(), &id)) ids.insert(id);
}
return ids;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %r14
addq $0x10, %r14
leaq 0xc(%rsp), %r15
movq (%r14), %r14
testq %r14, %r14
je 0x77bb5
movq 0x8(%r14), %rdi
mov... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/text_handler.cpp |
spvtools::assumedBitWidth(spvtools::IdType const&) | inline int assumedBitWidth(const IdType& type) {
switch (type.type_class) {
case IdTypeClass::kBottom:
return 32;
case IdTypeClass::kScalarIntegerType:
case IdTypeClass::kScalarFloatType:
return type.bitwidth;
default:
break;
}
// We don't care about this case.
return 0;
} | movl 0x8(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x77c67
movl (%rdi), %eax
retq
testl %eax, %eax
jne 0x77c6f
pushq $0x20
popq %rax
retq
xorl %eax, %eax
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/text_handler.h |
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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
movq %rdi, %r15
movq 0x8(%rdi), %r12
xorl %eax, %eax
xorl %r13d, %r13d
cmpq %r12, %r13
ja 0x77d73
xorl %edx, %edx
cmpq %r12, %r13
jae 0x77d41
movq (%r15), %rcx
movzbl (%rcx,%r13), %edx
movl %r1... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/util/string_utils.h |
spvtools::val::ValidateBinaryAndKeepValidationState(spv_context_t const*, spv_validator_options_t const*, unsigned int const*, unsigned long, spv_diagnostic_t**, std::unique_ptr<spvtools::val::ValidationState_t, std::default_delete<spvtools::val::ValidationState_t>>*) | spv_result_t ValidateBinaryAndKeepValidationState(
const spv_const_context context, spv_const_validator_options options,
const uint32_t* words, const size_t num_words, spv_diagnostic* pDiagnostic,
std::unique_ptr<ValidationState_t>* vstate) {
spv_context_t hijack_context = *context;
if (pDiagnostic) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, (%rsp)
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0x7651c
testq %rbx, %rbx
je 0x78c31
andq $0x0, (%rbx)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xdc847
movl $0x6... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate.cpp |
spvtools::val::(anonymous namespace)::ValidateBinaryUsingContextAndValidationState(spv_context_t const&, unsigned int const*, unsigned long, spv_diagnostic_t**, spvtools::val::ValidationState_t*) | spv_result_t ValidateBinaryUsingContextAndValidationState(
const spv_context_t& context, const uint32_t* words, const size_t num_words,
spv_diagnostic* pDiagnostic, ValidationState_t* vstate) {
auto binary = std::unique_ptr<spv_const_binary_t>(
new spv_const_binary_t{words, num_words});
spv_endiannes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x548, %rsp # imm = 0x548
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x295e0
movq %rax, %rbp
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x78(%rsp)
leaq 0x54(%rsp), %r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate.cpp |
spvValidateBinary | spv_result_t spvValidateBinary(const spv_const_context context,
const uint32_t* words, const size_t num_words,
spv_diagnostic* pDiagnostic) {
spv_context_t hijack_context = *context;
if (pDiagnostic) {
*pDiagnostic = nullptr;
spvtools::UseDiagnos... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6f8, %rsp # imm = 0x6F8
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
movq %rsp, %rdi
callq 0x7651c
testq %rbx, %rbx
je 0x79cce
andq $0x0, (%rbx)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xdc847
callq 0xe3ab6
movq %rax, ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate.cpp |
spvValidateWithOptions | spv_result_t spvValidateWithOptions(const spv_const_context context,
spv_const_validator_options options,
const spv_const_binary binary,
spv_diagnostic* pDiagnostic) {
spv_context_t hijack_context = *context;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x700, %rsp # imm = 0x700
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0x7651c
testq %rbx, %rbx
je 0x79d82
andq $0x0, (%rbx)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xdc847
movq (%r14), %rcx
movq 0x8... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate.cpp |
unsigned int spvtools::val::Instruction::GetOperandAs<unsigned int>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0x7a042
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0x7a05b
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x1d8fe7(%rip), %rdi # 0x253030
leaq 0x1d8ffd(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
spv::ExecutionModel spvtools::val::Instruction::GetOperandAs<spv::ExecutionModel>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0x7a0a2
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0x7a0bb
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x1d8f87(%rip), %rdi # 0x253030
leaq 0x1d8f9d(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
spvtools::val::ValidationState_t::RegisterEntryPoint(unsigned int, spv::ExecutionModel, spvtools::val::ValidationState_t::EntryPointDescription&&) | void RegisterEntryPoint(const uint32_t id,
spv::ExecutionModel execution_model,
EntryPointDescription&& desc) {
entry_points_.push_back(id);
entry_point_to_execution_models_[id].insert(execution_model);
entry_point_descriptions_[id].emplace_back(desc);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movl %esi, (%r15)
movq %rsp, %r12
movl %edx, (%r12)
addq $0x200, %rdi # imm = 0x200
movq %r15, %rsi
callq 0x5fa90
leaq 0x4b0(%r14), %rdi
movq %r15, %rsi
callq 0x7a344
movq %rax, %rdi
movq %r12, %rsi
ca... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.h |
spvtools::EnumSet<spv::Capability>::contains(spv::Capability) const | bool contains(T value) const {
const size_t index = FindBucketForValue(value);
if (index >= buckets_.size() ||
buckets_[index].start != ComputeBucketStart(value)) {
return false;
}
auto& bucket = buckets_[index];
return bucket.data & ComputeMaskForValue(value);
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x7b2d6
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rdx, %rax
jae 0x7b2cb
shlq $0x4, %rax
movl %ebx, %edx
andl $-0x40, %edx
cmpl %edx, 0x8(%rcx,%rax)
jne 0x7b2cb
addq %rax, %rcx
movq (%rcx), %rax
btq %rbx, %rax
setb ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/enum_set.h |
spvtools::val::ValidateAdjacency(spvtools::val::ValidationState_t&) | spv_result_t ValidateAdjacency(ValidationState_t& _) {
const auto& instructions = _.ordered_instructions();
int adjacency_status = PHI_AND_VAR_INVALID;
for (size_t i = 0; i < instructions.size(); ++i) {
const auto& inst = instructions[i];
switch (inst.opcode()) {
case spv::Op::OpFunction:
cas... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %r14
pushq $0x3
popq %rbx
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x1b0(%r14), %r13
movq 0x1b8(%r14), %rax
subq %r13, %rax
cqto
movl $0x88, %ecx
idivq %rcx
cmpq %rax, %rbp
jae 0x7c496
leaq (%r15,%r13),... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_adjacency.cpp |
spv::StorageClass spvtools::val::Instruction::GetOperandAs<spv::StorageClass>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0x7c602
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0x7c61b
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x1d6a27(%rip), %rdi # 0x253030
leaq 0x1d6a3d(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
spvtools::val::(anonymous namespace)::DecorationTakesIdParameters(spv::Decoration) | bool DecorationTakesIdParameters(spv::Decoration type) {
switch (type) {
case spv::Decoration::UniformId:
case spv::Decoration::AlignmentId:
case spv::Decoration::MaxByteOffsetId:
case spv::Decoration::HlslCounterBufferGOOGLE:
return true;
default:
break;
}
return false;
} | movb $0x1, %al
cmpl $0x2f, %edi
ja 0x7d4a5
movl %edi, %ecx
movabsq $0xc00008000000, %rdx # imm = 0xC00008000000
btq %rcx, %rdx
jae 0x7d4a5
retq
cmpl $0x1602, %edi # imm = 0x1602
je 0x7d4a4
xorl %eax, %eax
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_annotation.cpp |
spv::Decoration spvtools::val::Instruction::GetOperandAs<spv::Decoration>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0x7d5cc
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0x7d5e5
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x1d5a5d(%rip), %rdi # 0x253030
leaq 0x1d5a73(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
spv::FPFastMathModeMask spvtools::val::Instruction::GetOperandAs<spv::FPFastMathModeMask>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0x7d676
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0x7d68f
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x1d59b3(%rip), %rdi # 0x253030
leaq 0x1d59c9(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
spvtools::val::ValidationState_t::SpvDecorationString[abi:cxx11](unsigned int) | std::string SpvDecorationString(uint32_t decoration) {
spv_operand_desc desc = nullptr;
if (grammar_.lookupOperand(SPV_OPERAND_TYPE_DECORATION, decoration,
&desc) != SPV_SUCCESS) {
return std::string("Unknown");
}
return std::string(desc->name);
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x438(%rsi), %rdi
pushq $0x1c
popq %rsi
callq 0xda054
testl %eax, %eax
je 0x7d6de
leaq 0x1e53d4(%rip), %rsi # 0x262aab
leaq 0x7(%rsp), %rdx
jmp 0x7d6eb
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
c... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.h |
spv::BuiltIn spvtools::val::Instruction::GetOperandAs<spv::BuiltIn>(unsigned long) const | T GetOperandAs(size_t index) const {
const spv_parsed_operand_t& o = operands_.at(index);
assert(o.num_words * 4 >= sizeof(T));
assert(o.offset + o.num_words <= inst_.num_words);
return *reinterpret_cast<const T*>(&words_[o.offset]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x7a1d0
movzwl 0x2(%rax), %ecx
testl %ecx, %ecx
je 0x7d7bc
movzwl (%rax), %eax
addl %eax, %ecx
movzwl 0x38(%rbx), %edx
cmpl %edx, %ecx
ja 0x7d7d5
movq (%rbx), %rcx
movl (%rcx,%rax,4), %eax
popq %rbx
retq
leaq 0x1d586d(%rip), %rdi # 0x253030
leaq 0x1d5883(%rip), %rsi ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/instruction.h |
void spvtools::val::ValidationState_t::RegisterDecorationsForStructMember<std::_Rb_tree_const_iterator<spvtools::val::Decoration>>(unsigned int, unsigned int, std::_Rb_tree_const_iterator<spvtools::val::Decoration>, std::_Rb_tree_const_iterator<spvtools::val::Decoration>) | void RegisterDecorationsForStructMember(uint32_t struct_id,
uint32_t member_index, InputIt begin,
InputIt end) {
std::set<Decoration>& cur_decs = id_decorations_[struct_id];
for (InputIt iter = begin; iter != end; ++iter) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0x3d8, %rdi # imm = 0x3D8
movq %rax, %rsi
callq 0x7dade
movq %rax, %r15
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
cmpq %rbx, %r14
je... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validation_state.h |
spvtools::val::AtomicsPass(spvtools::val::ValidationState_t&, spvtools::val::Instruction const*) | spv_result_t AtomicsPass(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
switch (opcode) {
case spv::Op::OpAtomicLoad:
case spv::Op::OpAtomicStore:
case spv::Op::OpAtomicExchange:
case spv::Op::OpAtomicFAddEXT:
case spv::Op::OpAtomicCompareExchange:
ca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %r15
movq %rdi, %r12
movzwl 0x3a(%rsi), %r14d
leal -0xe3(%r14), %ebp
cmpl $0x10, %ebp
jae 0x800f7
movl 0x40(%r15), %eax
movl %eax, 0x8(%rsp)
cmpl $0xe4, %r14d
setne %r13b
cmpl $0x13f, %r14d ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_atomics.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %r9d, %ebp
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
movl %r9d, %esi
callq 0xd34fc
testb %al, %al
je 0x859fa
movq %r13, 0x8(%rsp)
movq (%r12), %rdi
mov... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateFragDepthAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateFragDepthAtReference(
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 = GetStorage... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %r8, %rbx
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x85d55
movq %rbx, %rdi
callq 0x84... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateF32Helper(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&, unsigned int) | spv_result_t BuiltInsValidator::ValidateF32Helper(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type) {
if (!_.IsFloatScalarType(underlying_type)) {
return diag(GetDefinitionDesc(decoration, inst) +
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rdi
movl %r8d, %esi
callq 0xd34e2
testb %al, %al
je 0x86088
movq (%r14), %rdi
movl %ebp, %esi
callq 0xd3454
xorl %r13... | /ValveSoftware[P]Fossilize/cli/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
movq (%rdi), %rdi
callq 0x84ca0
movl %eax, %r13d
testl %eax, %eax
jne 0x8680d
movq (%r12), %r... | /ValveSoftware[P]Fossilize/cli/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, %rbx
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x868de
movq 0x18(%rsp), %rd... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::GetVUIDForBuiltin(spv::BuiltIn, spvtools::val::(anonymous namespace)::VUIDError_) | uint32_t GetVUIDForBuiltin(spv::BuiltIn builtIn, VUIDError type) {
uint32_t vuid = 0;
for (const auto& iter: builtinVUIDInfo) {
if (iter.builtIn == builtIn) {
assert(type < VUIDErrorMax);
vuid = iter.vuid[type];
break;
}
}
return vuid;
} | xorl %eax, %eax
leaq 0x1cece6(%rip), %rcx # 0x255a20
xorl %edx, %edx
cmpq $0x270, %rdx # imm = 0x270
je 0x86d5c
leaq 0x10(%rdx), %r8
cmpl %edi, (%rdx,%rcx)
movq %r8, %rdx
jne 0x86d3c
movl %esi, %eax
leaq (%rcx,%rax,4), %rax
movl -0xc(%r8,%rax), %eax
retq
nop
| /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateFragmentShaderF32Vec3InputAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateFragmentShaderF32Vec3InputAtReference(
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 = dec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, %rbx
movq %rcx, 0x28(%rsp)
movq %rdx, %r13
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x86ddb
movq 0x10(%rsp), %rdi
call... | /ValveSoftware[P]Fossilize/cli/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %r8, %rbx
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x872a8
movq %rbx, %rdi
callq 0x8424f
cm... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateInvocationIdAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateInvocationIdAtReference(
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 = GetStor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %r8, %rbx
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x87631
movq %rbx, %rdi
callq 0x8424f
cm... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateInstanceIndexAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateInstanceIndexAtReference(
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 = GetSto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %r8, %rbx
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x87a9b
movq %rbx, %rdi
callq 0x8424f
cm... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidatePositionAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidatePositionAtReference(
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %r8, 0x8(%rsp)
movq %rcx, 0x48(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x89a3c
movq 0x8(%rsp), %rdi
... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateI32Arr(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::ValidateI32Arr(
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)) {
retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
movq (%rdi), %rdi
callq 0x84ca0
movl %eax, %ebp
testl %eax, %eax
jne 0x8aad8
movq (%r12), %rdi
movl 0xc(%rsp... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateSampleMaskAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateSampleMaskAtReference(
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 = GetStorag... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %al
je 0x8ab61
movq %rbx, %rdi
callq 0x8424f
cmp... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateTessLevelAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateTessLevelAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
uint32_t operand = (uint32_t)decoration.builtin();
if (spvIsVulkanEnv(_.context()->target_env)) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %r8, %rbx
movq %rcx, 0x28(%rsp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x90e9c
movl %eax, 0x1c(%rsp)
movq (%r14), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateDrawIndexAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateDrawIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
uint32_t operand = (uint32_t)decoration.builtin();
if (spvIsVulkanEnv(_.context()->target_env)) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, 0x10(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, %r14
movq %rsi, 0x20(%rsp)
movq %rsi, %rdi
callq 0x90e9c
movl %eax, 0x1c(%rsp)
movq (%r14), %rax
movq (%rax), %rax
movl (%rax), %edi
ca... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.cpp |
spvtools::val::(anonymous namespace)::BuiltInsValidator::ValidateViewIndexAtReference(spvtools::val::Decoration const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&, spvtools::val::Instruction const&) | spv_result_t BuiltInsValidator::ValidateViewIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
uint32_t operand = (uint32_t)decoration.builtin();
if (spvIsVulkanEnv(_.context()->target_env)) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %r8, %rbx
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x90e9c
movl %eax, %ebp
movq (%r14), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xe366f
testb %al, %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Tools/source/val/validate_builtins.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.