Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
 Community
1
name
string
code
string
asm
string
file
string
VkSampler_T** Fossilize::StateRecorder::Impl::copy<VkSampler_T*>(VkSampler_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 0x4c5ca movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x4adc0 testq %rax, %rax je 0x4c5ca 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
VkPushConstantRange* Fossilize::StateRecorder::Impl::copy<VkPushConstantRange>(VkPushConstantRange 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 0x4c649 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x54fdc testq %rax, %rax je 0x4c649 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
VkDescriptorSetLayout_T** Fossilize::StateRecorder::Impl::copy<VkDescriptorSetLayout_T*>(VkDescriptorSetLayout_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 0x4c68c movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x54ff0 testq %rax, %rax je 0x4c68c 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
VkSpecializationInfo* Fossilize::StateRecorder::Impl::copy<VkSpecializationInfo>(VkSpecializationInfo 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 0x4c6ce movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x55004 testq %rax, %rax je 0x4c6ce 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
VkSpecializationMapEntry* Fossilize::StateRecorder::Impl::copy<VkSpecializationMapEntry>(VkSpecializationMapEntry 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 0x4c710 movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x55018 testq %rax, %rax je 0x4c710 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
VkRayTracingPipelineCreateInfoKHR* Fossilize::StateRecorder::Impl::copy<VkRayTracingPipelineCreateInfoKHR>(VkRayTracingPipelineCreateInfoKHR 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 0x4c7a7 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x55040 testq %rax, %rax je 0x4c7a7 imulq $0x68, %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
bool Fossilize::StateRecorder::Impl::copy_dynamic_state<VkRayTracingPipelineCreateInfoKHR>(VkRayTracingPipelineCreateInfoKHR*, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*)
bool StateRecorder::Impl::copy_dynamic_state(CreateInfo *info, ScratchAllocator &alloc, const DynamicStateInfo *) { if (info->pDynamicState) { if (info->pDynamicState->pNext) { log_error_pnext_chain("pNext in VkPipelineDynamicStateCreateInfo not supported.", ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rsi, %r14 movq 0x48(%rsi), %rsi movb $0x1, %bl testq %rsi, %rsi je 0x4c955 cmpq $0x0, 0x8(%rsi) je 0x4c921 leaq 0x1ff5a7(%rip), %rsi # 0x24be9a leaq 0x8(%rsp), %rbx leaq 0x7(%rsp), %rdx movq %rbx, %rdi callq 0x291e0 movq 0x48(%r14), %rax movq 0x8(%ra...
/ValveSoftware[P]Fossilize/fossilize.cpp
bool Fossilize::StateRecorder::Impl::copy_sub_create_info<VkPipelineLibraryCreateInfoKHR>(VkPipelineLibraryCreateInfoKHR const*&, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*, unsigned int)
bool StateRecorder::Impl::copy_sub_create_info(const SubCreateInfo *&sub_info, ScratchAllocator &alloc, const DynamicStateInfo *dynamic_state_info, VkGraphicsPipelineLibraryFlagsEXT state_flags) { if (sub_info) { sub_info ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq (%rsi), %rsi movb $0x1, %bl testq %rsi, %rsi je 0x4c9c5 movl %r8d, %ebp movq %rcx, %r15 movq %rdx, %r12 movq %rdi, %r13 pushq $0x1 popq %rdx movq %r12, %rcx callq 0x4be0e movq %rax, (%r14) movq %rsp, %rcx andq $0x0, (%rcx)...
/ValveSoftware[P]Fossilize/fossilize.cpp
VkRayTracingShaderGroupCreateInfoKHR* Fossilize::StateRecorder::Impl::copy<VkRayTracingShaderGroupCreateInfoKHR>(VkRayTracingShaderGroupCreateInfoKHR 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 0x4ca7d movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x551a8 testq %rax, %rax je 0x4ca7d 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
bool Fossilize::StateRecorder::Impl::copy_sub_create_info<VkPipelineTessellationStateCreateInfo>(VkPipelineTessellationStateCreateInfo const*&, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*, unsigned int)
bool StateRecorder::Impl::copy_sub_create_info(const SubCreateInfo *&sub_info, ScratchAllocator &alloc, const DynamicStateInfo *dynamic_state_info, VkGraphicsPipelineLibraryFlagsEXT state_flags) { if (sub_info) { sub_info ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq (%rsi), %rsi movb $0x1, %bl testq %rsi, %rsi je 0x4cb2b movl %r8d, %ebp movq %rcx, %r15 movq %rdx, %r12 movq %rdi, %r13 pushq $0x1 popq %rdx movq %r12, %rcx callq 0x551d4 movq %rax, (%r14) movq %rsp, %rcx andq $0x0, (%rcx)...
/ValveSoftware[P]Fossilize/fossilize.cpp
bool Fossilize::StateRecorder::Impl::copy_sub_create_info<VkPipelineColorBlendStateCreateInfo>(VkPipelineColorBlendStateCreateInfo const*&, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*, unsigned int)
bool StateRecorder::Impl::copy_sub_create_info(const SubCreateInfo *&sub_info, ScratchAllocator &alloc, const DynamicStateInfo *dynamic_state_info, VkGraphicsPipelineLibraryFlagsEXT state_flags) { if (sub_info) { sub_info ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq (%rsi), %rsi movb $0x1, %bl testq %rsi, %rsi je 0x4cb9d movl %r8d, %ebp movq %rcx, %r15 movq %rdx, %r12 movq %rdi, %r13 pushq $0x1 popq %rdx movq %r12, %rcx callq 0x55228 movq %rax, (%r14) movq %rsp, %rcx andq $0x0, (%rcx)...
/ValveSoftware[P]Fossilize/fossilize.cpp
bool Fossilize::StateRecorder::Impl::copy_sub_create_info<VkPipelineVertexInputStateCreateInfo>(VkPipelineVertexInputStateCreateInfo const*&, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*, unsigned int)
bool StateRecorder::Impl::copy_sub_create_info(const SubCreateInfo *&sub_info, ScratchAllocator &alloc, const DynamicStateInfo *dynamic_state_info, VkGraphicsPipelineLibraryFlagsEXT state_flags) { if (sub_info) { sub_info ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq (%rsi), %rsi movb $0x1, %bl testq %rsi, %rsi je 0x4cc0f movl %r8d, %ebp movq %rcx, %r15 movq %rdx, %r12 movq %rdi, %r13 pushq $0x1 popq %rdx movq %r12, %rcx callq 0x5527c movq %rax, (%r14) movq %rsp, %rcx andq $0x0, (%rcx)...
/ValveSoftware[P]Fossilize/fossilize.cpp
bool Fossilize::StateRecorder::Impl::copy_sub_create_info<VkPipelineViewportStateCreateInfo>(VkPipelineViewportStateCreateInfo const*&, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*, unsigned int)
bool StateRecorder::Impl::copy_sub_create_info(const SubCreateInfo *&sub_info, ScratchAllocator &alloc, const DynamicStateInfo *dynamic_state_info, VkGraphicsPipelineLibraryFlagsEXT state_flags) { if (sub_info) { sub_info ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq (%rsi), %rsi movb $0x1, %bl testq %rsi, %rsi je 0x4ccf3 movl %r8d, %ebp movq %rcx, %r15 movq %rdx, %r12 movq %rdi, %r13 pushq $0x1 popq %rdx movq %r12, %rcx callq 0x55324 movq %rax, (%r14) movq %rsp, %rcx andq $0x0, (%rcx)...
/ValveSoftware[P]Fossilize/fossilize.cpp
bool Fossilize::StateRecorder::Impl::copy_sub_create_info<VkPipelineDepthStencilStateCreateInfo>(VkPipelineDepthStencilStateCreateInfo const*&, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*, unsigned int)
bool StateRecorder::Impl::copy_sub_create_info(const SubCreateInfo *&sub_info, ScratchAllocator &alloc, const DynamicStateInfo *dynamic_state_info, VkGraphicsPipelineLibraryFlagsEXT state_flags) { if (sub_info) { sub_info ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq (%rsi), %rsi movb $0x1, %bl testq %rsi, %rsi je 0x4cdd7 movl %r8d, %ebp movq %rcx, %r15 movq %rdx, %r12 movq %rdi, %r13 pushq $0x1 popq %rdx movq %r12, %rcx callq 0x553ce movq %rax, (%r14) movq %rsp, %rcx andq $0x0, (%rcx)...
/ValveSoftware[P]Fossilize/fossilize.cpp
bool Fossilize::StateRecorder::Impl::copy_sub_create_info<VkPipelineRasterizationStateCreateInfo>(VkPipelineRasterizationStateCreateInfo const*&, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*, unsigned int)
bool StateRecorder::Impl::copy_sub_create_info(const SubCreateInfo *&sub_info, ScratchAllocator &alloc, const DynamicStateInfo *dynamic_state_info, VkGraphicsPipelineLibraryFlagsEXT state_flags) { if (sub_info) { sub_info ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq (%rsi), %rsi movb $0x1, %bl testq %rsi, %rsi je 0x4ce49 movl %r8d, %ebp movq %rcx, %r15 movq %rdx, %r12 movq %rdi, %r13 pushq $0x1 popq %rdx movq %r12, %rcx callq 0x55422 movq %rax, (%r14) movq %rsp, %rcx andq $0x0, (%rcx)...
/ValveSoftware[P]Fossilize/fossilize.cpp
bool Fossilize::StateRecorder::Impl::copy_stages<VkGraphicsPipelineCreateInfo>(VkGraphicsPipelineCreateInfo*, Fossilize::ScratchAllocator&, VkDevice_T*, void (*)(VkDevice_T*, VkShaderModuleCreateInfo const*, VkShaderModuleIdentifierEXT*), Fossilize::DynamicStateInfo const*)
bool StateRecorder::Impl::copy_stages(CreateInfo *info, ScratchAllocator &alloc, VkDevice device, PFN_vkGetShaderModuleCreateInfoIdentifierEXT gsmcii, const DynamicStateInfo *dynamic_state_info) { info->pStages = copy(info->pStages, info->stag...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %r9, 0x30(%rsp) movq %r8, 0x20(%rsp) movq %rcx, 0x18(%rsp) movq %rdx, %r12 movq %rsi, %rbx movq 0x18(%rsi), %rsi movl 0x14(%rbx), %edx movq %rdi, 0x28(%rsp) movq %r12, %rcx callq 0x55054 movq %rbx, %rcx movq %rax, 0x18(%rbx) pushq $...
/ValveSoftware[P]Fossilize/fossilize.cpp
bool Fossilize::StateRecorder::Impl::copy_dynamic_state<VkGraphicsPipelineCreateInfo>(VkGraphicsPipelineCreateInfo*, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*)
bool StateRecorder::Impl::copy_dynamic_state(CreateInfo *info, ScratchAllocator &alloc, const DynamicStateInfo *) { if (info->pDynamicState) { if (info->pDynamicState->pNext) { log_error_pnext_chain("pNext in VkPipelineDynamicStateCreateInfo not supported.", ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rsi, %r14 movq 0x60(%rsi), %rsi movb $0x1, %bl testq %rsi, %rsi je 0x4cffd cmpq $0x0, 0x8(%rsi) je 0x4cfc9 leaq 0x1feeff(%rip), %rsi # 0x24be9a leaq 0x8(%rsp), %rbx leaq 0x7(%rsp), %rdx movq %rbx, %rdi callq 0x291e0 movq 0x60(%r14), %rax movq 0x8(%ra...
/ValveSoftware[P]Fossilize/fossilize.cpp
VkPipelineColorBlendAttachmentState* Fossilize::StateRecorder::Impl::copy<VkPipelineColorBlendAttachmentState>(VkPipelineColorBlendAttachmentState 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 0x4d044 movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x55478 testq %rax, %rax je 0x4d044 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
VkVertexInputBindingDescription* Fossilize::StateRecorder::Impl::copy<VkVertexInputBindingDescription>(VkVertexInputBindingDescription 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 0x4d0c5 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x554a0 testq %rax, %rax je 0x4d0c5 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
VkRenderPassCreateInfo2* Fossilize::StateRecorder::Impl::copy<VkRenderPassCreateInfo2>(VkRenderPassCreateInfo2 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 0x4d289 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x5552c testq %rax, %rax je 0x4d289 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
VkSubpassDescription2* Fossilize::StateRecorder::Impl::copy<VkSubpassDescription2>(VkSubpassDescription2 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 0x4d309 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x55554 testq %rax, %rax je 0x4d309 imulq $0x58, %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
bool Fossilize::StateRecorder::Impl::copy_pnext_chains<VkAttachmentDescription2>(VkAttachmentDescription2 const*, unsigned int, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*, unsigned int)
bool StateRecorder::Impl::copy_pnext_chains(const T *ts, uint32_t count, ScratchAllocator &alloc, const DynamicStateInfo *dynamic_state_info, VkGraphicsPipelineLibraryFlagsEXT state_flags) { for (uint32_t i = 0; i < count; i++) i...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r9d, 0x4(%rsp) movq %r8, %r14 movq %rcx, %r15 movq %rsi, %r12 movq %rdi, %r13 movl %edx, %ebp addq $0x8, %r12 xorl %ecx, %ecx movq %rcx, %rbx cmpq %rcx, %rbp je 0x4d3a6 movq (%r12), %rsi movq %r13, %rdi movq %r15, %rdx movq %r12, %rcx mo...
/ValveSoftware[P]Fossilize/fossilize.cpp
bool Fossilize::StateRecorder::Impl::copy_pnext_chains<VkSubpassDescription2>(VkSubpassDescription2 const*, unsigned int, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*, unsigned int)
bool StateRecorder::Impl::copy_pnext_chains(const T *ts, uint32_t count, ScratchAllocator &alloc, const DynamicStateInfo *dynamic_state_info, VkGraphicsPipelineLibraryFlagsEXT state_flags) { for (uint32_t i = 0; i < count; i++) i...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r9d, 0x4(%rsp) movq %r8, %r14 movq %rcx, %r15 movq %rsi, %r12 movq %rdi, %r13 movl %edx, %ebp addq $0x8, %r12 xorl %ecx, %ecx movq %rcx, %rbx cmpq %rcx, %rbp je 0x4d40e movq (%r12), %rsi movq %r13, %rdi movq %r15, %rdx movq %r12, %rcx mo...
/ValveSoftware[P]Fossilize/fossilize.cpp
bool Fossilize::StateRecorder::Impl::copy_pnext_chains<VkSubpassDependency2>(VkSubpassDependency2 const*, unsigned int, Fossilize::ScratchAllocator&, Fossilize::DynamicStateInfo const*, unsigned int)
bool StateRecorder::Impl::copy_pnext_chains(const T *ts, uint32_t count, ScratchAllocator &alloc, const DynamicStateInfo *dynamic_state_info, VkGraphicsPipelineLibraryFlagsEXT state_flags) { for (uint32_t i = 0; i < count; i++) i...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r9d, 0x4(%rsp) movq %r8, %r14 movq %rcx, %r15 movq %rsi, %r12 movq %rdi, %r13 movl %edx, %ebp addq $0x8, %r12 xorl %ecx, %ecx movq %rcx, %rbx cmpq %rcx, %rbp je 0x4d476 movq (%r12), %rsi movq %r13, %rdi movq %r15, %rdx movq %r12, %rcx mo...
/ValveSoftware[P]Fossilize/fossilize.cpp
Fossilize::StateRecorder::Impl::SubpassMetaStorage Fossilize::StateRecorder::Impl::analyze_subpass_meta_storage<VkRenderPassCreateInfo2>(VkRenderPassCreateInfo2 const&)
StateRecorder::Impl::SubpassMetaStorage StateRecorder::Impl::analyze_subpass_meta_storage(const CreateInfo &info) { SubpassMetaStorage storage = {}; storage.subpass_count = info.subpassCount; if (info.subpassCount > 16) storage.fallback.resize(((info.subpassCount - 16) + 15) / 16); for (uint32_t i = 0; i < info...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx xorps %xmm0, %xmm0 movups %xmm0, 0x10(%rdi) movups %xmm0, (%rdi) movl 0x20(%rsi), %esi movl %esi, 0x4(%rdi) cmpl $0x11, %esi jb 0x4d65d leaq 0x8(%rbx), %rdi decl %esi shrl $0x4, %esi callq 0x56892 movq 0x28(%r14), %rax addq $0x40, %rax xorl %edx, %edx pus...
/ValveSoftware[P]Fossilize/fossilize.cpp
Fossilize::StateRecorder::Impl::SubpassMetaStorage Fossilize::StateRecorder::Impl::analyze_subpass_meta_storage<VkRenderPassCreateInfo>(VkRenderPassCreateInfo const&)
StateRecorder::Impl::SubpassMetaStorage StateRecorder::Impl::analyze_subpass_meta_storage(const CreateInfo &info) { SubpassMetaStorage storage = {}; storage.subpass_count = info.subpassCount; if (info.subpassCount > 16) storage.fallback.resize(((info.subpassCount - 16) + 15) / 16); for (uint32_t i = 0; i < info...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx xorps %xmm0, %xmm0 movups %xmm0, 0x10(%rdi) movups %xmm0, (%rdi) movl 0x20(%rsi), %esi movl %esi, 0x4(%rdi) cmpl $0x11, %esi jb 0x4d72d leaq 0x8(%rbx), %rdi decl %esi shrl $0x4, %esi callq 0x56892 movq 0x28(%r14), %rax addq $0x30, %rax xorl %edx, %edx pus...
/ValveSoftware[P]Fossilize/fossilize.cpp
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::FindMember(char const*)
MemberIterator FindMember(const Ch* name) { GenericValue n(StringRef(name)); return FindMember(n); }
pushq %r15 pushq %r14 pushq %rbx subq $0x20, %rsp movq %rsi, %rbx movq %rdi, %r14 leaq 0x10(%rsp), %r15 movq %r15, %rdi movq %rdx, %rsi callq 0x501ec xorps %xmm0, %xmm0 movq %rsp, %rdx movaps %xmm0, (%rdx) movl 0x8(%r15), %eax movabsq $0x405000000000000, %rcx # imm = 0x405000000000000 orq (%r15), %rcx movq %rcx, 0x8(%r...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericMemberIterator<false, rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::FindMember<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rap...
bool IsObject() const { return data_.f.flags == kObjectFlag; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax cmpw $0x3, 0xe(%rsi) jne 0x501ad movq %rdx, %rbx testb $0x4, 0xf(%rdx) je 0x501cc movq %rsi, %r15 movq %rdi, %r14 callq 0x5022c movq %rsp, %r12 movq %r12, %rdi movq %r15, %rsi callq 0x50268 movq (%r14), %rsi cmpq (%rsp), %rsi je 0x5019e movq %rbx, %rdi callq 0x502a...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::MemberEnd()
bool IsObject() const { return data_.f.flags == kObjectFlag; }
cmpw $0x3, 0xe(%rsi) jne 0x5028d movabsq $0xffffffffffff, %rax # imm = 0xFFFFFFFFFFFF andq 0x8(%rsi), %rax movl (%rsi), %ecx shlq $0x5, %rcx addq %rax, %rcx movq %rcx, (%rdi) movq %rdi, %rax retq pushq %rax leaq 0x1f995d(%rip), %rdi # 0x249bf2 leaq 0x1f958c(%rip), %rsi # 0x249828 leaq 0x1f9ae8(%rip), %rcx # ...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
bool rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::StringEqual<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>> const&) const
bool IsString() const { return (data_.f.flags & kStringFlag) != 0; }
pushq %rbp pushq %r14 pushq %rbx testb $0x4, 0xf(%rdi) je 0x5030e movq %rsi, %rbx testb $0x4, 0xf(%rsi) je 0x5032d movq %rdi, %r14 callq 0x4b02a movl %eax, %ebp movq %rbx, %rdi callq 0x4b02a cmpl %eax, %ebp jne 0x50303 movq %r14, %rdi callq 0x4adfe movq %rax, %r14 movq %rbx, %rdi callq 0x4adfe cmpq %rax, %r14 je 0x5030...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GetDouble() const
double GetDouble() const { RAPIDJSON_ASSERT(IsNumber()); if ((data_.f.flags & kDoubleFlag) != 0) return data_.n.d; // exact type, no conversion. if ((data_.f.flags & kIntFlag) != 0) return data_.n.i.i; // int -> double if ((data_.f.flags & kUintFlag) !=...
pushq %rax movzwl 0xe(%rdi), %eax testb $0x10, %al je 0x50b9e btl $0x9, %eax jb 0x50b82 testb $0x20, %al jne 0x50b88 testb $0x40, %al jne 0x50b8e testb %al, %al js 0x50b97 btl $0x8, %eax jae 0x50bbd movsd (%rdi), %xmm1 unpcklps 0x1f72b4(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1] subpd 0x1f72bc(%rip), %xmm1 ...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>& rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator[]<rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>(rapidjson::GenericValue<rapidjson::UTF8<ch...
GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) { MemberIterator member = FindMember(name); if (member != MemberEnd()) return member->value; else { RAPIDJSON_ASSERT(false); // see above note // This will generate -Wexit-time-d...
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rsi, %rdx movq %rdi, %rbx leaq 0x8(%rsp), %r14 movq %r14, %rdi movq %rbx, %rsi callq 0x50152 movq %rsp, %r15 movq %r15, %rdi movq %rbx, %rsi callq 0x50268 movq (%r14), %rax cmpq (%r15), %rax je 0x51105 addq $0x10, %rax addq $0x10, %rsp popq %rbx popq %r14 popq %r1...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator[](unsigned int)
GenericValue& operator[](SizeType index) { RAPIDJSON_ASSERT(IsArray()); RAPIDJSON_ASSERT(index < data_.a.size); return GetElementsPointer()[index]; }
pushq %rax cmpw $0x4, 0xe(%rdi) jne 0x51363 cmpl %esi, (%rdi) jbe 0x51382 movabsq $0xffffffffffff, %rcx # imm = 0xFFFFFFFFFFFF andq 0x8(%rdi), %rcx movl %esi, %eax shlq $0x4, %rax addq %rcx, %rax popq %rcx retq leaq 0x1f84b4(%rip), %rdi # 0x24981e leaq 0x1f84b7(%rip), %rsi # 0x249828 leaq 0x1f91ae(%rip), %rcx ...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::EncodedInputStream<rapidjson::UTF8<char>, rapidjson::MemoryStream>::EncodedInputStream(rapidjson::MemoryStream&)
EncodedInputStream(MemoryStream& is) : is_(is) { if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take(); if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take(); if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take(); }
movq %rsi, (%rdi) movq (%rsi), %rax movq 0x10(%rsi), %rcx cmpq %rcx, %rax je 0x51580 cmpb $-0x11, (%rax) jne 0x51580 incq %rax movq %rax, (%rsi) cmpq %rcx, %rax je 0x51590 cmpb $-0x45, (%rax) jne 0x51590 incq %rax movq %rax, (%rsi) cmpq %rcx, %rax je 0x515a0 cmpb $-0x41, (%rax) jne 0x515a0 incq %rax movq %rax, (%rsi) r...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/encodedstream.h
rapidjson::ParseResult rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::Parse<0u, rapidjson::EncodedInputStream<rapidjson::UTF8<char>, rapidjson::MemoryStream>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapi...
ParseResult Parse(InputStream& is, Handler& handler) { if (parseFlags & kParseIterativeFlag) return IterativeParse<parseFlags>(is, handler); parseResult_.Clear(); ClearStackOnExit scope(*this); SkipWhitespaceAndComments<parseFlags>(is); RAPIDJSON_PARSE_ERROR_EARLY_...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %r15 movq %rdi, %rbx andl $0x0, 0x30(%rdi) movq %rsi, %r14 andq $0x0, 0x38(%rdi) movq %rsi, %rdi callq 0x517bb movl 0x30(%rbx), %eax testl %eax, %eax jne 0x5170b movq (%r14), %rcx movq (%rcx), %rdx pushq $0x1 popq %rax cmpq 0x10(%rcx), %rdx je 0x51720 cmpb $0x0, (%rdx) je 0x5...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/reader.h
void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseNumber<0u, rapidjson::EncodedInputStream<rapidjson::UTF8<char>, rapidjson::MemoryStream>, rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAl...
void ParseNumber(InputStream& is, Handler& handler) { internal::StreamLocalCopy<InputStream> copy(is); NumberStream<InputStream, ((parseFlags & kParseNumbersAsStringsFlag) != 0) ? ((parseFlags & kParseInsituFlag) == 0) : ((parseFlags & kParseFullPrecisionFlag)...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rdx, %rbx movq %rdi, 0x40(%rsp) leaq 0x38(%rsp), %r15 movq %rsi, (%r15) movq (%rsi), %rax movq (%rax), %rcx subq 0x8(%rax), %rcx movq %rcx, 0x50(%rsp) pushq $0x2d popq %rsi movq %r15, %rdi callq 0x5337a movq (%r15), %rcx movq (%rcx...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/reader.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>* rapidjson::internal::Stack<rapidjson::CrtAllocator>::PushUnsafe<rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>>(unsigned long)
RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) { RAPIDJSON_ASSERT(stackTop_); RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_)); T* ret = reinterpret_cast<T*>(stackTop_); stackTop_ += sizeof(T) * count; return ret; }
pushq %rax movq 0x18(%rdi), %rax testq %rax, %rax je 0x528a5 shlq $0x4, %rsi movq 0x20(%rdi), %rcx subq %rax, %rcx cmpq %rcx, %rsi jg 0x528c4 addq %rax, %rsi movq %rsi, 0x18(%rdi) popq %rcx retq leaq 0x1f8256(%rip), %rdi # 0x24ab02 leaq 0x1f7f65(%rip), %rsi # 0x24a818 leaq 0x1f8252(%rip), %rcx # 0x24ab0c movl ...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/stack.h
void rapidjson::internal::Stack<rapidjson::CrtAllocator>::Expand<rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>>(unsigned long)
void Expand(size_t count) { // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity. size_t newCapacity; if (stack_ == 0) { if (!allocator_) ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); newCa...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq 0x10(%rdi), %rax testq %rax, %rax je 0x5290a movq 0x20(%r14), %rdx subq %rax, %rdx leaq 0x1(%rdx), %rcx shrq %rcx addq %rdx, %rcx jmp 0x52925 cmpq $0x0, (%r14) jne 0x5291f pushq $0x1 popq %rdi callq 0x295e0 movq %rax, (%r14) movq %rax, 0x8(%r14) movq...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/stack.h
rapidjson::internal::Stack<rapidjson::CrtAllocator>::Resize(unsigned long)
void Resize(size_t newCapacity) { const size_t size = GetSize(); // Backup the current size stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity)); stackTop_ = stack_ + size; stackEnd_ = stack_ + newCapacity; }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 movq 0x18(%rdi), %r15 movq (%rdi), %rdi movq 0x10(%r14), %rsi subq %rsi, %r15 movq 0x20(%r14), %rdx subq %rsi, %rdx movq %rbx, %rcx callq 0x5298a movq %rax, 0x10(%r14) addq %rax, %r15 movq %r15, 0x18(%r14) addq %rbx, %rax movq %rax, 0x20(%r14) popq %rbx p...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/stack.h
void rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator>::ParseStringToStream<0u, rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::EncodedInputStream<rapidjson::UTF8<char>, rapidjson::MemoryStream>, rapidjson::GenericReader<rapidjson::UTF8<char>, rapidjson::UTF8<char>...
RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) { //!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN #define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 static const char escape[256] = { Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '/', Z16, Z16, 0, 0, 0, 0, 0, ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx leaq 0x1facc1(%rip), %rbp # 0x24d6a0 movq (%r15), %rax movq (%rax), %r13 movq 0x10(%rax), %rcx cmpq %rcx, %r13 je 0x52b78 movzbl (%r13), %edx cmpl $0x5c, %edx je 0x52a26 cmpl $0x22, %edx je 0x...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/reader.h
char* rapidjson::internal::Stack<rapidjson::CrtAllocator>::PushUnsafe<char>(unsigned long)
RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) { RAPIDJSON_ASSERT(stackTop_); RAPIDJSON_ASSERT(static_cast<std::ptrdiff_t>(sizeof(T) * count) <= (stackEnd_ - stackTop_)); T* ret = reinterpret_cast<T*>(stackTop_); stackTop_ += sizeof(T) * count; return ret; }
pushq %rax movq 0x18(%rdi), %rax testq %rax, %rax je 0x52e8f movq 0x20(%rdi), %rcx subq %rax, %rcx cmpq %rsi, %rcx jl 0x52eae addq %rax, %rsi movq %rsi, 0x18(%rdi) popq %rcx retq leaq 0x1f7c6c(%rip), %rdi # 0x24ab02 leaq 0x1f797b(%rip), %rsi # 0x24a818 leaq 0x1f83a9(%rip), %rcx # 0x24b24d movl $0x82, %edx call...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/stack.h
void rapidjson::internal::Stack<rapidjson::CrtAllocator>::Expand<char>(unsigned long)
void Expand(size_t count) { // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity. size_t newCapacity; if (stack_ == 0) { if (!allocator_) ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)(); newCa...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq 0x10(%rdi), %rax testq %rax, %rax je 0x52ef4 movq 0x20(%r14), %rdx subq %rax, %rdx leaq 0x1(%rdx), %rcx shrq %rcx addq %rdx, %rcx jmp 0x52f0f cmpq $0x0, (%r14) jne 0x52f09 pushq $0x1 popq %rdi callq 0x295e0 movq %rax, (%r14) movq %rax, 0x8(%r14) movq...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/stack.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericValue(char const*, unsigned int)
GenericValue(const Ch* s, SizeType length) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(StringRef(s, length)); }
pushq %r14 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx xorps %xmm0, %xmm0 movups %xmm0, (%rdi) leaq 0x8(%rsp), %r14 movq %r14, %rdi callq 0x5311a movw $0x405, 0xe(%rbx) # imm = 0x405 movabsq $0x405000000000000, %rax # imm = 0x405000000000000 orq (%r14), %rax movq %rax, 0x8(%rbx) movl 0x8(%r14), %eax movl %eax, (%...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::SetStringRaw(rapidjson::GenericStringRef<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetStringRaw(StringRefType s, Allocator& allocator) { Ch* str = 0; if (ShortString::Usable(s.length)) { data_.f.flags = kShortStringFlag; data_.ss.SetLength(s.length); str = data_.ss.str; } else { data_.f.flags = kCopyStringFlag; d...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 cmpl $0xd, 0x8(%rsi) ja 0x53004 movw $0x1c05, 0xe(%r14) # imm = 0x1C05 movb $0xd, %al subb 0x8(%rbx), %al movb %al, 0xd(%r14) jmp 0x5302e movw $0xc05, 0xe(%r14) # imm = 0xC05 movl 0x8(%rbx), %esi movl %esi, (%r14) incl %esi movq %rdx, %rdi call...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::Malloc(unsigned long)
void* Malloc(size_t size) { if (!size) return NULL; size = RAPIDJSON_ALIGN(size); if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity) if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size)) return NULL; void *buffer = r...
testq %rsi, %rsi je 0x530a9 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 addq $0x7, %rbx andq $-0x8, %rbx movq (%rdi), %rcx testq %rcx, %rcx je 0x53078 movq 0x8(%rcx), %rax leaq (%rax,%rbx), %rdx cmpq (%rcx), %rdx jbe 0x5309c movq 0x8(%r14), %rsi cmpq %rbx, %rsi cmovbeq %rbx, %rsi movq %r14, %rdi ca...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/allocators.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::SetObjectRaw(rapidjson::GenericMember<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*, unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) { data_.f.flags = kObjectFlag; if (count) { Member* m = static_cast<Member*>(allocator.Malloc(count * sizeof(Member))); SetMembersPointer(m); std::memcpy(static_cast<void*>(m), members, count * s...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movl %edx, %ebx movq %rdi, %r14 movabsq $-0x1000000000000, %r13 # imm = 0xFFFF000000000000 movw $0x3, 0xe(%rdi) testl %edx, %edx je 0x5328e movq %rsi, %r15 movl %ebx, %r12d shlq $0x5, %r12 movq %rcx, %rdi movq %r12, %rsi callq 0x5304c andq 0x8(%r14), %r13 orq %rax,...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::SetArrayRaw(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*, unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) { data_.f.flags = kArrayFlag; if (count) { GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue))); SetElementsPointer(e); std::memcpy(static_cast<void*>(...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movl %edx, %ebx movq %rdi, %r14 movabsq $-0x1000000000000, %r13 # imm = 0xFFFF000000000000 movw $0x4, 0xe(%rdi) testl %edx, %edx je 0x53364 movq %rsi, %r15 movl %ebx, %r12d shlq $0x4, %r12 movq %rcx, %rdi movq %r12, %rsi callq 0x5304c andq 0x8(%r14), %r13 orq %rax,...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::internal::StrtodNormalPrecision(double, int)
inline double StrtodNormalPrecision(double d, int p) { if (p < -308) { // Prevent expSum < -308, making Pow10(p) = 0 d = FastPath(d, -308); d = FastPath(d, p + 308); } else d = FastPath(d, p); return d; }
cmpl $0xfffffecb, %edi # imm = 0xFFFFFECB jg 0x534b9 divsd 0x1f4ac4(%rip), %xmm0 # 0x247ea0 addl $0x134, %edi # imm = 0x134 jmp 0x534b9 nop
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/strtod.h
rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::Int(int)
bool Int(int i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
pushq %rbx movl %esi, %ebx addq $0x20, %rdi pushq $0x1 popq %rsi callq 0x52846 andq $0x0, 0x8(%rax) movslq %ebx, %rcx movq %rcx, (%rax) testl %ecx, %ecx movl $0x1f6, %ecx # imm = 0x1F6 movl $0xb6, %edx cmovnsl %ecx, %edx movw %dx, 0xe(%rax) movb $0x1, %al popq %rbx retq nop
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::Uint(unsigned int)
bool Uint(unsigned i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
pushq %rbx movl %esi, %ebx addq $0x20, %rdi pushq $0x1 popq %rsi callq 0x52846 andq $0x0, 0x8(%rax) movl %ebx, %ecx movq %rcx, (%rax) xorl %ecx, %ecx testl %ebx, %ebx setns %cl shll $0x5, %ecx orl $0x1d6, %ecx # imm = 0x1D6 movw %cx, 0xe(%rax) movb $0x1, %al popq %rbx retq
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::internal::FastPath(double, int)
inline double FastPath(double significand, int exp) { if (exp < -308) return 0.0; else if (exp >= 0) return significand * internal::Pow10(exp); else return significand / internal::Pow10(-exp); }
movapd %xmm0, %xmm1 xorpd %xmm0, %xmm0 cmpl $0xfffffecc, %edi # imm = 0xFFFFFECC jl 0x534f7 pushq %rax movsd %xmm1, (%rsp) testl %edi, %edi js 0x534df callq 0x534f8 mulsd (%rsp), %xmm0 jmp 0x534f3 negl %edi callq 0x534f8 movsd (%rsp), %xmm1 divsd %xmm0, %xmm1 movapd %xmm1, %xmm0 addq $0x8, %rsp retq
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/strtod.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericValue(long)
explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_() { data_.n.i64 = i64; data_.f.flags = kNumberInt64Flag; if (i64 >= 0) { data_.f.flags |= kNumberUint64Flag; if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000))) data...
andq $0x0, 0x8(%rdi) movq %rsi, (%rdi) movw $0x96, 0xe(%rdi) testq %rsi, %rsi js 0x53567 xorl %ecx, %ecx movq %rsi, %rax shrq $0x20, %rax sete %cl shll $0x6, %ecx orl $0x196, %ecx # imm = 0x196 testq $-0x80000000, %rsi # imm = 0x80000000 movl $0x1f6, %eax # imm = 0x1F6 cmovnel %ecx, %eax jmp ...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericDocument<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>, rapidjson::CrtAllocator>::ClearStack()
void ClearStack() { if (Allocator::kNeedFree) while (stack_.GetSize() > 0) // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects) (stack_.template Pop<ValueType>(1))->~ValueType(); else stack_.Clear(); s...
leaq 0x20(%rdi), %rax movq 0x30(%rdi), %rcx movq %rcx, 0x38(%rdi) movq %rax, %rdi jmp 0x535ce
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::internal::Stack<rapidjson::CrtAllocator>::ShrinkToFit()
void ShrinkToFit() { if (Empty()) { // If the stack is empty, completely deallocate the memory. Allocator::Free(stack_); // NOLINT (+clang-analyzer-unix.Malloc) stack_ = 0; stackTop_ = 0; stackEnd_ = 0; } else Resize(GetSiz...
pushq %rbx movq %rdi, %rbx movq 0x10(%rdi), %rdi movq 0x18(%rbx), %rsi subq %rdi, %rsi je 0x535e8 movq %rbx, %rdi popq %rbx jmp 0x5294a addq $0x10, %rbx callq 0x29710 xorps %xmm0, %xmm0 movups %xmm0, (%rbx) andq $0x0, 0x10(%rbx) popq %rbx retq
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/stack.h
VkPipelineTessellationDomainOriginStateCreateInfo* Fossilize::StateRecorder::Impl::copy<VkPipelineTessellationDomainOriginStateCreateInfo>(VkPipelineTessellationDomainOriginStateCreateInfo 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 0x53823 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x5382e testq %rax, %rax je 0x53823 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
VkPipelineRasterizationDepthClipStateCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkPipelineRasterizationDepthClipStateCreateInfoEXT>(VkPipelineRasterizationDepthClipStateCreateInfoEXT 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 0x53877 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x53882 testq %rax, %rax je 0x53877 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
VkPipelineRasterizationStateStreamCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkPipelineRasterizationStateStreamCreateInfoEXT>(VkPipelineRasterizationStateStreamCreateInfoEXT 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 0x538cb movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x538d6 testq %rax, %rax je 0x538cb 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
VkPipelineColorBlendAdvancedStateCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkPipelineColorBlendAdvancedStateCreateInfoEXT>(VkPipelineColorBlendAdvancedStateCreateInfoEXT 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 0x53922 movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x5392c testq %rax, %rax je 0x53922 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
VkPipelineRasterizationConservativeStateCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkPipelineRasterizationConservativeStateCreateInfoEXT>(VkPipelineRasterizationConservativeStateCreateInfoEXT 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 0x53978 movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x53982 testq %rax, %rax je 0x53978 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
VkPipelineRasterizationLineStateCreateInfo* Fossilize::StateRecorder::Impl::copy<VkPipelineRasterizationLineStateCreateInfo>(VkPipelineRasterizationLineStateCreateInfo 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 0x539ce movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x539d8 testq %rax, %rax je 0x539ce 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
VkAttachmentDescriptionStencilLayout* Fossilize::StateRecorder::Impl::copy<VkAttachmentDescriptionStencilLayout>(VkAttachmentDescriptionStencilLayout 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 0x53a75 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x53a80 testq %rax, %rax je 0x53a75 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
VkSamplerReductionModeCreateInfo* Fossilize::StateRecorder::Impl::copy<VkSamplerReductionModeCreateInfo>(VkSamplerReductionModeCreateInfo 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 0x53bc5 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x53bd0 testq %rax, %rax je 0x53bc5 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
VkGraphicsPipelineLibraryCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkGraphicsPipelineLibraryCreateInfoEXT>(VkGraphicsPipelineLibraryCreateInfoEXT 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 0x53d3f movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x53d4a testq %rax, %rax je 0x53d3f 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
VkPipelineViewportDepthClipControlCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkPipelineViewportDepthClipControlCreateInfoEXT>(VkPipelineViewportDepthClipControlCreateInfoEXT 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 0x53d93 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x53d9e testq %rax, %rax je 0x53d93 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
VkRenderPassCreationControlEXT* Fossilize::StateRecorder::Impl::copy<VkRenderPassCreationControlEXT>(VkRenderPassCreationControlEXT 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 0x53e3b movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x53e46 testq %rax, %rax je 0x53e3b 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
VkSamplerBorderColorComponentMappingCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkSamplerBorderColorComponentMappingCreateInfoEXT>(VkSamplerBorderColorComponentMappingCreateInfoEXT 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 0x53e8f movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x53e9a testq %rax, %rax je 0x53e8f 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
VkMultisampledRenderToSingleSampledInfoEXT* Fossilize::StateRecorder::Impl::copy<VkMultisampledRenderToSingleSampledInfoEXT>(VkMultisampledRenderToSingleSampledInfoEXT 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 0x53ee3 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x53eee testq %rax, %rax je 0x53ee3 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
VkDepthBiasRepresentationInfoEXT* Fossilize::StateRecorder::Impl::copy<VkDepthBiasRepresentationInfoEXT>(VkDepthBiasRepresentationInfoEXT 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 0x53f37 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x53f42 testq %rax, %rax je 0x53f37 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
VkRenderPassFragmentDensityMapCreateInfoEXT* Fossilize::StateRecorder::Impl::copy<VkRenderPassFragmentDensityMapCreateInfoEXT>(VkRenderPassFragmentDensityMapCreateInfoEXT 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 0x53f8b movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x53f96 testq %rax, %rax je 0x53f8b 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
VkPipelineRobustnessCreateInfo* Fossilize::StateRecorder::Impl::copy<VkPipelineRobustnessCreateInfo>(VkPipelineRobustnessCreateInfo 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 0x53fe2 movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x53fec testq %rax, %rax je 0x53fe2 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
VkPhysicalDeviceMeshShaderFeaturesNV* Fossilize::StateRecorder::Impl::copy<VkPhysicalDeviceMeshShaderFeaturesNV>(VkPhysicalDeviceMeshShaderFeaturesNV 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 0x54dad movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x54db8 testq %rax, %rax je 0x54dad 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
VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* Fossilize::StateRecorder::Impl::copy<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT 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 0x54f02 movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x54f0c testq %rax, %rax je 0x54f02 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
VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* Fossilize::StateRecorder::Impl::copy<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT 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 0x54f55 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x54f60 testq %rax, %rax je 0x54f55 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
VkPipelineDynamicStateCreateInfo* Fossilize::StateRecorder::Impl::copy<VkPipelineDynamicStateCreateInfo>(VkPipelineDynamicStateCreateInfo 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 0x550e0 movq %rdx, %rbx movq %rsi, %r14 movq %rcx, %rdi movq %rdx, %rsi callq 0x5512c testq %rax, %rax je 0x550e0 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
VkRayTracingPipelineInterfaceCreateInfoKHR* Fossilize::StateRecorder::Impl::copy<VkRayTracingPipelineInterfaceCreateInfoKHR>(VkRayTracingPipelineInterfaceCreateInfoKHR 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 0x55189 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x55194 testq %rax, %rax je 0x55189 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
VkPipelineVertexInputStateCreateInfo* Fossilize::StateRecorder::Impl::copy<VkPipelineVertexInputStateCreateInfo>(VkPipelineVertexInputStateCreateInfo 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 0x552b1 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x552bc testq %rax, %rax je 0x552b1 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
VkPipelineMultisampleStateCreateInfo* Fossilize::StateRecorder::Impl::copy<VkPipelineMultisampleStateCreateInfo>(VkPipelineMultisampleStateCreateInfo 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 0x55305 movq %rdx, %r14 movq %rsi, %rbx movq %rcx, %rdi movq %rdx, %rsi callq 0x55310 testq %rax, %rax je 0x55305 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
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::AddMember(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>&, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocat...
bool IsObject() const { return data_.f.flags == kObjectFlag; }
pushq %r15 pushq %r14 pushq %rbx cmpw $0x3, 0xe(%rdi) jne 0x58ee8 movq %rsi, %r15 testb $0x4, 0xf(%rsi) je 0x58f07 movq %rdx, %r14 movq %rdi, %rbx movl (%rdi), %eax movl 0x4(%rdi), %edx cmpl %edx, %eax jb 0x58ea6 leal 0x1(%rdx), %eax shrl %eax addl %edx, %eax testl %edx, %edx pushq $0x10 popq %rsi cmovnel %eax, %esi mo...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::MemberReserve(unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
bool IsObject() const { return data_.f.flags == kObjectFlag; }
pushq %rbp pushq %rbx pushq %rax cmpw $0x3, 0xe(%rdi) jne 0x58f7b movl %esi, %ebp movq %rdi, %rbx movl 0x4(%rdi), %eax cmpl %esi, %eax jae 0x58f71 movabsq $0xffffffffffff, %rsi # imm = 0xFFFFFFFFFFFF andq 0x8(%rbx), %rsi shlq $0x5, %rax movl %ebp, %ecx shlq $0x5, %rcx movq %rdx, %rdi movq %rax, %rdx callq 0x58f9a mov...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::Reserve(unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
bool IsArray() const { return data_.f.flags == kArrayFlag; }
pushq %rbp pushq %rbx pushq %rax cmpw $0x4, 0xe(%rdi) jne 0x59089 movl %esi, %ebp movq %rdi, %rbx movl 0x4(%rdi), %eax cmpl %esi, %eax jae 0x5907f movabsq $0xffffffffffff, %rsi # imm = 0xFFFFFFFFFFFF andq 0x8(%rbx), %rsi shlq $0x4, %rax movl %ebp, %ecx shlq $0x4, %rcx movq %rdx, %rdi movq %rax, %rdx callq 0x58f9a mov...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
rapidjson::internal::DigitGen(rapidjson::internal::DiyFp const&, rapidjson::internal::DiyFp const&, unsigned long, char*, int*, int*)
inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) { static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 }; const DiyFp one(uint64_t(1) << -Mp.e, Mp.e); const DiyFp wp_w = Mp - W; uint32_t p1 = st...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %r9, 0x8(%rsp) movq %r8, %r13 movq %rcx, %rbx xorl %r14d, %r14d subl 0x8(%rsi), %r14d pushq $0x1 popq %r8 movl %r14d, %ecx shlq %cl, %r8 movq (%rsi), %r12 movq %r12, %rax subq (%rdi), %rax movq %rax, 0x10(%rsp) movq %rdx, %r15 movq ...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/dtoa.h
rapidjson::internal::DiyFp::NormalizeBoundary() const
DiyFp NormalizeBoundary() const { DiyFp res = *this; while (!(res.f & (kDpHiddenBit << 1))) { res.f <<= 1; res.e--; } res.f <<= (kDiySignificandSize - kDpSignificandSize - 2); res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2); return r...
movq (%rdi), %rax movl 0x8(%rdi), %edx addl $-0xa, %edx btq $0x35, %rax jb 0x59f13 addq %rax, %rax decl %edx jmp 0x59f05 shlq $0xa, %rax retq
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/diyfp.h
rapidjson::internal::GetCachedPowerByIndex(unsigned long)
inline DiyFp GetCachedPowerByIndex(size_t index) { // 10^-348, 10^-340, ..., 10^340 static const uint64_t kCachedPowers_F[] = { RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76), RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0...
cmpq $0x57, %rdi jae 0x59f35 leaq 0x1f434b(%rip), %rax # 0x24e270 movq (%rax,%rdi,8), %rax leaq 0x1f4600(%rip), %rcx # 0x24e530 movswl (%rcx,%rdi,2), %edx retq pushq %rax leaq 0x1f2d9c(%rip), %rdi # 0x24ccd9 leaq 0x1f2da0(%rip), %rsi # 0x24cce4 leaq 0x1f2e12(%rip), %rcx # 0x24cd5d movl $0xdc, %edx callq ...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/diyfp.h
rapidjson::internal::clzll(unsigned long)
inline uint32_t clzll(uint64_t x) { // Passing 0 to __builtin_clzll is UB in GCC and results in an // infinite loop in the software implementation. RAPIDJSON_ASSERT(x != 0); #if defined(_MSC_VER) unsigned long r = 0; #if defined(_WIN64) _BitScanReverse64(&r, x); #else // Scan the high 32 bits. ...
testq %rdi, %rdi je 0x59f62 bsrq %rdi, %rax xorl $0x3f, %eax retq pushq %rax leaq 0x1f2e2c(%rip), %rdi # 0x24cd96 leaq 0x1f2e2c(%rip), %rsi # 0x24cd9d leaq 0x1f2e9e(%rip), %rcx # 0x24ce16 pushq $0x23 popq %rdx callq 0x293b0
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/clzll.h
rapidjson::internal::CountDecimalDigit32(unsigned int)
inline int CountDecimalDigit32(uint32_t n) { // Simple pure C++ implementation was faster than __builtin_clz version in this situation. if (n < 10) return 1; if (n < 100) return 2; if (n < 1000) return 3; if (n < 10000) return 4; if (n < 100000) return 5; if (n < 1000000) return 6; if (n...
cmpl $0xa, %edi jae 0x59f89 pushq $0x1 jmp 0x59fcc cmpl $0x64, %edi jae 0x59f92 pushq $0x2 jmp 0x59fcc cmpl $0x3e8, %edi # imm = 0x3E8 jae 0x59f9e pushq $0x3 jmp 0x59fcc cmpl $0x2710, %edi # imm = 0x2710 jae 0x59faa pushq $0x4 jmp 0x59fcc cmpl $0x186a0, %edi # imm = 0x186A0 jae 0x59fb6 pus...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/dtoa.h
rapidjson::internal::GrisuRound(char*, int, unsigned long, unsigned long, unsigned long, unsigned long)
inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) { while (rest < wp_w && delta - rest >= ten_kappa && (rest + ten_kappa < wp_w || /// closer wp_w - rest > rest + ten_kappa - wp_w)) { buffer[len - 1]--; rest += ten...
movslq %esi, %rax subq %rcx, %rdx movq %r8, %rsi subq %r9, %rsi movq %r9, %r10 subq %rcx, %r10 cmpq %r9, %rcx jae 0x5a014 subq %r8, %rdx jb 0x5a014 leaq (%rcx,%r8), %r11 cmpq %r9, %r11 jb 0x5a008 addq %rsi, %rcx cmpq %rcx, %r10 jbe 0x5a014 decb -0x1(%rdi,%rax) subq %r8, %r10 movq %r11, %rcx jmp 0x59fed retq
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/dtoa.h
rapidjson::internal::WriteExponent(int, char*)
inline char* WriteExponent(int K, char* buffer) { if (K < 0) { *buffer++ = '-'; K = -K; } if (K >= 100) { *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100)); K %= 100; const char* d = GetDigitsLut() + K * 2; *buffer++ = d[0]; *buffer++ = ...
testl %edi, %edi jns 0x5a021 movb $0x2d, (%rsi) incq %rsi negl %edi cmpl $0x64, %edi jb 0x5a048 pushq $0x64 popq %rcx movl %edi, %eax xorl %edx, %edx divl %ecx addb $0x30, %al movb %al, (%rsi) leaq 0x1f45d6(%rip), %rax # 0x24e610 movzwl (%rax,%rdx,2), %eax movw %ax, 0x1(%rsi) addq $0x3, %rsi jmp 0x5a06d cmpl $0xa, %...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/dtoa.h
rapidjson::Writer<rapidjson::GenericStringBuffer<rapidjson::UTF8<char>, rapidjson::CrtAllocator>, rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator, 0u>::WriteInt(int)
inline bool Writer<StringBuffer>::WriteInt(int i) { char *buffer = os_->Push(11); const char* end = internal::i32toa(i, buffer); os_->Pop(static_cast<size_t>(11 - (end - buffer))); return true; }
pushq %r15 pushq %r14 pushq %rbx movl %esi, %ebx movq %rdi, %r14 movq (%rdi), %rdi pushq $0xb popq %rsi callq 0x52e3c movq %rax, %r15 movl %ebx, %edi movq %rax, %rsi callq 0x5a0ae movq (%r14), %rdi subq %rax, %r15 addq $0xb, %r15 movq %r15, %rsi callq 0x52f30 movb $0x1, %al popq %rbx popq %r14 popq %r15 retq
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/writer.h
rapidjson::internal::i32toa(int, char*)
inline char* i32toa(int32_t value, char* buffer) { RAPIDJSON_ASSERT(buffer != 0); uint32_t u = static_cast<uint32_t>(value); if (value < 0) { *buffer++ = '-'; u = ~u + 1; } return u32toa(u, buffer); }
testq %rsi, %rsi je 0x5a0c8 testl %edi, %edi jns 0x5a0e6 movb $0x2d, (%rsi) incq %rsi negl %edi jmp 0x5a0e6 pushq %rax leaq 0x1f2d74(%rip), %rdi # 0x24ce44 leaq 0x1f2d79(%rip), %rsi # 0x24ce50 leaq 0x1f2dea(%rip), %rcx # 0x24cec8 pushq $0x74 popq %rdx callq 0x293b0
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/itoa.h
rapidjson::internal::u32toa(unsigned int, char*)
inline char* u32toa(uint32_t value, char* buffer) { RAPIDJSON_ASSERT(buffer != 0); const char* cDigitsLut = GetDigitsLut(); if (value < 10000) { const uint32_t d1 = (value / 100) << 1; const uint32_t d2 = (value % 100) << 1; if (value >= 1000) *buffer++ = cDigitsLut[d1...
testq %rsi, %rsi je 0x5a319 cmpl $0x270f, %edi # imm = 0x270F ja 0x5a12c movw $0x64, %cx movl %edi, %eax xorl %edx, %edx divw %cx movzwl %ax, %ecx addl %ecx, %ecx movzwl %dx, %eax addl %eax, %eax cmpl $0x3e8, %edi # imm = 0x3E8 jb 0x5a1a5 leaq 0x1f44f1(%rip), %rdx # 0x24e610 movb (%rcx,%rdx), %d...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/itoa.h
rapidjson::Writer<rapidjson::GenericStringBuffer<rapidjson::UTF8<char>, rapidjson::CrtAllocator>, rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator, 0u>::WriteUint(unsigned int)
inline bool Writer<StringBuffer>::WriteUint(unsigned u) { char *buffer = os_->Push(10); const char* end = internal::u32toa(u, buffer); os_->Pop(static_cast<size_t>(10 - (end - buffer))); return true; }
pushq %r15 pushq %r14 pushq %rbx movl %esi, %ebx movq %rdi, %r14 movq (%rdi), %rdi pushq $0xa popq %rsi callq 0x52e3c movq %rax, %r15 movl %ebx, %edi movq %rax, %rsi callq 0x5a0e6 movq (%r14), %rdi subq %rax, %r15 addq $0xa, %r15 movq %r15, %rsi callq 0x52f30 movb $0x1, %al popq %rbx popq %r14 popq %r15 retq
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/writer.h
rapidjson::internal::i64toa(long, char*)
inline char* i64toa(int64_t value, char* buffer) { RAPIDJSON_ASSERT(buffer != 0); uint64_t u = static_cast<uint64_t>(value); if (value < 0) { *buffer++ = '-'; u = ~u + 1; } return u64toa(u, buffer); }
testq %rsi, %rsi je 0x5a3ce testq %rdi, %rdi jns 0x5a3ee movb $0x2d, (%rsi) incq %rsi negq %rdi jmp 0x5a3ee pushq %rax leaq 0x1f2a6e(%rip), %rdi # 0x24ce44 leaq 0x1f2a73(%rip), %rsi # 0x24ce50 leaq 0x1f2b4b(%rip), %rcx # 0x24cf2f movl $0x127, %edx # imm = 0x127 callq 0x293b0
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/itoa.h
rapidjson::internal::u64toa(unsigned long, char*)
inline char* u64toa(uint64_t value, char* buffer) { RAPIDJSON_ASSERT(buffer != 0); const char* cDigitsLut = GetDigitsLut(); const uint64_t kTen8 = 100000000; const uint64_t kTen9 = kTen8 * 10; const uint64_t kTen10 = kTen8 * 100; const uint64_t kTen11 = kTen8 * 1000; const uint64_t kTen12 ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax testq %rsi, %rsi je 0x5a981 cmpq $0x5f5e0ff, %rdi # imm = 0x5F5E0FF ja 0x5a443 cmpq $0x270f, %rdi # imm = 0x270F ja 0x5a521 pushq $0x64 popq %rcx movl %edi, %eax xorl %edx, %edx divl %ecx addq %rax, %rax addl %edx, %edx cmpq $0x3e8, %rdi ...
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/internal/itoa.h
rapidjson::Writer<rapidjson::GenericStringBuffer<rapidjson::UTF8<char>, rapidjson::CrtAllocator>, rapidjson::UTF8<char>, rapidjson::UTF8<char>, rapidjson::CrtAllocator, 0u>::WriteUint64(unsigned long)
inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) { char *buffer = os_->Push(20); const char* end = internal::u64toa(u, buffer); os_->Pop(static_cast<size_t>(20 - (end - buffer))); return true; }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 movq (%rdi), %rdi pushq $0x14 popq %rsi callq 0x52e3c movq %rax, %r15 movq %rbx, %rdi movq %rax, %rsi callq 0x5a3ee movq (%r14), %rdi subq %rax, %r15 addq $0x14, %r15 movq %r15, %rsi callq 0x52f30 movb $0x1, %al popq %rbx popq %r14 popq %r15 retq
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/writer.h
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkFilter>, rapidjson::internal::IsGenericValue<VkFilter>>)>::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 0x5ab62 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<float>, rapidjson::internal::IsGenericValue<float>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllo...
AddMember(StringRefType name, T value, Allocator& allocator) { GenericValue n(name); return AddMember(n, value, allocator); }
subq $0x18, %rsp movl 0x8(%rsi), %eax xorps %xmm1, %xmm1 movabsq $0x405000000000000, %rcx # imm = 0x405000000000000 orq (%rsi), %rcx movq %rsp, %rsi movaps %xmm1, (%rsi) movq %rcx, 0x8(%rsi) movl %eax, (%rsi) callq 0x5ab9a 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<VkCompareOp>, rapidjson::internal::IsGenericValue<VkCompareOp>>)>::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 0x5abc6 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<VkSamplerMipmapMode>, rapidjson::internal::IsGenericValue<VkSamplerMipmapMode>>)>::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 0x5abfe 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<VkBorderColor>, rapidjson::internal::IsGenericValue<VkBorderColor>>)>::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 0x5ac6e 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<VkTessellationDomainOrigin>, rapidjson::internal::IsGenericValue<VkTessellationDomainOrigin>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjs...
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 0x5acd4 addq $0x18, %rsp retq nop
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h