name string | code string | asm string | file string |
|---|---|---|---|
Fossilize::StateReplayer::Impl::parse_subpass_description_depth_stencil_resolve(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkSubpassDescriptionDepthStencilResolve**) | bool StateReplayer::Impl::parse_subpass_description_depth_stencil_resolve(const Value &state,
VkSubpassDescriptionDepthStencilResolve **out_info)
{
auto *info = allocator.allocate_cleared<VkSubpassDescriptionDepthStencilResolve>();
*out_info = ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4b3ba
movq %rax, %r14
movq %rax, (%r12)
leaq 0x20d580(%rip), %rsi # 0x248834
movq %r15, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r14)
leaq 0x20d576(%rip), %rsi # 0x248845
movq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_sampler_custom_border_color(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkSamplerCustomBorderColorCreateInfoEXT**) | bool StateReplayer::Impl::parse_sampler_custom_border_color(const Value &state,
VkSamplerCustomBorderColorCreateInfoEXT **out_info)
{
auto *info = allocator.allocate_cleared<VkSamplerCustomBorderColorCreateInfoEXT>();
*out_info = info;
for (uint32_t i = 0; i < 4; i++)
info->customBorderColor.uint32[i] ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
callq 0x4b416
movq %rax, %rbx
movq %rax, (%r15)
xorl %r15d, %r15d
leaq 0x20d278(%rip), %r12 # 0x248997
cmpq $0x4, %r15
je 0x3b74d
movq %r14, %rdi
movq %r12, %rsi
callq 0x4b84c
movq %rax, %rdi
movl %r15d, %esi
callq 0x5133e
movq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_input_attachment_aspect(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkRenderPassInputAttachmentAspectCreateInfo**) | bool StateReplayer::Impl::parse_input_attachment_aspect(const Value &state,
VkRenderPassInputAttachmentAspectCreateInfo **out_info)
{
auto *info = allocator.allocate_cleared<VkRenderPassInputAttachmentAspectCreateInfo>();
*out_info = info;
info->aspectReferenceCount = state["aspectReferences"].Size();... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4b42e
movq %rax, %r13
movq %r15, 0x10(%rsp)
movq %rax, (%r15)
leaq 0x20d1d9(%rip), %r12 # 0x2489b7
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4b84c
movq %rax, %rdi
callq 0x4add4
mov... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_discard_rectangles(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPipelineDiscardRectangleStateCreateInfoEXT**) | bool StateReplayer::Impl::parse_discard_rectangles(const Value &state,
VkPipelineDiscardRectangleStateCreateInfoEXT **out_info)
{
auto *info = allocator.allocate_cleared<VkPipelineDiscardRectangleStateCreateInfoEXT>();
*out_info = info;
info->flags = static_cast<Vk... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4b44e
movq %rax, %r14
movq %rax, (%r12)
leaq 0x241a1c(%rip), %rsi # 0x27d2f2
movq %r15, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r14)
leaq 0x20d0ec(%rip), %rsi # 0x2489dd
movq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_fragment_shading_rate(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPipelineFragmentShadingRateStateCreateInfoKHR**) | bool StateReplayer::Impl::parse_fragment_shading_rate(const Value &state,
VkPipelineFragmentShadingRateStateCreateInfoKHR **out_info)
{
auto *info = allocator.allocate_cleared<VkPipelineFragmentShadingRateStateCreateInfoKHR>();
*out_info = info;
// Could be null... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
callq 0x4b492
movq %rax, %r14
movq %rax, (%r15)
leaq 0x20d014(%rip), %rsi # 0x248a5a
movq %rbx, %rdi
callq 0x4aeca
testb %al, %al
je 0x3baa5
leaq 0x20d001(%rip), %r15 # 0x248a5a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b84c
lea... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_sampler_ycbcr_conversion(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkSamplerYcbcrConversionCreateInfo**) | bool StateReplayer::Impl::parse_sampler_ycbcr_conversion(const Value &state,
VkSamplerYcbcrConversionCreateInfo **out_info)
{
auto *info = allocator.allocate_cleared<VkSamplerYcbcrConversionCreateInfo>();
*out_info = info;
info->format = static_cast<VkFormat>... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
callq 0x4b49e
movq %rax, %rbx
movq %rax, (%r15)
leaq 0x271db7(%rip), %rsi # 0x2ad8d2
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%rbx)
leaq 0x20cf3e(%rip), %rsi # 0x248a73
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_multisampled_render_to_single_sampled(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkMultisampledRenderToSingleSampledInfoEXT**) | bool StateReplayer::Impl::parse_multisampled_render_to_single_sampled(const Value &state, VkMultisampledRenderToSingleSampledInfoEXT **out_info)
{
auto *info = allocator.allocate_cleared<VkMultisampledRenderToSingleSampledInfoEXT>();
info->multisampledRenderToSingleSampledEnable = state["multisampledRenderToSingleSam... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x4b4da
movq %rax, %r15
leaq 0x20ccee(%rip), %rsi # 0x248af4
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r15)
leaq 0x20c6bc(%rip), %rsi # 0x2484dd
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
mov... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_depth_bias_representation(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkDepthBiasRepresentationInfoEXT**) | bool StateReplayer::Impl::parse_depth_bias_representation(const Value &state, VkDepthBiasRepresentationInfoEXT **out_info)
{
auto *info = allocator.allocate_cleared<VkDepthBiasRepresentationInfoEXT>();
info->depthBiasExact = state["depthBiasExact"].GetUint();
info->depthBiasRepresentation = static_cast<VkDepthBiasRe... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x4b4e6
movq %rax, %r15
leaq 0x20ccc2(%rip), %rsi # 0x248b1c
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x14(%r15)
leaq 0x20ccb6(%rip), %rsi # 0x248b2b
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
mov... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_render_pass_fragment_density_map(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkRenderPassFragmentDensityMapCreateInfoEXT**) | bool StateReplayer::Impl::parse_render_pass_fragment_density_map(const Value &state, VkRenderPassFragmentDensityMapCreateInfoEXT **out_info)
{
auto *info = allocator.allocate_cleared<VkRenderPassFragmentDensityMapCreateInfoEXT>();
info->fragmentDensityMapAttachment.attachment = state["fragmentDensityMapAttachment"]["... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
callq 0x4b4f2
movq %rax, %r14
leaq 0x20cc92(%rip), %r12 # 0x248b43
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b84c
leaq 0x20cc9d(%rip), %rsi # 0x248b60
movq %rax, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_sample_locations_info(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkSampleLocationsInfoEXT**) | bool StateReplayer::Impl::parse_sample_locations_info(const Value &state, VkSampleLocationsInfoEXT **out_info)
{
auto *info = allocator.allocate_cleared<VkSampleLocationsInfoEXT>();
info->sampleLocationGridSize.width = state["sampleLocationGridSize"]["width"].GetUint();
info->sampleLocationGridSize.height = state["s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %r15
callq 0x4b4fe
movq %rax, %r14
leaq 0x20ca2a(%rip), %rbx # 0x24895c
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4b84c
leaq 0x23d46a(%rip), %rsi # 0x2793ae
movq %rax, %rdi
callq 0x4b84c
movq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_rendering_attachment_location_info(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkRenderingAttachmentLocationInfo**) | bool StateReplayer::Impl::parse_rendering_attachment_location_info(const Value &state, VkRenderingAttachmentLocationInfoKHR **out_info)
{
auto *info = allocator.allocate_cleared<VkRenderingAttachmentLocationInfoKHR>();
info->colorAttachmentCount = state["colorAttachmentCount"].GetUint();
if (state.HasMember("colorAt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x4b52e
movq %rax, %r15
leaq 0x20ca10(%rip), %rsi # 0x248bd1
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r15)
leaq 0x20ca0a(%rip), %rsi # 0x248be6
mov... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_rendering_input_attachment_index_info(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkRenderingInputAttachmentIndexInfo**) | bool StateReplayer::Impl::parse_rendering_input_attachment_index_info(const Value &state, VkRenderingInputAttachmentIndexInfoKHR **out_info)
{
auto *info = allocator.allocate_cleared<VkRenderingInputAttachmentIndexInfoKHR>();
info->colorAttachmentCount = state["colorAttachmentCount"].GetUint();
if (state.HasMember("... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
callq 0x4b54e
movq %rax, %r14
leaq 0x20c964(%rip), %rsi # 0x248bd1
movq %r15, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r14)
leaq 0x20c977(%rip), %rsi # 0x248bff
mov... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_fragment_shading_rate_features(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPhysicalDeviceFragmentShadingRateFeaturesKHR**) | bool StateReplayer::Impl::parse_fragment_shading_rate_features(
const Value &state,
VkPhysicalDeviceFragmentShadingRateFeaturesKHR **out_features)
{
auto *features = allocator.allocate_cleared<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>();
*out_features = features;
features->pipelineFragmentShadingRate = st... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
callq 0x4b5f8
movq %rax, %rbx
movq %rax, (%r15)
leaq 0x20c6b0(%rip), %rsi # 0x248d71
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%rbx)
leaq 0x20c6b2(%rip), %rsi # 0x248d8d
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_mesh_shader_features(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPhysicalDeviceMeshShaderFeaturesEXT**) | bool StateReplayer::Impl::parse_mesh_shader_features(
const Value &state,
VkPhysicalDeviceMeshShaderFeaturesEXT **out_features)
{
auto *features = allocator.allocate_cleared<VkPhysicalDeviceMeshShaderFeaturesEXT>();
*out_features = features;
features->taskShader = state["taskShader"].GetUint();
features->meshS... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
callq 0x4b604
movq %rax, %rbx
movq %rax, (%r15)
leaq 0x20c69b(%rip), %rsi # 0x248dc8
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%rbx)
leaq 0x20c68c(%rip), %rsi # 0x248dd3
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_mesh_shader_features_nv(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPhysicalDeviceMeshShaderFeaturesNV**) | bool StateReplayer::Impl::parse_mesh_shader_features_nv(
const Value &state,
VkPhysicalDeviceMeshShaderFeaturesNV **out_features)
{
auto *features = allocator.allocate_cleared<VkPhysicalDeviceMeshShaderFeaturesNV>();
*out_features = features;
features->taskShader = state["taskShader"].GetUint();
features->mesh... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x4b610
movq %rax, %r15
movq %rax, (%rbx)
leaq 0x20c5fb(%rip), %rsi # 0x248dc8
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r15)
leaq 0x20c5eb(%rip), %rsi # 0x248dd3
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_descriptor_buffer_features(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPhysicalDeviceDescriptorBufferFeaturesEXT**) | bool StateReplayer::Impl::parse_descriptor_buffer_features(
const Value &state,
VkPhysicalDeviceDescriptorBufferFeaturesEXT **out_features)
{
auto *features = allocator.allocate_cleared<VkPhysicalDeviceDescriptorBufferFeaturesEXT>();
*out_features = features;
features->descriptorBuffer = state["descriptorBuffer... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
callq 0x4b61c
movq %rax, %rbx
movq %rax, (%r15)
leaq 0x20c60a(%rip), %rsi # 0x248e2b
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%rbx)
leaq 0x20c601(%rip), %rsi # 0x248e3c
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_primitives_generated_query_features(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT**) | bool StateReplayer::Impl::parse_primitives_generated_query_features(
const Value &state,
VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT **out_features)
{
auto *features = allocator.allocate_cleared<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>();
*out_features = features;
features->primitivesGenerat... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
callq 0x4b634
movq %rax, %rbx
movq %rax, (%r15)
leaq 0x20c5c9(%rip), %rsi # 0x248eaa
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%rbx)
leaq 0x20c5c8(%rip), %rsi # 0x248ec3
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::parse_2d_view_of_3d_features(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT**) | bool StateReplayer::Impl::parse_2d_view_of_3d_features(
const Value &state,
VkPhysicalDeviceImage2DViewOf3DFeaturesEXT **out_features)
{
auto *features = allocator.allocate_cleared<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>();
*out_features = features;
features->image2DViewOf3D = state["image2DViewOf3D"].GetUi... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x4b640
movq %rax, %r15
movq %rax, (%rbx)
leaq 0x20c5cf(%rip), %rsi # 0x248f1c
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi
callq 0x4aea0
movl %eax, 0x10(%r15)
leaq 0x20c5c4(%rip), %rsi # 0x248f2c
movq %r14, %rdi
callq 0x4b84c
movq %rax, %rdi... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::copy_handle_references(Fossilize::StateReplayer::Impl const&) | void StateReplayer::Impl::copy_handle_references(const StateReplayer::Impl &other)
{
replayed_samplers = other.replayed_samplers;
replayed_descriptor_set_layouts = other.replayed_descriptor_set_layouts;
replayed_pipeline_layouts = other.replayed_pipeline_layouts;
replayed_shader_modules = other.replayed_shader_modu... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x4eeaa
leaq 0x40(%rbx), %rsi
leaq 0x40(%r14), %rdi
callq 0x4f0ec
leaq 0x78(%rbx), %rsi
leaq 0x78(%r14), %rdi
callq 0x4f32e
movl $0xb0, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x4f570
movl $0xe8, %edi
leaq (... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::forget_handle_references() | void StateReplayer::Impl::forget_handle_references()
{
replayed_samplers.clear();
replayed_descriptor_set_layouts.clear();
replayed_pipeline_layouts.clear();
replayed_shader_modules.clear();
replayed_render_passes.clear();
forget_pipeline_handle_references();
} | pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x4ee34
leaq 0x40(%rbx), %rdi
callq 0x4edac
leaq 0x78(%rbx), %rdi
callq 0x4ed24
leaq 0xb0(%rbx), %rdi
callq 0x4ec9c
leaq 0xe8(%rbx), %rdi
callq 0x4ec14
movq %rbx, %rdi
popq %rbx
jmp 0x3cade
| /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateReplayer::Impl::forget_pipeline_handle_references() | void StateReplayer::Impl::forget_pipeline_handle_references()
{
replayed_compute_pipelines.clear();
replayed_graphics_pipelines.clear();
replayed_raytracing_pipelines.clear();
} | pushq %rbx
movq %rdi, %rbx
addq $0x120, %rdi # imm = 0x120
callq 0x4eb8c
leaq 0x158(%rbx), %rdi
callq 0x4eb8c
addq $0x190, %rbx # imm = 0x190
movq %rbx, %rdi
popq %rbx
jmp 0x4eb8c
| /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_pnext_struct(VkPipelineVertexInputDivisorStateCreateInfo const*, Fossilize::ScratchAllocator&) | void *StateRecorder::Impl::copy_pnext_struct(
const VkPipelineVertexInputDivisorStateCreateInfoKHR *create_info,
ScratchAllocator &alloc)
{
auto *info = copy(create_info, 1, alloc);
if (info->pVertexBindingDivisors)
{
info->pVertexBindingDivisors = copy(create_info->pVertexBindingDivisors,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x4b8aa
movq %rax, %r14
cmpq $0x0, 0x18(%rax)
je 0x3cb49
movq 0x18(%r12), %rsi
movl 0x10(%r12), %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x4b8ec
movq %rax, 0x18(%r14)
movq ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_pnext_struct(VkRenderPassMultiviewCreateInfo const*, Fossilize::ScratchAllocator&) | void *StateRecorder::Impl::copy_pnext_struct(
const VkRenderPassMultiviewCreateInfo *create_info,
ScratchAllocator &alloc)
{
auto *info = copy(create_info, 1, alloc);
if (info->pViewMasks)
info->pViewMasks = copy(create_info->pViewMasks, create_info->subpassCount, alloc);
if (info->pViewOffsets)
info->pViewO... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x4b92e
movq %rax, %r14
cmpq $0x0, 0x18(%rax)
je 0x3cb97
movq 0x18(%r12), %rsi
movl 0x10(%r12), %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x4b970
movq %rax, 0x18(%r14)
cmpq ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_pnext_chain(void const*, Fossilize::ScratchAllocator&, void const**, Fossilize::DynamicStateInfo const*, unsigned int) | bool StateRecorder::Impl::copy_pnext_chain(const void *pNext, ScratchAllocator &alloc, const void **out_pnext,
const DynamicStateInfo *dynamic_state_info,
VkGraphicsPipelineLibraryFlagsEXT state_flags)
{
VkBaseInStructure new_pnext =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r15
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
leaq 0x20(%rsp), %r14
andq $0x0, (%r14)
movq %rdi, %r13
leaq 0x200(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rsi, %rdi
callq 0x3d79d
movq %rax, %rbx
testq %rax, %rax... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_pnext_struct(VkFragmentShadingRateAttachmentInfoKHR const*, Fossilize::ScratchAllocator&) | void *StateRecorder::Impl::copy_pnext_struct(const VkFragmentShadingRateAttachmentInfoKHR *create_info,
ScratchAllocator &alloc)
{
auto *resolve = copy(create_info, 1, alloc);
if (resolve->pFragmentShadingRateAttachment)
{
auto *att = copy(resolve->pFragmentShadingRateA... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x4bb80
movq %rax, %rbx
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x3d3bd
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x4bb3e
movq %rax, %r12
leaq 0x8(%rax), %rcx
movq 0x8(%ra... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_pnext_struct(VkPipelineDiscardRectangleStateCreateInfoEXT const*, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*) | void *StateRecorder::Impl::copy_pnext_struct(const VkPipelineDiscardRectangleStateCreateInfoEXT *create_info,
ScratchAllocator &alloc,
const DynamicStateInfo *dynamic_state_info)
{
auto *discard_rectangles = copy(create_info, 1, ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r15
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x4bd8c
movq %rax, %r14
testq %r12, %r12
je 0x3d58f
cmpb $0x1, 0x1b(%r12)
jne 0x3d58f
andq $0x0, 0x20(%r14)
jmp 0x3d5a6
movq 0x20(%r14), %rsi
movl 0x18(%r14), %edx
movq %r15,... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_pnext_struct(VkPipelineShaderStageModuleIdentifierCreateInfoEXT const*, Fossilize::ScratchAllocator&) | void *StateRecorder::Impl::copy_pnext_struct(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *create_info,
ScratchAllocator &alloc)
{
auto *identifier = copy(create_info, 1, alloc);
// Safeguard since we'll be copying these to stack variables later.
identifier->i... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x4be92
movq %rax, %r15
movl 0x10(%rax), %eax
cmpl $0x20, %eax
pushq $0x20
popq %rdx
cmovbl %eax, %edx
movl %edx, 0x10(%r15)
movq 0x18(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rcx
callq 0x4bed4
movq %rax, 0x18(%r1... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_pnext_struct(VkPipelineViewportDepthClampControlCreateInfoEXT const*, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*) | void *StateRecorder::Impl::copy_pnext_struct(const VkPipelineViewportDepthClampControlCreateInfoEXT *info, ScratchAllocator &alloc,
const DynamicStateInfo *dynamic_state)
{
auto *clamp_control = copy(info, 1, alloc);
if ((!dynamic_state || !dynamic_state->depth_clamp_range... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r15
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x4bf52
movq %rax, %r14
testq %r12, %r12
je 0x3d698
cmpb $0x0, 0x3f(%r12)
jne 0x3d6bc
cmpl $0x1, 0x10(%r14)
jne 0x3d6bc
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x3d6bc
push... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::pnext_chain_skip_ignored_entries(void const*) | static const void *pnext_chain_skip_ignored_entries(const void *pNext)
{
while (pNext)
{
auto *base = static_cast<const VkBaseInStructure *>(pNext);
bool ignored;
switch (base->sType)
{
case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACH... | movq %rdi, %rax
testq %rax, %rax
je 0x3d7e0
movl (%rax), %ecx
leal -0x3ba1c712(%rcx), %edx
cmpl $0x2, %edx
jb 0x3d7da
cmpl $0x3b9cbe00, %ecx # imm = 0x3B9CBE00
je 0x3d7da
cmpl $0x3b9d3b01, %ecx # imm = 0x3B9D3B01
je 0x3d7da
cmpl $0x3b9db800, %ecx # imm = 0x3B9DB800
je 0x3d7da
cmpl $0x3ba228ba, %ecx ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_ycbcr_conversion(VkSamplerYcbcrConversionCreateInfo const*, Fossilize::ScratchAllocator&, VkSamplerYcbcrConversionCreateInfo**) | bool StateRecorder::Impl::copy_ycbcr_conversion(const VkSamplerYcbcrConversionCreateInfo *create_info,
ScratchAllocator &alloc, VkSamplerYcbcrConversionCreateInfo **out_info)
{
auto *info = copy(create_info, 1, alloc);
// Don't support pNext in this struct.
if (create... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rcx
movq %rsi, %r14
pushq $0x1
popq %rdx
callq 0x4c396
movq 0x8(%r14), %rcx
testq %rcx, %rcx
jne 0x3d803
movq %rax, (%rbx)
testq %rcx, %rcx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_shader_module(VkShaderModuleCreateInfo const*, Fossilize::ScratchAllocator&, bool, VkShaderModuleCreateInfo**) | bool StateRecorder::Impl::copy_shader_module(const VkShaderModuleCreateInfo *create_info, ScratchAllocator &alloc,
bool ignore_pnext, VkShaderModuleCreateInfo **out_create_info)
{
auto *info = copy(create_info, 1, alloc);
if (ignore_pnext)
info->pNext = nullptr;
else i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %r15
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x4c316
movq %rax, %r12
leaq 0x8(%rax), %rcx
testl %ebp, %ebp
je 0x3d844
andq $0x0, (%rcx)
jmp 0x3d85f
movq (%rcx), %rsi
xorl %r13d, %r13... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::ScratchAllocator::reset() | void ScratchAllocator::reset()
{
// Keep track of how large the buffer can grow.
size_t peak = get_peak_memory_consumption();
if (peak > impl->peak_history_size)
impl->peak_history_size = peak;
if (impl->blocks.size() > 0)
{
// free all but first block
if (impl->blocks.size() > 1)
impl->blocks.erase(impl... | pushq %rbx
movq %rdi, %rbx
callq 0x3d962
movq (%rbx), %rdi
cmpq 0x18(%rdi), %rax
jbe 0x3d938
movq %rax, 0x18(%rdi)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rsi, %rax
je 0x3d960
cmpq $0x21, %rax
jb 0x3d95c
addq $0x20, %rsi
callq 0x4c1a8
movq (%rbx), %rax
movq (%rax), %rsi
andq $0x0, (%rsi)
popq %rbx
... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::ScratchAllocator::get_peak_memory_consumption() const | size_t ScratchAllocator::get_peak_memory_consumption() const
{
size_t current_size = 0;
for (auto &block : impl->blocks)
current_size += block.blob.size();
if (impl->peak_history_size > current_size)
return impl->peak_history_size;
else
return current_size;
} | movq (%rdi), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rsi
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x3d981
addq 0x10(%rdx), %rax
subq 0x8(%rdx), %rax
addq $0x20, %rdx
jmp 0x3d96e
movq 0x18(%rcx), %rcx
cmpq %rax, %rcx
cmovaq %rcx, %rax
retq
nop
| /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::record_application_info(VkApplicationInfo const&) | bool StateRecorder::record_application_info(const VkApplicationInfo &info)
{
if (info.pNext)
{
log_error_pnext_chain("pNext in VkApplicationInfo not supported.", info.pNext);
return false;
}
std::lock_guard<std::mutex> lock(impl->record_lock);
if (!impl->copy_application_info(&info, impl->allocator, &impl->ap... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %r12
testq %r12, %r12
je 0x3d9fc
leaq 0x20b68d(%rip), %rsi # 0x249061
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x291e0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3da58
movq %rbx, %rdi
callq 0x29770
j... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_physical_device_features(void const*, Fossilize::ScratchAllocator&, VkPhysicalDeviceFeatures2**) | bool StateRecorder::Impl::copy_physical_device_features(const void *device_pnext,
ScratchAllocator &alloc,
VkPhysicalDeviceFeatures2 **out_pdf)
{
// Reorder so that PDF2 comes first in the chain.
// Caller ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x40af7
testq %rax, %rax
je 0x3dc5c
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x4c450
movq %rax, %r13
leaq 0x8(%rax), %rcx
andq $0x0, 0x8(%rax)
mo... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::copy_render_pass2(VkRenderPassCreateInfo2 const*, Fossilize::ScratchAllocator&, VkRenderPassCreateInfo2**) | bool StateRecorder::Impl::copy_render_pass2(const VkRenderPassCreateInfo2 *create_info, ScratchAllocator &alloc,
VkRenderPassCreateInfo2 **out_create_info)
{
auto *info = copy(create_info, 1, alloc);
info->pAttachments = copy(info->pAttachments, info->attachmentCount, alloc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r12
pushq $0x1
popq %rdx
movq %rsi, 0x8(%rsp)
movq %r15, %rcx
callq 0x4d254
movq %rax, %r14
movq 0x18(%rax), %rsi
movl 0x14(%rax), %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x4d294
movq %rax, ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::get_hash_for_shader_module(VkPipelineShaderStageModuleIdentifierCreateInfoEXT const*, unsigned long*) const | bool StateRecorder::Impl::get_hash_for_shader_module(
const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *info, Hash *hash) const
{
VkShaderModuleIdentifierEXT ident = { VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT };
ident.identifierSize = std::min<uint32_t>(info->identifierSize, VK_MAX_SHADER_MODULE_IDENT... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x14(%rsp), %rdi
movaps %xmm0, -0x14(%rdi)
movaps %xmm0, 0xc(%rdi)
movaps %xmm0, -0x4(%rdi)
andq $0x0, 0x1c(%rdi)
movl $0x3ba1d6b3, -0x14(%rdi) # imm = 0x3BA1D6B3
movl 0x10(%rsi), %eax
cmpl $0x20, %eax
pushq $0x20
popq %rdx
c... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::get_subpass_meta_for_pipeline(VkGraphicsPipelineCreateInfo const&, unsigned long, Fossilize::StateRecorder::SubpassMeta*) const | bool StateRecorder::Impl::get_subpass_meta_for_pipeline(const VkGraphicsPipelineCreateInfo &create_info,
Hash render_pass_hash,
SubpassMeta *meta) const
{
auto *library_info = find_pnext<VkGraphicsPipelineLi... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq 0x8(%rsi), %r14
movq %r14, %rdi
callq 0x416d7
testq %r15, %r15
setne %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x40871
movl 0x10(%rax), %eax
andl $0xc, %eax
cmpl $0x4, %eax
sete %al
jmp 0x408... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkPhysicalDeviceFeatures2 const* Fossilize::find_pnext<VkPhysicalDeviceFeatures2>(VkStructureType, void const*) | static const T *find_pnext(VkStructureType sType, const void *pNext)
{
while (pNext)
{
auto *base_in = static_cast<const VkBaseInStructure *>(pNext);
if (base_in->sType == sType)
return static_cast<const T *>(pNext);
pNext = base_in->pNext;
}
return nullptr;
} | movq %rdi, %rax
testq %rax, %rax
je 0x40b0d
cmpl $0x3b9bb078, (%rax) # imm = 0x3B9BB078
je 0x40b0d
movq 0x8(%rax), %rax
jmp 0x40afa
retq
| /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::remap_pipeline_layout_handle(VkPipelineLayout_T*, VkPipelineLayout_T**) const | bool StateRecorder::Impl::remap_pipeline_layout_handle(VkPipelineLayout layout, VkPipelineLayout *out_layout) const
{
if (layout == VK_NULL_HANDLE)
{
// This is allowed in VK_EXT_graphics_pipeline_library.
*out_layout = VK_NULL_HANDLE;
return true;
}
auto itr = pipeline_layout_to_hash.find(layout);
if (itr ... | pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x40d5b
addq $0x270, %rdi # imm = 0x270
leaq 0x8(%rsp), %rsi
callq 0x555b8
testq %rax, %rax
je 0x40d69
movq 0x10(%rax), %rax
movq %rax, (%rbx)
jmp 0x40d5f
andq $0x0, (%rbx)
movb $0x1, %bl
movl %ebx, %eax
addq $0x10, %rsp
pop... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::remap_graphics_pipeline_ci(VkGraphicsPipelineCreateInfo*) | bool StateRecorder::Impl::remap_graphics_pipeline_ci(VkGraphicsPipelineCreateInfo *info)
{
if (!remap_render_pass_handle(info->renderPass, &info->renderPass))
return false;
if (!remap_pipeline_layout_handle(info->layout, &info->layout))
return false;
auto *library = find_pnext<VkPipelineLibraryCreateInfoKHR>(
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rsi), %rdx
movq 0x70(%rsi), %rsi
callq 0x40e3e
testb %al, %al
je 0x41575
leaq 0x68(%rbx), %rdx
movq 0x68(%rbx), %rsi
movq %r14, %rdi
callq 0x40d2a
testb %al, %al
je 0x41575
movq %rbx, %r15
movq 0x8(%r15), %r15
testq %r15, ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::remap_compute_pipeline_ci(VkComputePipelineCreateInfo*) | bool StateRecorder::Impl::remap_compute_pipeline_ci(VkComputePipelineCreateInfo *info)
{
if (!remap_shader_module_handle(info->stage))
return false;
if (info->basePipelineHandle != VK_NULL_HANDLE)
if (!remap_compute_pipeline_handle(info->basePipelineHandle, &info->basePipelineHandle))
return false;
if (!rem... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rsi
callq 0x41236
testb %al, %al
je 0x415cc
movq 0x50(%rbx), %rsi
testq %rsi, %rsi
je 0x415b2
leaq 0x50(%rbx), %rdx
movq %r14, %rdi
callq 0x40fd6
testb %al, %al
je 0x415cc
movq 0x48(%rbx), %rsi
addq $0x48, %rbx
movq %r14, %rdi
movq %rbx, %rdx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::remap_raytracing_pipeline_ci(VkRayTracingPipelineCreateInfoKHR*) | bool StateRecorder::Impl::remap_raytracing_pipeline_ci(VkRayTracingPipelineCreateInfoKHR *info)
{
if (!remap_shader_module_handles(info))
return false;
if (info->basePipelineHandle != VK_NULL_HANDLE)
if (!remap_raytracing_pipeline_handle(info->basePipelineHandle, &info->basePipelineHandle))
return false;
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4d53c
testb %al, %al
je 0x41655
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x41606
leaq 0x58(%rbx), %rdx
movq %r14, %rdi
callq 0x40f50
testb %al, %al
je 0x41655
leaq 0x50(%rbx), %rdx
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::get_subpass_meta_for_render_pass_hash(unsigned long, unsigned int, Fossilize::StateRecorder::SubpassMeta*) const | bool StateRecorder::Impl::get_subpass_meta_for_render_pass_hash(Hash render_pass_hash, uint32_t subpass,
SubpassMeta *meta) const
{
auto itr = render_pass_hash_to_subpass_meta.find(render_pass_hash);
if (itr != render_pass_hash_to_subpass_meta.end() && s... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movq %rsp, %rax
movq %rsi, (%rax)
addq $0x3f8, %rdi # imm = 0x3F8
movq %rax, %rsi
callq 0x559d0
testq %rax, %rax
je 0x416a5
cmpl %r14d, 0x14(%rax)
jbe 0x416a5
cmpl $0xf, %r14d
ja 0x416a9
movl 0x10(%rax), %eax
jmp 0x416b7
xorl %eax, %eax
jmp 0x... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkGraphicsPipelineLibraryCreateInfoEXT const* Fossilize::find_pnext<VkGraphicsPipelineLibraryCreateInfoEXT>(VkStructureType, void const*) | static const T *find_pnext(VkStructureType sType, const void *pNext)
{
while (pNext)
{
auto *base_in = static_cast<const VkBaseInStructure *>(pNext);
if (base_in->sType == sType)
return static_cast<const T *>(pNext);
pNext = base_in->pNext;
}
return nullptr;
} | movq %rdi, %rax
testq %rax, %rax
je 0x416ed
cmpl $0x3b9fac02, (%rax) # imm = 0x3B9FAC02
je 0x416ed
movq 0x8(%rax), %rax
jmp 0x416da
retq
| /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::register_application_link_hash(Fossilize::ResourceTag, unsigned long, std::vector<unsigned char, std::allocator<unsigned char>>&) const | bool StateRecorder::Impl::register_application_link_hash(ResourceTag tag, Hash hash, vector<uint8_t> &blob) const
{
if (!application_feature_links)
return false;
PayloadWriteFlags payload_flags = 0;
if (checksum)
payload_flags |= PAYLOAD_WRITE_COMPUTE_CHECKSUM_BIT;
Hash link_hash = get_application_link_hash(t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, 0x562(%rdi)
jne 0x4178b
movq %rcx, %rbx
movq %rdx, %r13
movl %esi, %r12d
movq %rdi, %r14
movb 0x561(%rdi), %al
movb %al, 0x4(%rsp)
callq 0x4329a
movq %rax, %r15
pushq $0x8
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
movq %rax, %rdx
ca... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::serialize_shader_module(unsigned long, VkShaderModuleCreateInfo const&, std::vector<unsigned char, std::allocator<unsigned char>>&, Fossilize::ScratchAllocator&) const | bool StateRecorder::Impl::serialize_shader_module(Hash hash, const VkShaderModuleCreateInfo &create_info,
vector<uint8_t> &blob, ScratchAllocator &blob_allocator) const
{
Document doc;
doc.SetObject();
auto &alloc = doc.GetAllocator();
Value serialized_shader_modul... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %r8, %rbp
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
leaq 0xe0(%rsp), %rbx
movl $0x400, %edx # imm = 0x400
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x4b7f0
xorps %xmm... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::serialize_sampler(unsigned long, VkSamplerCreateInfo const&, std::vector<unsigned char, std::allocator<unsigned char>>&) const | bool StateRecorder::Impl::serialize_sampler(Hash hash, const VkSamplerCreateInfo &create_info, vector<uint8_t> &blob) const
{
Document doc;
doc.SetObject();
auto &alloc = doc.GetAllocator();
Value value;
if (!json_value(create_info, alloc, &value))
return false;
Value serialized_samplers(kObjectType);
serial... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
leaq 0x80(%rsp), %r14
movl $0x400, %edx # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x4b7f0
xorps %xmm0, %xmm0
movaps %xmm0, (%r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<Fossilize::$_2>, rapidjson::internal::IsGenericValue<Fossilize::$_2>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x28, %rsp
movq %rdx, %rcx
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %rdx # imm = 0x405000000000000
orq (%rsi), %rdx
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rdx, 0x8(%rsi)
movl %eax, (%rsi)
movabsq $0x1f6000000000000, %rax # imm = 0x1F6000000000000
leaq 0x18(%rsp), %rdx
movq %rax, 0x8... | /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
Fossilize::StateRecorder::Impl::get_application_link_hash(Fossilize::ResourceTag, unsigned long) const | Hash StateRecorder::Impl::get_application_link_hash(ResourceTag tag, Hash hash) const
{
return Hashing::compute_hash_application_info_link(application_feature_hash, tag, hash);
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
addq $0x478, %rdi # imm = 0x478
callq 0x316b1
movl %eax, %ecx
movabsq $-0x509c42b379fe4821, %rdx # imm = 0xAF63BD4C8601B7DF
xorq %rcx, %rdx
shrq $0x20, %rax
movabsq $0x100000001b3, %rcx # imm = 0x100000001B3
imulq %rcx, %rdx
xorq %rdx, %rax
... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::Impl::serialize_application_blob_link(unsigned long, Fossilize::ResourceTag, std::vector<unsigned char, std::allocator<unsigned char>>&) const | bool StateRecorder::Impl::serialize_application_blob_link(Hash hash, ResourceTag tag, vector<uint8_t> &blob) const
{
Document doc;
doc.SetObject();
auto &alloc = doc.GetAllocator();
doc.AddMember("version", FOSSILIZE_FORMAT_VERSION, alloc);
Value links(kArrayType);
Value link(kObjectType);
Hasher h;
Hashing:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rcx, 0x10(%rsp)
movl %edx, %ebp
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
leaq 0xf0(%rsp), %rbx
movl $0x400, %edx # imm = 0x400
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x4b7f0
xorps %xm... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkSamplerCreateInfo const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*) | static bool json_value(const VkSamplerCreateInfo& sampler, Allocator& alloc, Value *out_value)
{
Value s(kObjectType);
s.AddMember("flags", sampler.flags, alloc);
s.AddMember("minFilter", sampler.minFilter, alloc);
s.AddMember("magFilter", sampler.magFilter, alloc);
s.AddMember("maxAnisotropy", sampler.maxAnisotro... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movw $0x3, 0xe(%r14)
leaq 0x239d53(%rip), %rax # 0x27d2f2
leaq 0x128(%rsp), %rsi
movq %rax, (... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkDescriptorSetLayoutCreateInfo const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*) | static bool json_value(const VkDescriptorSetLayoutCreateInfo& layout, Allocator& alloc, Value *out_value)
{
Value l(kObjectType);
l.AddMember("flags", layout.flags, alloc);
Value bindings(kArrayType);
for (uint32_t i = 0; i < layout.bindingCount; i++)
{
auto &b = layout.pBindings[i];
Value binding(kObjectType... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x38(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movw $0x3, 0xe(%rdi)
leaq 0x239a41(%rip), %rax # 0x27d2f2
leaq 0xd8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkPipelineLayoutCreateInfo const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*) | static bool json_value(const VkPipelineLayoutCreateInfo& layout, Allocator& alloc, Value *out_value)
{
Value p(kObjectType);
p.AddMember("flags", layout.flags, alloc);
Value push(kArrayType);
for (uint32_t i = 0; i < layout.pushConstantRangeCount; i++)
{
Value range(kObjectType);
range.AddMember("stageFlags", ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movw $0x3, 0xe(%rdi)
leaq 0x2397ab(%rip), %rax # 0x27d2f2
leaq 0xa8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkRenderPassCreateInfo const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*) | static bool json_value(const VkRenderPassCreateInfo& pass, Allocator& alloc, Value *out_value)
{
Value json_object(kObjectType);
json_object.AddMember("flags", pass.flags, alloc);
Value deps(kArrayType);
Value subpasses(kArrayType);
Value attachments(kArrayType);
if (pass.pDependencies)
{
for (uint32_t i = 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movq %rdx, 0x80(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
movw $0x3, 0xe(%rdi)
leaq 0x2395bf(%rip), %rax # 0x27d2f2
leaq 0x2a8(%rsp), %rsi
movq %rax, ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkRenderPassCreateInfo2 const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*) | static bool json_value(const VkRenderPassCreateInfo2 &pass, Allocator &alloc, Value *out_value)
{
Value json_object(kObjectType);
json_object.AddMember("flags", pass.flags, alloc);
Value deps(kArrayType);
Value subpasses(kArrayType);
Value attachments(kArrayType);
if (pass.pCorrelatedViewMasks)
{
Value view_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rdx, 0x88(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
movw $0x3, 0xe(%rdi)
leaq 0x238bd8(%rip), %rax # 0x27d2f2
leaq 0x268(%rsp), %rsi
movq %rax, ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkGraphicsPipelineCreateInfo const&, Fossilize::StateRecorder::SubpassMeta const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAll... | static bool json_value(const VkGraphicsPipelineCreateInfo &pipe,
const StateRecorder::SubpassMeta &subpass_meta,
Allocator &alloc, Value *out_value)
{
Value p(kObjectType);
p.AddMember("flags", pipe.flags, alloc);
p.AddMember("basePipelineHandle", uint64_string(api_objec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x688, %rsp # imm = 0x688
movq %rcx, 0x110(%rsp)
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %rbp
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r13
movaps %xmm0, (%r13)
movw $0x3, 0xe(%r13)
leaq 0x238184(%rip), %rax # 0x27d2f2
leaq 0x678(%rsp),... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkRayTracingPipelineCreateInfoKHR const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*) | static bool json_value(const VkRayTracingPipelineCreateInfoKHR &pipe, Allocator &alloc, Value *out_value)
{
Value p(kObjectType);
p.AddMember("flags", pipe.flags, alloc);
p.AddMember("layout", uint64_string(api_object_cast<uint64_t>(pipe.layout), alloc), alloc);
p.AddMember("basePipelineHandle", uint64_string(api_o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movw $0x3, 0xe(%rbx)
leaq 0x236436(%rip), %rax # 0x27d2f2
leaq 0x178(%rsp), %rsi
movq %rax, (%rsi)... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::init_recording_thread(Fossilize::DatabaseInterface*) | void StateRecorder::init_recording_thread(DatabaseInterface *iface)
{
impl->database_iface = iface;
impl->record_data = {};
impl->should_record_identifier_only =
impl->module_identifier_database_iface && impl->on_use_database_iface;
auto level = get_thread_log_level();
auto cb = Internal::get_thread_log_callba... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rsi, 0x18(%rdi)
leaq 0x18(%rsp), %r14
movb $0x1, -0x10(%r14)
andl $0x0, -0xc(%r14)
movw $0x100, -0x8(%r14) # imm = 0x100
addq $0x568, %rdi # imm = 0x568
xorps %xmm0, %xmm0
movups %xmm0, (%r14)... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::StateRecorder::init_recording_synchronized(Fossilize::DatabaseInterface*) | void StateRecorder::init_recording_synchronized(DatabaseInterface *iface)
{
impl->database_iface = iface;
impl->record_data = {};
impl->should_record_identifier_only =
impl->module_identifier_database_iface && impl->on_use_database_iface;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rsi, 0x18(%rdi)
leaq 0x10(%rsp), %r14
movb $0x1, -0x10(%r14)
andl $0x0, -0xc(%r14)
movw $0x100, -0x8(%r14) # imm = 0x100
addq $0x568, %rdi # imm = 0x568
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rsp,... | /ValveSoftware[P]Fossilize/fossilize.cpp |
Fossilize::Hashing::hash_reference_base(Fossilize::Hasher&, VkAttachmentReference2 const&) | static bool hash_reference_base(Hasher &h, const VkAttachmentReference2 &ref)
{
h.u32(ref.attachment);
h.u32(ref.layout);
h.u32(ref.aspectMask);
return hash_pnext_chain(nullptr, h, ref.pNext, nullptr, 0);
} | movq %rdi, %rax
movl 0x10(%rsi), %ecx
movl 0x14(%rsi), %edx
movabsq $0x100000001b3, %rdi # imm = 0x100000001B3
movq (%rax), %r8
imulq %rdi, %r8
xorq %rcx, %r8
imulq %rdi, %r8
xorq %rdx, %r8
movl 0x18(%rsi), %ecx
imulq %rdi, %r8
xorq %rcx, %r8
movq %r8, (%rax)
movq 0x8(%rsi), %rdx
xorl %edi, %edi
movq %rax, %rsi
xorl... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::pnext_chain_json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(void const*, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*, Fossilize::DynamicStateInfo const*) | static bool pnext_chain_json_value(const void *pNext, Allocator &alloc, Value *out_value,
const DynamicStateInfo *dynamic_state_info)
{
Value nexts(kArrayType);
while ((pNext = pnext_chain_skip_ignored_entries(pNext)) != nullptr)
{
auto *pin = static_cast<const VkBaseInStructure... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, 0xd0(%rsp)
movq %rdx, 0xd8(%rsp)
movq %rsi, %r15
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %r13
movaps %xmm0, (%r13)
movw $0x4, 0xe(%r13)
movq %rsp, %r12
leaq 0x40(%rsp), %r14
callq 0x3d79d
movq %rax, %rbp
... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkPipelineLibraryCreateInfoKHR const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, bool, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*) | static bool json_value(const VkPipelineLibraryCreateInfoKHR &create_info, Allocator &alloc,
bool in_pnext_chain, Value *out_value)
{
Value library_info(kObjectType);
Value libraries(kArrayType);
for (uint32_t i = 0; i < create_info.libraryCount; i++)
libraries.PushBack(uint64_string(api_obje... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x18(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movw $0x3, 0xe(%rsp)
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movw $0x4, 0xe(%r15)
xorl %ebx, %ebx
leaq 0x20(%rsp), %r13
movl... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkAttachmentReference2 const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*) | static bool json_value(const VkAttachmentReference2 &att, Allocator &alloc, Value *out_value)
{
Value value(kObjectType);
value.AddMember("attachment", att.attachment, alloc);
value.AddMember("layout", att.layout, alloc);
value.AddMember("aspectMask", att.aspectMask, alloc);
if (!pnext_chain_add_json_value(value, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movw $0x3, 0xe(%r14)
leaq 0x1fe68c(%rip), %rax # 0x248b60
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
pushq $0xa
popq %rbp
movl %ebp, 0x8(%rsi)
m... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkPipelineDynamicStateCreateInfo const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*) | static bool json_value(const VkPipelineDynamicStateCreateInfo &dynamic, Allocator &alloc, Value *out_value)
{
Value dyn(kObjectType);
dyn.AddMember("flags", dynamic.flags, alloc);
Value dynamics(kArrayType);
for (uint32_t i = 0; i < dynamic.dynamicStateCount; i++)
dynamics.PushBack(dynamic.pDynamicStates[i], allo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movw $0x3, 0xe(%r15)
leaq 0x232d21(%rip), %rax # 0x27d2f2
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)
movl ... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::json_value<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(VkPipelineShaderStageCreateInfo const*, unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*) | static bool json_value(const VkPipelineShaderStageCreateInfo *pStages, uint32_t stageCount,
Allocator &alloc, Value *out_value)
{
Value stages(kArrayType);
for (uint32_t i = 0; i < stageCount; i++)
{
auto &s = pStages[i];
Value stage(kObjectType);
stage.AddMember("flags", s.flags, alloc)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rcx, 0x50(%rsp)
movq %rdx, %r14
movq %rdi, 0x58(%rsp)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rax
movaps %xmm0, (%rax)
movw $0x4, 0xe(%rax)
movl %esi, %eax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x30(%rsp... | /ValveSoftware[P]Fossilize/fossilize.cpp |
bool Fossilize::pnext_chain_add_json_value<VkPipelineShaderStageCreateInfo, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>&, VkPipelineShaderStageCreateInfo const&, rapidjson::MemoryPoolAllocator<rapidjson:... | static bool pnext_chain_add_json_value(Value &base, const T &t, Allocator &alloc,
const DynamicStateInfo *dynamic_state_info)
{
if (t.pNext)
{
Value nexts;
if (!pnext_chain_json_value(t.pNext, alloc, &nexts, dynamic_state_info))
return false;
base.AddMember("pNext", nex... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r15
movq 0x8(%rsi), %rdi
movb $0x1, %bl
testq %rdi, %rdi
je 0x4acc4
movq %rdx, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x47f01
testb %al, %al
je 0x4acc2
leaq 0x1fd350(%rip), %rax # 0x247ff3
leaq 0... | /ValveSoftware[P]Fossilize/fossilize.cpp |
rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::GenericDocument(rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>*, unsigned long, rapidjson::CrtAllocator*) | GenericValue() RAPIDJSON_NOEXCEPT : data_() { data_.f.flags = kNullFlag; } | xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq %rdx, 0x48(%rdi)
andl $0x0, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
testq %rsi, %rsi
je 0x4b81e
retq
pushq %rbx
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x295e0
an... | /ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h |
VkPipelineVertexInputDivisorStateCreateInfo* Fossilize::StateRecorder::Impl::copy<VkPipelineVertexInputDivisorStateCreateInfo>(VkPipelineVertexInputDivisorStateCreateInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4b8e2
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x535fe
testq %rax, %rax
je 0x4b8e2
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
unsigned int* Fossilize::StateRecorder::Impl::copy<unsigned int>(unsigned int const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4b9a8
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x4b160
testq %rax, %rax
je 0x4b9a8
shlq $0x2, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
int* Fossilize::StateRecorder::Impl::copy<int>(int const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4b9ea
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x4b174
testq %rax, %rax
je 0x4b9ea
shlq $0x2, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkDescriptorSetLayoutBindingFlagsCreateInfo* Fossilize::StateRecorder::Impl::copy<VkDescriptorSetLayoutBindingFlagsCreateInfo>(VkDescriptorSetLayoutBindingFlagsCreateInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4ba2c
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x5363a
testq %rax, %rax
je 0x4ba2c
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkMutableDescriptorTypeCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkMutableDescriptorTypeCreateInfoEXT>(VkMutableDescriptorTypeCreateInfoEXT const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4ba6e
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x5364e
testq %rax, %rax
je 0x4ba6e
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkDescriptorType* Fossilize::StateRecorder::Impl::copy<VkDescriptorType>(VkDescriptorType const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4baf2
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x4b5b4
testq %rax, %rax
je 0x4baf2
shlq $0x2, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkSubpassDescriptionDepthStencilResolve* Fossilize::StateRecorder::Impl::copy<VkSubpassDescriptionDepthStencilResolve>(VkSubpassDescriptionDepthStencilResolve const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bb34
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x53676
testq %rax, %rax
je 0x4bb34
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkAttachmentReference2* Fossilize::StateRecorder::Impl::copy<VkAttachmentReference2>(VkAttachmentReference2 const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bb76
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x5368a
testq %rax, %rax
je 0x4bb76
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkFragmentShadingRateAttachmentInfoKHR* Fossilize::StateRecorder::Impl::copy<VkFragmentShadingRateAttachmentInfoKHR>(VkFragmentShadingRateAttachmentInfoKHR const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bbb8
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x5369e
testq %rax, %rax
je 0x4bbb8
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkPipelineRenderingCreateInfo* Fossilize::StateRecorder::Impl::copy<VkPipelineRenderingCreateInfo>(VkPipelineRenderingCreateInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bbf7
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x536b2
testq %rax, %rax
je 0x4bbf7
imulq $0x28, %r14, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkPipelineColorWriteCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkPipelineColorWriteCreateInfoEXT>(VkPipelineColorWriteCreateInfoEXT const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bc7c
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x536da
testq %rax, %rax
je 0x4bc7c
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkSampleLocationEXT* Fossilize::StateRecorder::Impl::copy<VkSampleLocationEXT>(VkSampleLocationEXT const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bd00
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x4b3f6
testq %rax, %rax
je 0x4bd00
shlq $0x3, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkRenderPassInputAttachmentAspectCreateInfo* Fossilize::StateRecorder::Impl::copy<VkRenderPassInputAttachmentAspectCreateInfo>(VkRenderPassInputAttachmentAspectCreateInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bd42
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x53702
testq %rax, %rax
je 0x4bd42
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkInputAttachmentAspectReference* Fossilize::StateRecorder::Impl::copy<VkInputAttachmentAspectReference>(VkInputAttachmentAspectReference const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bd81
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x53716
testq %rax, %rax
je 0x4bd81
imulq $0xc, %r14, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r1... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkPipelineDiscardRectangleStateCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkPipelineDiscardRectangleStateCreateInfoEXT>(VkPipelineDiscardRectangleStateCreateInfoEXT const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bdc1
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x5372a
testq %rax, %rax
je 0x4bdc1
imulq $0x28, %r14, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkRect2D* Fossilize::StateRecorder::Impl::copy<VkRect2D>(VkRect2D const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4be04
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x5373e
testq %rax, %rax
je 0x4be04
shlq $0x4, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkPipelineLibraryCreateInfoKHR* Fossilize::StateRecorder::Impl::copy<VkPipelineLibraryCreateInfoKHR>(VkPipelineLibraryCreateInfoKHR const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4be46
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x53752
testq %rax, %rax
je 0x4be46
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkPipeline_T** Fossilize::StateRecorder::Impl::copy<VkPipeline_T*>(VkPipeline_T* const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4be88
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x4b47e
testq %rax, %rax
je 0x4be88
shlq $0x3, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkPipelineShaderStageModuleIdentifierCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkPipelineShaderStageModuleIdentifierCreateInfoEXT>(VkPipelineShaderStageModuleIdentifierCreateInfoEXT const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4beca
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x53766
testq %rax, %rax
je 0x4beca
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
unsigned char* Fossilize::StateRecorder::Impl::copy<unsigned char>(unsigned char const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bf08
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x5377a
testq %rax, %rax
je 0x4bf08
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /ValveSoftware[P]Fossilize/fossilize.cpp |
VkSampleLocationsInfoEXT* Fossilize::StateRecorder::Impl::copy<VkSampleLocationsInfoEXT>(VkSampleLocationsInfoEXT const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bf47
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x5378a
testq %rax, %rax
je 0x4bf47
imulq $0x28, %r14, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkPipelineViewportDepthClampControlCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkPipelineViewportDepthClampControlCreateInfoEXT>(VkPipelineViewportDepthClampControlCreateInfoEXT const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4bf8a
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x5379e
testq %rax, %rax
je 0x4bf8a
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkRenderingAttachmentLocationInfo* Fossilize::StateRecorder::Impl::copy<VkRenderingAttachmentLocationInfo>(VkRenderingAttachmentLocationInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c00e
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x537c6
testq %rax, %rax
je 0x4c00e
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkRenderingInputAttachmentIndexInfo* Fossilize::StateRecorder::Impl::copy<VkRenderingInputAttachmentIndexInfo>(VkRenderingInputAttachmentIndexInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c04d
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x537da
testq %rax, %rax
je 0x4c04d
imulq $0x30, %r14, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkShaderModuleCreateInfo* Fossilize::StateRecorder::Impl::copy<VkShaderModuleCreateInfo>(VkShaderModuleCreateInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c34b
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x54be6
testq %rax, %rax
je 0x4c34b
imulq $0x28, %r14, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkSamplerCreateInfo* Fossilize::StateRecorder::Impl::copy<VkSamplerCreateInfo>(VkSamplerCreateInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c38b
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x54bfa
testq %rax, %rax
je 0x4c38b
imulq $0x50, %r14, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkSamplerYcbcrConversionCreateInfo* Fossilize::StateRecorder::Impl::copy<VkSamplerYcbcrConversionCreateInfo>(VkSamplerYcbcrConversionCreateInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c3ce
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x54c0e
testq %rax, %rax
je 0x4c3ce
shlq $0x6, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkPhysicalDeviceFeatures2* Fossilize::StateRecorder::Impl::copy<VkPhysicalDeviceFeatures2>(VkPhysicalDeviceFeatures2 const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c488
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x54f74
testq %rax, %rax
je 0x4c488
imulq $0xf0, %r14, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkApplicationInfo* Fossilize::StateRecorder::Impl::copy<VkApplicationInfo>(VkApplicationInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c4c7
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x54f8c
testq %rax, %rax
je 0x4c4c7
imulq $0x30, %r14, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r... | /ValveSoftware[P]Fossilize/fossilize.cpp |
char* Fossilize::StateRecorder::Impl::copy<char>(char const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c506
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x4adb0
testq %rax, %rax
je 0x4c506
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /ValveSoftware[P]Fossilize/fossilize.cpp |
VkDescriptorSetLayoutCreateInfo* Fossilize::StateRecorder::Impl::copy<VkDescriptorSetLayoutCreateInfo>(VkDescriptorSetLayoutCreateInfo const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c548
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x54fa0
testq %rax, %rax
je 0x4c548
shlq $0x5, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx... | /ValveSoftware[P]Fossilize/fossilize.cpp |
VkDescriptorSetLayoutBinding* Fossilize::StateRecorder::Impl::copy<VkDescriptorSetLayoutBinding>(VkDescriptorSetLayoutBinding const*, unsigned long, Fossilize::ScratchAllocator&) | T *StateRecorder::Impl::copy(const T *src, size_t count, ScratchAllocator &alloc)
{
if (!count)
return nullptr;
auto *new_data = alloc.allocate_n<T>(count);
if (new_data)
std::copy(src, src + count, new_data);
return new_data;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4c587
movq %rdx, %r14
movq %rsi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x54fb4
testq %rax, %rax
je 0x4c587
imulq $0x18, %r14, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x299d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r... | /ValveSoftware[P]Fossilize/fossilize.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.