name string | code string | asm string | file string |
|---|---|---|---|
cfgfile::lexical_analyzer_t<cfgfile::qstring_trait_t>::skip_spaces() | void skip_spaces()
{
if( m_stream.at_end() )
return;
typename Trait::char_t ch = m_stream.get();
while( is_space_char( ch ) )
{
if( m_stream.at_end() )
return;
ch = m_stream.get();
}
m_stream.put_back( ch );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0xb0(%r14), %rax
cmpq 0x90(%r14), %rax
jne 0x43c3c
movq (%r14), %rdi
callq 0x7200
testb %al, %al
je 0x43c3c
movq 0xe8(%r14), %rax
cmpq 0xe0(%r14), %rax
jne 0x43c3c
addq $0x8, %rsp
popq %rbx
popq %r12
popq... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/lex.hpp |
cfgfile::tag_no_value_t<cfgfile::qstring_trait_t>::print(int) const | typename Trait::string_t print( int indent = 0 ) const override
{
typename Trait::string_t result;
if( this->is_defined() )
{
result.append( typename Trait::string_t( indent,
const_t< Trait >::c_tab ) );
result.push_back( const_t< Trait >::c_begin_tag );
result.append( this->name() );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x3f0b0
testb %al, %al
je 0x450e3
leaq 0x2129b(%rip), %rax # 0x66238
movslq %ebp, %r14
movzwl (%rax),... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/tag_no_value.hpp |
cfgfile::tag_no_value_t<cfgfile::qstring_trait_t>::on_string(cfgfile::parser_info_t<cfgfile::qstring_trait_t> const&, cfgfile::qstring_wrapper_t const&) | void on_string( const parser_info_t< Trait > & info,
const typename Trait::string_t & str ) override
{
throw exception_t< Trait >( Trait::from_ascii( "Tag \"" ) +
this->name() + Trait::from_ascii( "\" doesn't allow any values. "
"But we've got this: \"" ) +
str + Trait::from_ascii( "\". In file \""... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl $0x28, %edi
callq 0x72f0
movq %rax, %rbx
leaq 0x1e8(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x6c06(%rip), %rsi # 0x4c3b4
leaq 0x6c04(%rip), %rdx # 0... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/tag_no_value.hpp |
doctest::String doctest::detail::stringifyBinaryExpr<cfgfile::qstring_wrapper_t, char [125]>(cfgfile::qstring_wrapper_t const&, char const*, char const (&) [125]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x71b7(%rip), %rsi # 0x4d793
leaq 0x30(%rsp), %rdi
callq 0xa554
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
mo... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::StringMakerBase<true>::convert<char [125]>(char const (&) [125]) | static String convert(const DOCTEST_REF_WRAP(T) in) {
/* When parameter "in" is a null terminated const char* it works.
* When parameter "in" is a T arr[N] without '\0' we can fill the
* stringstream with N objects (T=char).If in is char pointer *
* without '\0' , it w... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa325
movq %rax, %r15
movq %rbx, %rdi
callq 0x7310
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7780
movq %r14, %rdi
callq 0xa38e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<cfgfile::qstring_wrapper_t, char [130]>(cfgfile::qstring_wrapper_t const&, char const*, char const (&) [130]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x6fa5(%rip), %rsi # 0x4d793
leaq 0x30(%rsp), %rdi
callq 0xa554
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
mo... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
secp256k1_ge_is_valid_var | static int secp256k1_ge_is_valid_var(const secp256k1_ge *a) {
secp256k1_fe y2, x3;
SECP256K1_GE_VERIFY(a);
if (a->infinity) {
return 0;
}
/* y^2 = x^3 + 7 */
secp256k1_fe_sqr(&y2, &a->y);
secp256k1_fe_sqr(&x3, &a->x); secp256k1_fe_mul(&x3, &x3, &a->x);
secp256k1_fe_add_int(&x3, ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
callq 0x3ff0f
xorl %eax, %eax
cmpl $0x0, 0x60(%rbx)
jne 0x3ff05
leaq 0x30(%rbx), %rsi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x3ff6a
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3ff6a
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq ... | /TheCharlatan[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_ge_to_bytes | static void secp256k1_ge_to_bytes(unsigned char *buf, const secp256k1_ge *a) {
secp256k1_ge_storage s;
/* We require that the secp256k1_ge_storage type is exactly 64 bytes.
* This is formally not guaranteed by the C standard, but should hold on any
* sane compiler in the real world. */
STATIC_ASS... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3ff0f
cmpl $0x0, 0x60(%r14)
jne 0x4086b
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x40870
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x30(%r15), %xmm3
movups %xmm3, 0x... | /TheCharlatan[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_der_read_len | static int secp256k1_der_read_len(size_t *len, const unsigned char **sigp, const unsigned char *sigend) {
size_t lenleft;
unsigned char b1;
VERIFY_CHECK(len != NULL);
*len = 0;
if (*sigp >= sigend) {
return 0;
}
b1 = *((*sigp)++);
if (b1 == 0xFF) {
/* X.690-0207 8.1.3.5.c... | pushq %rax
testq %rdi, %rdi
je 0x40ecf
movq $0x0, (%rdi)
movq (%rsi), %rcx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x40ecd
leaq 0x1(%rcx), %r9
movq %r9, (%rsi)
movzbl (%rcx), %r8d
cmpq $0xff, %r8
je 0x40ecd
testb %r8b, %r8b
js 0x40e66
movq %r8, (%rdi)
movl $0x1, %eax
jmp 0x40ecd
cmpl $0x80, %r8d
je 0x40ecd
andl $0x7f, %r8d... | /TheCharlatan[P]bitcoin/src/secp256k1/src/ecdsa_impl.h |
secp256k1_scalar_verify | SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp256k1_scalar *a) {
int yes = 0;
int no = 0;
no |= (a->d[3] < SECP256K1_N_3); /* No need for a > check. */
no |= (a->d[2] < SECP256K1_N_2);
yes |= (a->d[2] > SECP256K1_N_2) & ~no;
no |= (a->d[1] < SECP256K1_N_1);
yes |= (a-... | cmpq $-0x1, 0x18(%rdi)
sete %al
movq 0x10(%rdi), %rcx
cmpq $-0x2, %rcx
setae %dl
cmpq $-0x1, %rcx
sete %cl
andb %al, %cl
movzbl %cl, %ecx
movq 0x8(%rdi), %rsi
movabsq $-0x4551231950b75fc6, %r8 # imm = 0xBAAEDCE6AF48A03A
cmpq %r8, %rsi
seta %r9b
andb %al, %dl
andb %r9b, %dl
incq %r8
xorl %eax, %eax
cmpq %r8, %rsi
movzbl... | /TheCharlatan[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_gej_eq_x_var | static int secp256k1_gej_eq_x_var(const secp256k1_fe *x, const secp256k1_gej *a) {
secp256k1_fe r;
SECP256K1_FE_VERIFY(x);
SECP256K1_GEJ_VERIFY(a);
VERIFY_CHECK(!a->infinity);
secp256k1_fe_sqr(&r, &a->z); secp256k1_fe_mul(&r, &r, x);
return secp256k1_fe_equal(&r, &a->x);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x243ae
movq %rbx, %rdi
callq 0x430aa
cmpl $0x0, 0x90(%rbx)
jne 0x4178b
leaq 0x60(%rbx), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x3ff6a
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x402ae
movq %r15, %rdi
movq %rbx, %rs... | /TheCharlatan[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_fe_add | SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe *r, const secp256k1_fe *a) {
SECP256K1_FE_VERIFY(r);
SECP256K1_FE_VERIFY(a);
VERIFY_CHECK(r->magnitude + a->magnitude <= 32);
secp256k1_fe_impl_add(r, a);
r->magnitude += a->magnitude;
r->normalized = 0;
SECP256K1_FE_VERIFY(r);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x243ae
movq %r14, %rdi
callq 0x243ae
movl 0x28(%r14), %eax
addl 0x28(%rbx), %eax
cmpl $0x21, %eax
jge 0x41850
movq (%r14), %rcx
addq %rcx, (%rbx)
movq 0x8(%r14), %rcx
addq %rcx, 0x8(%rbx)
movq 0x10(%r14), %rcx
addq %rcx, 0x10(%rbx)
movq 0x18(%r14),... | /TheCharlatan[P]bitcoin/src/secp256k1/src/field_impl.h |
secp256k1_scalar_from_signed62 | static void secp256k1_scalar_from_signed62(secp256k1_scalar *r, const secp256k1_modinv64_signed62 *a) {
const uint64_t a0 = a->v[0], a1 = a->v[1], a2 = a->v[2], a3 = a->v[3], a4 = a->v[4];
/* The output from secp256k1_modinv64{_var} should be normalized to range [0,modulus), and
* have limbs in [0,2^62). ... | pushq %rax
movq (%rsi), %rdx
movq %rdx, %rax
shrq $0x3e, %rax
jne 0x41e50
movabsq $0x3fffffffffffffff, %r9 # imm = 0x3FFFFFFFFFFFFFFF
movq 0x8(%rsi), %r8
cmpq %r9, %r8
ja 0x41e55
movq 0x10(%rsi), %rcx
cmpq %r9, %rcx
ja 0x41e5a
movq 0x18(%rsi), %rax
cmpq %r9, %rax
ja 0x41e5f
movq 0x20(%rsi), %rsi
cmpq $0x100, %rsi ... | /TheCharlatan[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_scalar_inverse | static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k1_scalar *x) {
secp256k1_modinv64_signed62 s;
#ifdef VERIFY
int zero_in = secp256k1_scalar_is_zero(x);
#endif
SECP256K1_SCALAR_VERIFY(x);
secp256k1_scalar_to_signed62(&s, x);
secp256k1_modinv64(&s, &secp256k1_const_modinfo_scal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x41016
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
orps %xmm0, %xmm1
movaps %xmm1, (%rsp)
movq %r14, %rdi
callq 0x41016
movq (%r14), %r15
movq 0x8(%r14), %r12
movq 0x10(%r14), %r13... | /TheCharlatan[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_fe_cmov | SECP256K1_INLINE static void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag) {
VERIFY_CHECK(flag == 0 || flag == 1);
SECP256K1_FE_VERIFY(a);
SECP256K1_FE_VERIFY(r);
secp256k1_fe_impl_cmov(r, a, flag);
if (a->magnitude > r->magnitude) r->magnitude = a->magnitude;
if (!a->norm... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpl $0x2, %edx
jae 0x441ee
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x243ae
movq %rbx, %rdi
callq 0x243ae
movl %ebp, 0x4(%rsp)
leaq 0x10(%rsp), %rax
movq $0x4d430005, (%rax) # imm = 0x4D430005
movq %rbx, 0x8(%rax)
movq $0x28, 0x10(%rax)... | /TheCharlatan[P]bitcoin/src/secp256k1/src/field_impl.h |
secp256k1_gej_double | static SECP256K1_INLINE void secp256k1_gej_double(secp256k1_gej *r, const secp256k1_gej *a) {
/* Operations: 3 mul, 4 sqr, 8 add/half/mul_int/negate */
secp256k1_fe l, s, t;
SECP256K1_GEJ_VERIFY(a);
r->infinity = a->infinity;
/* Formula used:
* L = (3/2) * X1^2
* S = Y1^2
* T = -X1*... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x430aa
movl 0x90(%r14), %eax
movl %eax, 0x90(%rbx)
leaq 0x60(%rbx), %rdi
leaq 0x60(%r14), %rsi
leaq 0x30(%r14), %r15
movq %r15, %rdx
callq 0x402ae
movq %rsp, %rdi
movq %r15, %rsi
callq 0x3ff6a
... | /TheCharlatan[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_fe_half | SECP256K1_INLINE static void secp256k1_fe_half(secp256k1_fe *r) {
SECP256K1_FE_VERIFY(r);
SECP256K1_FE_VERIFY_MAGNITUDE(r, 31);
secp256k1_fe_impl_half(r);
r->magnitude = (r->magnitude >> 1) + 1;
r->normalized = 0;
SECP256K1_FE_VERIFY(r);
} | pushq %rbx
movq %rdi, %rbx
callq 0x243ae
movq %rbx, %rdi
movl $0x1f, %esi
callq 0x3ff54
movq (%rbx), %rsi
movl %esi, %eax
andl $0x1, %eax
negq %rax
movq %rax, %rcx
shrq $0xc, %rcx
movabsq $0xffffefffffc2f, %rdx # imm = 0xFFFFEFFFFFC2F
andq %rcx, %rdx
addq %rsi, %rdx
testb $0x1, %dl
jne 0x447f9
shrq $0x10, %rax
addq 0x... | /TheCharlatan[P]bitcoin/src/secp256k1/src/field_impl.h |
secp256k1_ecmult_strauss_wnaf | static void secp256k1_ecmult_strauss_wnaf(const struct secp256k1_strauss_state *state, secp256k1_gej *r, size_t num, const secp256k1_gej *a, const secp256k1_scalar *na, const secp256k1_scalar *ng) {
secp256k1_ge tmpa;
secp256k1_fe Z;
/* Split G factors. */
secp256k1_scalar ng_1, ng_128;
int wnaf_ng_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp # imm = 0x538
movq %r9, 0x28(%rsp)
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, 0x30(%rsp)
movq %rdi, %r14
leaq 0xb0(%rsp), %rdi
movq $0x1, (%rdi)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x8(%rdi)
movdqu %xmm0, 0x18(%rdi... | /TheCharlatan[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
smf::Binasc::readFromBinary(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | int Binasc::readFromBinary(const std::string& outfile, const std::string& infile) {
std::ifstream input;
input.open(infile.c_str());
if (!input.is_open()) {
std::cerr << "Cannot open " << infile
<< " for reading in binasc." << std::endl;
return 0;
}
std::ofstream output;
output.open(outfile.c_str... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x200(%rsp), %r12
movq %r12, %rdi
callq 0xe370
movq (%r15), %rsi
movq %r12, %rdi
movl $0x8, %edx
callq 0xe1e0
leaq 0x278(%rsp), %rdi
callq 0xe0b0
testb %al, %al
je 0x1cf7f
movq %rs... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::outputStyleMidi(std::ostream&, std::istream&) | int Binasc::outputStyleMidi(std::ostream& out, std::istream& input) {
uchar ch; // current input byte
std::stringstream tempout;
input.read((char*)&ch, 1);
if (input.eof()) {
std::cerr << "End of the file right away!" << std::endl;
return 0;
}
// Read the MIDI file header:
// The firs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, %r14
movq %rsi, 0x58(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xe220
leaq 0x9(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0xe3f0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x... | /dean-deng[P]midifile/src-library/Binasc.cpp |
shim_vkGetDeviceQueue(VkDevice_T*, unsigned int, unsigned int, VkQueue_T**) | VKAPI_ATTR void VKAPI_CALL shim_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
for (auto& physical_devices : mock.physical_devices_details) {
auto it = std::find(
std::begin(physical_devices.created_device_handles), std::end(physical_devices.... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq 0x1516b(%rip), %rax # 0x30ed8
addq $0xb0, %rax
movq %rax, -0x20(%rbp)
movq 0x1515a(%rip), %rdi # 0x30ed8
addq $0xb0, %rdi
callq 0x18f30
movq %rax, -0x28(%rbp)
movq 0x15143(%... | /charles-lunarg[P]vk-bootstrap/tests/vulkan_mock.cpp |
shim_vkGetSwapchainImagesKHR(VkDevice_T*, VkSwapchainKHR_T*, unsigned int*, VkImage_T**) | VKAPI_ATTR VkResult VKAPI_CALL shim_vkGetSwapchainImagesKHR(
[[maybe_unused]] VkDevice device, [[maybe_unused]] VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
std::vector<VkImage> images{ get_uint64_handle<VkImage>(0x0000EDD0U),
get_uint64_handle<VkImage>(0x0000E... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0xedd0, %edi # imm = 0xEDD0
callq 0x18de0
movq %rax, -0x60(%rbp)
movl $0xedd1, %edi # imm = 0xEDD1
movq %rdi, -0x88(%rbp)
callq 0x18de0
movq -0x88(%rbp), %rdi
... | /charles-lunarg[P]vk-bootstrap/tests/vulkan_mock.cpp |
shim_vkGetDeviceProcAddr(VkDevice_T*, char const*) | VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL shim_vkGetDeviceProcAddr(VkDevice device, const char* pName) {
if (device == VK_NULL_HANDLE) {
return nullptr;
}
GPA_IMPL(vkDestroyDevice)
GPA_IMPL(vkGetDeviceQueue)
GPA_IMPL(vkCreateCommandPool)
GPA_IMPL(vkCreateFence)
GPA_IMPL(vkDestroyFence... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c154
movq $0x0, -0x8(%rbp)
jmp 0x1c2e7
movq -0x18(%rbp), %rdi
leaq 0xaf8c(%rip), %rsi # 0x270eb
callq 0x19fc0
cmpl $0x0, %eax
jne 0x1c179
movq 0x14e38(%rip), %rax # 0x30fa8
movq %rax, -0x8(%r... | /charles-lunarg[P]vk-bootstrap/tests/vulkan_mock.cpp |
VkResult fill_out_count_pointer_pair<VkExtensionProperties>(std::vector<VkExtensionProperties, std::allocator<VkExtensionProperties>> const&, unsigned int*, VkExtensionProperties*) | VkResult fill_out_count_pointer_pair(std::vector<T> const& data_vec, uint32_t* pCount, T* pData) {
if (pCount == nullptr) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
if (pData == nullptr) {
if (pCount) *pCount = static_cast<uint32_t>(data_vec.size());
return VK_SUCCESS;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1cda7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1cea2
cmpq $0x0, -0x20(%rbp)
jne 0x1cdd2
cmpq $0x0, -0x18(%rbp)
je 0x1cdc6
movq -0x10(%rbp), %rdi
callq 0x19270
movl %... | /charles-lunarg[P]vk-bootstrap/tests/vulkan_mock.cpp |
VkResult fill_out_count_pointer_pair<VkLayerProperties>(std::vector<VkLayerProperties, std::allocator<VkLayerProperties>> const&, unsigned int*, VkLayerProperties*) | VkResult fill_out_count_pointer_pair(std::vector<T> const& data_vec, uint32_t* pCount, T* pData) {
if (pCount == nullptr) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
if (pData == nullptr) {
if (pCount) *pCount = static_cast<uint32_t>(data_vec.size());
return VK_SUCCESS;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1cf57
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d052
cmpq $0x0, -0x20(%rbp)
jne 0x1cf82
cmpq $0x0, -0x18(%rbp)
je 0x1cf76
movq -0x10(%rbp), %rdi
callq 0x18d60
movl %... | /charles-lunarg[P]vk-bootstrap/tests/vulkan_mock.cpp |
VkResult fill_out_count_pointer_pair<VkPhysicalDevice_T*>(std::vector<VkPhysicalDevice_T*, std::allocator<VkPhysicalDevice_T*>> const&, unsigned int*, VkPhysicalDevice_T**) | VkResult fill_out_count_pointer_pair(std::vector<T> const& data_vec, uint32_t* pCount, T* pData) {
if (pCount == nullptr) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
if (pData == nullptr) {
if (pCount) *pCount = static_cast<uint32_t>(data_vec.size());
return VK_SUCCESS;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1d0a7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d195
cmpq $0x0, -0x20(%rbp)
jne 0x1d0d2
cmpq $0x0, -0x18(%rbp)
je 0x1d0c6
movq -0x10(%rbp), %rdi
callq 0x1a8b0
movl %... | /charles-lunarg[P]vk-bootstrap/tests/vulkan_mock.cpp |
VkResult fill_out_count_pointer_pair<VkQueueFamilyProperties>(std::vector<VkQueueFamilyProperties, std::allocator<VkQueueFamilyProperties>> const&, unsigned int*, VkQueueFamilyProperties*) | VkResult fill_out_count_pointer_pair(std::vector<T> const& data_vec, uint32_t* pCount, T* pData) {
if (pCount == nullptr) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
if (pData == nullptr) {
if (pCount) *pCount = static_cast<uint32_t>(data_vec.size());
return VK_SUCCESS;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1d227
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d32b
cmpq $0x0, -0x20(%rbp)
jne 0x1d252
cmpq $0x0, -0x18(%rbp)
je 0x1d246
movq -0x10(%rbp), %rdi
callq 0x19210
movl %... | /charles-lunarg[P]vk-bootstrap/tests/vulkan_mock.cpp |
VkResult fill_out_count_pointer_pair<VkImage_T*>(std::vector<VkImage_T*, std::allocator<VkImage_T*>> const&, unsigned int*, VkImage_T**) | VkResult fill_out_count_pointer_pair(std::vector<T> const& data_vec, uint32_t* pCount, T* pData) {
if (pCount == nullptr) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
if (pData == nullptr) {
if (pCount) *pCount = static_cast<uint32_t>(data_vec.size());
return VK_SUCCESS;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1e0a7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e195
cmpq $0x0, -0x20(%rbp)
jne 0x1e0d2
cmpq $0x0, -0x18(%rbp)
je 0x1e0c6
movq -0x10(%rbp), %rdi
callq 0x19ff0
movl %... | /charles-lunarg[P]vk-bootstrap/tests/vulkan_mock.cpp |
VkResult fill_out_count_pointer_pair<VkSurfaceFormatKHR>(std::vector<VkSurfaceFormatKHR, std::allocator<VkSurfaceFormatKHR>> const&, unsigned int*, VkSurfaceFormatKHR*) | VkResult fill_out_count_pointer_pair(std::vector<T> const& data_vec, uint32_t* pCount, T* pData) {
if (pCount == nullptr) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
if (pData == nullptr) {
if (pCount) *pCount = static_cast<uint32_t>(data_vec.size());
return VK_SUCCESS;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1e277
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e368
cmpq $0x0, -0x20(%rbp)
jne 0x1e2a2
cmpq $0x0, -0x18(%rbp)
je 0x1e296
movq -0x10(%rbp), %rdi
callq 0x19360
movl %... | /charles-lunarg[P]vk-bootstrap/tests/vulkan_mock.cpp |
SyMemBackendPoolAlloc | JX9_PRIVATE void * SyMemBackendPoolAlloc(SyMemBackend *pBackend, sxu32 nByte)
{
void *pChunk;
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) ){
return 0;
}
#endif
if( pBackend->pMutexMethods ){
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
}
pChunk = MemBackendPoolAlloc(&(*pBac... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xb3d2
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xb3d2
callq *0x20(%rax)
movl %ebp, %esi
addq $0x8, %rsi
cmpl $0x7ff7, %ebp # imm = 0x7FF7
jbe 0xb3ff
movq %rbx, %rdi
callq 0xf26a
testq... | /symisc[P]unqlite/unqlite.c |
SyMemBackendPoolFree | JX9_PRIVATE sxi32 SyMemBackendPoolFree(SyMemBackend *pBackend, void * pChunk)
{
sxi32 rc;
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) || pChunk == 0 ){
return SXERR_CORRUPT;
}
#endif
if( pBackend->pMutexMethods ){
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
}
rc = MemBacke... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xb5a1
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xb5a1
callq *0x20(%rax)
movl -0x8(%r14), %eax
movl %eax, %ecx
andl $0xffff0000, %ecx # imm = 0xFFFF0000
movl $0xffffffe8, %ebp # imm = 0xFFFFFFE8
cmpl $0xd... | /symisc[P]unqlite/unqlite.c |
unqlite_close | int unqlite_close(unqlite *pDb)
{
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPG... | pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffe8, %ebx # imm = 0xFFFFFFE8
testq %rdi, %rdi
je 0xb97a
movq %rdi, %r14
cmpl $0xdb7c2712, 0x110(%rdi) # imm = 0xDB7C2712
jne 0xb97a
movq %r14, %rdi
callq 0xb984
movl %eax, %ebx
movq 0x4e9e3(%rip), %rax # 0x5a308
cmpq %r14, %rax
jne 0xb938
movq 0x100(%rax), %rax
mo... | /symisc[P]unqlite/unqlite.c |
unqlite_vm_config | int unqlite_vm_config(unqlite_vm *pVm,int iOp,...)
{
va_list ap;
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THRE... | subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xbf9f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc... | /symisc[P]unqlite/unqlite.c |
unqlite_vm_dump | int unqlite_vm_dump(unqlite_vm *pVm, int (*xConsumer)(const void *, unsigned int, void *), void *pUserData)
{
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sU... | movl $0xffffffe8, %eax # imm = 0xFFFFFFE8
testq %rdi, %rdi
je 0xc235
cmpl $0xdead2bad, 0xf0(%rdi) # imm = 0xDEAD2BAD
je 0xc235
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0xd8(%rdi), %rax
movq 0xe8(%rax), %rax
movq 0x8(%rax), %r15
movl 0x10(%ra... | /symisc[P]unqlite/unqlite.c |
unqlite_create_function | int unqlite_create_function(unqlite_vm *pVm, const char *zName,int (*xFunc)(unqlite_context *,int,unqlite_value **),void *pUserData)
{
SyString sName;
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
SyStringInitFromBuf(&sName, zName, SyStrlen(zName));
/* Remove leading and trailing white... | movl $0xffffffe8, %eax # imm = 0xFFFFFFE8
testq %rdi, %rdi
je 0xc444
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
cmpl $0xdead2bad, 0xf0(%rdi) # imm = 0xDEAD2BAD
je 0xc436
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, (%rsp)
cmpb $0x0, (%rsi)
movq %rsi, %r12
je 0... | /symisc[P]unqlite/unqlite.c |
unqlite_delete_function | int unqlite_delete_function(unqlite_vm *pVm, const char *zName)
{
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREA... | pushq %rbp
pushq %rbx
pushq %rax
movl $0xffffffe8, %ebp # imm = 0xFFFFFFE8
testq %rdi, %rdi
je 0xc63e
cmpl $0xdead2bad, 0xf0(%rdi) # imm = 0xDEAD2BAD
je 0xc63e
movq 0xd8(%rdi), %rbx
movq $0x0, (%rsp)
leaq 0x2c0(%rbx), %rdi
cmpb $0x0, (%rsi)
movq %rsi, %rdx
je 0xc605
leaq 0x2(%rsi), %rdx
cmpb $0x0, -0x1(%rdx)
je 0... | /symisc[P]unqlite/unqlite.c |
jx9_value_double | JX9_PRIVATE int jx9_value_double(jx9_value *pVal, double Value)
{
/* Invalidate any prior representation */
jx9MemObjRelease(pVal);
pVal->x.rVal = (jx9_real)Value;
MemObjSetType(pVal, MEMOBJ_REAL);
/* Try to get an integer representation also */
jx9MemObjTryInteger(pVal);
return JX9_OK;
} | pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0xcb9a
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movl $0xfffffe90, %eax # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl $0x4, %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x1fdf6
| /symisc[P]unqlite/unqlite.c |
unqlite_value_string_format | int unqlite_value_string_format(unqlite_value *pVal, const char *zFormat,...)
{
va_list ap;
int rc;
if((pVal->iFlags & MEMOBJ_STRING) == 0 ){
/* Invalidate any prior representation */
jx9MemObjRelease(pVal);
MemObjSetType(pVal, MEMOBJ_STRING);
}
va_start(ap, zFormat);
rc = SyBlobFormatAp(&pVal->sB... | pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0xcb21
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5,... | /symisc[P]unqlite/unqlite.c |
unqlite_kv_cursor_last_entry | int unqlite_kv_cursor_last_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xLast == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;... | movq (%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x60(%rax), %rax
testq %rax, %rax
je 0xe439
jmpq *%rax
movl $0xffffffef, %eax # imm = 0xFFFFFFEF
retq
| /symisc[P]unqlite/unqlite.c |
unqlite_kv_cursor_valid_entry | int unqlite_kv_cursor_valid_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xValid == 0 ){
rc = UNQLITE_NOTIMPLEMENTE... | movq (%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0xe454
jmpq *%rax
movl $0xffffffef, %eax # imm = 0xFFFFFFEF
retq
| /symisc[P]unqlite/unqlite.c |
unqlite_kv_cursor_next_entry | int unqlite_kv_cursor_next_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xNext == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;... | movq (%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x70(%rax), %rax
testq %rax, %rax
je 0xe46f
jmpq *%rax
movl $0xffffffef, %eax # imm = 0xFFFFFFEF
retq
| /symisc[P]unqlite/unqlite.c |
unqlite_kv_cursor_prev_entry | int unqlite_kv_cursor_prev_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xPrev == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;... | movq (%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x78(%rax), %rax
testq %rax, %rax
je 0xe48a
jmpq *%rax
movl $0xffffffef, %eax # imm = 0xFFFFFFEF
retq
| /symisc[P]unqlite/unqlite.c |
unqlite_kv_cursor_delete_entry | int unqlite_kv_cursor_delete_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xDelete == 0 ){
rc = UNQLITE_NOTIMPLEMEN... | movq (%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x80(%rax), %rax
testq %rax, %rax
je 0xe4a8
jmpq *%rax
movl $0xffffffef, %eax # imm = 0xFFFFFFEF
retq
| /symisc[P]unqlite/unqlite.c |
unqlite_kv_cursor_reset | int unqlite_kv_cursor_reset(unqlite_kv_cursor *pCursor)
{
int rc = UNQLITE_OK;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xReset == 0 ){
rc = UNQLITE_NOTIMP... | movq (%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0xe4ce
pushq %rax
callq *%rax
xorl %eax, %eax
addq $0x8, %rsp
retq
movl $0xffffffef, %eax # imm = 0xFFFFFFEF
retq
| /symisc[P]unqlite/unqlite.c |
unqlite_kv_cursor_seek | int unqlite_kv_cursor_seek(unqlite_kv_cursor *pCursor,const void *pKey,int nKeyLen,int iPos)
{
int rc = UNQLITE_OK;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
if( nKeyLen < 0 ){
/* Assume a null terminated string and compute it's length */
nKeyLen = SyStrlen((const char *)pK... | testl %edx, %edx
jns 0xe515
cmpb $0x0, (%rsi)
movq %rsi, %rdx
je 0xe513
leaq 0x2(%rsi), %rdx
cmpb $0x0, -0x1(%rdx)
je 0xe50b
cmpb $0x0, (%rdx)
je 0xe513
cmpb $0x0, 0x1(%rdx)
je 0xe510
leaq 0x4(%rdx), %rax
cmpb $0x0, 0x2(%rdx)
movq %rax, %rdx
jne 0xe4e4
addq $-0x2, %rax
movq %rax, %rdx
jmp 0xe513
decq %rdx
jmp 0xe513
in... | /symisc[P]unqlite/unqlite.c |
unixDelete | static int unixDelete(
unqlite_vfs *NotUsed, /* VFS containing this as the xDelete method */
const char *zPath, /* Name of file to be deleted */
int dirSync /* If true, fsync() directory after deleting file */
){
int rc = UNQLITE_OK;
SXUNUSED(NotUsed);
if( unlink(zPath)==... | pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xa0a0
cmpl $-0x1, %eax
jne 0xf6a5
callq 0xa080
movq %rax, %rcx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpl $0x2, (%rcx)
jne 0xf6e0
testl %ebp, %ebp
je 0xf6de
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8a0
testl %eax, %ea... | /symisc[P]unqlite/unqlite.c |
unixAccess | static int unixAccess(
unqlite_vfs *NotUsed, /* The VFS containing this xAccess method */
const char *zPath, /* Path of the file to examine */
int flags, /* What do we want to learn about the zPath file? */
int *pResOut /* Write result boolean here */
){
int amode = 0;
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
xorl %eax, %eax
cmpl $0x1, %edx
movl $0x6, %ecx
cmovnel %eax, %ecx
cmpl $0x2, %edx
movl $0x4, %esi
cmovnel %ecx, %esi
movq %r14, %rdi
callq 0xa350
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, (%rbx)
orl %ebp, %eax
... | /symisc[P]unqlite/unqlite.c |
unixFullPathname | static int unixFullPathname(
unqlite_vfs *pVfs, /* Pointer to vfs object */
const char *zPath, /* Possibly relative input path */
int nOut, /* Size of output buffer in bytes */
char *zOut /* Output buffer */
){
if( zPath[0]=='/' ){
Systrcp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
cmpb $0x2f, (%rsi)
jne 0xf77b
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xf933
jmp 0xf7fb
movslq %ebp, %rsi
movb $0x0, -0x1(%r15,%rsi)
decq %rsi
movq %r15, %rdi
callq 0xa1f0
movl $0xfffffff... | /symisc[P]unqlite/unqlite.c |
unixSleep | static int unixSleep(unqlite_vfs *NotUsed, int microseconds)
{
#if defined(HAVE_USLEEP) && HAVE_USLEEP
usleep(microseconds);
SXUNUSED(NotUsed);
return microseconds;
#else
int seconds = (microseconds+999999)/1000000;
SXUNUSED(NotUsed);
sleep(seconds);
return seconds*1000000;
#endif
} | pushq %rbx
addl $0xf423f, %esi # imm = 0xF423F
movslq %esi, %rax
imulq $0x431bde83, %rax, %rbx # imm = 0x431BDE83
movq %rbx, %rax
shrq $0x3f, %rax
sarq $0x32, %rbx
addl %eax, %ebx
movl %ebx, %edi
callq 0xa3b0
imull $0xf4240, %ebx, %eax # imm = 0xF4240
popq %rbx
retq
| /symisc[P]unqlite/unqlite.c |
unixCurrentTime | static int unixCurrentTime(unqlite_vfs *pVfs,Sytm *pOut)
{
struct tm *pTm;
time_t tt;
SXUNUSED(pVfs);
time(&tt);
pTm = gmtime(&tt);
if( pTm ){ /* Yes, it can fail */
STRUCT_TM_TO_SYTM(pTm,pOut);
}
return UNQLITE_OK;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0xa2a0
movq %r14, %rdi
callq 0xa370
testq %rax, %rax
je 0xf896
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rbx)
movl 0x4(%rax), %ecx
movl %ecx, 0x4(%rbx)
movl (%rax), %ecx
movl %ecx, (%rbx)
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%rbx)
movl 0... | /symisc[P]unqlite/unqlite.c |
openDirectory | static int openDirectory(const char *zFilename, int *pFd){
sxu32 ii;
int fd = -1;
char zDirname[MAX_PATHNAME+1];
sxu32 n;
n = Systrcpy(zDirname,sizeof(zDirname),zFilename,0);
for(ii=n; ii>1 && zDirname[ii]!='/'; ii--);
if( ii>0 ){
zDirname[ii] = '\0';
fd = open(zDirname, O_RDONLY|O_BINARY... | pushq %rbp
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rsi, %rbx
movq %rdi, %rdx
movq %rsp, %rdi
movl $0x201, %esi # imm = 0x201
xorl %ecx, %ecx
callq 0xf933
cmpl $0x2, %eax
jb 0xf8d7
movl %eax, %ecx
cmpb $0x2f, (%rsp,%rcx)
je 0xf8d7
decl %eax
cmpl $0x1, %eax
ja 0xf8c3
movl $0x1, %eax
testl %... | /symisc[P]unqlite/unqlite.c |
Systrcpy | JX9_PRIVATE sxu32 Systrcpy(char *zDest, sxu32 nDestLen, const char *zSrc, sxu32 nLen)
{
unsigned char *zBuf = (unsigned char *)zDest;
unsigned char *zIn = (unsigned char *)zSrc;
unsigned char *zEnd;
#if defined(UNTRUST)
if( zSrc == (const char *)zDest ){
return 0;
}
#endif
if( nLen <= 0 ){
nLen = ... | pushq %rbx
testl %ecx, %ecx
jne 0xf975
cmpb $0x0, (%rdx)
movq %rdx, %rcx
je 0xf973
leaq 0x2(%rdx), %rcx
cmpb $0x0, -0x1(%rcx)
je 0xf96b
cmpb $0x0, (%rcx)
je 0xf973
cmpb $0x0, 0x1(%rcx)
je 0xf970
leaq 0x4(%rcx), %rax
cmpb $0x0, 0x2(%rcx)
movq %rax, %rcx
jne 0xf944
addq $-0x2, %rax
movq %rax, %rcx
jmp 0xf973
decq %rcx
jm... | /symisc[P]unqlite/unqlite.c |
unixClose | static int unixClose(unqlite_file *id){
int rc = UNQLITE_OK;
if( id ){
unixFile *pFile = (unixFile *)id;
unixUnlock(id, NO_LOCK);
unixEnterMutex();
if( pFile->pInode && pFile->pInode->nLock ){
/* If there are outstanding locks, do not actually close the file just
** yet because t... | testq %rdi, %rdi
je 0xface
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0xffb7
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xfab0
cmpl $0x0, 0x1c(%r14)
je 0xfa60
movq 0x28(%rbx), %rax
movq 0x20(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x20(%r14)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
... | /symisc[P]unqlite/unqlite.c |
unixRead | static int unixRead(
unqlite_file *id,
void *pBuf,
unqlite_int64 amt,
unqlite_int64 offset
){
unixFile *pFile = (unixFile *)id;
int got;
got = seekAndRead(pFile, offset, pBuf, (int)amt);
if( got==(int)amt ){
return UNQLITE_OK;
}else if( got<0 ){
/* lastErrno set by seekAndRea... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x10(%rdi), %edi
xorl %ebp, %ebp
movq %rcx, %rsi
xorl %edx, %edx
callq 0xa1c0
cmpq %r12, %rax
jne 0xfb74
movl 0x10(%r15), %edi
movslq %r14d, %rdx
movq %rbx, %rsi
callq 0xa230
movq %rax, %r12
testl... | /symisc[P]unqlite/unqlite.c |
unixWrite | static int unixWrite(
unqlite_file *id,
const void *pBuf,
unqlite_int64 amt,
unqlite_int64 offset
){
unixFile *pFile = (unixFile*)id;
int wrote = 0;
while( amt>0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt))>0 ){
amt -= wrote;
offset += wrote;
pBuf = &((char*)pBuf)[wrote]... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
setg %bpl
jle 0xfc89
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl 0x10(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa1c0
cmpq %r14, %rax
jne 0xfc44
movl 0x10(%rbx), %edi
movq %r12, %rsi
movq %r15... | /symisc[P]unqlite/unqlite.c |
unixTruncate | static int unixTruncate(unqlite_file *id, sxi64 nByte){
unixFile *pFile = (unixFile *)id;
int rc;
rc = ftruncate(pFile->h, (off_t)nByte);
if( rc ){
pFile->lastErrno = errno;
return UNQLITE_IOERR;
}else{
return UNQLITE_OK;
}
} | pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %edi
callq 0xa1a0
testl %eax, %eax
je 0xfce4
callq 0xa080
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
jmp 0xfce6
xorl %eax, %eax
popq %rbx
retq
| /symisc[P]unqlite/unqlite.c |
unixSync | static int unixSync(unqlite_file *id, int flags){
int rc;
unixFile *pFile = (unixFile*)id;
int isDataOnly = (flags&UNQLITE_SYNC_DATAONLY);
int isFullsync = (flags&0x0F)==UNQLITE_SYNC_FULL;
rc = full_fsync(pFile->h, isFullsync, isDataOnly);
if( rc ){
pFile->lastErrno = errno;
return UNQ... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %edi
callq 0xa090
cmpl $-0x1, %eax
je 0xfd15
movl 0x14(%rbx), %edi
xorl %ebp, %ebp
testl %edi, %edi
js 0xfd24
callq 0xa090
movl 0x14(%rbx), %edi
callq 0xa200
testl %eax, %eax
je 0xfd2d
callq 0xa080
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
movl $0xfffffffe... | /symisc[P]unqlite/unqlite.c |
unixFileSize | static int unixFileSize(unqlite_file *id,sxi64 *pSize){
int rc;
struct stat buf;
rc = fstat(((unixFile*)id)->h, &buf);
if( rc!=0 ){
((unixFile*)id)->lastErrno = errno;
return UNQLITE_IOERR;
}
*pSize = buf.st_size;
/* When opening a zero-size database, the findInodeInfo() procedu... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rdi), %edi
leaq 0x8(%rsp), %rsi
callq 0xa3c0
testl %eax, %eax
je 0xfd69
callq 0xa080
movl (%rax), %eax
movl %eax, 0x1c(%r14)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
jmp 0xfd80
movq 0x38(%rsp), %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
... | /symisc[P]unqlite/unqlite.c |
unixLock | static int unixLock(unqlite_file *id, int eFileLock){
/* The following describes the implementation of the various locks and
** lock transitions in terms of the POSIX advisory shared and exclusive
** lock primitives (called read-locks and write-locks below, to avoid
** confusion with SQLite lock names). The... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movzbl 0x18(%rdi), %eax
xorl %r14d, %r14d
cmpl %esi, %eax
jge 0xfdea
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movl 0x14(%r12), %ecx
cmpl %eax, %ecx
je 0xfdcc
cmpl $0x3, %ecx
setge %dl
cmpl $0x2, %ebp
setge %sil
orb %dl, %sil
movl $0xfff... | /symisc[P]unqlite/unqlite.c |
unqliteErrorFromPosixError | static int unqliteErrorFromPosixError(int posixError, int unqliteIOErr) {
switch (posixError) {
case 0:
return UNQLITE_OK;
case EAGAIN:
case ETIMEDOUT:
case EBUSY:
case EINTR:
case ENOLCK:
/* random NFS retry error, unless during file system support
* introspection, in whi... | movl %edi, %eax
cmpl $0x3, %edi
jle 0x10244
cmpl $0x25, %eax
ja 0x10265
movl %eax, %ecx
movabsq $0x2000010810, %rdx # imm = 0x2000010810
btq %rcx, %rdx
jae 0x10253
movl $0xfffffff2, %eax # imm = 0xFFFFFFF2
retq
testl %eax, %eax
je 0x1026f
cmpl $0x1, %eax
jne 0x1026a
movl $0xffffffed, %eax # imm = 0xFFFF... | /symisc[P]unqlite/unqlite.c |
SyMemcmp | JX9_PRIVATE sxi32 SyMemcmp(const void *pB1, const void *pB2, sxu32 nSize)
{
sxi32 rc;
if( nSize <= 0 ){
return 0;
}
if( pB1 == 0 || pB2 == 0 ){
return pB1 != 0 ? 1 : (pB2 == 0 ? 0 : -1);
}
SX_MACRO_FAST_CMP(pB1, pB2, nSize, rc);
return rc;
} | testl %edx, %edx
je 0x10297
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x1029a
xorl %ecx, %ecx
negq %rsi
sbbl %ecx, %ecx
testq %rdi, %rdi
movl $0x1, %eax
cmovel %ecx, %eax
retq
xorl %eax, %eax
retq
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r10d
leaq -0x1(%r10), %r11
leaq -0x2(%r10), %rbx
lea... | /symisc[P]unqlite/unqlite.c |
SyMemcpy | JX9_PRIVATE sxu32 SyMemcpy(const void *pSrc, void *pDest, sxu32 nLen)
{
if( pSrc == 0 || pDest == 0 ){
return 0;
}
if( pSrc == (const void *)pDest ){
return nLen;
}
SX_MACRO_FAST_MEMCPY(pSrc, pDest, nLen);
return nLen;
} | testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %r8b
xorl %eax, %eax
orb %cl, %r8b
jne 0x10395
movl %edx, %eax
cmpq %rsi, %rdi
setne %cl
testl %edx, %edx
setne %dl
testb %dl, %cl
jne 0x10396
retq
leaq -0x1(%rax), %rcx
leaq -0x2(%rax), %rdx
leaq -0x3(%rax), %r8
xorl %r9d, %r9d
movb (%rdi,%r9), %r10b
movb %r10b, (%rsi,%r... | /symisc[P]unqlite/unqlite.c |
SyBufferFormat | JX9_PRIVATE sxu32 SyBufferFormat(char *zBuf, sxu32 nLen, const char *zFormat, ...)
{
SyBlob sBlob;
va_list ap;
sxu32 n;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zFormat) ){
return 0;
}
#endif
if( SXRET_OK != SyBlobInitFromBuf(&sBlob, zBuf, nLen - 1) ){
return 0;
}
va_start(ap, zFormat);
Form... | pushq %rbp
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r10
leaq 0x50(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x10446
movaps %xmm0, 0x80(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm3, 0xb0(%rsp)
movaps %xmm4, 0xc0(%rsp)
mo... | /symisc[P]unqlite/unqlite.c |
FormatMount | static sxi32 FormatMount(sxi32 nType, void *pConsumer, ProcConsumer xUserCons, void *pUserData, sxu32 *pOutLen, const char *zFormat, va_list ap)
{
SyFmtConsumer sCons;
sCons.nType = nType;
sCons.rc = SXRET_OK;
sCons.nLen = 0;
if( pOutLen ){
*pOutLen = 0;
}
switch(nType){
case SXFMT_CONS_PROC:
#if d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
movq %r9, %rbp
movl %edi, 0x6c(%rsp)
xorl %eax, %eax
movl %eax, 0x70(%rsp)
movl %eax, 0x68(%rsp)
movq %r8, 0x38(%rsp)
testq %r8, %r8
je 0x10503
movq 0x38(%rsp), %rax
movl $0x0, (%rax)
cmpl $0x6, %edi
je 0x10527
... | /symisc[P]unqlite/unqlite.c |
SyBlobAppend | JX9_PRIVATE sxi32 SyBlobAppend(SyBlob *pBlob, const void *pData, sxu32 nSize)
{
sxu8 *zBlob;
sxi32 rc;
if( nSize < 1 ){
return SXRET_OK;
}
rc = BlobPrepareGrow(&(*pBlob), &nSize);
if( SXRET_OK != rc ){
return rc;
}
if( pData ){
zBlob = (sxu8 *)pBlob->pBlob ;
zBlob = &zBlob[pBlob->nByte];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %edx, %edx
je 0x11532
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl 0x18(%rdi), %eax
testb $0x3, %al
je 0x1142c
movl 0x10(%r15), %ecx
movl 0x14(%r15), %edx
movl %edx, %eax
subl %ecx, %eax
xorl %r12d, %r12d
cmpl %r14d, %eax
jae 0x114b5
xorl %esi, %esi
... | /symisc[P]unqlite/unqlite.c |
FormatConsumer | static sxi32 FormatConsumer(const void *pSrc, unsigned int nLen, void *pData)
{
SyFmtConsumer *pConsumer = (SyFmtConsumer *)pData;
sxi32 rc = SXERR_ABORT;
switch(pConsumer->nType){
case SXFMT_CONS_PROC:
/* User callback */
rc = pConsumer->uConsumer.sFunc.xUserConsumer(pSrc, nLen, pConsumer->uConsumer.s... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
movl 0x4(%rdx), %ecx
cmpl $0x6, %ecx
je 0x1156c
movl $0xfffffff6, %eax # imm = 0xFFFFFFF6
cmpl $0x1, %ecx
jne 0x11577
movq 0x18(%rbx), %rdx
movq %rsi, %rdi
movl %ebp, %esi
callq *0x10(%rbx)
jmp 0x11577
movq 0x10(%rbx), %rdi
movl %ebp... | /symisc[P]unqlite/unqlite.c |
SyMemBackendDup | JX9_PRIVATE void * SyMemBackendDup(SyMemBackend *pBackend, const void *pSrc, sxu32 nSize)
{
void *pNew;
#if defined(UNTRUST)
if( pSrc == 0 || nSize <= 0 ){
return 0;
}
#endif
pNew = SyMemBackendAlloc(&(*pBackend), nSize);
if( pNew ){
SyMemcpy(pSrc, pNew, nSize);
}
return pNew;
} | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movl %edx, %esi
callq 0xef9b
movq %rax, %r15
testq %rax, %rax
je 0x115a9
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x10370
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /symisc[P]unqlite/unqlite.c |
MemHashInit | static int MemHashInit(unqlite_kv_engine *pKvEngine,int iPageSize)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKvEngine;
/* Note that this instance is already zeroed */
/* Memory backend */
SyMemBackendInitFromParent(&pEngine->sAlloc,unqliteExportMemBackend());
//#if defined(UNQLITE_ENABLE_THREADS... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x48c4c(%rip), %rsi # 0x5a210
movq %r14, %rdi
callq 0x11af0
leaq 0x57b(%rip), %rax # 0x11b4e
movq %rax, 0xc0(%rbx)
leaq -0x1371(%rip), %rax # 0x10270
movq %rax, 0xc8(%rbx)
movq %r14, %rdi
movl $0x200, %esi # imm = 0x200
... | /symisc[P]unqlite/unqlite.c |
MemHashReplace | static int MemHashReplace(
unqlite_kv_engine *pKv,
const void *pKey,int nKeyLen,
const void *pData,unqlite_int64 nDataLen
)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKv;
mem_hash_record *pRecord;
if( nDataLen > SXU32_HIGH ){
/* Database limit */
pEngine->pIo->xErr(pEngine->pIo-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x100000000, %rax # imm = 0x100000000
cmpq %rax, %r8
jl 0x11702
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x32df1(%rip), %rsi # 0x444e3
callq *0x80(%rax)
movl $0xfffffff9, %ebp # imm = 0xFFFFFFF9
jmp 0x11... | /symisc[P]unqlite/unqlite.c |
MemHashAppend | static int MemHashAppend(
unqlite_kv_engine *pKv,
const void *pKey,int nKeyLen,
const void *pData,unqlite_int64 nDataLen
)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKv;
mem_hash_record *pRecord;
if( nDataLen > SXU32_HIGH ){
/* Database limit */
pEngine->pIo->xErr(pEngine->pIo->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x100000000, %r15 # imm = 0x100000000
cmpq %r15, %r8
jl 0x11811
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x32ce2(%rip), %rsi # 0x444e3
callq *0x80(%rax)
movl $0xfffffff9, %eax # imm = 0xFFFFFFF9
jmp 0x11... | /symisc[P]unqlite/unqlite.c |
MemHashCursorData | static int MemHashCursorData(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData)
{
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
int rc;
if( pMem->pCur == 0){
return UNQLITE_EOF;
}
/* Invoke the callback */
rc = xConsumer(pMem->pCur->pData,pMem->pCur->nD... | movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x11adb
movq %rsi, %rax
movq 0x20(%rcx), %rdi
movl 0x28(%rcx), %esi
jmpq *%rax
movl $0xffffffee, %eax # imm = 0xFFFFFFEE
retq
| /symisc[P]unqlite/unqlite.c |
MemHashGrowTable | static int MemHashGrowTable(mem_hash_kv_engine *pEngine)
{
sxu32 nNewSize = pEngine->nBucket << 1;
mem_hash_record *pEntry;
mem_hash_record **apNew;
sxu32 n,iBucket;
/* Allocate a new larger table */
apNew = (mem_hash_record **)SyMemBackendAlloc(&pEngine->sAlloc, nNewSize * sizeof(mem_hash_record *));
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0xd4(%rdi), %r12d
leaq 0x8(%rdi), %r14
movl %r12d, %ebp
shll $0x4, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0xef9b
testq %rax, %rax
je 0x11ece
movq %rax, %r15
testl %ebp, %ebp
je 0x11dd0
movl %ebp, %ecx
movq %r15, %rax
addq %rcx, %rax
movq %r... | /symisc[P]unqlite/unqlite.c |
lhash_kv_init | static int lhash_kv_init(unqlite_kv_engine *pEngine,int iPageSize)
{
lhash_kv_engine *pHash = (lhash_kv_engine *)pEngine;
int rc;
/* This structure is always zeroed, go to the initialization directly */
SyMemBackendInitFromParent(&pHash->sAllocator,unqliteExportMemBackend());
pHash->iPageSize = iPageSize;
... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x48325(%rip), %rsi # 0x5a210
movq %r14, %rdi
callq 0x11af0
movl %ebp, 0x110(%rbx)
leaq 0x7de(%rip), %rax # 0x126de
movq %rax, 0xc0(%rbx)
leaq -0x1c9e(%rip), %rax # 0x10270
movq %rax, 0xc8(%rbx)
movl $0x20, 0xe4(%rb... | /symisc[P]unqlite/unqlite.c |
lhash_kv_config | static int lhash_kv_config(unqlite_kv_engine *pEngine,int op,va_list ap)
{
lhash_kv_engine *pHash = (lhash_kv_engine *)pEngine;
int rc = UNQLITE_OK;
switch(op){
case UNQLITE_KV_CONFIG_HASH_FUNC: {
/* Default hash function */
if( pHash->nBuckRec > 0 ){
/* Locked operation */
rc = UNQLITE_LOCKED;
... | cmpl $0x2, %esi
je 0x11fff
movl $0xfffffff3, %eax # imm = 0xFFFFFFF3
cmpl $0x1, %esi
jne 0x11ffe
movl $0xfffffffc, %eax # imm = 0xFFFFFFFC
cmpl $0x0, 0xe0(%rdi)
je 0x1202b
retq
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x12015
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x12021
m... | /symisc[P]unqlite/unqlite.c |
lhash_kv_open | static int lhash_kv_open(unqlite_kv_engine *pEngine,pgno dbSize)
{
lhash_kv_engine *pHash = (lhash_kv_engine *)pEngine;
unqlite_page *pHeader;
int rc;
if( dbSize < 1 ){
/* A new database, create the header */
rc = pEngine->pIo->xNew(pEngine->pIo->pHandle,&pHeader);
if( rc != UNQLITE_OK ){
return r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
testq %rsi, %rsi
je 0x121ec
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq *0x10(%rax)
testl %eax, %eax
jne 0x12207
movq 0x8(%rsp), %r13
movq (%r13), %r12
movq %r13, 0xd0(%rbx)
movl (%r12),... | /symisc[P]unqlite/unqlite.c |
lhInitCursor | static void lhInitCursor(unqlite_kv_cursor *pPtr)
{
lhash_kv_engine *pEngine = (lhash_kv_engine *)pPtr->pStore;
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pPtr;
/* Init */
pCur->iState = L_HASH_CURSOR_STATE_NEXT_PAGE;
pCur->pCell = 0;
pCur->pRec = pEngine->pFirst;
pCur->pRaw = 0;
pCur->is_first... | movq (%rdi), %rax
movl $0x1, %ecx
movl %ecx, 0x8(%rdi)
xorl %edx, %edx
movq %rdx, 0x10(%rdi)
movq 0xf0(%rax), %rax
movq %rax, 0x20(%rdi)
movq %rdx, 0x18(%rdi)
movl %ecx, 0xc(%rdi)
retq
| /symisc[P]unqlite/unqlite.c |
lhCursorSeek | static int lhCursorSeek(unqlite_kv_cursor *pCursor,const void *pKey,int nByte,int iPos)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
int rc;
/* Perform a lookup */
rc = lhRecordLookup((lhash_kv_engine *)pCur->pStore,pKey,nByte,&pCur->pCell);
if( rc != UNQLITE_OK ){
SXUNUSED(iPos);
pCur->pCell ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movq (%r15), %rax
movq (%rax), %rdi
leaq 0xd0(%r15), %rdx
movl $0x1, %esi
callq *0x10(%rax)
testl %eax, %eax
je 0x12351
movl %eax, %r13d
testl %r13d, %r13d
je 0x123bd
movq $0x0,... | /symisc[P]unqlite/unqlite.c |
lhCursorFirst | static int lhCursorFirst(unqlite_kv_cursor *pCursor)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhash_kv_engine *pEngine = (lhash_kv_engine *)pCursor->pStore;
int rc;
if( pCur->is_first ){
/* Read the database header first */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,1,&pEngine->pHeader);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpl $0x0, 0xc(%rdi)
je 0x12462
movq (%r14), %rax
movq (%rax), %rdi
leaq 0xd0(%r14), %rdx
movl $0x1, %esi
callq *0x10(%rax)
testl %eax, %eax
je 0x1245b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x0, 0xc(%rbx)
movq 0xf0(%r14), %rax
movq %rax, 0x20(%... | /symisc[P]unqlite/unqlite.c |
lhCursorLast | static int lhCursorLast(unqlite_kv_cursor *pCursor)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhash_kv_engine *pEngine = (lhash_kv_engine *)pCursor->pStore;
int rc;
if( pCur->is_first ){
/* Read the database header first */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,1,&pEngine->pHeader);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpl $0x0, 0xc(%rdi)
je 0x124b4
movq (%r14), %rax
movq (%rax), %rdi
leaq 0xd0(%r14), %rdx
movl $0x1, %esi
callq *0x10(%rax)
testl %eax, %eax
je 0x124ad
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x0, 0xc(%rbx)
movq 0xe8(%r14), %rax
movq %rax, 0x20(%... | /symisc[P]unqlite/unqlite.c |
lhCursorNext | static int lhCursorNext(unqlite_kv_cursor *pCursor)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
int rc;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Load the cells of the next page */
rc = lhCursorNextPage(pCur);
return rc;
}
pCell = pCur->pCell;... | cmpl $0x2, 0x8(%rdi)
jne 0x15236
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x15236
movq 0x60(%rax), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x15236
xorl %eax, %eax
retq
| /symisc[P]unqlite/unqlite.c |
lhCursorPrev | static int lhCursorPrev(unqlite_kv_cursor *pCursor)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
int rc;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Load the cells of the previous page */
rc = lhCursorPrevPage(pCur);
return rc;
}
pCell = pCur->pC... | cmpl $0x2, 0x8(%rdi)
jne 0x152de
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x152de
movq 0x68(%rax), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x152de
xorl %eax, %eax
retq
| /symisc[P]unqlite/unqlite.c |
lhCursorDelete | static int lhCursorDelete(unqlite_kv_cursor *pCursor)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
int rc;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Invalid state */
return UNQLITE_INVALID;
}
/* Point to the target cell */
pCell = pCur->pCell;
... | movl $0xfffffff7, %eax # imm = 0xFFFFFFF7
cmpl $0x2, 0x8(%rdi)
jne 0x12656
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x12656
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x60(%rcx), %rax
movq %rax, 0x10(%rdi)
movq 0x18(%rcx), %r12
testq %r12, %r12
je 0x12640
movq %rcx, 0... | /symisc[P]unqlite/unqlite.c |
lhCursorKeyLength | static int lhCursorKeyLength(unqlite_kv_cursor *pCursor,int *pLen)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Invalid state */
return UNQLITE_INVALID;
}
/* Point to the target cell */
pCell = pCur->pCe... | movl $0xfffffff7, %eax # imm = 0xFFFFFFF7
cmpl $0x2, 0x8(%rdi)
jne 0x12672
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x12672
movl 0x4(%rcx), %eax
movl %eax, (%rsi)
xorl %eax, %eax
retq
| /symisc[P]unqlite/unqlite.c |
lhCursorKey | static int lhCursorKey(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
int rc;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Invalid state */
return UNQLITE_INVALID... | cmpl $0x2, 0x8(%rdi)
jne 0x12692
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x12692
movq %rsi, %rax
movl 0x50(%rdi), %esi
testl %esi, %esi
je 0x12698
movq 0x48(%rdi), %rdi
jmpq *%rax
movl $0xfffffff7, %eax # imm = 0xFFFFFFF7
retq
movq %rax, %rsi
xorl %ecx, %ecx
jmp 0x14b45
| /symisc[P]unqlite/unqlite.c |
lhCursorDataLength | static int lhCursorDataLength(unqlite_kv_cursor *pCursor,unqlite_int64 *pLen)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Invalid state */
return UNQLITE_INVALID;
}
/* Point to the target cell */
pCell ... | movl $0xfffffff7, %eax # imm = 0xFFFFFFF7
cmpl $0x2, 0x8(%rdi)
jne 0x126bf
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x126bf
movq 0x8(%rcx), %rax
movq %rax, (%rsi)
xorl %eax, %eax
retq
| /symisc[P]unqlite/unqlite.c |
lhash_bin_hash | static sxu32 lhash_bin_hash(const void *pSrc,sxu32 nLen)
{
register unsigned char *zIn = (unsigned char *)pSrc;
unsigned char *zEnd;
sxu32 nH = 5381;
if( nLen > 2048 /* 2K */ ){
nLen = 2048;
}
zEnd = &zIn[nLen];
for(;;){
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ... | movl $0x800, %ecx # imm = 0x800
cmpl %ecx, %esi
cmovbl %esi, %ecx
testl %esi, %esi
je 0x12745
addq %rdi, %rcx
movl $0x1505, %eax # imm = 0x1505
movl %eax, %edx
shll $0x5, %edx
addl %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jae 0x12744
movl %eax, %esi
shll $0x5, %esi
m... | /symisc[P]unqlite/unqlite.c |
lhash_page_release | static void lhash_page_release(void *pUserData)
{
lhpage *pPage = (lhpage *)pUserData;
lhash_kv_engine *pEngine = pPage->pHash;
lhcell *pNext,*pCell = pPage->pList;
unqlite_page *pRaw = pPage->pRaw;
sxu32 n;
/* Drop in-memory cells */
for( n = 0 ; n < pPage->nCell ; ++n ){
pNext = pCell->pNext;
SyB... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x38(%rdi)
je 0x1279e
movq 0x28(%rbx), %r12
leaq 0x8(%r14), %r15
xorl %ebp, %ebp
movq 0x60(%r12), %r13
leaq 0x40(%r12), %rdi
callq 0xdbfd
movq %r15, %rdi
movq ... | /symisc[P]unqlite/unqlite.c |
lhMapLoadPage | static int lhMapLoadPage(lhash_kv_engine *pEngine,lhash_bmap_page *pMap,const unsigned char *zRaw)
{
const unsigned char *zEnd = &zRaw[pEngine->iPageSize];
const unsigned char *zPtr = zRaw;
pgno iLogic,iReal;
sxu32 n;
int rc;
if( pMap->iPtr == 0 ){
/* Read the map header */
SyBigEndianUnpack64(zRaw,&... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movslq 0x110(%rdi), %r12
movzwl 0x8(%rsi), %eax
testq %rax, %rax
jne 0x12822
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x127da
movl 0x8(%r14), %eax
bswapl %eax
movl %eax, 0xc(%rbx)
movl $0xc, %... | /symisc[P]unqlite/unqlite.c |
lhStoreCell | static int lhStoreCell(
lhpage *pPage, /* Target page */
const void *pKey,sxu32 nKeyLen, /* Payload: Key */
const void *pData,unqlite_int64 nDataLen, /* Payload: Data */
sxu32 nHash, /* Hash of the key */
int auto_append /* Auto append a slave page if full */
)
{
lhash_kv_engine *pEngine = pPage->pHash;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r14d
movq %r8, %rbx
movq %rcx, 0x18(%rsp)
movl %edx, %r15d
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movq (%rdi), %r12
movq (%r12), %rax
movq 0x8(%rdi), %rdi
callq *0x28(%rax)
movl %eax, %ebp
testl %eax, %eax
je 0x1389e
movl %ebp... | /symisc[P]unqlite/unqlite.c |
lhMapWriteRecord | static int lhMapWriteRecord(lhash_kv_engine *pEngine,pgno iLogic,pgno iReal)
{
lhash_bmap_page *pMap = &pEngine->sPageMap;
unqlite_page *pPage = 0;
int rc;
if( pMap->iPtr > (pEngine->iPageSize - 16) /* 8 byte logical bucket number + 8 byte real bucket number */ ){
unqlite_page *pOld;
/* Point to the old ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, (%rsp)
movzwl 0x100(%rdi), %eax
movl 0x110(%rdi), %ecx
addl $-0x10, %ecx
cmpl %eax, %ecx
jge 0x13b08
movq (%rbx), %rax
movq 0xf8(%rbx), %rsi
movq (%rax), %rdi
leaq 0x8(%rsp), %rdx
callq *0x10(%rax)
testl %eax, %... | /symisc[P]unqlite/unqlite.c |
lhLoadPage | static int lhLoadPage(lhash_kv_engine *pEngine,pgno pnum,lhpage *pMaster,lhpage **ppOut,int iNest)
{
unqlite_page *pRaw;
lhpage *pPage = 0; /* cc warning */
int rc;
/* Aquire the page from the pager first */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,pnum,&pRaw);
if( rc != UNQLITE_OK ){
return rc;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rdi
leaq 0x40(%rsp), %rdx
callq *0x10(%rax)
movl %eax, %r13d
testl %eax, %eax
jne 0x13eb1
movq 0x40(%rsp), %rsi
movq 0x8(%rsi), %r12
testq %r12, %r12
je 0x13... | /symisc[P]unqlite/unqlite.c |
lhFindCell | static lhcell * lhFindCell(
lhpage *pPage, /* Target page */
const void *pKey, /* Lookup key */
sxu32 nByte, /* Key length */
sxu32 nHash /* Hash of the key */
)
{
lhcell *pEntry;
if( pPage->nCell < 1 ){
/* Don't bother hashing */
return 0;
}
/* Point to the corresponding bucket *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x38(%rdi)
je 0x13fad
movl %ecx, %ebx
movq %rdi, %r15
movq 0x20(%rdi), %rax
movl 0x3c(%rdi), %ecx
decl %ecx
andl %ebx, %ecx
movq (%rax,%rcx,8), %r12
testq %r12, %r12
je 0x13fad
movl %edx, %ebp
movq %rsi, %r14
movl %edx, %eax
a... | /symisc[P]unqlite/unqlite.c |
lhAllocateSpace | static int lhAllocateSpace(lhpage *pPage,sxu64 nAmount,sxu16 *pOfft)
{
const unsigned char *zEnd,*zPtr;
sxu16 iNext,iBlksz,nByte;
unsigned char *zPrev;
int rc;
if( (sxu64)pPage->nFree < nAmount ){
/* Don't bother looking for a free chunk */
return UNQLITE_FULL;
}
if( pPage->nCell < 10 && ((int)nAmo... | movzwl 0x5c(%rdi), %ecx
movl $0xffffffb7, %eax # imm = 0xFFFFFFB7
cmpq %rsi, %rcx
jb 0x142bd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x9, 0x38(%rdi)
ja 0x14011
movq (%r15), %rcx
movl 0x110(%rcx), %edx
movl %edx, %ecx
... | /symisc[P]unqlite/unqlite.c |
lhNewCell | static lhcell * lhNewCell(lhash_kv_engine *pEngine,lhpage *pPage)
{
lhcell *pCell;
pCell = (lhcell *)SyMemBackendPoolAlloc(&pEngine->sAllocator,sizeof(lhcell));
if( pCell == 0 ){
return 0;
}
/* Zero the structure */
SyZero(pCell,sizeof(lhcell));
/* Fill in the structure */
SyBlobInit(&pCell->sKey,&p... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
movq %r14, %rdi
movl $0x80, %esi
callq 0xb3b2
testq %rax, %rax
je 0x1430f
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x7c, %rcx
jb 0x142e5
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rax)
movq %r14, 0x40(%rax)
movl $0x0, 0... | /symisc[P]unqlite/unqlite.c |
lhInstallCell | static int lhInstallCell(lhcell *pCell)
{
lhpage *pPage = pCell->pPage->pMaster;
sxu32 iBucket;
if( pPage->nCell < 1 ){
sxu32 nTableSize = 32; /* Must be a power of two */
lhcell **apTable;
/* Allocate a new cell table */
apTable = (lhcell **)SyMemBackendAlloc(&pPage->pHash->sAllocator, nTableSize * ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x40(%rax), %r15
cmpl $0x0, 0x38(%r15)
jne 0x14375
movq (%r15), %rdi
addq $0x8, %rdi
movl $0x100, %esi # imm = 0x100
callq 0xef9b
testq %rax, %rax
je 0x144a4
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4,... | /symisc[P]unqlite/unqlite.c |
lhCellDiscard | static void lhCellDiscard(lhcell *pCell)
{
lhpage *pPage = pCell->pPage->pMaster;
if( pCell->pPrevCol ){
pCell->pPrevCol->pNextCol = pCell->pNextCol;
}else{
pPage->apCell[pCell->nHash & (pPage->nCellSize - 1)] = pCell->pNextCol;
}
if( pCell->pNextCol ){
pCell->pNextCol->pPrevCol = pCell->pPrevCo... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
movq 0x70(%rdi), %rax
movq 0x40(%rcx), %r14
movq 0x78(%rdi), %rcx
testq %rcx, %rcx
je 0x14813
addq $0x70, %rcx
jmp 0x14823
movl 0x3c(%r14), %ecx
decl %ecx
andl (%rbx), %ecx
shlq $0x3, %rcx
addq 0x20(%r14), %rcx
movq %rax, (%rcx)
movq 0x70(%rbx), %ra... | /symisc[P]unqlite/unqlite.c |
lhConsumeCellkey | static int lhConsumeCellkey(
lhcell *pCell, /* Target cell */
int (*xConsumer)(const void *,unsigned int,void *), /* Consumer callback */
void *pUserData, /* Last argument to xConsumer() */
int offt_only
)
{
lhpage *pPage = pCell->pPage;
const unsigned char *zRaw = pPage->pRaw->zData;
const unsigned ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, 0x24(%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %rax
testq %rbx, %rbx
je 0x14c70
movl 0x4(%rdi), %r13d
xorl %ebp, %ebp
testl %r13d, %r13d
je 0x14ccb
movq (%rax), %r14
movl 0x110(%r14), %eax
ad... | /symisc[P]unqlite/unqlite.c |
lhPageSplit | static int lhPageSplit(
lhpage *pOld, /* Page to be split */
lhpage *pNew, /* New page */
pgno split_bucket, /* Current split bucket */
pgno high_mask /* High mask (Max split bucket - 1) */
)
{
lhcell *pCell,*pNext;
SyBlob sWorker;
pgno iBucket;
int rc;
SyBlobInit(&sWorker,&pOld->pHa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq (%rdi), %rax
addq $0x8, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movl $0x0, 0x38(%rsp)
movq 0x28(%rdi), %r12
testq %r12, %r12
je 0x14f03
movq %rcx, %rbp
movq %rdx, %r15
movl (%r12)... | /symisc[P]unqlite/unqlite.c |
lhUnlinkCell | static int lhUnlinkCell(lhcell *pCell)
{
lhash_kv_engine *pEngine = pCell->pPage->pHash;
lhpage *pPage = pCell->pPage;
sxu16 nByte = L_HASH_CELL_SZ;
lhcell *pPrev;
int rc;
rc = pEngine->pIo->xWrite(pPage->pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
/* Bring the link */
pPrev = lhFindSibeling(pCe... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq (%r14), %rax
movq 0x8(%r14), %rdi
movq (%rax), %rax
callq *0x28(%rax)
testl %eax, %eax
jne 0x15135
movq 0x20(%rbx), %rcx
movq 0x40(%rcx), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x150ce
cmpq %rcx, 0x20(%rax)
jne 0x150c8
movzwl 0x10(%rax)... | /symisc[P]unqlite/unqlite.c |
lhRestorePage | static int lhRestorePage(lhash_kv_engine *pEngine,unqlite_page *pPage)
{
int rc;
rc = pEngine->pIo->xWrite(pEngine->pHeader);
if( rc != UNQLITE_OK ){
return rc;
}
rc = pEngine->pIo->xWrite(pPage);
if( rc != UNQLITE_OK ){
return rc;
}
/* Link to the list of free page */
SyBigEndianPack64(pPage->... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0xd0(%rdi), %rdi
callq *0x28(%rax)
testl %eax, %eax
jne 0x1522e
movq (%rbx), %rax
movq %r14, %rdi
callq *0x28(%rax)
testl %eax, %eax
jne 0x1522e
movq (%r14), %rax
movq 0x118(%rbx), %rcx
bswapq %rcx
movq %rcx, (%rax)
movq 0x10(%r14),... | /symisc[P]unqlite/unqlite.c |
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.