name string | code string | asm string | file string |
|---|---|---|---|
format_octal | static int
format_octal(int64_t v, char *p, int s)
{
int len;
len = s;
/* Octal values can't be negative, so use 0. */
if (v < 0) {
while (len-- > 0)
*p++ = '0';
return (-1);
}
p += s; /* Start at the end and work backwards. */
while (s-- > 0) {
*--p = (char)('0' + (v & 7));
v >>= 3;
}
if (v ==... | pushq %rbx
movl %edx, %eax
testq %rdi, %rdi
js 0x555d59
testl %eax, %eax
jle 0x555d73
movl %eax, %edx
addq %rdx, %rsi
leal 0x1(%rax), %ecx
movq %rdi, %r8
movl %r8d, %r9d
andb $0x7, %r9b
orb $0x30, %r9b
movb %r9b, -0x1(%rsi)
decq %rsi
shrq $0x3, %rdi
decl %ecx
cmpl $0x1, %ecx
ja 0x555d10
testl %eax, %eax
setle %al
xorl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ustar.c |
archive_write_set_format_v7tar | int
archive_write_set_format_v7tar(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct v7tar *v7tar;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_v7tar");
/* If someone else was already registered, unregister them. */
if (a->format_... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x17298a(%rip), %rcx # 0x6c8717
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x55de18
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x555e5d
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0x555dbb
movq %rbx, %rdi
callq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_v7tar.c |
warc_data | static ssize_t
_warc_data(struct archive_write *a, const void *buf, size_t len)
{
struct warc_s *w = a->format_data;
if (w->typ == AE_IFREG) {
int rc;
/* never write more bytes than announced */
if (len > w->populz) {
len = (size_t)w->populz;
}
/* now then, out we put the whole shebang */
rc = __arc... | pushq %rbx
movq %rdx, %rbx
movq 0xf8(%rdi), %rax
cmpl $0x8000, 0x10(%rax) # imm = 0x8000
jne 0x556a4a
movq 0x18(%rax), %rax
cmpq %rbx, %rax
cmovbq %rax, %rbx
movq %rbx, %rdx
callq 0x53e917
testl %eax, %eax
cltq
cmovneq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_warc.c |
popul_ehdr | static ssize_t
_popul_ehdr(struct archive_string *tgt, size_t tsz, warc_essential_hdr_t hdr)
{
static const char _ver[] = "WARC/1.0\r\n";
static const char * const _typ[LAST_WT] = {
NULL, "warcinfo", "metadata", "resource", NULL
};
char std_uuid[48U];
if (hdr.type == WT_NONE || hdr.type > WT_RSRC) {
/* brilli... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x70(%rsp), %r14d
leal -0x4(%r14), %ecx
movq $-0x1, %rax
cmpl $-0x3, %ecx
jb 0x556c73
movq %rdi, %rbx
leaq 0x70(%rsp), %r15
movq $0x0, 0x8(%rdi)
leaq 0x171ff4(%rip), %rsi # 0x6c8ad1
movl $0xa, %edx
callq 0x53a01f
leaq 0x3055b2(%rip), %rax # 0x85c0a... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_warc.c |
xstrftime | static void
xstrftime(struct archive_string *as, const char *fmt, time_t t)
{
/** like strftime(3) but for time_t objects */
struct tm *rt;
#if defined(HAVE_GMTIME_R) || defined(HAVE__GMTIME64_S)
struct tm timeHere;
#endif
#if defined(HAVE__GMTIME64_S)
errno_t terr;
__time64_t tmptime;
#endif
char strtime[100];
s... | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
movq %rdx, (%rdi)
leaq 0x8(%rsp), %rsi
callq 0x40ca0
testq %rax, %rax
je 0x556ccc
leaq 0x40(%rsp), %r15
movl $0x63, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x410f0
movq %rbx, %rdi
movq %r15, %rsi
movq %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_warc.c |
archive_write_zip_data | static ssize_t
archive_write_zip_data(struct archive_write *a, const void *buff, size_t s)
{
int ret;
struct zip *zip = a->format_data;
if ((int64_t)s > zip->entry_uncompressed_limit)
s = (size_t)zip->entry_uncompressed_limit;
zip->entry_uncompressed_written += s;
if (s == 0) return 0;
if (zip->entry_flags &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq 0xf8(%rdi), %r13
movq 0x28(%r13), %rax
cmpq %rdx, %rax
cmovlq %rax, %rbx
addq %rbx, 0x20(%r13)
testq %rbx, %rbx
je 0x557f4e
movq %rsi, %rbp
movq %rdi, %r14
testb $0x1, 0x44(%r13)
je 0x557f65
movl 0x40(%r13), %eax
lea... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_zip.c |
ZSTD_ldm_fillHashTable | void ZSTD_ldm_fillHashTable(
ldmState_t* ldmState, const BYTE* ip,
const BYTE* iend, ldmParams_t const* params)
{
U32 const minMatchLength = params->minMatchLength;
U32 const hBits = params->hashLog - params->bucketSizeLog;
BYTE const* const base = ldmState->window.base;
BYTE con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movl 0xc(%rcx), %r11d
movl 0x4(%rcx), %eax
movl 0x8(%rcx), %esi
movq %rdi, 0x10(%rsp)
movq 0x8(%rdi), %rdi
movq %rdi, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
movl 0x10(%rcx), %ecx
cmpl $0x40, %r11d
movl $0x40, %edi
cmovbl %r11d,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_skipSequences | void ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize, U32 const minMatch) {
while (srcSize > 0 && rawSeqStore->pos < rawSeqStore->size) {
rawSeq* seq = rawSeqStore->seq + rawSeqStore->pos;
if (srcSize <= seq->litLength) {
/* Skip past srcSize literals */
seq... | testq %rsi, %rsi
je 0x5e3695
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %r8
leaq (%rax,%rax,2), %rcx
leaq 0x4(,%rcx,4), %rcx
cmpq %r8, %rax
jae 0x5e3695
movq (%rdi), %r9
movl (%r9,%rcx), %r11d
movq %rsi, %r10
subq %r11, %r10
jbe 0x5e3696
movl $0x0, (%r9,%rcx)
movl 0x4(%r9,%rcx), %esi
cmpq %rsi, %r10
jb 0x5e369e
incq %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_blockCompress | size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
ZSTD_useRowMatchFinderMode_e useRowMatchFinder,
void const* src, size_t srcSize)
{
const ZSTD_compressionParameters* const cParams = &ms->cParams;
unsigned const minMatch = c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movq %rcx, 0x20(%rsp)
movq %rdx, %rcx
movq %rsi, %r12
movq %rdi, %r14
movl 0x1c(%rsi), %eax
movl 0x108(%rsi), %edi
movl $0x1, %edx
cmpl 0x18(%rsi), %eax
jb 0x5e3760
movq 0xe8(%r12), %rax
testq %rax, %rax
je 0x5e375e
cmpl $... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_insertBt1 | static U32 ZSTD_insertBt1(
ZSTD_matchState_t* ms,
const BYTE* const ip, const BYTE* const iend,
U32 const mls, const int extDict)
{
const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32* const hashTable = ms->hashTable;
U32 const hashLog = c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r8d, 0x30(%rsp)
movl %ecx, %eax
movq 0x60(%rdi), %r13
movl 0xf8(%rdi), %ecx
addl $-0x5, %eax
cmpl $0x3, %eax
ja 0x607c13
leaq 0xcec13(%rip), %r8 # 0x6d6490
movslq (%r8,%rax,4), %rax
addq %r8, %rax
jmpq *%rax
movabsq $-0x30e443... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_litLengthPrice | static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr, int optLevel)
{
if (optPtr->priceType == zop_predef) return WEIGHT(litLength, optLevel);
/* dynamic statistics */
{ U32 const llCode = ZSTD_LLcode(litLength);
return (LL_bits[llCode] * BITCOST_MULTIPLIER)
... | movl %edi, %eax
cmpl $0x1, 0x50(%rsi)
jne 0x60840c
incl %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
xorl $0x1f, %ecx
testl %edx, %edx
je 0x60845f
movl %ecx, %edx
shll $0x8, %edx
shll $0x8, %eax
shrl %cl, %eax
addl %edx, %eax
retq
cmpl $0x40, %eax
jb 0x60841c
bsrl %eax, %eax
xorl $-0x20, %eax
addl $0x33, %eax
jmp 0x608429
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_initDCtx_internal | static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
{
dctx->staticSize = 0;
dctx->ddict = NULL;
dctx->ddictLocal = NULL;
dctx->dictEnd = NULL;
dctx->ddictIsCold = 0;
dctx->dictUses = ZSTD_dont_use;
dctx->inBuff = NULL;
dctx->inBuffSize = 0;
dctx->outBuffSize = 0;
... | pushq %rbx
xorl %esi, %esi
movq %rsi, 0x75d0(%rdi)
movq %rsi, 0x74d8(%rdi)
movq %rsi, 0x75f4(%rdi)
movq %rsi, 0x7638(%rdi)
movq %rsi, 0x7658(%rdi)
movl %esi, 0x7660(%rdi)
movl %esi, 0x766c(%rdi)
movq %rsi, 0x276c8(%rdi)
xorl %eax, %eax
cpuid
xorps %xmm0, %xmm0
movups %xmm0, 0x75e0(%rdi)
movups %xmm0, 0x760c(%rdi)
movl ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_DCtx_trace_end | static void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64 compressedSize, unsigned streaming)
{
#if ZSTD_TRACE
if (dctx->traceCtx && ZSTD_trace_decompress_end != NULL) {
ZSTD_Trace trace;
ZSTD_memset(&trace, 0, sizeof(trace));
trace.version = ZSTD_VERSION_NUMBER;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x276d0(%rdi), %rdi
testq %rdi, %rdi
sete %al
cmpq $0x0, 0x2544a3(%rip) # 0x85df30
sete %dl
orb %al, %dl
jne 0x609b03
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_decompressBegin | size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
{
assert(dctx != NULL);
#if ZSTD_TRACE
dctx->traceCtx = (ZSTD_trace_decompress_begin != NULL) ? ZSTD_trace_decompress_begin(dctx) : 0;
#endif
dctx->expected = ZSTD_startingInputLength(dctx->format); /* dctx->format must be properly set */
dctx->stage = ZSTDd... | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x2541c8(%rip) # 0x85df28
je 0x609d6c
movq %rbx, %rdi
callq 0x41ea0
jmp 0x609d6e
xorl %eax, %eax
movq %rax, 0x276d0(%rbx)
xorl %eax, %eax
cmpl $0x0, 0x7590(%rbx)
sete %al
leaq 0x1(,%rax,4), %rax
movq %rax, 0x74e0(%rbx)
leaq 0x20(%rbx), %rax
leaq 0x2838(%rbx), %rcx
xorps %xmm0, %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_decompressBegin_usingDict | size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
{
FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
if (dict && dictSize)
RETURN_ERROR_IF(
ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),
dictionary_corrupted, "");
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x609d54
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x609ebc
movq %r14, %rax
cmpq $0x8, %rbx
jb 0x609e89
cmpl $0xec30a437, (%r14) # imm = 0xEC30A437
movq %r14, %rax
jne 0x609e89
movl 0x4(%r14), %eax
movl... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_initDStream | size_t ZSTD_initDStream(ZSTD_DStream* zds)
{
DEBUGLOG(4, "ZSTD_initDStream");
return ZSTD_initDStream_usingDDict(zds, NULL);
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movl %ebp, 0x760c(%rdi)
movl %ebp, 0x766c(%rdi)
movq 0x75e0(%rdi), %rdi
callq 0x614dda
movl %ebp, 0x75f8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x75e0(%rbx)
xorl %eax, %eax
cmpl %ebp, 0x7590(%rbx)
sete %al
leaq 0x1(,%rax,4), %rax
addq $0x8, %rsp
popq %rbx... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_DCtx_refDDict | size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
{
RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
ZSTD_clearDict(dctx);
if (ddict) {
dctx->ddict = ddict;
dctx->dictUses = ZSTD_use_indefinitely;
if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleD... | movq $-0x3c, %rax
cmpl $0x0, 0x760c(%rdi)
je 0x60a249
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x75e0(%rdi), %rdi
callq 0x614dda
movl $0x0, 0x75f8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x75e0(%r15)
testq %rbx, %rbx
je 0x60a40e
movq %rbx, 0x75e8(%... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_dParam_getBounds | ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)
{
ZSTD_bounds bounds = { 0, 0, 0 };
switch(dParam) {
case ZSTD_d_windowLogMax:
bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN;
bounds.upperBound = ZSTD_WINDOWLOG_MAX;
return bounds;
case ZSTD_d_format:
... | leal -0x3e8(%rdi), %eax
cmpl $0x3, %eax
ja 0x60a4b2
leaq 0xcc274(%rip), %rcx # 0x6d6710
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $0x100000000, %rdx # imm = 0x100000000
xorl %eax, %eax
retq
cmpl $0x64, %edi
jne 0x60a4c3
movabsq $0x1f0000000a, %rdx # imm = 0x1F0000000A
jmp 0x60a4af
movq ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_DCtx_setFormat | size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)
{
return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, (int)format);
} | movq $-0x3c, %rax
cmpl $0x0, 0x760c(%rdi)
je 0x60a4de
retq
movq $-0x2a, %rax
cmpl $0x1, %esi
ja 0x60a4dd
movl %esi, 0x7590(%rdi)
xorl %eax, %eax
retq
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_decompressStream | size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
{
const char* const src = (const char*)input->src;
const char* const istart = input->pos != 0 ? src + input->pos : src;
const char* const iend = input->size != 0 ? src + input->size : src;
const char* ip = ista... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq 0x10(%rdx), %rax
movq (%rdx), %r10
movq 0x8(%rdx), %rcx
movq (%rsi), %r15
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rdi
leaq (%r15,%rdi), %r9
movq %r9, 0x28(%rsp)
movq $-0x48, %r14
movq %rcx, %r11
subq %rax, %r11
jb 0x60... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_DDictHashSet_emplaceDDict | static size_t ZSTD_DDictHashSet_emplaceDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict) {
const U32 dictID = ZSTD_getDictID_fromDDict(ddict);
size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID);
const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1;
RETURN_ERROR_IF(hashSet->ddictPtrC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x614f58
movl %eax, %ebp
leaq 0xc(%rsp), %rdi
movl %eax, (%rdi)
movl $0x4, %esi
xorl %edx, %edx
callq 0x60cfca
movq %rax, %r15
movq 0x8(%rbx), %r12
movq 0x10(%rbx), %rcx
movq $-0x1, %rax
cmpq %r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
HUF_readStats_wksp | size_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize, U32* rankStats,
U32* nbSymbolsPtr, U32* tableLogPtr,
const void* src, size_t srcSize,
void* workSpace, size_t wkspSize,
int bmi2)
{
#if DYNAMIC_BMI2
if (bmi2) {
retu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq 0x30(%rsp), %rdx
movq $-0x48, %rax
testq %rdx, %rdx
je 0x60b710
movq %r8, %r13
movq %rcx, %rbx
movq %rdi, %r12
movzbl (%r9), %r14d
testb %r14b, %r14b
js 0x60b5cc
cmpq %rdx, %r14
jae 0x60b710
movq 0x38(%rsp), %rax
decq %rsi
incq %r9
movq %r12, %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/entropy_common.c |
FSE_decompress_wksp_bmi2 | size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize, int bmi2)
{
#if DYNAMIC_BMI2
if (bmi2) {
return FSE_decompress_wksp_body_bmi2(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize);
}
#endif
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0xc0(%rsp), %r14
movl $0xff, 0x24(%rsp)
movq $-0x1, %rax
cmpq $0x204, %r14 # imm = 0x204
jb 0x60c5de
movq %r9, %r13
movl %r8d, %r15d
movq %rcx, %r8
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, 0x18(%rsp)
leaq 0x24(%rsp), %r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/fse_decompress.c |
BIT_initDStream | MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
{
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
bitD->start = (const char*)srcBuffer;
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
if (srcSize >= sizeof... | testq %rdx, %rdx
je 0x60cd3a
movq %rdx, %rax
movq %rsi, 0x18(%rdi)
leaq 0x8(%rsi), %rcx
movq %rcx, 0x20(%rdi)
cmpq $0x8, %rdx
jb 0x60cd54
leaq (%rsi,%rax), %rcx
addq $-0x8, %rcx
movq %rcx, 0x10(%rdi)
movq (%rcx), %rdx
movq %rdx, (%rdi)
movzbl 0x7(%rcx), %ecx
testl %ecx, %ecx
je 0x60cde8
bsrl %ecx, %ecx
notl %ecx
addl $... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/bitstream.h |
XXH32_reset | XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
{
XXH32_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
ZSTD_memset(&state, 0, sizeof(state)-4); /* do not write into reserved, for future removal */
state.v1 = seed + PRI... | leal 0x24234428(%rsi), %eax
leal -0x7a143589(%rsi), %ecx
movq $0x0, (%rdi)
movl %eax, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movl %esi, 0x10(%rdi)
addl $0x61c8864f, %esi # imm = 0x61C8864F
movl %esi, 0x14(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl $0x0, 0x28(%rdi)
xorl %eax, %eax
retq
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/xxhash.c |
XXH64_digest | XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
{
XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
return XXH64_digest_endian(state_in, XXH_littleEndian);
else
return XXH6... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
movabsq $-0x7a1435883d4d519d, %rsi # imm = 0x85EBCA77C2B2AE63
movabsq $0x27d4eb2f165667c5, %rdx # imm = 0x27D4EB2F165667C5
movl 0x48(%rdi), %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/xxhash.c |
FSE_buildCTable_wksp | size_t FSE_buildCTable_wksp(FSE_CTable* ct,
const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
void* workSpace, size_t wkspSize)
{
U32 const tableSize = 1 << tableLog;
U32 const tableMask = tableSize - 1;
void* const ptr = ct;
U1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x1, %ebx
shll %cl, %ebx
movl $0x1, %r11d
movl %ebx, %r14d
shrl %r14d
testl %ecx, %ecx
cmovnel %r14d, %r11d
movq $-0x1, %rax
testb $0x3, %r8b
jne 0x60da50
movl %ecx, %r10d
leal 0x2(%rdx), %r13d
leal -0x2(%r10), %ecx
movl $0x1, %r15d
shlq %cl, %r15
... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/fse_compress.c |
FSE_writeNCount_generic | static size_t
FSE_writeNCount_generic (void* header, size_t headerBufferSize,
const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
unsigned writeIsSafe)
{
BYTE* const ostart = (BYTE*) header;
BYTE* out = ostart;
BYTE* const oend = ostart + h... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %r15d
movq $-0x1, %rax
incl %r15d
je 0x60dd19
addq %rdi, %rsi
leal -0x5(%r8), %r11d
movl $0x1, %r14d
movl %r8d, %ecx
shll %cl, %r14d
leal 0x1(%r14), %ebp
incl %r8d
addq $-0x2, %rsi
movl %r15d, %eax
movq %rax, -0x8(%rsp)
movl $0x4, %ecx
xorl %r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/fse_compress.c |
FSE_optimalTableLog_internal | unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
{
U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - minus;
U32 tableLog = maxTableLog;
U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);
assert(srcSize > 1); /* Not supported, RL... | leal -0x1(%rsi), %eax
bsrl %eax, %eax
subl %ecx, %eax
bsrl %esi, %ecx
xorl $-0x20, %ecx
addl $0x21, %ecx
bsrl %edx, %edx
xorl $-0x20, %edx
addl $0x22, %edx
cmpl %edx, %ecx
cmovbl %ecx, %edx
testl %edi, %edi
movl $0xb, %ecx
cmovnel %edi, %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
cmpl %ecx, %edx
cmoval %edx, %ecx
cmpl $0x6,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/fse_compress.c |
FSE_optimalTableLog | unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
{
U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - minus;
U32 tableLog = maxTableLog;
U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);
assert(srcSize > 1); /* Not supported, RL... | leal -0x1(%rsi), %eax
bsrl %eax, %eax
xorl $-0x20, %eax
addl $0x1e, %eax
bsrl %esi, %ecx
xorl $-0x20, %ecx
addl $0x21, %ecx
bsrl %edx, %edx
xorl $-0x20, %edx
addl $0x22, %edx
cmpl %edx, %ecx
cmovbl %ecx, %edx
testl %edi, %edi
movl $0xb, %ecx
cmovnel %edi, %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
cmpl %ecx, %edx
cmoval %e... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/fse_compress.c |
FSE_normalizeCount | size_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog,
const unsigned* count, size_t total,
unsigned maxSymbolValue, unsigned useLowProbCount)
{
/* Sanity checks */
if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
if (tableLog < FSE_MIN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testl %esi, %esi
movl $0xb, %ebx
cmovnel %esi, %ebx
movq $-0x1, %rax
cmpl $0x5, %ebx
jb 0x60e055
movq $-0x2c, %rax
cmpl $0xc, %ebx
ja 0x60e055
movl %r8d, %r12d
movq %rcx, %r11
bsrl %r11d, %eax
xorl $-0x20, %eax
addl $0x21, %eax
bsrl %r8d, %ecx
xorl $-0x2... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/fse_compress.c |
FSE_buildCTable_raw | size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits)
{
const unsigned tableSize = 1 << nbBits;
const unsigned tableMask = tableSize - 1;
const unsigned maxSymbolValue = tableMask;
void* const ptr = ct;
U16* const tableU16 = ( (U16*) ptr) + 2;
void* const FSCT = ((U32*)ptr) + 1 /* header ... | movl %esi, %ecx
movl $0x1, %eax
shll %cl, %eax
testl %esi, %esi
je 0x60e442
movl %eax, %esi
shrl %esi
movw %cx, (%rdi)
leal -0x1(%rax), %edx
movw %dx, 0x2(%rdi)
movl %eax, %edx
leaq 0x7(%rdx), %r8
andq $-0x8, %r8
leaq -0x1(%rdx), %r9
movq %r9, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
movdqa 0x88823(%... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/fse_compress.c |
HIST_count_simple | unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize)
{
const BYTE* ip = (const BYTE*)src;
const BYTE* const end = ip + srcSize;
unsigned maxSymbolValue = *maxSymbolValuePtr;
unsigned largestCount=0;
ZSTD_memset(count, 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %rbx
leaq (%rdx,%rcx), %r14
movq %rsi, (%rsp)
movl (%rsi), %r13d
leal 0x1(%r13), %edx
shlq $0x2, %rdx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x3fa90
testq %r12, %r12
je 0x60ebca
movq (%rsp), %rcx
jle 0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/hist.c |
HIST_count_parallel_wksp | static size_t HIST_count_parallel_wksp(
unsigned* count, unsigned* maxSymbolValuePtr,
const void* source, size_t sourceSize,
HIST_checkInput_e check,
U32* const workSpace)
{
const BYTE* ip... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl (%rsi), %r14d
incl %r14d
shlq $0x2, %r14
testq %rcx, %rcx
je 0x60ed95
movq %r9, %r15
movq %rcx, %rbp
movq %rdx, %r13
movl %r8d, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
leaq (%rdx,%rcx), %r12
movl $0x1000, %edx # im... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/hist.c |
HIST_count_wksp | size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
const void* source, size_t sourceSize,
void* workSpace, size_t workSpaceSize)
{
if ((size_t)workSpace & 3) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */
if (workSpaceSize < HI... | movq %r8, %r10
movq $-0x1, %rax
testb $0x3, %r10b
jne 0x60eee7
movq $-0x42, %rax
cmpq $0x1000, %r9 # imm = 0x1000
jae 0x60eee8
retq
cmpl $0xfe, (%rsi)
ja 0x60eefe
movl $0x1, %r8d
movq %r10, %r9
jmp 0x60ec24
movl $0xff, (%rsi)
movq %r10, %r8
jmp 0x60ebe5
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/hist.c |
HUF_writeCTable_wksp | size_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize,
const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog,
void* workspace, size_t workspaceSize)
{
BYTE* op = (BYTE*)dst;
U32 n;
HUF_WriteCTableWksp* wksp = (HUF_WriteCTableWksp*)worksp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq $-0x1, %r14
cmpq $0x2c0, 0x70(%rsp) # imm = 0x2C0
jb 0x60f7a3
movl %ecx, %ebx
movq $-0x2e, %r14
cmpl $0xff, %ecx
ja 0x60f7a3
movq %r9, %r12
movb $0x0, 0x1b4(%r9)
leal 0x1(%r8), %eax
cmpl $0x2, %eax
jb 0x60f5ab
movl %eax, %ecx
l... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/huf_compress.c |
HUF_readCTable | size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned* hasZeroWeights)
{
BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1]; /* init not required, even though some static analyzer may complain */
U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1]; /* large enough for v... | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %r8, %r15
movq %rdx, %r9
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
leaq 0xc(%rsp), %r8
movl %edx, (%r8)
leaq 0x8(%rsp), %rax
movl %edx, (%rax)
movq %rcx, (%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movl $0x100, %esi ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/huf_compress.c |
HUF_compress1X_usingCTable_internal | FORCE_INLINE_TEMPLATE size_t
HUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize,
const void* src, size_t srcSize,
const HUF_CElt* CTable)
{
const BYTE* ip = (const BYTE*) src;
BYTE* const ostart = (BYTE*)dst;
BYTE* const o... | cmpq $0x8, %rsi
jae 0x610116
xorl %eax, %eax
retq
xorl %eax, %eax
cmpq $0x8, %rsi
je 0x6102a6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r9
leaq (%rdi,%rsi), %r10
addq $-0x8, %r10
movq %rcx, %r11
andq $-0x4, %r11
andl $0x3, %r9d
leaq 0xc707a(%rip), %rcx # 0x6d71c0
movslq (%rcx,%r9,4), %rsi
addq %rcx, %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/huf_compress.c |
HUF_compress4X_usingCTable_internal | static size_t
HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,
const void* src, size_t srcSize,
const HUF_CElt* CTable, int bmi2)
{
size_t const segmentSize = (srcSize+3)/4; /* first 3 segments */
const BYTE* ip = (const BYTE*) src;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbp
cmpq $0x11, %rsi
setb %al
cmpq $0xc, %rcx
setb %cl
orb %al, %cl
je 0x6102d3
xorl %eax, %eax
jmp 0x6103c9
movq %r8, %r15
movq %rdx, %r12
movq %rsi, %r13
leaq 0x3(%rbp), %rbx
shrq $0x2, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x6(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/huf_compress.c |
HUF_compress_internal | static size_t
HUF_compress_internal (void* dst, size_t dstSize,
const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog,
HUF_nbStreams_e nbStreams,
void* workSpace_align4, size_t wkspSize,
HUF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %eax
movq 0x70(%rsp), %r9
movl %r8d, 0xc(%rsp)
movq $-0x42, %rbp
cmpq $0x1900, %r9 # imm = 0x1900
jb 0x61052c
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
testq %rcx, %rcx
sete %cl
testq %rsi, %rsi
sete %dl
orb %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/huf_compress.c |
ZSTD_noCompressLiterals | size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
{
BYTE* const ostart = (BYTE*)dst;
U32 const flSize = 1 + (srcSize>31) + (srcSize>4095);
RETURN_ERROR_IF(srcSize + flSize > dstCapacity, dstSize_tooSmall, "");
switch(flSize)
{
case 1: /* 2 - ... | pushq %rbx
xorl %r8d, %r8d
cmpq $0x20, %rcx
setae %r8b
cmpq $0x1000, %rcx # imm = 0x1000
sbbl $-0x1, %r8d
leaq (%r8,%rcx), %rbx
incq %rbx
movq $-0x46, %rax
cmpq %rsi, %rbx
ja 0x61099c
incq %r8
cmpl $0x3, %r8d
je 0x610976
cmpl $0x2, %r8d
jne 0x610982
movl %ecx, %eax
shll $0x4, %eax
orl $0x4, %eax
movw %ax, (%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_literals.c |
ZSTD_compressRleLiteralsBlock | size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
{
BYTE* const ostart = (BYTE*)dst;
U32 const flSize = 1 + (srcSize>31) + (srcSize>4095);
(void)dstCapacity; /* dstCapacity already guaranteed to be >=4, hence large enough */
switch(flSize)
{
... | xorl %eax, %eax
cmpq $0x20, %rcx
setae %al
cmpq $0x1000, %rcx # imm = 0x1000
sbbq $-0x1, %rax
incq %rax
cmpq $0x3, %rax
je 0x6109cb
cmpl $0x2, %eax
jne 0x6109d5
shll $0x4, %ecx
orl $0x5, %ecx
movw %cx, (%rdi)
jmp 0x6109dc
shll $0x4, %ecx
orl $0xd, %ecx
movl %ecx, (%rdi)
jmp 0x6109dc
shlb $0x3, %cl
incb %cl
mo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_literals.c |
HUF_readDTableX1_wksp_bmi2 | size_t HUF_readDTableX1_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int bmi2)
{
U32 tableLog = 0;
U32 nbSymbols = 0;
size_t iSize;
void* const dtPtr = DTable + 1;
HUF_DEltX1* const dt = (HUF_DEltX1*)dtPtr;
HUF_ReadDTableX1_Workspace* wksp = (H... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
xorl %ecx, %ecx
movl %ecx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movq $-0x2c, %r12
cmpq $0x5e8, %r8 # imm = 0x5E8
jb 0x611043
movl %r9d, %r10d
movq %rdx, %rax
movq %rsi, %r9
movq %rdi, %r14
leaq 0x4e8(%rbx), %r15
lea... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_decompress1X1_DCtx_wksp | size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize,
void* workSpace, size_t wkspSize)
{
const BYTE* ip = (const BYTE*) cSrc;
size_t const hSize = HUF_readDTableX1_wksp(DCtx, cSrc... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq 0x30(%rsp), %r8
movq %rcx, %rsi
movq %rbx, %rdx
movq %r9, %rcx
xorl %r9d, %r9d
callq 0x610cd4
movq %rax, %rcx
cmpq $-0x78, %rax
ja 0x6112f6
movq $-0x48, %rcx
subq %rax, %rbx
jbe 0x6... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_readDTableX2_wksp | size_t HUF_readDTableX2_wksp(HUF_DTable* DTable,
const void* src, size_t srcSize,
void* workSpace, size_t wkspSize)
{
U32 tableLog, maxW, sizeOfSort, nbSymbols;
DTableDesc dtd = HUF_getDTableDesc(DTable);
U32 const maxTableLog = dtd.maxTableLog;
size_t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq $-0x1, %r12
cmpq $0x944, %r8 # imm = 0x944
jb 0x61292f
movq %rcx, %r14
movq %rdi, %rbx
movl (%rdi), %ebp
movzbl %bpl, %ecx
pxor %xmm0, %xmm0
movdqu %xmm0, 0x2cc(%r14)
movdqu %xmm0, 0x2c0(%r14)
movdqu %xmm0, 0x2b0(%r14)
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_decompress4X2_DCtx_wksp_bmi2 | static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize,
void* workSpace, size_t wkspSize, int bmi2)
{
const BYTE* ip = (const BYTE*) cSrc;
size_t hSize = HUF_readDTableX2... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq 0x30(%rsp), %r8
movq %rcx, %rsi
movq %rbx, %rdx
movq %r9, %rcx
callq 0x6122e5
movq %rax, %rcx
cmpq $-0x78, %rax
ja 0x6142f2
movq $-0x48, %rcx
subq %rax, %rbx
jbe 0x6142f2
addq %rax,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_decompress4X_hufOnly_wksp | size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
size_t dstSize, const void* cSrc,
size_t cSrcSize, void* workSpace,
size_t wkspSize)
{
/* validation checks */
if (dstSize == 0) return... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x6143cc
movq %r8, %r14
testq %r8, %r8
je 0x6143d5
movq %r9, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq %rdx, %rdi
movq %r14, %rsi
callq 0x61431f
movq %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_decompress1X_usingDTable_bmi2 | size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
{
DTableDesc const dtd = HUF_getDTableDesc(DTable);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)dtd;
assert(dtd.tableType == 0);
return HUF_decompress1X1_usingDTab... | cmpb $0x0, 0x1(%r8)
je 0x611064
jmp 0x612958
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_decompress | size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{
#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
static const decompressionAlgo decompress[2] = { HUF_decompress4X1, HUF_decompress4X2 };
#endif
/* validation checks */
if (dstSize == 0) return ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6148ad
movq %rcx, %r15
movq %rsi, %rbx
movq $-0x14, %rax
cmpq %rsi, %rcx
ja 0x6148ce
movq %rdx, %r14
movq %rdi, %r12
jne 0x6148b6
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3f250
jmp 0x6148cb
movq $-0x46, %rax
jmp 0x6148ce
cmpq $0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_decompress4X_DCtx | size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{
/* validation checks */
if (dstSize == 0) return ERROR(dstSize_tooSmall);
if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */
if (cSrcSize == dstSize) { ZSTD_memcpy(dst,... | testq %rdx, %rdx
je 0x61494c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa00, %rsp # imm = 0xA00
movq %r8, %r15
movq %rdx, %rbx
movq $-0x14, %rax
cmpq %rdx, %r8
ja 0x6149c6
movq %rcx, %r14
movq %rsi, %r12
jne 0x614954
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3f250
jmp 0x6149... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
ZSTD_copyDDictParameters | void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
{
DEBUGLOG(4, "ZSTD_copyDDictParameters");
assert(dctx != NULL);
assert(ddict != NULL);
dctx->dictID = ddict->dictID;
dctx->prefixStart = ddict->dictContent;
dctx->virtualStart = ddict->dictContent;
dctx->dictEnd = (cons... | movl 0x6ab4(%rsi), %eax
movl %eax, 0x75f0(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x74c8(%rdi)
movq %rax, 0x74d0(%rdi)
addq 0x10(%rsi), %rax
movq %rax, 0x74d8(%rdi)
movq %rax, 0x74c0(%rdi)
cmpl $0x0, 0x6ab8(%rsi)
je 0x614bcd
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x7528(%rdi)
leaq 0x18(%rsi), %rax... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_ddict.c |
ZSTD_initStaticDDict | const ZSTD_DDict* ZSTD_initStaticDDict(
void* sBuffer, size_t sBufferSize,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x7, %bl
jne 0x614ed7
movq %rcx, %r14
movl $0x6ad8, %eax # imm = 0x6AD8
addq %rax, %rcx
cmpl $0x1, %r8d
cmoveq %rax, %rcx
cmpq %rsi, %rcx
jbe 0x614ee4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_ddict.c |
ZSTD_decodeLiteralsBlock | size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */
{
DEBUGLOG(5, "ZSTD_decodeLiteralsBlock");
RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, "");
{ const BYTE* const istart = (const BYTE*) src;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq $-0x14, %r14
cmpq $0x3, %rdx
jae 0x614fe6
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %rcx
movq %rdi, %rbx
movzbl (%rsi), %r15d
movl %r15d, %r12d
andl $0x3, %r12d
leaq 0xc2452(%rip), %rax # 0x6d7450
movslq (%rax,%r12,4... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress_block.c |
ZSTD_decodeSeqHeaders | size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
const void* src, size_t srcSize)
{
const BYTE* const istart = (const BYTE*)src;
const BYTE* const iend = istart + srcSize;
const BYTE* ip = istart;
int nbSeq;
DEBUGLOG(5, "ZSTD_decodeSeqHeaders");
/* check... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq $-0x48, %r15
testq %rcx, %rcx
je 0x6157b7
movq %rcx, %r14
movq %rdx, %rbx
movzbl (%rdx), %ebp
testl %ebp, %ebp
je 0x6157a9
movq %rdi, %r12
testb %bpl, %bpl
js 0x6157c9
leaq 0x1(%rbx), %rax
addq %rbx, %r14
movl %ebp, (%rsi)
leaq 0x1(... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress_block.c |
ZSTD_decompressBlock | size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize)
{
size_t dSize;
ZSTD_checkContinuity(dctx, dst, dstCapacity);
dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x74c0(%rdi), %rax
cmpq %rsi, %rax
sete %sil
testq %rdx, %rdx
sete %dil
orb %sil, %dil
jne 0x617354
movq %rax, 0x74d8(%r14)
movq 0x74c8(%r14), %rsi
subq %rax, %rsi
addq %rbx, %rsi
movq %rsi, 0x74d0(%r14)
movq %rbx, 0x74c8(%r14)
movq %rbx, 0x74c0(%r14... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress_block.c |
ZSTD_initFseState | static void
ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt)
{
const void* ptr = dt;
const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr;
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
DEBUGLOG(6, "ZSTD_initFseState : val=%u... | movl 0x4(%rdx), %r8d
movq (%rsi), %r9
movl 0x8(%rsi), %eax
addl %r8d, %eax
movl %eax, %ecx
negb %cl
shrq %cl, %r9
leaq 0xc0a21(%rip), %rcx # 0x6d7db0
andl (%rcx,%r8,4), %r9d
movl %eax, 0x8(%rsi)
movq %r9, (%rdi)
cmpl $0x40, %eax
ja 0x6173f5
movq 0x10(%rsi), %rcx
cmpq 0x20(%rsi), %rcx
jae 0x6173db
movq 0x18(%rsi), %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress_block.c |
BIT_reloadDStream | MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
{
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
return BIT_DStream_overflow;
if (bitD->ptr >= bitD->limitPtr) {
return BIT_reloadDStreamFast(bitD);
}
if (bitD->pt... | movl 0x8(%rdi), %eax
cmpq $0x40, %rax
ja 0x61745a
movq 0x10(%rdi), %rcx
cmpq 0x20(%rdi), %rcx
jae 0x617442
movq 0x18(%rdi), %rdx
cmpq %rdx, %rcx
je 0x61745a
movl %eax, %esi
shrl $0x3, %esi
movq %rcx, %r8
subq %rsi, %r8
movl %ecx, %r9d
subl %edx, %r9d
cmpq %rdx, %r8
cmovael %esi, %r9d
subq %r9, %rcx
movq %rcx, 0x10(%rdi... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/../common/bitstream.h |
ZSTD_execSequenceEnd | FORCE_NOINLINE
size_t ZSTD_execSequenceEnd(BYTE* op,
BYTE* const oend, seq_t sequence,
const BYTE** litPtr, const BYTE* const litLimit,
const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
{
BYTE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rax
movq %rdx, %r12
movq %rsi, %r15
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %rbx
leaq (%rbx,%rcx), %rsi
movq %r15, %rdx
subq %rdi, %rdx
movq $-0x46, %rbp
cmpq %rdx, %rsi
ja 0x617561
movq (%r12), %rdx
subq %rdx, %rax
movq $-0x1... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress_block.c |
ZSTD_safecopy | static void ZSTD_safecopy(BYTE* op, BYTE* const oend_w, BYTE const* ip, ptrdiff_t length, ZSTD_overlap_e ovtype) {
ptrdiff_t const diff = op - ip;
BYTE* const oend = op + length;
assert((ovtype == ZSTD_no_overlap && (diff <= -8 || diff >= 8 || op >= oend_w)) ||
(ovtype == ZSTD_overlap_src_before... | leaq (%rdi,%rcx), %rax
cmpq $0x7, %rcx
jg 0x6175a7
testq %rcx, %rcx
jle 0x61770b
movb (%rdx), %cl
incq %rdx
movb %cl, (%rdi)
incq %rdi
cmpq %rax, %rdi
jb 0x617593
jmp 0x61770b
cmpl $0x1, %r8d
jne 0x61760b
movq %rdi, %r9
subq %rdx, %r9
cmpq $0x7, %r9
ja 0x6175fd
leaq 0xc0890(%rip), %r10 # 0x6d7e50
movslq (%r10,%r9,4... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress_block.c |
rhash_file | RHASH_API int rhash_file(unsigned hash_id, const char* filepath, unsigned char* result)
{
FILE* fd;
rhash ctx;
int res;
hash_id &= RHASH_ALL_HASHES;
if (hash_id == 0) {
errno = EINVAL;
return -1;
}
if ((fd = fopen(filepath, "rb")) == NULL) return -1;
if ((ctx = rhash_init(hash_id)) == NULL) {
fclose(fd... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
andl $0x3ff, %ebp # imm = 0x3FF
je 0x617ded
movq %rdx, %rbx
leaq 0x2bec1(%rip), %rax # 0x643c60
movq %rsi, %rdi
movq %rax, %rsi
callq 0x417b0
testq %rax, %rax
je 0x617e02
movq %rax, %r14
movl %ebp, %edi
callq 0x617720
testq %rax, %rax... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/rhash.c |
rhash_init_algorithms | void rhash_init_algorithms(unsigned mask)
{
(void)mask; /* unused now */
/* verify that RHASH_HASH_COUNT is the index of the major bit of RHASH_ALL_HASHES */
assert(1 == (RHASH_ALL_HASHES >> (RHASH_HASH_COUNT - 1)));
#ifdef GENERATE_GOST94_LOOKUP_TABLE
rhash_gost94_init_table();
#endif
rhash_uninitialized_algori... | movl $0x0, 0x253a2e(%rip) # 0x86b8e0
retq
| /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/algorithms.c |
rhash_md5_init | void rhash_md5_init(md5_ctx* ctx)
{
ctx->length = 0;
/* initialize state */
ctx->hash[0] = 0x67452301;
ctx->hash[1] = 0xefcdab89;
ctx->hash[2] = 0x98badcfe;
ctx->hash[3] = 0x10325476;
} | movq $0x0, 0x40(%rdi)
movaps 0x92e75(%rip), %xmm0 # 0x6aad60
movups %xmm0, 0x48(%rdi)
retq
| /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/md5.c |
rhash_md5_update | void rhash_md5_update(md5_ctx* ctx, const unsigned char* msg, size_t size)
{
unsigned index = (unsigned)ctx->length & 63;
ctx->length += size;
/* fill partial block */
if (index) {
unsigned left = md5_block_size - index;
le32_copy((char*)ctx->message, index, msg, (size < left ? size : left));
if (size < left... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x40(%rdi), %rdi
leaq (%rdi,%rdx), %rcx
movl %edi, %eax
movq %rcx, 0x40(%r14)
andl $0x3f, %eax
je 0x617f4e
movl $0x40, %r12d
subl %eax, %r12d
andl $0x3f, %edi
addq %r14, %rdi
cmpq %rbx, %r12
movq %rbx, %rdx
cmovb... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/md5.c |
rhash_md5_process_block | static void rhash_md5_process_block(unsigned state[4], const unsigned* x)
{
register unsigned a, b, c, d;
a = state[0];
b = state[1];
c = state[2];
d = state[3];
MD5_ROUND1(a, b, c, d, x[ 0], 7, 0xd76aa478);
MD5_ROUND1(d, a, b, c, x[ 1], 12, 0xe8c7b756);
MD5_ROUND1(c, d, a, b, x[ 2], 17, 0x242070db);
MD5_ROU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r9
movq %rdi, -0x20(%rsp)
movl (%rdi), %r8d
movq %r8, -0x8(%rsp)
movl 0x4(%rdi), %r10d
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
movl %ecx, %eax
xorl %edx, %eax
andl %r10d, %eax
xorl %ecx, %eax
movq %rcx, %rsi
movq %rcx, -0x10(%rsp)
movl (%r9... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/md5.c |
rhash_md5_final | void rhash_md5_final(md5_ctx* ctx, unsigned char* result)
{
unsigned index = ((unsigned)ctx->length & 63) >> 2;
unsigned shift = ((unsigned)ctx->length & 3) * 8;
/* pad message and run for last block */
/* append the byte 0x80 to the message */
ctx->message[index] &= ~(0xFFFFFFFFu << shift);
ctx->message[inde... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x40(%rdi), %ecx
movl %ecx, %eax
shll $0x3, %ecx
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
shll %cl, %edx
movl $0x80, %edi
shll %cl, %edi
shrl $0x2, %eax
andl $0xf, %eax
notl %edx
andl (%rbx,%rax,4), %edx
movq %rsi, %r14
xorl %edx, %edi
movl %edi, (%rbx,%rax,4... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/md5.c |
rhash_sha1_update | void rhash_sha1_update(sha1_ctx* ctx, const unsigned char* msg, size_t size)
{
unsigned index = (unsigned)ctx->length & 63;
ctx->length += size;
/* fill partial block */
if (index) {
unsigned left = sha1_block_size - index;
memcpy(ctx->message + index, msg, (size < left ? size : left));
if (size < left) retu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x40(%rdi), %rdi
leaq (%rdi,%rdx), %rcx
movl %edi, %eax
movq %rcx, 0x40(%r14)
andl $0x3f, %eax
je 0x618849
movl $0x40, %r12d
subl %eax, %r12d
andl $0x3f, %edi
addq %r14, %rdi
cmpq %rbx, %r12
movq %rbx, %rdx
cmovb... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha1.c |
rhash_sha1_process_block | static void rhash_sha1_process_block(unsigned* hash, const unsigned* block)
{
int t; /* Loop counter */
uint32_t temp; /* Temporary word value */
uint32_t W[80]; /* Word sequence */
uint32_t A, B, C, D, E; /* Word buffers */
/* initialize the f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
xorl %eax, %eax
pxor %xmm0, %xmm0
movdqu (%rsi,%rax,4), %xmm1
movdqa %xmm1, %xmm2
punpckhbw %xmm0, %xmm2 # xmm2 = xmm2[8],xmm0[8],xmm2[9],xmm0[9],xmm2[10],xmm0[10],xmm2[11],xmm0[11],xmm2[12],xmm0[12],xmm2[13],xmm0[13],xmm2[14],xmm0[14... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha1.c |
rhash_sha256_init | void rhash_sha256_init(sha256_ctx* ctx)
{
/* Initial values. These words were obtained by taking the first 32
* bits of the fractional parts of the square roots of the first
* eight prime numbers. */
static const unsigned SHA256_H0[8] = {
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c,... | movq $0x0, 0x40(%rdi)
movl $0x20, 0x68(%rdi)
movaps 0xb02d6(%rip), %xmm0 # 0x6c8ed0
movups %xmm0, 0x48(%rdi)
movaps 0xb02db(%rip), %xmm0 # 0x6c8ee0
movups %xmm0, 0x58(%rdi)
retq
| /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha256.c |
rhash_sha256_process_block | static void rhash_sha256_process_block(unsigned hash[8], unsigned block[16])
{
unsigned A, B, C, D, E, F, G, H;
unsigned W[16];
const unsigned* k;
int i;
A = hash[0], B = hash[1], C = hash[2], D = hash[3];
E = hash[4], F = hash[5], G = hash[6], H = hash[7];
/* Compute SHA using alternate Method: FIPS 180-3 6.1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl (%rdi), %r12d
movl 0x4(%rdi), %r15d
movl 0x8(%rdi), %ebx
movl 0xc(%rdi), %r8d
movl 0x10(%rdi), %r14d
movl 0x14(%rdi), %r11d
movl 0x18(%rdi), %r9d
movq %rdi, 0x58(%rsp)
movl 0x1c(%rdi), %edx
movl %r14d, %eax
roll $0x1a, %eax
movl %r1... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha256.c |
rhash_sha256_final | void rhash_sha256_final(sha256_ctx* ctx, unsigned char* result)
{
size_t index = ((unsigned)ctx->length & 63) >> 2;
unsigned shift = ((unsigned)ctx->length & 3) * 8;
/* pad message and run for last block */
/* append the byte 0x80 to the message */
ctx->message[index] &= le2me_32(~(0xFFFFFFFFu << shift));
ctx... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x40(%rdi), %ecx
movl %ecx, %eax
shll $0x3, %ecx
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
shll %cl, %edx
movl $0x80, %edi
shll %cl, %edi
shrl $0x2, %eax
andl $0xf, %eax
notl %edx
andl (%rbx,%rax,4), %edx
movq %rsi, %r14
xorl %edx, %edi
movl %edi, (%rbx,%rax,4... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha256.c |
rhash_sha3_process_block | static void rhash_sha3_process_block(uint64_t hash[25], const uint64_t* block, size_t block_size)
{
/* expanded loop */
hash[ 0] ^= le2me_64(block[ 0]);
hash[ 1] ^= le2me_64(block[ 1]);
hash[ 2] ^= le2me_64(block[ 2]);
hash[ 3] ^= le2me_64(block[ 3]);
hash[ 4] ^= le2me_64(block[ 4]);
hash[ 5] ^= le2me_64(block[ ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq (%rdi), %r11
xorq (%rsi), %r11
movq 0x8(%rdi), %rax
movq %r11, (%rdi)
xorq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rdi), %r9
xorq 0x10(%rsi), %r9
movq %r9, 0x10(%rdi)
movq 0x18(%rdi), %rbp
xorq 0x18(%rsi), %rbp
movq %rbp, 0x... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha3.c |
rhash_sha3_final | void rhash_sha3_final(sha3_ctx* ctx, unsigned char* result)
{
size_t digest_length = 100 - ctx->block_size / 2;
const size_t block_size = ctx->block_size;
if (!(ctx->rest & SHA3_FINALIZED))
{
/* clear the rest of the data queue */
memset((char*)ctx->message + ctx->rest, 0, block_size - ctx->rest);
((char*)ct... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18c(%rdi), %r12d
movl %r12d, %eax
shrl %eax
movl $0x64, %r15d
subl %eax, %r15d
movslq 0x188(%rdi), %rax
testq %rax, %rax
js 0x61a9fc
leaq 0xc8(%rbx), %r13
leaq (%rbx,%rax), %rdi
addq $0xc8, %rdi
movq %r12, %rdx
subq %rax, %rdx... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha3.c |
rhash_sha512_process_block | static void rhash_sha512_process_block(uint64_t hash[8], uint64_t block[16])
{
uint64_t A, B, C, D, E, F, G, H;
uint64_t W[16];
const uint64_t* k;
int i;
A = hash[0], B = hash[1], C = hash[2], D = hash[3];
E = hash[4], F = hash[5], G = hash[6], H = hash[7];
/* Compute SHA using alternate Method: FIPS 180-3 6.1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq (%rdi), %r12
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rbx
movq 0x18(%rdi), %r11
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r10
movq 0x30(%rdi), %r9
movq %r14, %rax
rolq $0x32, %rax
movq %rdi, 0xb0(%rsp)
movq 0x38(%rdi), %rdx
movq %r14, %... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha512.c |
rhash_swap_copy_u64_to_str | void rhash_swap_copy_u64_to_str(void* to, const void* from, size_t length)
{
/* if all pointers and length are 64-bits aligned */
if ( 0 == (( (int)((char*)to - (char*)0) | ((char*)from - (char*)0) | length ) & 7) ) {
/* copy aligned memory block as 64-bit integers */
const uint64_t* src = (const uint64_t*)from;
... | movl %esi, %eax
orl %edi, %eax
movl %edx, %ecx
orl %eax, %ecx
testb $0x7, %cl
je 0x61c466
testq %rdx, %rdx
je 0x61c484
xorl %eax, %eax
movq %rax, %rcx
xorq $0x7, %rcx
movb (%rsi,%rcx), %cl
movb %cl, (%rdi,%rax)
incq %rax
cmpq %rax, %rdx
jne 0x61c44f
jmp 0x61c484
testq %rdx, %rdx
jle 0x61c484
addq %rsi, %rdx
movq (%rsi)... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/byte_order.c |
uv_timer_stop | int uv_timer_stop(uv_timer_t* handle) {
if (!uv__is_active(handle))
return 0;
heap_remove(timer_heap(handle->loop),
(struct heap_node*) &handle->heap_node,
timer_less_than);
uv__handle_stop(handle);
return 0;
} | testb $0x4, 0x58(%rdi)
je 0x61c7cb
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movl 0x210(%rcx), %edx
testl %edx, %edx
je 0x61c7ac
leaq 0x208(%rcx), %r14
leaq 0x68(%rbx), %rax
movq %r14, %r8
cmpl $0x1, %edx
je 0x61c6aa
xorl %esi, %esi
movl %edx, %r9d
xorl %edi, %edi
movl %edx, %r8d
movl %r9d, ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/timer.c |
uv__next_timeout | int uv__next_timeout(const uv_loop_t* loop) {
const struct heap_node* heap_node;
const uv_timer_t* handle;
uint64_t diff;
heap_node = heap_min(timer_heap(loop));
if (heap_node == NULL)
return -1; /* block indefinitely */
handle = container_of(heap_node, uv_timer_t, heap_node);
if (handle->timeout <=... | movq 0x208(%rdi), %rax
testq %rax, %rax
je 0x61c868
movq 0x18(%rax), %rcx
xorl %eax, %eax
subq 0x220(%rdi), %rcx
jbe 0x61c867
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpq %rax, %rcx
cmovbq %rcx, %rax
retq
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/timer.c |
uv__run_timers | void uv__run_timers(uv_loop_t* loop) {
struct heap_node* heap_node;
uv_timer_t* handle;
for (;;) {
heap_node = heap_min(timer_heap(loop));
if (heap_node == NULL)
break;
handle = container_of(heap_node, uv_timer_t, heap_node);
if (handle->timeout > loop->time)
break;
uv_timer_sto... | pushq %r15
pushq %r14
pushq %rbx
movq 0x208(%rdi), %r15
testq %r15, %r15
je 0x61c8b6
movq %rdi, %rbx
movq 0x18(%r15), %rax
cmpq 0x220(%rbx), %rax
ja 0x61c8b6
leaq -0x68(%r15), %r14
movq %r14, %rdi
callq 0x61c635
movq %r14, %rdi
callq 0x61c7ce
movq %r14, %rdi
callq *-0x8(%r15)
movq 0x208(%rbx), %r15
testq %r15, %r15
jne... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/timer.c |
uv__reallocf | void* uv__reallocf(void* ptr, size_t size) {
void* newptr;
newptr = uv__realloc(ptr, size);
if (newptr == NULL)
if (size > 0)
uv__free(ptr);
return newptr;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x61ca59
movq %rbx, %rdi
callq *0x244d34(%rip) # 0x861788
testq %rax, %rax
jne 0x61ca71
callq 0x415e0
movq %rax, %r14
movl (%rax), %ebp
movq %rbx, %rdi
callq *0x244d2c(%rip) # 0x861798
movl %ebp, (%r14)
xorl %eax, %eax
popq %rbx
popq %... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_replace_allocator | int uv_replace_allocator(uv_malloc_func malloc_func,
uv_realloc_func realloc_func,
uv_calloc_func calloc_func,
uv_free_func free_func) {
if (malloc_func == NULL || realloc_func == NULL ||
calloc_func == NULL || free_func == NULL) {
r... | movq %rsi, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0 # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_strerror | const char* uv_strerror(int err) {
switch (err) {
UV_ERRNO_MAP(UV_STRERROR_GEN)
}
return uv__unknown_err_code(err);
} | cmpl $-0x7e, %edi
jle 0x61d959
leal 0x7d(%rdi), %eax
cmpl $0x7c, %eax
ja 0x61d9d4
leaq 0xbb444(%rip), %rcx # 0x6d8d8c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xbbc3b(%rip), %rax # 0x6d9593
retq
cmpl $0xfffff043, %edi # imm = 0xFFFFF043
jle 0x61d984
leal 0xbc6(%rdi), %eax
cmpl $0xe, %eax... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_tcp_bind | int uv_tcp_bind(uv_tcp_t* handle,
const struct sockaddr* addr,
unsigned int flags) {
unsigned int addrlen;
if (handle->type != UV_TCP)
return UV_EINVAL;
if (uv__is_closing(handle)) {
return UV_EINVAL;
}
if (addr->sa_family == AF_INET)
addrlen = sizeof(struct sockad... | cmpl $0xc, 0x10(%rdi)
jne 0x61dd50
testb $0x3, 0x58(%rdi)
je 0x61dd56
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
retq
movl %edx, %ecx
movzwl (%rsi), %eax
cmpl $0x2, %eax
je 0x61dd6f
cmpl $0xa, %eax
jne 0x61dd50
movl $0x1c, %edx
jmp 0x62850f
movl $0x10, %edx
jmp 0x62850f
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_udp_connect | int uv_udp_connect(uv_udp_t* handle, const struct sockaddr* addr) {
unsigned int addrlen;
if (handle->type != UV_UDP)
return UV_EINVAL;
/* Disconnect the handle */
if (addr == NULL) {
if (!(handle->flags & UV_HANDLE_UDP_CONNECTED))
return UV_ENOTCONN;
return uv__udp_disconnect(handle);
}
... | movl $0xffffffea, %eax # imm = 0xFFFFFFEA
cmpl $0xf, 0x10(%rdi)
jne 0x61de85
testq %rsi, %rsi
je 0x61de61
movzwl (%rsi), %ecx
cmpl $0x2, %ecx
je 0x61de71
cmpl $0xa, %ecx
jne 0x61de85
movl $0x1c, %edx
jmp 0x61de76
movl $0xffffff95, %eax # imm = 0xFFFFFF95
testb $0x2, 0x5b(%rdi)
je 0x61de85
jmp 0x629ca5
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_walk | void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) {
QUEUE queue;
QUEUE* q;
uv_handle_t* h;
QUEUE_MOVE(&loop->handle_queue, &queue);
while (!QUEUE_EMPTY(&queue)) {
q = QUEUE_HEAD(&queue);
h = QUEUE_DATA(q, uv_handle_t, handle_queue);
QUEUE_REMOVE(q);
QUEUE_INSERT_TAIL(&loop->handle... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x10(%rdi), %r12
movq 0x10(%rdi), %rax
cmpq %rax, %r12
je 0x61e068
movq %rdi, %r15
movq 0x18(%rdi), %rcx
movq %rsp, %r13
movq %rcx, 0x8(%r13)
movq %r13, (%rcx)
movq %rax, (%r13)
movq 0x8(%rax), %rcx
movq %rcx, 0x18(%rdi)
movq %r12, (%rcx)
movq... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv__fs_scandir_cleanup | void uv__fs_scandir_cleanup(uv_fs_t* req) {
uv__dirent_t** dents;
unsigned int* nbufs = uv__get_nbufs(req);
dents = req->ptr;
if (*nbufs > 0 && *nbufs != (unsigned int) req->result)
(*nbufs)--;
for (; *nbufs < (unsigned int) req->result; (*nbufs)++)
uv__fs_scandir_free(dents[*nbufs]);
uv__fs_scan... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x124(%rdi), %eax
movl 0x58(%rdi), %ecx
testl %eax, %eax
je 0x61e2a1
cmpl %ecx, %eax
je 0x61e2a3
decl %eax
movl %eax, 0x124(%rbx)
jmp 0x61e2a3
xorl %eax, %eax
movq 0x60(%rbx), %r14
cmpl %ecx, %eax
jae 0x61e2cd
movl %eax, %eax
movq (%r14,%rax,8), %rdi
callq 0x41e70
m... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_fs_scandir_next | int uv_fs_scandir_next(uv_fs_t* req, uv_dirent_t* ent) {
uv__dirent_t** dents;
uv__dirent_t* dent;
unsigned int* nbufs;
/* Check to see if req passed */
if (req->result < 0)
return req->result;
/* Ptr will be null if req was canceled or no files found */
if (!req->ptr)
return UV_EOF;
nbufs = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x58(%rdi), %rax
testq %rax, %rax
js 0x61e32c
movq %rdi, %r14
movq 0x60(%rdi), %r15
movl $0xfffff001, %ebp # imm = 0xFFFFF001
testq %r15, %r15
je 0x61e369
movq %rsi, %rbx
movl 0x124(%r14), %ecx
testl %ecx, %ecx
je 0x61e330
decl %ecx
movq (%r15,%rcx,8), %... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv__fs_get_dirent_type | uv_dirent_type_t uv__fs_get_dirent_type(uv__dirent_t* dent) {
uv_dirent_type_t type;
#ifdef HAVE_DIRENT_TYPES
switch (dent->d_type) {
case UV__DT_DIR:
type = UV_DIRENT_DIR;
break;
case UV__DT_FILE:
type = UV_DIRENT_FILE;
break;
case UV__DT_LINK:
type = UV_DIRENT_LINK;
... | movb 0x12(%rdi), %cl
decb %cl
xorl %eax, %eax
cmpb $0xb, %cl
ja 0x61e38f
movzbl %cl, %eax
leaq 0xbad04(%rip), %rcx # 0x6d9090
movl (%rcx,%rax,4), %eax
retq
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv__fs_readdir_cleanup | void uv__fs_readdir_cleanup(uv_fs_t* req) {
uv_dir_t* dir;
uv_dirent_t* dirents;
int i;
if (req->ptr == NULL)
return;
dir = req->ptr;
dirents = dir->dirents;
req->ptr = NULL;
if (dirents == NULL)
return;
for (i = 0; i < req->result; ++i) {
uv__free((char*) dirents[i].name);
dirents... | movq 0x60(%rdi), %rax
testq %rax, %rax
je 0x61e3f0
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rax), %r15
movq $0x0, 0x60(%rdi)
testq %r15, %r15
je 0x61e3e8
cmpq $0x0, 0x58(%rbx)
jle 0x61e3e8
callq 0x415e0
movq %rax, %r14
movl (%rax), %ebp
xorl %r12d, %r12d
movq (%r15), %rdi
callq *0x2... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_loop_configure | int uv_loop_configure(uv_loop_t* loop, uv_loop_option option, ...) {
va_list ap;
int err;
va_start(ap, option);
/* Any platform-agnostic options should be handled here. */
err = uv__loop_configure(loop, option, ap);
va_end(ap);
return err;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x61e448
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... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_default_loop | uv_loop_t* uv_default_loop(void) {
if (default_loop_ptr != NULL)
return default_loop_ptr;
if (uv_loop_init(&default_loop_struct))
return NULL;
default_loop_ptr = &default_loop_struct;
return default_loop_ptr;
} | pushq %rbx
movq 0x24d46b(%rip), %rbx # 0x86b8e8
testq %rbx, %rbx
jne 0x61e4a0
leaq 0x24d467(%rip), %rbx # 0x86b8f0
movq %rbx, %rdi
callq 0x623ff0
testl %eax, %eax
je 0x61e499
xorl %ebx, %ebx
jmp 0x61e4a0
movq %rbx, 0x24d448(%rip) # 0x86b8e8
movq %rbx, %rax
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_loop_new | uv_loop_t* uv_loop_new(void) {
uv_loop_t* loop;
loop = uv__malloc(sizeof(*loop));
if (loop == NULL)
return NULL;
if (uv_loop_init(loop)) {
uv__free(loop);
return NULL;
}
return loop;
} | pushq %rbp
pushq %r14
pushq %rbx
movl $0x350, %edi # imm = 0x350
callq *0x2432cc(%rip) # 0x861780
testq %rax, %rax
je 0x61e4de
movq %rax, %rbx
movq %rax, %rdi
callq 0x623ff0
testl %eax, %eax
je 0x61e4e0
callq 0x415e0
movq %rax, %r14
movl (%rax), %ebp
movq %rbx, %rdi
callq *0x2432bd(%rip) # 0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_free_cpu_info | void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) {
int i;
for (i = 0; i < count; i++)
uv__free(cpu_infos[i].model);
uv__free(cpu_infos);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x415e0
movq %rax, %r14
testl %ebp, %ebp
jle 0x61e676
movl %ebp, %eax
movl (%r14), %ebp
imulq $0x38, %rax, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
callq *0x24312e(%rip) # 0x861798
movl %ebp, (%r14)
addq $0x38, %r1... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_library_shutdown | __attribute__((destructor))
#endif
void uv_library_shutdown(void) {
static int was_shutdown;
if (uv__load_relaxed(&was_shutdown))
return;
uv__process_title_cleanup();
uv__signal_cleanup();
#ifdef __MVS__
/* TODO(itodorov) - zos: revisit when Woz compiler is available. */
uv__os390_cleanup();
#else
u... | cmpb $0x0, 0x24d5ab(%rip) # 0x86bc40
jne 0x61e6b2
pushq %rax
callq 0x62d7de
callq 0x625940
callq 0x62e510
movb $0x1, 0x24d592(%rip) # 0x86bc40
addq $0x8, %rsp
retq
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_async_init | int uv_async_init(uv_loop_t* loop, uv_async_t* handle, uv_async_cb async_cb) {
int err;
err = uv__async_start(loop);
if (err)
return err;
uv__handle_init(loop, (uv_handle_t*)handle, UV_ASYNC);
handle->async_cb = async_cb;
handle->pending = 0;
QUEUE_INSERT_TAIL(&loop->async_handles, &handle->queue);... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x61e804
testl %eax, %eax
jne 0x61e7fe
movq %r14, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
leaq 0x10(%r14), %rcx
leaq 0x20(%rbx), %rdx
movq %rcx, 0x20(%rbx)
movq 0x18(%r14), %rcx
movq %rcx, 0x28(%rbx)
movq %rdx, (%rcx)
movq %rdx, 0x18(%r14)
m... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/async.c |
uv__async_start | static int uv__async_start(uv_loop_t* loop) {
int pipefd[2];
int err;
if (loop->async_io_watcher.fd != -1)
return 0;
#ifdef __linux__
err = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
if (err < 0)
return UV__ERR(errno);
pipefd[0] = err;
pipefd[1] = -1;
#else
err = uv__make_pipe(pipefd, UV_NONBLOC... | pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpl $-0x1, 0x1f8(%rdi)
jne 0x61e867
movq %rdi, %r14
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x80800, %esi # imm = 0x80800
callq 0x41d30
testl %eax, %eax
js 0x61e85e
leaq 0x1c8(%r14), %r15
leaq 0x1ca(%rip), %rsi # 0x61ea01
movq %r15, %rdi
movl %eax, %edx
cal... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/async.c |
uv_async_send | int uv_async_send(uv_async_t* handle) {
/* Do a cheap read first. */
if (ACCESS_ONCE(int, handle->pending) != 0)
return 0;
/* Tell the other thread we're busy with the handle. */
if (cmpxchgi(&handle->pending, 0, 1) != 0)
return 0;
/* Wake up the other thread's event loop. */
uv__async_send(handle... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x78(%rdi)
jne 0x61e907
movq %rdi, %rbx
movl $0x1, %ecx
xorl %eax, %eax
lock
cmpxchgl %ecx, 0x78(%rdi)
testl %eax, %eax
jne 0x61e907
movq 0x8(%rbx), %rax
movl 0x200(%rax), %ebp
cmpl $-0x1, %ebp
je 0x61e8b1
leaq 0xa07a0(%rip), %r15 # 0x6bf049
movl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/async.c |
uv__async_stop | void uv__async_stop(uv_loop_t* loop) {
if (loop->async_io_watcher.fd == -1)
return;
if (loop->async_wfd != -1) {
if (loop->async_wfd != loop->async_io_watcher.fd)
uv__close(loop->async_wfd);
loop->async_wfd = -1;
}
uv__io_stop(loop, &loop->async_io_watcher, POLLIN);
uv__close(loop->async_i... | movl 0x1f8(%rdi), %eax
cmpl $-0x1, %eax
je 0x61ea00
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1c8(%rdi), %r14
movl 0x200(%rdi), %edi
cmpl $-0x1, %edi
je 0x61e9d4
cmpl %eax, %edi
je 0x61e9ca
callq 0x61f25b
movl $0xffffffff, 0x200(%rbx) # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
call... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/async.c |
uv__nonblock_ioctl | int uv__nonblock_ioctl(int fd, int set) {
int r;
do
r = ioctl(fd, FIONBIO, &set);
while (r == -1 && errno == EINTR);
if (r)
return UV__ERR(errno);
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4(%rsp), %r14
movl %esi, (%r14)
movl $0x5421, %esi # imm = 0x5421
movl %ebx, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3f3d0
cmpl $-0x1, %eax
jne 0x61f1fe
callq 0x415e0
cmpl $0x4, (%rax)
je 0x61f1dc
jmp 0x61f207
testl %eax, %eax
je 0x61f20e
callq 0x41... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__read_start | int uv__read_start(uv_stream_t* stream,
uv_alloc_cb alloc_cb,
uv_read_cb read_cb) {
assert(stream->type == UV_TCP || stream->type == UV_NAMED_PIPE ||
stream->type == UV_TTY);
/* The UV_HANDLE_READING flag is irrelevant of the state of the stream - it
* just expresses ... | pushq %rbx
movl 0x10(%rdi), %eax
cmpl $0xe, %eax
ja 0x628078
movl $0x5080, %ecx # imm = 0x5080
btl %eax, %ecx
jae 0x628078
movq %rdi, %rbx
movl $0xffffe7ff, %eax # imm = 0xFFFFE7FF
andl 0x58(%rdi), %eax
orl $0x1000, %eax # imm = 0x1000
movl %eax, 0x58(%rdi)
cmpl $0x0, 0xb8(%rdi)
js 0x62803a
te... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv__stream_close | void uv__stream_close(uv_stream_t* handle) {
unsigned int i;
uv__stream_queued_fds_t* queued_fds;
#if defined(__APPLE__) && !defined(CMAKE_BOOTSTRAP)
/* Terminate select loop first */
if (handle->select != NULL) {
uv__stream_select_t* s;
s = handle->select;
uv_sem_post(&s->close_sem);
uv_sem_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x88(%r14), %rbx
movq %rbx, %rsi
callq 0x61f8bd
movq %r14, %rdi
callq 0x628097
movl 0x58(%r14), %ecx
testb $0x4, %cl
jne 0x62812d
movl %ecx, %eax
jmp 0x62813e
movl %ecx, %eax
andl $-0x5, %eax
testb $0x8, %cl
je 0x62813e
mov... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv__write_req_finish | static void uv__write_req_finish(uv_write_t* req) {
uv_stream_t* stream = req->handle;
/* Pop the req off tcp->write_queue. */
QUEUE_REMOVE(&req->queue);
/* Only free when there was no error. On error, we touch up write_queue_size
* right before making the callback. The reason we don't do that right away
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x50(%rdi), %rbx
movq 0x58(%rdi), %rax
leaq 0x58(%rdi), %r15
movq 0x60(%rdi), %rcx
movq %rax, (%rcx)
movq 0x60(%rdi), %rcx
movq %rcx, 0x8(%rax)
cmpl $0x0, 0x7c(%rdi)
jne 0x6282c5
movq 0x70(%r14), %rdi
leaq 0x80(%r14), %rax
cmpq %rax, %rdi
je 0x6282bd
callq 0x61c9db
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.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.