LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/sds.c
// Function: sdsRemoveFreeSpace
sds sdsRemoveFreeSpace(sds s) {
    void *sh, *newsh;
    char type, oldtype = s[-1] & SDS_TYPE_MASK;
    int hdrlen;
    size_t len = sdslen(s);
    sh = (char*)s-sdsHdrSize(oldtype);

    type = sdsReqType(len);
    hdrlen = sdsHdrSize(type);
    if (oldtype==type) {
        newsh = s_realloc(sh, hdrlen+len+1);
        if (newsh == NULL) return NULL;
        s = (char*)newsh+hdrlen;
    } else {
        newsh = s_malloc(hdrlen+len+1);
        if (newsh == NULL) return NULL;
        memcpy((char*)newsh+hdrlen, s, len+1);
        s_free(sh);
        s = (char*)newsh+hdrlen;
        s[-1] = type;
        sdssetlen(s, len);
    }
    sdssetalloc(s, len);
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl -0x1(%rdi), %r12d
movl %r12d, %eax
andl $0x7, %eax
movl %r12d, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x18837
leaq 0x21fbe(%rip), %rdx     # 0x3a7cc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %r12d
jmp 0x1883a
movq -0x11(%rbx), %r12
jmp 0x1883a
movzwl -0x5(%rbx), %r12d
jmp 0x1883a
movl -0x9(%rbx), %r12d
jmp 0x1883a
movzbl -0x3(%rbx), %r12d
jmp 0x1883a
xorl %r12d, %r12d
cmpb $0x4, %al
ja 0x1884b
leaq 0x222bb(%rip), %rcx     # 0x3ab00
movq (%rcx,%rax,8), %r15
jmp 0x1884e
xorl %r15d, %r15d
cmpq $0x20, %r12
jae 0x18858
xorl %ecx, %ecx
jmp 0x1887b
movb $0x1, %cl
cmpq $0xff, %r12
jb 0x1887b
movb $0x2, %cl
cmpq $0xffff, %r12           # imm = 0xFFFF
jb 0x1887b
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %r12
movb $0x4, %cl
sbbb $0x0, %cl
addq %rbx, %r15
movzbl %cl, %ebp
leaq 0x22250(%rip), %rcx     # 0x3aad8
movq (%rcx,%rbp,8), %r13
leaq (%r12,%r13), %rsi
incq %rsi
cmpb %bpl, %al
jne 0x188d8
movq %r15, %rdi
callq 0xb3d0
testq %rax, %rax
je 0x1892e
movq %rax, %r14
addq %r13, %r14
movzbl -0x1(%r14), %eax
andl $0x7, %eax
decl %eax
cmpl $0x3, %eax
ja 0x18944
leaq 0x21f2b(%rip), %rcx     # 0x3a7f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb %r12b, -0x2(%r14)
jmp 0x18944
movq %rsi, %rdi
callq 0xb390
testq %rax, %rax
je 0x1892e
movq %rax, %r14
movq %rax, (%rsp)
addq %r13, %r14
leaq 0x1(%r12), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb340
movq %r15, %rdi
callq 0xb050
movq (%rsp), %rax
movb %bpl, -0x1(%rax,%r13)
leaq 0x21ec9(%rip), %rax     # 0x3a7e0
movslq (%rax,%rbp,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leal (,%r12,8), %eax
movb %al, -0x1(%r14)
jmp 0x188af
xorl %r14d, %r14d
jmp 0x18944
movl %r12d, -0x5(%r14)
jmp 0x18944
movq %r12, -0x9(%r14)
jmp 0x18944
movw %r12w, -0x3(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, -0x11(%r14)
jmp 0x188af
movw %r12w, -0x5(%r14)
jmp 0x188af
movl %r12d, -0x9(%r14)
jmp 0x188af
movb %r12b, -0x3(%r14)
jmp 0x188af
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/./sds.h
// Function: sdsAllocSize
static inline size_t sdsalloc(const sds s) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            return SDS_TYPE_5_LEN(flags);
        case SDS_TYPE_8:
            return SDS_HDR(8,s)->alloc;
        case SDS_TYPE_16:
            return SDS_HDR(16,s)->alloc;
        case SDS_TYPE_32:
            return SDS_HDR(32,s)->alloc;
        case SDS_TYPE_64:
            return SDS_HDR(64,s)->alloc;
    }
    return 0;
}

// Assembly:
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x189b7
leaq 0x21e74(%rip), %rdx     # 0x3a804
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %eax, %ecx
shrl $0x3, %ecx
jmp 0x189b9
movq -0x9(%rdi), %rcx
jmp 0x189b9
movzwl -0x3(%rdi), %ecx
jmp 0x189b9
movl -0x5(%rdi), %ecx
jmp 0x189b9
movzbl -0x2(%rdi), %ecx
jmp 0x189b9
xorl %ecx, %ecx
andb $0x7, %al
cmpb $0x4, %al
ja 0x189cf
movzbl %al, %eax
leaq 0x2210f(%rip), %rdx     # 0x3aad8
movq (%rdx,%rax,8), %rax
jmp 0x189d1
xorl %eax, %eax
addq %rcx, %rax
incq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/sds.c
// Function: sdsgrowzero
sds sdsgrowzero(sds s, size_t len) {
    size_t curlen = sdslen(s);

    if (len <= curlen) return s;
    s = sdsMakeRoomFor(s,len-curlen);
    if (s == NULL) return NULL;

    /* Make sure added region doesn't contain garbage */
    memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
    sdssetlen(s, len);
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl -0x1(%rdi), %r15d
movl %r15d, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x18c1c
leaq 0x21c39(%rip), %rcx     # 0x3a82c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %r15d
jmp 0x18c1f
movq -0x11(%rbx), %r15
jmp 0x18c1f
movzwl -0x5(%rbx), %r15d
jmp 0x18c1f
movl -0x9(%rbx), %r15d
jmp 0x18c1f
movzbl -0x3(%rbx), %r15d
jmp 0x18c1f
xorl %r15d, %r15d
movq %r14, %r12
subq %r15, %r12
jbe 0x18c8e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x185b5
testq %rax, %rax
je 0x18c73
movq %rax, %rbx
addq %rax, %r15
incq %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xb230
movzbl -0x1(%rbx), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x18c8e
leaq 0x21be0(%rip), %rcx     # 0x3a840
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlb $0x3, %r14b
movb %r14b, -0x1(%rbx)
jmp 0x18c8e
xorl %ebx, %ebx
jmp 0x18c8e
movq %r14, -0x11(%rbx)
jmp 0x18c8e
movw %r14w, -0x5(%rbx)
jmp 0x18c8e
movl %r14d, -0x9(%rbx)
jmp 0x18c8e
movb %r14b, -0x3(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/sds.c
// Function: sdscatlen
sds sdscatlen(sds s, const void *t, size_t len) {
    size_t curlen = sdslen(s);

    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    memcpy(s+curlen, t, len);
    sdssetlen(s, curlen+len);
    s[curlen+len] = '\0';
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movzbl -0x1(%rdi), %r12d
movl %r12d, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x18ceb
leaq 0x21b92(%rip), %rcx     # 0x3a854
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %r12d
jmp 0x18cee
movq -0x11(%rdi), %r12
jmp 0x18cee
movzwl -0x5(%rdi), %r12d
jmp 0x18cee
movl -0x9(%rdi), %r12d
jmp 0x18cee
movzbl -0x3(%rdi), %r12d
jmp 0x18cee
xorl %r12d, %r12d
movq %rbx, %rsi
callq 0x185b5
testq %rax, %rax
je 0x18d3d
movq %rax, %r15
movq %rax, %rdi
addq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xb340
addq %rbx, %r12
movzbl -0x1(%r15), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x18d59
leaq 0x21b42(%rip), %rcx     # 0x3a868
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leal (,%r12,8), %eax
movb %al, -0x1(%r15)
jmp 0x18d59
xorl %r15d, %r15d
jmp 0x18d5e
movq %r12, -0x11(%r15)
jmp 0x18d59
movw %r12w, -0x5(%r15)
jmp 0x18d59
movl %r12d, -0x9(%r15)
jmp 0x18d59
movb %r12b, -0x3(%r15)
movb $0x0, (%r15,%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/sds.c
// Function: sdscpylen
sds sdscpylen(sds s, const char *t, size_t len) {
    if (sdsalloc(s) < len) {
        s = sdsMakeRoomFor(s,len-sdslen(s));
        if (s == NULL) return NULL;
    }
    memcpy(s, t, len);
    s[len] = '\0';
    sdssetlen(s, len);
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x18e2e
leaq 0x21a89(%rip), %rdx     # 0x3a890
movslq (%rdx,%rcx,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movl %eax, %edx
shrl $0x3, %edx
jmp 0x18e30
movq -0x9(%rbx), %rdx
jmp 0x18e30
movzwl -0x3(%rbx), %edx
jmp 0x18e30
movl -0x5(%rbx), %edx
jmp 0x18e30
movzbl -0x2(%rbx), %edx
jmp 0x18e30
xorl %edx, %edx
cmpq %r14, %rdx
jae 0x18e80
cmpl $0x4, %ecx
ja 0x18e68
movl %ecx, %ecx
leaq 0x21a61(%rip), %rdx     # 0x3a8a4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x18e6a
movq -0x11(%rbx), %rax
jmp 0x18e6a
movzwl -0x5(%rbx), %eax
jmp 0x18e6a
movl -0x9(%rbx), %eax
jmp 0x18e6a
movzbl -0x3(%rbx), %eax
jmp 0x18e6a
xorl %eax, %eax
movq %r14, %rsi
subq %rax, %rsi
movq %rbx, %rdi
callq 0x185b5
movq %rax, %rbx
testq %rax, %rax
je 0x18eb9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb340
movb $0x0, (%rbx,%r14)
movzbl -0x1(%rbx), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x18ed4
leaq 0x21a12(%rip), %rcx     # 0x3a8b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlb $0x3, %r14b
movb %r14b, -0x1(%rbx)
jmp 0x18ed4
xorl %ebx, %ebx
jmp 0x18ed4
movq %r14, -0x11(%rbx)
jmp 0x18ed4
movw %r14w, -0x5(%rbx)
jmp 0x18ed4
movl %r14d, -0x9(%rbx)
jmp 0x18ed4
movb %r14b, -0x3(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/sds.c
// Function: sdscatvprintf
sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
    va_list cpy;
    char staticbuf[1024], *buf = staticbuf, *t;
    size_t buflen = strlen(fmt)*2;

    /* We try to start using a static buffer for speed.
     * If not possible we revert to heap allocation. */
    if (buflen > sizeof(staticbuf)) {
        buf = s_malloc(buflen);
        if (buf == NULL) return NULL;
    } else {
        buflen = sizeof(staticbuf);
    }

    /* Try with buffers two times bigger every time we fail to
     * fit the string in the current buffer size. */
    while(1) {
        buf[buflen-2] = '\0';
        va_copy(cpy,ap);
        vsnprintf(buf, buflen, fmt, cpy);
        va_end(cpy);
        if (buf[buflen-2] != '\0') {
            if (buf != staticbuf) s_free(buf);
            buflen *= 2;
            buf = s_malloc(buflen);
            if (buf == NULL) return NULL;
            continue;
        }
        break;
    }

    /* Finally concat the obtained string to the SDS string and return it. */
    t = sdscat(s, buf);
    if (buf != staticbuf) s_free(buf);
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
callq 0xb190
movq %rax, %rbx
addq %rax, %rbx
movl $0x400, %ebp            # imm = 0x400
leaq 0x30(%rsp), %r13
movq %r13, %r12
cmpq $0x401, %rbx            # imm = 0x401
jb 0x19062
movq %rbx, %rdi
callq 0xb390
movq %rax, %r12
movq %rbx, %rbp
testq %rax, %rax
je 0x190b8
leaq 0x10(%rsp), %rbx
movb $0x0, -0x2(%rbp,%r12)
movq 0x10(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xb0f0
cmpb $0x0, -0x2(%rbp,%r12)
je 0x190bc
cmpq %r13, %r12
je 0x190a5
movq %r12, %rdi
callq 0xb050
addq %rbp, %rbp
movq %rbp, %rdi
callq 0xb390
movq %rax, %r12
testq %rax, %rax
jne 0x19067
xorl %ebx, %ebx
jmp 0x190e9
movq %r12, %rdi
callq 0xb190
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x18c9d
movq %rax, %rbx
leaq 0x30(%rsp), %rax
cmpq %rax, %r12
je 0x190e9
movq %r12, %rdi
callq 0xb050
movq %rbx, %rax
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/sds.c
// Function: sdstrim
sds sdstrim(sds s, const char *cset) {
    char *start, *end, *sp, *ep;
    size_t len;

    sp = start = s;
    ep = end = s+sdslen(s)-1;
    while(sp <= end && strchr(cset, *sp)) sp++;
    while(ep > sp && strchr(cset, *ep)) ep--;
    len = (sp > ep) ? 0 : ((ep-sp)+1);
    if (s != sp) memmove(s, sp, len);
    s[len] = '\0';
    sdssetlen(s,len);
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x198c0
leaq 0x210fd(%rip), %rdx     # 0x3a998
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x198c2
movq -0x11(%rbx), %rax
jmp 0x198c2
movzwl -0x5(%rbx), %eax
jmp 0x198c2
movl -0x9(%rbx), %eax
jmp 0x198c2
movzbl -0x3(%rbx), %eax
jmp 0x198c2
xorl %eax, %eax
leaq (%rbx,%rax), %r12
decq %r12
movq %rbx, %r15
cmpq %rbx, %r12
jb 0x198ed
movq %rbx, %r15
movsbl (%r15), %esi
movq %r14, %rdi
callq 0xb1b0
testq %rax, %rax
je 0x198ed
incq %r15
cmpq %r12, %r15
jbe 0x198d4
cmpq %r15, %r12
jbe 0x1990f
movsbl (%r12), %esi
movq %r14, %rdi
callq 0xb1b0
testq %rax, %rax
je 0x1990f
decq %r12
cmpq %r15, %r12
ja 0x198f2
movq %r15, %r12
xorl %r14d, %r14d
subq %r15, %r12
leaq 0x1(%r12), %rax
cmovaeq %rax, %r14
cmpq %rbx, %r15
je 0x19931
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb450
movb $0x0, (%rbx,%r14)
movzbl -0x1(%rbx), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x19973
leaq 0x21063(%rip), %rcx     # 0x3a9ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlb $0x3, %r14b
movb %r14b, -0x1(%rbx)
jmp 0x19973
movq %r14, -0x11(%rbx)
jmp 0x19973
movw %r14w, -0x5(%rbx)
jmp 0x19973
movl %r14d, -0x9(%rbx)
jmp 0x19973
movb %r14b, -0x3(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/sds.c
// Function: sdsrange
void sdsrange(sds s, int start, int end) {
    size_t newlen, len = sdslen(s);

    if (len == 0) return;
    if (start < 0) {
        start = len+start;
        if (start < 0) start = 0;
    }
    if (end < 0) {
        end = len+end;
        if (end < 0) end = 0;
    }
    newlen = (start > end) ? 0 : (end-start)+1;
    if (newlen != 0) {
        if (start >= (signed)len) {
            newlen = 0;
        } else if (end >= (signed)len) {
            end = len-1;
            newlen = (start > end) ? 0 : (end-start)+1;
        }
    } else {
        start = 0;
    }
    if (start && newlen) memmove(s, s+start, newlen);
    s[newlen] = 0;
    sdssetlen(s,newlen);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl -0x1(%rdi), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
ja 0x199c3
leaq 0x21022(%rip), %rdi     # 0x3a9c0
movslq (%rdi,%rcx,4), %rcx
addq %rdi, %rcx
jmpq *%rcx
shrl $0x3, %eax
jmp 0x199c5
movq -0x11(%rbx), %rax
jmp 0x199c5
movzwl -0x5(%rbx), %eax
jmp 0x199c5
movl -0x9(%rbx), %eax
jmp 0x199c5
movzbl -0x3(%rbx), %eax
jmp 0x199c5
xorl %eax, %eax
testq %rax, %rax
je 0x19a7b
leal (%rax,%rsi), %ecx
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
testl %esi, %esi
cmovnsl %esi, %ecx
leal (%rax,%rdx), %esi
testl %esi, %esi
cmovlel %edi, %esi
testl %edx, %edx
cmovnsl %edx, %esi
movl %esi, %edx
subl %ecx, %edx
leal 0x1(%rdx), %edx
cmovbl %edi, %edx
testl %edx, %edx
je 0x19a07
movl %eax, %edi
subl %ecx, %edi
jle 0x19a0c
cmpl %eax, %esi
jge 0x19a11
movslq %edx, %r14
jmp 0x19a1d
xorl %r14d, %r14d
jmp 0x19a1f
xorl %r14d, %r14d
jmp 0x19a1d
decl %eax
xorl %edx, %edx
cmpl %eax, %ecx
cmovgl %edx, %edi
movslq %edi, %r14
movl %ecx, %edi
testl %edi, %edi
je 0x19a39
testq %r14, %r14
je 0x19a39
movslq %edi, %rsi
addq %rbx, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb450
movb $0x0, (%rbx,%r14)
movzbl -0x1(%rbx), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x19a7b
leaq 0x20f83(%rip), %rcx     # 0x3a9d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlb $0x3, %r14b
movb %r14b, -0x1(%rbx)
jmp 0x19a7b
movq %r14, -0x11(%rbx)
jmp 0x19a7b
movw %r14w, -0x5(%rbx)
jmp 0x19a7b
movl %r14d, -0x9(%rbx)
jmp 0x19a7b
movb %r14b, -0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/sds.c
// Function: sdsfreesplitres
void sdsfreesplitres(sds *tokens, int count) {
    if (!tokens) return;
    while(count--)
        sdsfree(tokens[count]);
    s_free(tokens);
}

// Assembly:
testq %rdi, %rdi
je 0x19df7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x19de8
movslq %esi, %r14
movq -0x8(%rbx,%r14,8), %rdi
callq 0x18503
decq %r14
jne 0x19dd9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb050
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/sds.c
// Function: sdsjoin
sds sdsjoin(char **argv, int argc, char *sep) {
    sds join = sdsempty();
    int j;

    for (j = 0; j < argc; j++) {
        join = sdscat(join, argv[j]);
        if (j != argc-1) join = sdscat(join,sep);
    }
    return join;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movl %esi, %r12d
movq %rdi, %r14
movl $0x4, %edi
callq 0xb390
testq %rax, %rax
je 0x1a3e6
movq %rax, %r15
addq $0x3, %r15
movl $0x10000, (%rax)        # imm = 0x10000
jmp 0x1a3e9
xorl %r15d, %r15d
testl %r12d, %r12d
jle 0x1a43f
leal -0x1(%r12), %r13d
movl %r12d, %ebp
xorl %ebx, %ebx
movq (%r14,%rbx,8), %r12
movq %r12, %rdi
callq 0xb190
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x18c9d
movq %rax, %r15
cmpq %rbx, %r13
je 0x1a437
movq (%rsp), %r12
movq %r12, %rdi
callq 0xb190
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x18c9d
movq %rax, %r15
incq %rbx
cmpq %rbx, %rbp
jne 0x1a3f8
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/net.c
// Function: redisKeepAlive
int redisKeepAlive(redisContext *c, int interval) {
    int val = 1;
    int fd = c->fd;

    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val)) == -1){
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }

    val = interval;

#ifdef _OSX
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }
#else
#ifndef __sun
    val = interval;
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }

    val = interval/3;
    if (val == 0) val = 1;
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }

    val = 3;
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }
#endif
#endif

    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movl 0x84(%rdi), %ebp
movl %ebp, %edi
movl $0x1, %esi
movl $0x9, %edx
movl $0x4, %r8d
callq 0xb100
cmpl $-0x1, %eax
je 0x1a5b1
leaq 0xc(%rsp), %rcx
movl %r14d, (%rcx)
movl %ebp, %edi
movl $0x6, %esi
movl $0x4, %edx
movl $0x4, %r8d
callq 0xb100
testl %eax, %eax
js 0x1a5b1
movslq %r14d, %rax
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
addl $0x2, %r14d
cmpl $0x5, %r14d
movl $0x1, %edx
cmovael %eax, %edx
leaq 0xc(%rsp), %rcx
movl %edx, (%rcx)
movl %ebp, %edi
movl $0x6, %esi
movl $0x5, %edx
movl $0x4, %r8d
callq 0xb100
testl %eax, %eax
js 0x1a5b1
leaq 0xc(%rsp), %rcx
movl $0x3, (%rcx)
movl %ebp, %edi
movl $0x6, %esi
movl $0x6, %edx
movl $0x4, %r8d
callq 0xb100
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jns 0x1a5d2
callq 0xb080
movl (%rax), %edi
callq 0xb560
movq %rbx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x17424
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/net.c
// Function: _redisSetErrorFromErrno
static void __redisSetErrorFromErrno(redisContext *c, int type, const char *prefix) {
    char buf[128] = { 0 };
    size_t len = 0;

    if (prefix != NULL)
        len = snprintf(buf,sizeof(buf),"%s: ",prefix);
    strerror_r(errno,buf+len,sizeof(buf)-len);
    __redisSetError(c,type,buf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %rsi, %rsi
je 0x1a69e
movq %rsi, %rcx
leaq 0x206bb(%rip), %rdx     # 0x3ad45
movq %rsp, %rdi
movl $0x80, %esi
xorl %eax, %eax
callq 0xb1d0
movslq %eax, %r14
jmp 0x1a6a1
xorl %r14d, %r14d
callq 0xb080
movl (%rax), %edi
leaq (%rsp,%r14), %rsi
movl $0x80, %edx
subq %r14, %rdx
callq 0xb110
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x17424
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/hiredis/net.c
// Function: redisContextConnectUnix
int redisContextConnectUnix(redisContext *c, const char *path, const struct timeval *timeout) {
    int blocking = (c->flags & REDIS_BLOCK);
    struct sockaddr_un sa;

    if (redisCreateSocket(c,AF_LOCAL) < 0)
        return REDIS_ERR;
    if (redisSetBlocking(c,0) != REDIS_OK)
        return REDIS_ERR;

    sa.sun_family = AF_LOCAL;
    strncpy(sa.sun_path,path,sizeof(sa.sun_path)-1);
    if (connect(c->fd, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
        if (errno == EINPROGRESS && !blocking) {
            /* This is ok. */
        } else {
            if (redisContextWaitReady(c,timeout) != REDIS_OK)
                return REDIS_ERR;
        }
    }

    /* Reset socket to be blocking after connect(2). */
    if (blocking && redisSetBlocking(c,1) != REDIS_OK)
        return REDIS_ERR;

    c->flags |= REDIS_CONNECTED;
    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x88(%rdi), %r13d
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0xb600
movl %eax, %r12d
cmpl $-0x1, %eax
je 0x1ab02
movl %r12d, 0x84(%rbx)
jmp 0x1ab0c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1a644
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $-0x1, %r12d
je 0x1ab9e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1abaf
testl %eax, %eax
jne 0x1ab9e
leaq 0xc(%rsp), %rdi
movw $0x1, -0x2(%rdi)
movl $0x6b, %edx
movq %r15, %rsi
callq 0xb0a0
movl 0x84(%rbx), %edi
leaq 0xa(%rsp), %rsi
movl $0x6e, %edx
callq 0xb510
cmpl $-0x1, %eax
jne 0x1ab7e
callq 0xb080
movl (%rax), %eax
xorl $0x73, %eax
movl %r13d, %ecx
andl $0x1, %ecx
orl %eax, %ecx
je 0x1ab7e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ac42
testl %eax, %eax
jne 0x1ab9e
testb $0x1, %r13b
je 0x1ab95
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1abaf
testl %eax, %eax
jne 0x1ab9e
orb $0x2, 0x88(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_arena_init
arena_t *
arena_init(tsdn_t *tsdn, unsigned ind)
{
	arena_t *arena;

	malloc_mutex_lock(tsdn, &arenas_lock);
	arena = arena_init_locked(tsdn, ind);
	malloc_mutex_unlock(tsdn, &arenas_lock);
	return (arena);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x316b3(%rip), %r15     # 0x4c548
movq %r15, %rdi
callq 0xb5a0
movq %r14, %rdi
movl %ebx, %esi
callq 0x1aebb
movq %rax, %rbx
movq %r15, %rdi
callq 0xb380
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: arena_init_locked
static arena_t *
arena_init_locked(tsdn_t *tsdn, unsigned ind)
{
	arena_t *arena;

	assert(ind <= narenas_total_get());
	if (ind > MALLOCX_ARENA_MAX)
		return (NULL);
	if (ind == narenas_total_get())
		narenas_total_inc();

	/*
	 * Another thread may have already initialized arenas[ind] if it's an
	 * auto arena.
	 */
	arena = arena_get(tsdn, ind, false);
	if (arena != NULL) {
		assert(ind < narenas_auto);
		return (arena);
	}

	/* Actually initialize the arena. */
	arena = arena_new(tsdn, ind);
	arena_set(ind, arena);
	return (arena);
}

// Assembly:
cmpl $0xffe, %esi            # imm = 0xFFE
jbe 0x1aec6
xorl %eax, %eax
retq
pushq %rbx
xorl %eax, %eax
lock
xaddl %eax, 0x3166f(%rip)     # 0x4c540
cmpl %esi, %eax
jne 0x1aee2
movl $0x1, %eax
lock
xaddl %eax, 0x3165e(%rip)     # 0x4c540
movq 0x316c7(%rip), %rcx     # 0x4c5b0
movl %esi, %ebx
movq (%rcx,%rbx,8), %rax
testq %rax, %rax
je 0x1af0e
testq %rax, %rax
jne 0x1af0c
callq 0x23e98
movq 0x316ab(%rip), %rcx     # 0x4c5b0
movq %rax, %rdx
xchgq %rdx, (%rcx,%rbx,8)
popq %rbx
retq
xorl %eax, %eax
lock
xaddq %rax, (%rcx,%rbx,8)
jmp 0x1aef4
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_arena_migrate
void
arena_migrate(tsd_t *tsd, unsigned oldind, unsigned newind)
{
	arena_t *oldarena, *newarena;

	oldarena = arena_get(tsd_tsdn(tsd), oldind, false);
	newarena = arena_get(tsd_tsdn(tsd), newind, false);
	arena_nthreads_dec(oldarena, false);
	arena_nthreads_inc(newarena, false);
	tsd_arena_set(tsd, newarena);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3168a(%rip), %rax     # 0x4c5b0
movl %esi, %ecx
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x1af60
movq 0x31678(%rip), %rax     # 0x4c5b0
movl %edx, %ecx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x1af6a
xorl %esi, %esi
callq 0x23e7b
movq %r14, %rdi
xorl %esi, %esi
callq 0x23e6d
movq %r14, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
lock
xaddq %rdi, (%rax,%rcx,8)
jmp 0x1af31
xorl %r14d, %r14d
lock
xaddq %r14, (%rax,%rcx,8)
jmp 0x1af43
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_arena_get
JEMALLOC_INLINE arena_t *
arena_get(tsdn_t *tsdn, unsigned ind, bool init_if_missing)
{
	arena_t *ret;

	assert(ind <= MALLOCX_ARENA_MAX);

	ret = arenas[ind];
	if (unlikely(ret == NULL)) {
		ret = atomic_read_p((void *)&arenas[ind]);
		if (init_if_missing && unlikely(ret == NULL))
			ret = arena_init(tsdn, ind);
	}
	return (ret);
}

// Assembly:
movq 0x31634(%rip), %rcx     # 0x4c5b0
movl %esi, %r8d
movq (%rcx,%r8,8), %rax
testq %rax, %rax
jne 0x1afa1
xorl %eax, %eax
lock
xaddq %rax, (%rcx,%r8,8)
testq %rax, %rax
sete %cl
andb %dl, %cl
cmpb $0x1, %cl
je 0x1ae84
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_u2rz
JEMALLOC_INLINE size_t
u2rz(size_t usize)
{
	size_t ret;

	if (usize <= SMALL_MAXCLASS) {
		szind_t binind = size2index(usize);
		ret = arena_bin_info[binind].redzone_size;
	} else
		ret = 0;

	return (ret);
}

// Assembly:
cmpq $0x3800, %rdi           # imm = 0x3800
ja 0x1d555
pushq %rax
cmpq $0x1000, %rdi           # imm = 0x1000
ja 0x1d558
decq %rdi
shrq $0x3, %rdi
leaq 0x1e886(%rip), %rax     # 0x3bdc0
movzbl (%rdi,%rax), %eax
movl %eax, %eax
shlq $0x6, %rax
leaq 0x2f095(%rip), %rcx     # 0x4c5e0
movq 0x8(%rcx,%rax), %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
callq 0xb8ec
jmp 0x1d53e
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_free
JEMALLOC_NOTHROW
je_free(void *ptr)
{

	UTRACE(ptr, 0, 0);
	if (likely(ptr != NULL)) {
		tsd_t *tsd = tsd_fetch();
		witness_assert_lockless(tsd_tsdn(tsd));
		if (likely(!malloc_slow))
			ifree(tsd, ptr, tcache_get(tsd, false), false);
		else
			ifree(tsd, ptr, tcache_get(tsd, false), true);
		witness_assert_lockless(tsd_tsdn(tsd));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1d595
movq %rdi, %rbx
movq 0x2ea76(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %r14
addq %rax, %r14
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x1d59d
cmpl $0x2, %ecx
je 0x1d5a6
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbfb8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %fs:(%rax)
jmp 0x1d5ad
movl $0x3, %fs:(%rax)
leaq 0x2ff20(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %r14, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x1d58a
leaq 0x1ebb8(%rip), %rdi     # 0x3c181
callq 0x35efc
cmpb $0x1, 0x2ef4b(%rip)     # 0x4c520
jne 0x1d58a
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_dallocx
JEMALLOC_NOTHROW
je_dallocx(void *ptr, int flags)
{
	tsd_t *tsd;
	tcache_t *tcache;

	assert(ptr != NULL);
	assert(malloc_initialized() || IS_INITIALIZER);

	tsd = tsd_fetch();
	witness_assert_lockless(tsd_tsdn(tsd));
	if (unlikely((flags & MALLOCX_TCACHE_MASK) != 0)) {
		if ((flags & MALLOCX_TCACHE_MASK) == MALLOCX_TCACHE_NONE)
			tcache = NULL;
		else
			tcache = tcaches_get(tsd, MALLOCX_TCACHE_GET(flags));
	} else
		tcache = tcache_get(tsd, false);

	UTRACE(ptr, 0, 0);
	if (likely(!malloc_slow))
		ifree(tsd, ptr, tcache, false);
	else
		ifree(tsd, ptr, tcache, true);
	witness_assert_lockless(tsd_tsdn(tsd));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
movq 0x2c86c(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %r14
addq %rax, %r14
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x1f7c8
cmpl $0x2, %ecx
je 0x1f7fa
andl $0xfff00, %r15d         # imm = 0xFFF00
jne 0x1f7bb
leaq 0x8(%r14), %r15
movq (%r15), %rdx
movzbl 0x2cbad(%rip), %ecx     # 0x4c358
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1d2d1
cmpl $0x100, %r15d           # imm = 0x100
jne 0x1f7d1
xorl %edx, %edx
jmp 0x1f7a4
movl $0x1, %fs:(%rax)
jmp 0x1f801
shrl $0x8, %r15d
addl $-0x2, %r15d
leaq 0x2dca8(%rip), %rax     # 0x4d488
movq (%rax), %rax
leaq (%rax,%r15,8), %r15
cmpq $0x0, (%r15)
jne 0x1f7a1
movq %r14, %rdi
movq %r15, %rsi
callq 0xc6e2
jmp 0x1f7a1
movl $0x3, %fs:(%rax)
leaq 0x2dccc(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %r14, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x1f794
leaq 0x1c960(%rip), %rdi     # 0x3c181
callq 0x35efc
cmpb $0x1, 0x2ccf3(%rip)     # 0x4c520
jne 0x1f794
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_mallctl
JEMALLOC_NOTHROW
je_mallctl(const char *name, void *oldp, size_t *oldlenp, void *newp,
    size_t newlen)
{
	int ret;
	tsd_t *tsd;

	if (unlikely(malloc_init()))
		return (EAGAIN);

	tsd = tsd_fetch();
	witness_assert_lockless(tsd_tsdn(tsd));
	ret = ctl_byname(tsd, name, oldp, oldlenp, newp, newlen);
	witness_assert_lockless(tsd_tsdn(tsd));
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
cmpl $0x0, 0x2c383(%rip)     # 0x4c35c
jne 0x20029
cmpq $0x0, 0x2c545(%rip)     # 0x4c528
jne 0x20046
movq 0x2bffc(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbp
addq %rax, %rbp
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x2004d
cmpl $0x2, %ecx
je 0x20056
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2797c
callq 0x216e9
testb %al, %al
je 0x1ffdb
movl $0xb, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xcac2
jmp 0x1ffe5
movl $0x1, %fs:(%rax)
jmp 0x2005d
movl $0x3, %fs:(%rax)
leaq 0x2d470(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbp, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x20004
leaq 0x1c108(%rip), %rdi     # 0x3c181
callq 0x35efc
cmpb $0x1, 0x2c49b(%rip)     # 0x4c520
jne 0x20004
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_mallctlnametomib
JEMALLOC_NOTHROW
je_mallctlnametomib(const char *name, size_t *mibp, size_t *miblenp)
{
	int ret;
	tsdn_t *tsdn;

	if (unlikely(malloc_init()))
		return (EAGAIN);

	tsdn = tsdn_fetch();
	witness_assert_lockless(tsdn);
	ret = ctl_nametomib(tsdn, name, mibp, miblenp);
	witness_assert_lockless(tsdn);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x2c2b4(%rip)     # 0x4c35c
jne 0x20107
cmpq $0x0, 0x2c476(%rip)     # 0x4c528
jne 0x20121
leaq 0x2d3f5(%rip), %rax     # 0x4d4b0
cmpb $0x1, (%rax)
jne 0x200e8
movq 0x2bf21(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %r12
addq %rax, %r12
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x20128
cmpl $0x2, %ecx
jne 0x200eb
movl $0x3, %fs:(%rax)
jmp 0x2012f
xorl %r12d, %r12d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x27d9c
callq 0x216e9
testb %al, %al
je 0x200aa
movl $0xb, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xcb46
jmp 0x200b4
movl $0x1, %fs:(%rax)
leaq 0x2d39e(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %r12, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x200eb
leaq 0x1c036(%rip), %rdi     # 0x3c181
callq 0x35efc
cmpb $0x1, 0x2c3c9(%rip)     # 0x4c520
jne 0x200eb
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_mallctlbymib
JEMALLOC_NOTHROW
je_mallctlbymib(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
  void *newp, size_t newlen)
{
	int ret;
	tsd_t *tsd;

	if (unlikely(malloc_init()))
		return (EAGAIN);

	tsd = tsd_fetch();
	witness_assert_lockless(tsd_tsdn(tsd));
	ret = ctl_bymib(tsd, mib, miblen, oldp, oldlenp, newp, newlen);
	witness_assert_lockless(tsd_tsdn(tsd));
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %r9
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbp
cmpl $0x0, 0x2c1d7(%rip)     # 0x4c35c
jne 0x201d7
cmpq $0x0, 0x2c399(%rip)     # 0x4c528
jne 0x201ed
movq 0x2be50(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x201fa
cmpl $0x2, %ecx
je 0x20203
movq %r12, (%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x27df4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r9, %rbx
callq 0x216e9
movq %rbx, %r9
testb %al, %al
je 0x20187
movl $0xb, %eax
jmp 0x201c8
movq %r9, %rbx
callq 0xcbca
movq %rbx, %r9
jmp 0x20191
movl $0x1, %fs:(%rax)
jmp 0x2020a
movl $0x3, %fs:(%rax)
leaq 0x2d2c3(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
movq %r9, 0x10(%rsp)
callq 0xb5b0
movq 0x10(%rsp), %r9
testl %eax, %eax
je 0x201b0
leaq 0x1bf51(%rip), %rdi     # 0x3c181
callq 0x35efc
movq 0x10(%rsp), %r9
cmpb $0x1, 0x2c2df(%rip)     # 0x4c520
jne 0x201b0
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_malloc_stats_print
JEMALLOC_NOTHROW
je_malloc_stats_print(void (*write_cb)(void *, const char *), void *cbopaque,
    const char *opts)
{
	tsdn_t *tsdn;

	tsdn = tsdn_fetch();
	witness_assert_lockless(tsdn);
	stats_print(write_cb, cbopaque, opts);
	witness_assert_lockless(tsdn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2d24f(%rip), %rax     # 0x4d4b0
cmpb $0x1, (%rax)
jne 0x20285
movq 0x2bd7b(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rsi
addq %rax, %rsi
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x20298
cmpl $0x2, %ecx
je 0x202a1
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x307a0
movl $0x1, %fs:(%rax)
jmp 0x202a8
movl $0x3, %fs:(%rax)
leaq 0x2d225(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
callq 0xb5b0
testl %eax, %eax
je 0x20285
leaq 0x1bec0(%rip), %rdi     # 0x3c181
callq 0x35efc
cmpb $0x1, 0x2c253(%rip)     # 0x4c520
jne 0x20285
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_malloc_usable_size
JEMALLOC_NOTHROW
je_malloc_usable_size(JEMALLOC_USABLE_SIZE_CONST void *ptr)
{
	size_t ret;
	tsdn_t *tsdn;

	assert(malloc_initialized() || IS_INITIALIZER);
	malloc_thread_init();

	tsdn = tsdn_fetch();
	witness_assert_lockless(tsdn);

	if (config_ivsalloc)
		ret = ivsalloc(tsdn, ptr, config_prof);
	else
		ret = (ptr == NULL) ? 0 : isalloc(tsdn, ptr, config_prof);

	witness_assert_lockless(tsdn);
	return (ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x2c245(%rip)     # 0x4c528
jne 0x20380
leaq 0x2d1c0(%rip), %rax     # 0x4d4b0
cmpb $0x1, (%rax)
jne 0x20324
movq 0x2bcec(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %r14
addq %rax, %r14
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x203ad
cmpl $0x2, %ecx
jne 0x20327
movl $0x3, %fs:(%rax)
jmp 0x203b4
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x20376
leaq 0x2cd9d(%rip), %rax     # 0x4d0d0
movq (%rax), %rax
notq %rax
andq %rbx, %rax
cmpq %rbx, %rax
je 0x2038a
subq %rax, %rbx
shrq $0xc, %rbx
leaq 0x2cc71(%rip), %rcx     # 0x4cfc0
subq (%rcx), %rbx
movq 0x78(%rax,%rbx,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
je 0x2039c
movl %ecx, %eax
leaq 0x1b2d0(%rip), %rcx     # 0x3b640
movq (%rcx,%rax,8), %rax
jmp 0x20378
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xcc4e
jmp 0x202e9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e4e2
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x20378
movl $0x1, %fs:(%rax)
leaq 0x2d119(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %r14, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x20327
leaq 0x1bdad(%rip), %rdi     # 0x3c181
callq 0x35efc
cmpb $0x1, 0x2c140(%rip)     # 0x4c520
jne 0x20327
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_prefork
void
jemalloc_prefork(void)
#else
JEMALLOC_EXPORT void
_malloc_prefork(void)
#endif
{
	tsd_t *tsd;
	unsigned i, j, narenas;
	arena_t *arena;

#ifdef JEMALLOC_MUTEX_INIT_CB
	if (!malloc_initialized())
		return;
#endif
	assert(malloc_initialized());

	tsd = tsd_fetch();

	narenas = narenas_total_get();

	witness_prefork(tsd);
	/* Acquire all mutexes in a safe order. */
	ctl_prefork(tsd_tsdn(tsd));
	malloc_mutex_prefork(tsd_tsdn(tsd), &arenas_lock);
	prof_prefork0(tsd_tsdn(tsd));
	for (i = 0; i < 3; i++) {
		for (j = 0; j < narenas; j++) {
			if ((arena = arena_get(tsd_tsdn(tsd), j, false)) !=
			    NULL) {
				switch (i) {
				case 0:
					arena_prefork0(tsd_tsdn(tsd), arena);
					break;
				case 1:
					arena_prefork1(tsd_tsdn(tsd), arena);
					break;
				case 2:
					arena_prefork2(tsd_tsdn(tsd), arena);
					break;
				default: not_reached();
				}
			}
		}
	}
	base_prefork(tsd_tsdn(tsd));
	for (i = 0; i < narenas; i++) {
		if ((arena = arena_get(tsd_tsdn(tsd), i, false)) != NULL)
			arena_prefork3(tsd_tsdn(tsd), arena);
	}
	prof_prefork1(tsd_tsdn(tsd));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x2bbc5(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x20539
cmpl $0x2, %ecx
je 0x20542
xorl %r15d, %r15d
xorl %ebp, %ebp
lock
xaddl %ebp, 0x2c0f0(%rip)     # 0x4c540
movq %rbx, %rdi
callq 0x370bc
movq %rbx, %rdi
callq 0x27ee8
leaq 0x2c0e1(%rip), %rsi     # 0x4c548
movq %rbx, %rdi
callq 0x2e62e
movq %rbx, %rdi
callq 0x2fba1
movl %ebp, %r14d
leaq (,%r14,8), %r12
testl %ebp, %ebp
je 0x204d5
xorl %r13d, %r13d
movq 0x2c120(%rip), %rax     # 0x4c5b0
movq (%rax,%r13), %rsi
testq %rsi, %rsi
je 0x204cb
testq %rsi, %rsi
je 0x204c0
movq %rbx, %rdi
cmpl $0x2, %r15d
je 0x204b4
cmpl $0x1, %r15d
jne 0x204bb
callq 0x2494d
jmp 0x204c0
callq 0x24959
jmp 0x204c0
callq 0x24944
addq $0x8, %r13
cmpq %r13, %r12
jne 0x20489
jmp 0x204d5
xorl %esi, %esi
lock
xaddq %rsi, (%rax,%r13)
jmp 0x20499
incl %r15d
cmpl $0x3, %r15d
jne 0x20482
movq %rbx, %rdi
callq 0x263e6
testl %ebp, %ebp
je 0x20523
shlq $0x3, %r14
xorl %r15d, %r15d
movq 0x2c0b8(%rip), %rax     # 0x4c5b0
movq (%rax,%r15), %rsi
testq %rsi, %rsi
je 0x20519
testq %rsi, %rsi
je 0x2050e
movq %rbx, %rdi
callq 0x24965
addq $0x8, %r15
cmpq %r15, %r14
jne 0x204f1
jmp 0x20523
xorl %esi, %esi
lock
xaddq %rsi, (%rax,%r15)
jmp 0x20501
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2fc19
movl $0x1, %fs:(%rax)
jmp 0x20549
movl $0x3, %fs:(%rax)
leaq 0x2cf84(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x20443
leaq 0x1bc18(%rip), %rdi     # 0x3c181
callq 0x35efc
cmpb $0x1, 0x2bfab(%rip)     # 0x4c520
jne 0x20443
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_postfork_parent
void
jemalloc_postfork_parent(void)
#else
JEMALLOC_EXPORT void
_malloc_postfork(void)
#endif
{
	tsd_t *tsd;
	unsigned i, narenas;

#ifdef JEMALLOC_MUTEX_INIT_CB
	if (!malloc_initialized())
		return;
#endif
	assert(malloc_initialized());

	tsd = tsd_fetch();

	witness_postfork_parent(tsd);
	/* Release all mutexes, now that fork() has completed. */
	base_postfork_parent(tsd_tsdn(tsd));
	for (i = 0, narenas = narenas_total_get(); i < narenas; i++) {
		arena_t *arena;

		if ((arena = arena_get(tsd_tsdn(tsd), i, false)) != NULL)
			arena_postfork_parent(tsd_tsdn(tsd), arena);
	}
	prof_postfork_parent(tsd_tsdn(tsd));
	malloc_mutex_postfork_parent(tsd_tsdn(tsd), &arenas_lock);
	ctl_postfork_parent(tsd_tsdn(tsd));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x2ba5c(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x2062a
cmpl $0x2, %ecx
je 0x20633
movq %rbx, %rdi
callq 0x370c1
movq %rbx, %rdi
callq 0x263f2
xorl %eax, %eax
lock
xaddl %eax, 0x2bf7a(%rip)     # 0x4c540
testl %eax, %eax
je 0x20606
movl %eax, %r14d
shlq $0x3, %r14
xorl %r15d, %r15d
movq 0x2bfd5(%rip), %rax     # 0x4c5b0
movq (%rax,%r15), %rsi
testq %rsi, %rsi
je 0x205fc
testq %rsi, %rsi
je 0x205f1
movq %rbx, %rdi
callq 0x249b6
addq $0x8, %r15
cmpq %r15, %r14
jne 0x205d4
jmp 0x20606
xorl %esi, %esi
lock
xaddq %rsi, (%rax,%r15)
jmp 0x205e4
movq %rbx, %rdi
callq 0x2fc70
leaq 0x2bf33(%rip), %rsi     # 0x4c548
movq %rbx, %rdi
callq 0x2e636
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x27ef4
movl $0x1, %fs:(%rax)
jmp 0x2063a
movl $0x3, %fs:(%rax)
leaq 0x2ce93(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x205ac
leaq 0x1bb27(%rip), %rdi     # 0x3c181
callq 0x35efc
cmpb $0x1, 0x2beba(%rip)     # 0x4c520
jne 0x205ac
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_postfork_child
void
jemalloc_postfork_child(void)
{
	tsd_t *tsd;
	unsigned i, narenas;

	assert(malloc_initialized());

	tsd = tsd_fetch();

	witness_postfork_child(tsd);
	/* Release all mutexes, now that fork() has completed. */
	base_postfork_child(tsd_tsdn(tsd));
	for (i = 0, narenas = narenas_total_get(); i < narenas; i++) {
		arena_t *arena;

		if ((arena = arena_get(tsd_tsdn(tsd), i, false)) != NULL)
			arena_postfork_child(tsd_tsdn(tsd), arena);
	}
	prof_postfork_child(tsd_tsdn(tsd));
	malloc_mutex_postfork_child(tsd_tsdn(tsd), &arenas_lock);
	ctl_postfork_child(tsd_tsdn(tsd));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x2b96b(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x2071b
cmpl $0x2, %ecx
je 0x20724
movq %rbx, %rdi
callq 0x370c6
movq %rbx, %rdi
callq 0x263fe
xorl %eax, %eax
lock
xaddl %eax, 0x2be89(%rip)     # 0x4c540
testl %eax, %eax
je 0x206f7
movl %eax, %r14d
shlq $0x3, %r14
xorl %r15d, %r15d
movq 0x2bee4(%rip), %rax     # 0x4c5b0
movq (%rax,%r15), %rsi
testq %rsi, %rsi
je 0x206ed
testq %rsi, %rsi
je 0x206e2
movq %rbx, %rdi
callq 0x24a2e
addq $0x8, %r15
cmpq %r15, %r14
jne 0x206c5
jmp 0x206f7
xorl %esi, %esi
lock
xaddq %rsi, (%rax,%r15)
jmp 0x206d5
movq %rbx, %rdi
callq 0x2fd37
leaq 0x2be42(%rip), %rsi     # 0x4c548
movq %rbx, %rdi
callq 0x2e63e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x27f00
movl $0x1, %fs:(%rax)
jmp 0x2072b
movl $0x3, %fs:(%rax)
leaq 0x2cda2(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x2069d
leaq 0x1ba36(%rip), %rdi     # 0x3c181
callq 0x35efc
cmpb $0x1, 0x2bdc9(%rip)     # 0x4c520
jne 0x2069d
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_a0
static bool
malloc_init_hard_a0(void)
{
	bool ret;

	malloc_mutex_lock(TSDN_NULL, &init_lock);
	ret = malloc_init_hard_a0_locked();
	malloc_mutex_unlock(TSDN_NULL, &init_lock);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x2ba6c(%rip), %rbx     # 0x4c360
movq %rbx, %rdi
callq 0xb5a0
callq 0x20914
movl %eax, %ebp
movq %rbx, %rdi
callq 0xb380
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/jemalloc.c
// Function: stats_print_atexit
static void
stats_print_atexit(void)
{

	if (config_tcache && config_stats) {
		tsdn_t *tsdn;
		unsigned narenas, i;

		tsdn = tsdn_fetch();

		/*
		 * Merge stats from extant threads.  This is racy, since
		 * individual threads do not lock when recording tcache stats
		 * events.  As a consequence, the final stats may be slightly
		 * out of date by the time they are reported, if other threads
		 * continue to allocate.
		 */
		for (i = 0, narenas = narenas_total_get(); i < narenas; i++) {
			arena_t *arena = arena_get(tsdn, i, false);
			if (arena != NULL) {
				tcache_t *tcache;

				/*
				 * tcache_stats_merge() locks bins, so if any
				 * code is introduced that acquires both arena
				 * and bin locks in the opposite order,
				 * deadlocks may result.
				 */
				malloc_mutex_lock(tsdn, &arena->lock);
				ql_foreach(tcache, &arena->tcache_ql, link) {
					tcache_stats_merge(tsdn, tcache, arena);
				}
				malloc_mutex_unlock(tsdn, &arena->lock);
			}
		}
	}
	je_malloc_stats_print(NULL, NULL, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2bed1(%rip), %rax     # 0x4d4b0
cmpb $0x1, (%rax)
jne 0x21613
movq 0x2a9fd(%rip), %rax     # 0x4bfe8
movq %fs:0x0, %rbx
addq %rax, %rbx
movl %fs:(%rax), %ecx
testl %ecx, %ecx
je 0x216ab
cmpl $0x2, %ecx
jne 0x21615
movl $0x3, %fs:(%rax)
jmp 0x216b2
xorl %ebx, %ebx
xorl %eax, %eax
lock
xaddl %eax, 0x2af21(%rip)     # 0x4c540
testl %eax, %eax
je 0x21692
movl %eax, %r13d
xorl %ebp, %ebp
movq 0x2af81(%rip), %rax     # 0x4c5b0
movq (%rax,%rbp,8), %r14
testq %r14, %r14
je 0x21687
testq %r14, %r14
je 0x2167d
leaq 0x10(%r14), %r15
movq %r15, %rdi
callq 0xb5a0
movq 0xe0(%r14), %r12
testq %r12, %r12
je 0x21675
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x35aba
movq (%r12), %r12
cmpq 0xe0(%r14), %r12
jne 0x21650
xorl %r12d, %r12d
jmp 0x21650
movq %r15, %rdi
callq 0xb380
incq %rbp
cmpq %r13, %rbp
jne 0x21628
jmp 0x21692
xorl %r14d, %r14d
lock
xaddq %r14, (%rax,%rbp,8)
jmp 0x21638
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2024c
movl $0x1, %fs:(%rax)
leaq 0x2be1b(%rip), %rax     # 0x4d4d4
movl (%rax), %edi
movq %rbx, %rsi
callq 0xb5b0
testl %eax, %eax
je 0x21615
leaq 0x1aaaf(%rip), %rdi     # 0x3c181
callq 0x35efc
cmpb $0x1, 0x2ae42(%rip)     # 0x4c520
jne 0x21615
callq 0xb070
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/jemalloc/src/arena.c
// Function: je_arena_chunk_cache_maybe_insert
void
arena_chunk_cache_maybe_insert(arena_t *arena, extent_node_t *node, bool cache)
{

	if (cache) {
		extent_node_dirty_linkage_init(node);
		extent_node_dirty_insert(node, &arena->runs_dirty,
		    &arena->chunks_cache);
		arena->ndirty += arena_chunk_dirty_npages(node);
	}
}

// Assembly:
testl %edx, %edx
je 0x219f4
leaq 0x30(%rsi), %rax
movq %rax, 0x30(%rsi)
movq %rax, 0x38(%rsi)
movq %rsi, 0x40(%rsi)
movq %rsi, 0x48(%rsi)
leaq 0x138(%rdi), %rcx
leaq 0x148(%rdi), %rdx
movq 0x140(%rdi), %r8
movq %rax, (%r8)
movq %rcx, 0x30(%rsi)
movq %rax, 0x140(%rdi)
movq %r8, 0x38(%rsi)
movq 0x190(%rdi), %rax
movq %rsi, 0x40(%rax)
movq %rdx, 0x40(%rsi)
movq %rsi, 0x190(%rdi)
movq %rax, 0x48(%rsi)
movq 0x10(%rsi), %rax
shrq $0xc, %rax
addq %rax, 0x130(%rdi)
retq