name string | code string | asm string | file string |
|---|---|---|---|
ZSTD_encodeSequences | size_t ZSTD_encodeSequences(
void* dst, size_t dstCapacity,
FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
seqDef const* ... | movq $-0x46, %rax
cmpq $0x9, %rsi
jb 0x4f16d4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r11
movzwl (%rdx), %r10d
leal -0x1(%r10), %ecx
movl $0x1, %eax
shll %cl, %eax
movq 0x50(%rsp), %rbp
movq %r11, -0x8(%rsp)
movzbl -0x1(%r11,%rbp), %r12d
movq %r10, -0x30(%rsp)
testl %r10d, %r10d
cl... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_sequences.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_generateSequences | size_t ZSTD_ldm_generateSequences(
ldmState_t* ldmState, rawSeqStore_t* sequences,
ldmParams_t const* params, void const* src, size_t srcSize)
{
U32 const maxDist = 1U << params->windowLog;
BYTE const* const istart = (BYTE const*)src;
BYTE const* const iend = istart + srcSize;
size_t con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r8, %r9
movq %rcx, %r11
movb 0x14(%rdx), %cl
movl $0x1, %r8d
shll %cl, %r8d
movq %r9, %rax
shrq $0x14, %rax
xorl %ecx, %ecx
testl $0xfffff, %r9d # imm = 0xFFFFF
setne %cl
addq %rax, %rcx
movq %rcx... | /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 0x53e035
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %r8
leaq (%rax,%rax,2), %rcx
leaq 0x4(,%rcx,4), %rcx
cmpq %r8, %rax
jae 0x53e035
movq (%rdi), %r9
movl (%r9,%rcx), %r11d
movq %rsi, %r10
subq %r11, %r10
jbe 0x53e036
movl $0x0, (%r9,%rcx)
movl 0x4(%r9,%rcx), %esi
cmpq %rsi, %r10
jb 0x53e03e
incq %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_count_2segments | MEM_STATIC size_t
ZSTD_count_2segments(const BYTE* ip, const BYTE* match,
const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart)
{
const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
size_t const matchLength = ZSTD_count(ip, match, vEnd);
if (match + matchLength != mEnd) return m... | pushq %r14
pushq %rbx
movq %rcx, %r9
subq %rsi, %r9
addq %rdi, %r9
cmpq %rdx, %r9
cmovaeq %rdx, %r9
leaq -0x7(%r9), %r11
movq %rsi, %r10
movq %rdi, %rax
cmpq %rdi, %r11
jbe 0x5626a0
movq (%rsi), %rax
movq (%rdi), %r10
cmpq %r10, %rax
jne 0x562684
leaq 0x8(%rdi), %rax
xorl %ebx, %ebx
leaq (%rax,%rbx), %r14
cmpq %r11, %r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_rescaleFreqs | static void
ZSTD_rescaleFreqs(optState_t* const optPtr,
const BYTE* const src, size_t const srcSize,
int const optLevel)
{
int const compressedLiterals = ZSTD_compressedLiterals(optPtr);
DEBUGLOG(5, "ZSTD_rescaleFreqs (srcSize=%u)", (unsigned)srcSize);
optPtr->priceType = zop_d... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
movl 0x60(%rdi), %esi
movl $0x0, 0x50(%rdi)
cmpl $0x0, 0x34(%rdi)
je 0x562969
cmpl $0x2, %esi
je 0x5628b3
movq (%r14), %rax
pxor %xmm0, %xmm0
xorl %ecx, %ecx
pcmpeqd %xmm1, %xmm1
movdqu (%rax,%rcx,4), ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_frameHeaderSize_internal | static size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZSTD_format_e format)
{
size_t const minInputSize = ZSTD_startingInputLength(format);
RETURN_ERROR_IF(srcSize < minInputSize, srcSize_wrong, "");
{ BYTE const fhd = ((const BYTE*)src)[minInputSize-1];
U32 const dictID= f... | xorl %eax, %eax
testl %edx, %edx
sete %al
leaq 0x1(,%rax,4), %rcx
movq $-0x48, %rax
cmpq %rsi, %rcx
ja 0x563353
movzbl -0x1(%rdi,%rcx), %eax
movl %eax, %edx
andl $0x3, %edx
movl %eax, %esi
andl $0x20, %esi
movl %esi, %edi
shrl $0x5, %edi
leaq 0xc16bb(%rip), %r8 # 0x6249e0
movl %eax, %r9d
shrl $0x3, %r9d
andl $0x18... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_nextInputType | ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {
switch(dctx->stage)
{
default: /* should not happen */
assert(0);
case ZSTDds_getFrameHeaderSize:
case ZSTDds_decodeFrameHeader:
return ZSTDnit_frameHeader;
case ZSTDds_decodeBlockHeader:
return ZSTDnit_blockHea... | movl 0x7524(%rdi), %ecx
addl $-0x2, %ecx
xorl %eax, %eax
cmpl $0x5, %ecx
ja 0x563e69
movl %ecx, %eax
leaq 0xc0b56(%rip), %rcx # 0x6249bc
movl (%rcx,%rax,4), %eax
retq
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_DCtx_loadDictionary_advanced | size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType)
{
RETURN_ERROR_IF(dctx->stre... | movq $-0x3c, %rax
cmpl $0x0, 0x760c(%rdi)
je 0x5649a2
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x75e0(%rdi), %rdi
callq 0x56f77a
movl $0x0, 0x75f8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x75e0(%rbx)... | /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 0x564e52
leaq 0xbf734(%rip), %rcx # 0x624570
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $0x100000000, %rdx # imm = 0x100000000
xorl %eax, %eax
retq
cmpl $0x64, %edi
jne 0x564e63
movabsq $0x1f0000000a, %rdx # imm = 0x1F0000000A
jmp 0x564e4f
movq ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_estimateDStreamSize_fromFrame | size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
{
U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX; /* note : should be user-selectable, but requires an additional parameter (or a dctx) */
ZSTD_frameHeader zfh;
size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize);
if... | subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rdi
xorl %ecx, %ecx
callq 0x563354
cmpq $-0x78, %rax
ja 0x565075
movq %rax, %rcx
movq $-0x48, %rax
testq %rcx, %rcx
jne 0x565075
movq 0x8(%rsp), %rcx
movq $-0x10, %rax
movl $0x80000000, %edx # imm = 0x80000000
cmpq %rdx, %rcx
ja 0x565075
movl $0x20000, ... | /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 0x56f8f8
movl %eax, %ebp
leaq 0xc(%rsp), %rdi
movl %eax, (%rdi)
movl $0x4, %esi
xorl %edx, %edx
callq 0x56796a
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 |
FSE_readNCount_bmi2 | size_t FSE_readNCount_bmi2(
short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
const void* headerBuffer, size_t hbSize, int bmi2)
{
#if DYNAMIC_BMI2
if (bmi2) {
return FSE_readNCount_body_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
}
#endif
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r13
movq %rdi, %r12
cmpq $0x7, %r8
ja 0x565ca1
leaq 0x10(%rsp), %rbp
movq $0x0, (%rbp)
movq %rbp, %rdi
movq %rsi, %rbx
movq %r14, %rsi
movq %r15, %rdx
callq 0x39260
movl $0x8, %r8d
movq %r12, %r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/entropy_common.c |
FSE_buildDTable_rle | size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
{
void* ptr = dt;
FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
void* dPtr = dt + 1;
FSE_decode_t* const cell = (FSE_decode_t*)dPtr;
DTableH->tableLog = 0;
DTableH->fastMode = 0;
cell->newState = 0;
cell->symbol ... | movl $0x0, (%rdi)
movw $0x0, 0x4(%rdi)
movb %sil, 0x6(%rdi)
movb $0x0, 0x7(%rdi)
xorl %eax, %eax
retq
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/fse_decompress.c |
XXH64_reset | XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
{
XXH64_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
ZSTD_memset(&state, 0, sizeof(state)-8); /* do not write into reserved, for future removal */
state.v1 = seed... | movabsq $0x60ea27eeadc0b5d6, %rax # imm = 0x60EA27EEADC0B5D6
addq %rsi, %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
addq %rsi, %rcx
movabsq $0x61c8864e7a143579, %rdx # imm = 0x61C8864E7A143579
addq %rsi, %rdx
xorl %r8d, %r8d
movq %r8, (%rdi)
movq %rax, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %rsi, 0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/xxhash.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 0x56aecc
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_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 0x56b36b
cmpl $0x2, %eax
jne 0x56b375
shll $0x4, %ecx
orl $0x5, %ecx
movw %cx, (%rdi)
jmp 0x56b37c
shll $0x4, %ecx
orl $0xd, %ecx
movl %ecx, (%rdi)
jmp 0x56b37c
shlb $0x3, %cl
incb %cl
mo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_literals.c |
ZSTD_compressLiterals | size_t ZSTD_compressLiterals (ZSTD_hufCTables_t const* prevHuf,
ZSTD_hufCTables_t* nextHuf,
ZSTD_strategy strategy, int disableLiteralCompression,
void* dst, size_t dstCapacity,
const void* src, size_t srcS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x30(%rsp)
movq %r8, 0x18(%rsp)
movl %ecx, 0x8(%rsp)
movl %edx, %r15d
movq %rdi, %r8
movl 0xb0(%rsp), %eax
movq %rax, 0x48(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x98(%rsp), %r14
leal -0x1(%r15), %eax
cmpl $0x8,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_literals.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 0x56f56d
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x7528(%rdi)
leaq 0x18(%rsi), %rax... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_ddict.c |
rhash_reset | RHASH_API void rhash_reset(rhash ctx)
{
rhash_context_ext* const ectx = (rhash_context_ext*)ctx;
unsigned i;
assert(ectx->hash_vector_size > 0);
assert(ectx->hash_vector_size <= RHASH_HASH_COUNT);
ectx->state = STATE_ACTIVE; /* re-activate the structure */
/* re-initialize every hash in a loop */
for (i = 0; i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x10(%rdi), %eax
testl %eax, %eax
je 0x572455
cmpl $0xb, %eax
jae 0x572474
movq %rdi, %rbx
movl $0xb01dbabe, 0x18(%rdi) # imm = 0xB01DBABE
leaq 0x40(%rdi), %r14
xorl %r15d, %r15d
movq -0x8(%r14), %r12
movq 0x30(%r12), %rax
testq %rax, %rax
je 0x572408
movq (%r... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/rhash.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_sha3_update | void rhash_sha3_update(sha3_ctx* ctx, const unsigned char* msg, size_t size)
{
size_t index = (size_t)ctx->rest;
size_t block_size = (size_t)ctx->block_size;
if (ctx->rest & SHA3_FINALIZED) return; /* too late for additional input */
ctx->rest = (unsigned)((ctx->rest + size) % block_size);
/* fill partial block ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x188(%rdi), %ecx
testl %ecx, %ecx
js 0x574c60
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x18c(%rdi), %r12d
leaq (%rcx,%rdx), %rax
xorl %edx, %edx
divq %r12
movl %edx, 0x188(%rdi)
testq %rcx, %rcx
je 0x574bf6
movq %r12, %r13
su... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha3.c |
rhash_sha512_final | void rhash_sha512_final(sha512_ctx* ctx, unsigned char* result)
{
size_t index = ((unsigned)ctx->length & 127) >> 3;
unsigned shift = ((unsigned)ctx->length & 7) * 8;
/* pad message and process the last block */
/* append the byte 0x80 to the message */
ctx->message[index] &= le2me_64( ~(I64(0xFFFFFFFFFFFFFFFF... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x80(%rdi), %ecx
movl %ecx, %edx
shrl $0x3, %edx
andl $0xf, %edx
shll $0x3, %ecx
movq $-0x1, %rax
shlq %cl, %rax
notq %rax
andq (%rdi,%rdx,8), %rax
movl $0x80, %esi
shlq %cl, %rsi
xorq %rax, %rsi
movq %rsi, (%rdi,%rdx,8)
leaq 0x1(%rdx), %rax
cmpl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha512.c |
rhash_swap_copy_str_to_u64 | void rhash_swap_copy_str_to_u64(void* to, int index, 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) | index | length ) & 7) ) {
/* copy aligned memory block as 64-bit integers */
const uint64_t* src = (con... | movslq %esi, %rax
movl %edi, %esi
orl %edx, %esi
movl %eax, %r8d
orl %ecx, %r8d
orl %esi, %r8d
testb $0x7, %r8b
je 0x576dd9
addq %rax, %rcx
cmpq %rax, %rcx
jbe 0x576dfa
movq %rax, %rsi
shlq $0x20, %rsi
movabsq $0x100000000, %r8 # imm = 0x100000000
movb (%rdx), %r9b
incq %rdx
movq %rsi, %r10
sarq $0x20, %r10
xorq ... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/byte_order.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 0x576e26
testq %rdx, %rdx
je 0x576e44
xorl %eax, %eax
movq %rax, %rcx
xorq $0x7, %rcx
movb (%rsi,%rcx), %cl
movb %cl, (%rdi,%rax)
incq %rax
cmpq %rax, %rdx
jne 0x576e0f
jmp 0x576e44
testq %rdx, %rdx
jle 0x576e44
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 0x57718b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movl 0x210(%rcx), %edx
testl %edx, %edx
je 0x57716c
leaq 0x208(%rcx), %r14
leaq 0x68(%rbx), %rax
movq %r14, %r8
cmpl $0x1, %edx
je 0x57706a
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 0x577228
movq 0x18(%rax), %rcx
xorl %eax, %eax
subq 0x220(%rdi), %rcx
jbe 0x577227
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_ip6_addr | int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr) {
char address_part[40];
size_t address_part_size;
const char* zone_index;
memset(addr, 0, sizeof(*addr));
addr->sin6_family = AF_INET6;
addr->sin6_port = htons(port);
#ifdef SIN6_LEN
addr->sin6_len = sizeof(*addr);
#endif
zone_index... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdx)
movq $0x0, 0x14(%rdx)
movw $0xa, (%rdx)
rolw $0x8, %si
movw %si, 0x2(%rdx)
movl $0x25, %esi
callq 0x3a240
testq %rax, %rax
je 0x578685
movq %rax, %r15
subq %r14, %rax
cmpq $... | /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 0x578710
testb $0x3, 0x58(%rdi)
je 0x578716
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
retq
movl %edx, %ecx
movzwl (%rsi), %eax
cmpl $0x2, %eax
je 0x57872f
cmpl $0xa, %eax
jne 0x578710
movl $0x1c, %edx
jmp 0x582ecf
movl $0x10, %edx
jmp 0x582ecf
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_tcp_connect | int uv_tcp_connect(uv_connect_t* req,
uv_tcp_t* handle,
const struct sockaddr* addr,
uv_connect_cb cb) {
unsigned int addrlen;
if (handle->type != UV_TCP)
return UV_EINVAL;
if (addr->sa_family == AF_INET)
addrlen = sizeof(struct sockaddr_in);
el... | cmpl $0xc, 0x10(%rsi)
jne 0x5787ed
movq %rcx, %r8
movzwl (%rdx), %eax
cmpl $0x2, %eax
je 0x5787f3
cmpl $0xa, %eax
jne 0x5787ed
movl $0x1c, %ecx
jmp 0x582ff0
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
retq
movl $0x10, %ecx
jmp 0x582ff0
| /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 0x578cec
movq %rdi, %r14
movq 0x60(%rdi), %r15
movl $0xfffff001, %ebp # imm = 0xFFFFF001
testq %r15, %r15
je 0x578d29
movq %rsi, %rbx
movl 0x124(%r14), %ecx
testl %ecx, %ecx
je 0x578cf0
decl %ecx
movq (%r15,%rcx,8), %... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_os_free_environ | void uv_os_free_environ(uv_env_item_t* envitems, int count) {
int i;
for (i = 0; i < count; i++) {
uv__free(envitems[i].name);
}
uv__free(envitems);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3b610
movq %rax, %r14
testl %ebp, %ebp
jle 0x578fe3
movl %ebp, %r15d
movl (%r14), %ebp
shlq $0x4, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
callq *0x210081(%rip) # 0x789058
movl %ebp, (%r14)
addq $0x10, %r12
cmpq ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_close | void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
assert(!uv__is_closing(handle));
handle->flags |= UV_HANDLE_CLOSING;
handle->close_cb = close_cb;
switch (handle->type) {
case UV_NAMED_PIPE:
uv__pipe_close((uv_pipe_t*)handle);
break;
case UV_TTY:
uv__stream_close((uv_stream_t*)handl... | pushq %rbx
movl 0x58(%rdi), %eax
testb $0x3, %al
jne 0x5795c0
movq %rdi, %rbx
orl $0x1, %eax
movl %eax, 0x58(%rdi)
movq %rsi, 0x18(%rdi)
movl 0x10(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x5795df
leaq 0xae57b(%rip), %rcx # 0x627aa0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x5792d... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__open_file | FILE* uv__open_file(const char* path) {
int fd;
FILE* fp;
fd = uv__open_cloexec(path, O_RDONLY);
if (fd < 0)
return NULL;
fp = fdopen(fd, "r");
if (fp == NULL)
uv__close(fd);
return fp;
} | pushq %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x579c7f
testl %eax, %eax
js 0x579c75
movl %eax, %ebp
leaq 0x695b7(%rip), %rsi # 0x5e3214
movl %eax, %edi
callq 0x39200
movq %rax, %rbx
testq %rax, %rax
jne 0x579c75
movl %ebp, %edi
callq 0x579c1b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__accept | int uv__accept(int sockfd) {
int peerfd;
int err;
(void) &err;
assert(sockfd >= 0);
do
#ifdef uv__accept4
peerfd = uv__accept4(sockfd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
#else
peerfd = accept(sockfd, NULL, NULL);
#endif
while (peerfd == -1 && errno == EINTR);
if (peerfd == -1)
return ... | pushq %rbx
testl %edi, %edi
js 0x579ccb
movl %edi, %ebx
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
movl $0x80800, %ecx # imm = 0x80800
callq 0x39c50
cmpl $-0x1, %eax
jne 0x579cc9
callq 0x3b610
movl (%rax), %eax
cmpl $0x4, %eax
je 0x579ca6
negl %eax
popq %rbx
retq
leaq 0xadfb4(%rip), %rdi # 0x627c86
le... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv_os_tmpdir | int uv_os_tmpdir(char* buffer, size_t* size) {
const char* buf;
size_t len;
if (buffer == NULL || size == NULL || *size == 0)
return UV_EINVAL;
#define CHECK_ENV_VAR(name) \
do { \
... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
jne 0x57a819
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %r13
testq %r13, %r13
je 0x57a810
movq %rdi, %r14
leaq 0x98f3f(%rip), %rdi # 0x6136d7
callq 0x3ab20
testq ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv_os_getpriority | int uv_os_getpriority(uv_pid_t pid, int* priority) {
int r;
if (priority == NULL)
return UV_EINVAL;
errno = 0;
r = getpriority(PRIO_PROCESS, (int) pid);
if (r == -1 && errno != 0)
return UV__ERR(errno);
*priority = r;
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x57aa89
movq %rsi, %rbx
movl %edi, %r15d
callq 0x3b610
movq %rax, %r14
movl $0x0, (%rax)
xorl %ebp, %ebp
xorl %edi, %edi
movl %r15d, %esi
callq 0x39fd0
cmpl $-0x1, %eax
je 0x57aa90
movl %eax, (%rbx)
jmp 0x57aa9b
movl $0xffffffea, %ebp # i... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv_fs_rmdir | int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
INIT(RMDIR);
PATH;
POST;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x57daf9
movq %rsi, %rbx
movq %rdi, %r14
movl $0x6, 0x8(%rsi)
movl $0x12, 0x40(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsi)
movq %rdi, 0x48(%rsi)
xorl %eax, %eax
movq %rax, 0x68(%rsi)
movq %rax, 0x110(%rsi)
movq %rax, 0x128(%rsi)
movq %rcx, 0x50(%rsi)
testq %rdx... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv__pipe_listen | int uv__pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
if (uv__stream_fd(handle) == -1)
return UV_EINVAL;
if (handle->ipc)
return UV_EINVAL;
#if defined(__MVS__) || defined(__PASE__)
/* On zOS, backlog=0 has undefined behaviour */
/* On IBMi PASE, backlog=0 leads to "Connection ref... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xb8(%rdi), %edi
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
cmpl $-0x1, %edi
je 0x57efbc
cmpl $0x0, 0xf8(%rbx)
jne 0x57efbc
movq %rdx, %r14
callq 0x3bb20
testl %eax, %eax
je 0x57ef90
callq 0x3b610
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
jmp 0x57efbc
l... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/pipe.c |
uv__poll_stop | static void uv__poll_stop(uv_poll_t* handle) {
uv__io_stop(handle->loop,
&handle->io_watcher,
POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
uv__handle_stop(handle);
uv__platform_invalidate_fd(handle->loop, handle->io_watcher.fd);
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x68(%rbx), %rsi
movl $0x2007, %edx # imm = 0x2007
callq 0x57a167
movl 0x58(%rbx), %eax
testb $0x4, %al
jne 0x57f647
movq 0x8(%rbx), %rdi
jmp 0x57f65a
movl %eax, %ecx
andl $-0x5, %ecx
movl %ecx, 0x58(%rbx)
movq 0x8(%rbx), %rdi
testb $0x8, %al
je 0x57f65a
de... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/poll.c |
uv__signal_global_init | static void uv__signal_global_init(void) {
if (uv__signal_lock_pipefd[0] == -1)
/* pthread_atfork can register before and after handlers, one
* for each child. This only registers one for the child. That
* state is both persistent and cumulative, so if we keep doing
* it the handler functions will ... | pushq %rax
cmpl $-0x1, 0x208d0e(%rip) # 0x789060
jne 0x580368
leaq 0xb3a(%rip), %rdx # 0x580e95
xorl %edi, %edi
xorl %esi, %esi
callq 0x593cb0
testl %eax, %eax
jne 0x58036e
popq %rax
jmp 0x580e95
callq 0x3aab0
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/signal.c |
uv__drain | static void uv__drain(uv_stream_t* stream) {
uv_shutdown_t* req;
int err;
assert(QUEUE_EMPTY(&stream->write_queue));
if (!(stream->flags & UV_HANDLE_CLOSING)) {
uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT);
uv__stream_osx_interrupt_select(stream);
}
if (!(stream->flags & UV_HANDLE_SHUTT... | pushq %r14
pushq %rbx
pushq %rax
leaq 0xc0(%rdi), %rax
cmpq 0xc0(%rdi), %rax
jne 0x581f1a
movq %rdi, %rbx
movl 0x58(%rdi), %eax
testb $0x1, %al
jne 0x581e7c
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %rsi
movl $0x4, %edx
callq 0x57a167
movl 0x58(%rbx), %eax
btl $0x8, %eax
jae 0x581f12
movq 0x80(%rbx), %r14
testq %r14, %r14
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv_tcp_keepalive | int uv_tcp_keepalive(uv_tcp_t* handle, int on, unsigned int delay) {
int err;
if (uv__stream_fd(handle) != -1) {
err =uv__tcp_keepalive(uv__stream_fd(handle), on, delay);
if (err)
return err;
}
if (on)
handle->flags |= UV_HANDLE_TCP_KEEPALIVE;
else
handle->flags &= ~UV_HANDLE_TCP_KEEPA... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0xb8(%rdi), %edi
cmpl $-0x1, %edi
je 0x58342d
movl %ebp, %esi
callq 0x583311
testl %eax, %eax
jne 0x583446
xorl %eax, %eax
testl %ebp, %ebp
setne %al
movl $0xfdffffff, %ecx # imm = 0xFDFFFFFF
andl 0x58(%rbx), %ecx
shll $0x19, %eax
orl %ecx, %ea... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv_thread_create_ex | int uv_thread_create_ex(uv_thread_t* tid,
const uv_thread_options_t* params,
void (*entry)(void *arg),
void *arg) {
int err;
pthread_attr_t* attr;
pthread_attr_t attr_storage;
size_t pagesize;
size_t stack_size;
size_t min_stack_size;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
testb $0x1, (%rsi)
je 0x583645
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x583645
callq 0x3ba90
movslq %eax, %r12
leaq (%r12,%r13), %rax
decq %rax
negq %r12
andq %rax, %r12
callq 0x5835ba
cmpq %rax, %r... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv_sem_post | void uv_sem_post(uv_sem_t* sem) {
if (platform_needs_custom_semaphore)
uv__custom_sem_post(sem);
else
uv__sem_post(sem);
} | pushq %rbx
cmpl $0x0, 0x20fa6e(%rip) # 0x7933e4
je 0x5839ab
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0x398c0
testl %eax, %eax
jne 0x5839b6
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x58(%rbx)
testl %eax, %eax
jne 0x5839a1
leaq 0x28(%rbx), %rdi
callq 0x3a990
testl %eax, %eax
jne 0x5839b6
movq %rbx, %rdi
ca... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv__udp_run_completed | static void uv__udp_run_completed(uv_udp_t* handle) {
uv_udp_send_t* req;
QUEUE* q;
assert(!(handle->flags & UV_HANDLE_UDP_PROCESSING));
handle->flags |= UV_HANDLE_UDP_PROCESSING;
while (!QUEUE_EMPTY(&handle->write_completed_queue)) {
q = QUEUE_HEAD(&handle->write_completed_queue);
QUEUE_REMOVE(q);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x58(%rdi), %eax
btl $0x18, %eax
jb 0x5843b7
movq %rdi, %rbx
orl $0x1000000, %eax # imm = 0x1000000
movl %eax, 0x58(%rdi)
leaq 0xc8(%rdi), %r15
movq 0xc8(%rdi), %r14
cmpq %r14, %r15
je 0x584324
xorl %ebp, %ebp
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__set_reuse | static int uv__set_reuse(int fd) {
int yes;
yes = 1;
#if defined(SO_REUSEPORT) && defined(__MVS__)
struct sockaddr_in sockfd;
unsigned int sockfd_len = sizeof(sockfd);
if (getsockname(fd, (struct sockaddr*) &sockfd, &sockfd_len) == -1)
return UV__ERR(errno);
if (sockfd.sin_family == AF_UNIX) {
if... | pushq %rax
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x39410
testl %eax, %eax
je 0x584579
callq 0x3b610
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
jmp 0x58457b
xorl %eax, %eax
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_udp_set_broadcast | int uv_udp_set_broadcast(uv_udp_t* handle, int on) {
if (setsockopt(handle->io_watcher.fd,
SOL_SOCKET,
SO_BROADCAST,
&on,
sizeof(on))) {
return UV__ERR(errno);
}
return 0;
} | pushq %rax
leaq 0x4(%rsp), %rcx
movl %esi, (%rcx)
movl 0xb0(%rdi), %edi
movl $0x1, %esi
movl $0x6, %edx
movl $0x4, %r8d
callq 0x39410
testl %eax, %eax
je 0x58585c
callq 0x3b610
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
jmp 0x58585e
xorl %eax, %eax
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_resident_set_memory | int uv_resident_set_memory(size_t* rss) {
char buf[1024];
const char* s;
ssize_t n;
long val;
int fd;
int i;
do
fd = open("/proc/self/stat", O_RDONLY);
while (fd == -1 && errno == EINTR);
if (fd == -1)
return UV__ERR(errno);
do
n = read(fd, buf, sizeof(buf) - 1);
while (n == -1 && e... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %rdi, %rbx
leaq 0xa3721(%rip), %r14 # 0x629c38
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x39f10
cmpl $-0x1, %eax
jne 0x58653b
callq 0x3b610
movl (%rax), %ebp
cmpl $0x4, %ebp
je 0x586517
negl %ebp
jmp 0x586615
mo... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv__read_proc_meminfo | static uint64_t uv__read_proc_meminfo(const char* what) {
uint64_t rc;
char* p;
char buf[4096]; /* Large enough to hold all of /proc/meminfo. */
if (uv__slurp("/proc/meminfo", buf, sizeof(buf)))
return 0;
p = strstr(buf, what);
if (p == NULL)
return 0;
p += strlen(what);
rc = 0;
sscanf(p... | pushq %r14
pushq %rbx
subq $0x1018, %rsp # imm = 0x1018
movq %rdi, %rbx
leaq 0x6a7c7(%rip), %rdi # 0x5f1740
leaq 0x10(%rsp), %rsi
movl $0x1000, %edx # imm = 0x1000
callq 0x57a3e6
testl %eax, %eax
je 0x586f90
xorl %eax, %eax
jmp 0x586fd7
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x3a010
testq %... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv_set_process_title | int uv_set_process_title(const char* title) {
struct uv__process_title* pt;
size_t len;
/* If uv_setup_args wasn't called or failed, we can't continue. */
if (args_mem == NULL)
return UV_ENOBUFS;
pt = &process_title;
len = strlen(title);
uv_once(&process_title_mutex_once, init_process_title_mutex_o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x20b3f1(%rip) # 0x793440
je 0x5880e1
movq %rdi, %r15
callq 0x39d50
movq %rax, %r12
leaq 0x20b3f9(%rip), %rdi # 0x793460
leaq 0x89(%rip), %rsi # 0x5880f7
callq 0x583832
leaq 0x20b3ee(%rip), %r14 # 0x793468
movq %r14,... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/proctitle.c |
uv_fs_poll_getpath | int uv_fs_poll_getpath(uv_fs_poll_t* handle, char* buffer, size_t* size) {
struct poll_ctx* ctx;
size_t required_len;
if (!uv_is_active((uv_handle_t*)handle)) {
*size = 0;
return UV_EINVAL;
}
ctx = handle->poll_ctx;
assert(ctx != NULL);
required_len = strlen(ctx->path);
if (required_len >= *s... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x579af9
testl %eax, %eax
je 0x5886f4
movq 0x60(%r15), %r15
testq %r15, %r15
je 0x588719
addq $0x320, %r15 # imm = 0x320
movq %r15, %rdi
callq 0x39d50
movq %rax, %r12
cmpq (%rbx), %rax
jae 0x588702
mo... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
uv__strtok | char* uv__strtok(char* str, const char* sep, char** itr) {
const char* sep_itr;
char* tmp;
char* start;
if (str == NULL)
start = tmp = *itr;
else
start = tmp = str;
if (tmp == NULL)
return NULL;
while (*tmp != '\0') {
sep_itr = sep;
while (*sep_itr != '\0') {
if (*tmp == *sep_... | movq %rdi, %rax
testq %rdi, %rdi
jne 0x588e84
movq (%rdx), %rax
testq %rax, %rax
je 0x588ecd
movb (%rax), %cl
testb %cl, %cl
je 0x588eb9
movb (%rsi), %dil
incq %rsi
movq %rax, %r8
movq %rsi, %r9
movl %edi, %r10d
testb %dil, %dil
je 0x588eae
cmpb %r10b, %cl
je 0x588ec1
movb (%r9), %r10b
incq %r9
testb %r10b, %r10b
jne 0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/strtok.c |
cm_zlib_deflateInit2_ | int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
version, stream_size)
z_streamp strm;
int level;
int method;
int windowBits;
int memLevel;
int strategy;
const char *version;
int stream_size;
{
deflate_state *s;
int wrap = 1;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x40(%rsp), %rax
movl $0xfffffffa, %ebx # imm = 0xFFFFFFFA
testq %rax, %rax
je 0x589e4c
cmpl $0x70, 0x48(%rsp)
jne 0x589e4c
cmpb $0x31, (%rax)
jne 0x589e4c
movq %rdi, %r14
movl $0xfffffffe, %ebx # imm = 0xFFFFFFFE
testq %rdi, ... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
cm_zlib_deflateReset | int ZEXPORT deflateReset (strm)
z_streamp strm;
{
int ret;
ret = deflateResetKeep(strm);
if (ret == Z_OK)
lm_init(strm->state);
return ret;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x58a528
movl %eax, %ebx
testl %eax, %eax
jne 0x58a005
movq 0x38(%r14), %r14
movl 0x50(%r14), %eax
addq %rax, %rax
movq %rax, 0x68(%r14)
movq 0x78(%r14), %rdi
movl 0x84(%r14), %edx
decl %edx
movw $0x0, (%rdi,%rdx,2)
addq %rdx, %rdx
xorl %r15d, %r15d
xorl %esi, %esi... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
cm_zlib_deflate | int ZEXPORT deflate (strm, flush)
z_streamp strm;
int flush;
{
int old_flush; /* value of flush param for previous deflate call */
deflate_state *s;
if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
return Z_STREAM_ERROR;
}
s = strm->state;
if (strm->next_out == Z_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r13d
movq %rdi, %rbx
callq 0x58a219
movl $0xfffffffe, %r12d # imm = 0xFFFFFFFE
cmpl $0x5, %r13d
ja 0x58a8a4
testl %eax, %eax
jne 0x58a8a4
cmpq $0x0, 0x18(%rbx)
je 0x58a895
movq 0x38(%rbx), %r14
movl 0x8(%rbx), %edx
testl %edx,... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
gz_open | local gzFile gz_open(path, fd, mode)
const void *path;
int fd;
const char *mode;
{
gz_statep state;
z_size_t len;
int oflag;
#ifdef O_CLOEXEC
int cloexec = 0;
#endif
#ifdef O_EXCL
int exclusive = 0;
#endif
/* check input */
if (path == NULL)
return NULL;
/* allocate... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x58d047
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
movl $0xf0, %edi
callq 0x3bee0
movq %rax, %rbx
xorl %eax, %eax
testq %rbx, %rbx
je 0x58d047
movabsq $0x200000000000, %rcx # imm = 0x200000000000
movq %rcx, 0x28(%r... | /JKorbelRA[P]CMake/Utilities/cmzlib/gzlib.c |
gz_read | local z_size_t gz_read(state, buf, len)
gz_statep state;
voidp buf;
z_size_t len;
{
z_size_t got;
unsigned n;
/* if len is zero, avoid unnecessary operations */
if (len == 0)
return 0;
/* process a skip request */
if (state->seek) {
state->seek = 0;
if (gz_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x58d6d0
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x0, 0x70(%rdi)
je 0x58d5ee
movl $0x0, 0x70(%r14)
movq 0x68(%r14), %rsi
movq %r14, %rdi
callq 0x58d8af
cmpl $-0x1, %eax
je 0x58d6d0
xorl %r12d, %r12d
movl $0xff... | /JKorbelRA[P]CMake/Utilities/cmzlib/gzread.c |
cm_zlib_gzvprintf | int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
{
int len;
unsigned left;
char *next;
gz_statep state;
z_streamp strm;
/* get internal structure */
if (file == NULL)
return Z_STREAM_ERROR;
state = (gz_statep)file;
strm = &(state->strm);
/* check tha... | movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0x58e347
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x79b1, 0x18(%rdi) # imm = 0x79B1
jne 0x58e33f
cmpl $0x0, 0x74(%rbx)
je 0x58e348
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rsi,... | /JKorbelRA[P]CMake/Utilities/cmzlib/gzwrite.c |
cm_zlib_gzflush | int ZEXPORT gzflush(file, flush)
gzFile file;
int flush;
{
gz_statep state;
/* get internal structure */
if (file == NULL)
return Z_STREAM_ERROR;
state = (gz_statep)file;
/* check that we're writing and that there's no error */
if (state->mode != GZ_WRITE || state->err != Z_OK)... | movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0x58e7e7
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x79b1, 0x18(%rdi) # imm = 0x79B1
jne 0x58e7e1
movl %esi, %ebp
cmpl $0x4, %esi
ja 0x58e7e1
cmpl $0x0, 0x74(%rbx)
jne 0x58e7e1
cmpl $0x0, 0x70(%rbx)
je 0x58e7d4
movl $0x0, 0x70(%rbx)
mo... | /JKorbelRA[P]CMake/Utilities/cmzlib/gzwrite.c |
updatewindow | local int updatewindow(strm, end, copy)
z_streamp strm;
const Bytef *end;
unsigned copy;
{
struct inflate_state FAR *state;
unsigned dist;
state = (struct inflate_state FAR *)strm->state;
/* if it hasn't been done already, allocate space for the window */
if (state->window == Z_NULL) {
sta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rax
movq 0x38(%rdi), %r12
movq 0x48(%r12), %rdi
testq %rdi, %rdi
jne 0x590730
movq 0x50(%rax), %rdi
movb 0x38(%r12), %cl
movl $0x1, %ebp
movl $0x1, %esi
shll %cl, %esi
movl $0x1, %edx
callq *0x40(%rax)
movq %rax, %rdi
mo... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateSync | int ZEXPORT inflateSync(strm)
z_streamp strm;
{
unsigned len; /* number of bytes to look at or looked at */
int flags; /* temporary to save header status */
unsigned long in, out; /* temporary to save total_in and total_out */
unsigned char buf[4]; /* to restore... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x58e9cd
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
testl %eax, %eax
je 0x5909c8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%rbx), %r14
movl 0x8(%rbx), ... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateCopy | int ZEXPORT inflateCopy(dest, source)
z_streamp dest;
z_streamp source;
{
struct inflate_state FAR *state;
struct inflate_state FAR *copy;
unsigned char FAR *window;
unsigned wsize;
/* check input */
if (inflateStateCheck(source) || dest == Z_NULL)
return Z_STREAM_ERROR;
state = (st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x58e9cd
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
testq %rbx, %rbx
je 0x590c93
testl %eax, %eax
jne 0x590c93
movq 0x38(%r13), %r15
movq 0x50(%r13), %rdi
movl $0x1, %esi
movl $0x1bf8,... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateValidate | int ZEXPORT inflateValidate(strm, check)
z_streamp strm;
int check;
{
struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (check && state->wrap)
state->wrap |= 4;
else
state->wrap &= ~4;
return ... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x58e9cd
movl %eax, %ecx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testl %ecx, %ecx
jne 0x590d06
movq 0x38(%r14), %rax
movl 0x10(%rax), %ecx
testl %ebx, %ebx
je 0x590cfa
testl %ecx, %ecx
je 0x590cff
orl $0x4, %ecx
jmp 0x590d01
andl $-0x5, %ecx... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
bi_windup | local void bi_windup(s)
deflate_state *s;
{
if (s->bi_valid > 8) {
put_short(s, s->bi_buf);
} else if (s->bi_valid > 0) {
put_byte(s, (Byte)s->bi_buf);
}
s->bi_buf = 0;
s->bi_valid = 0;
#ifdef ZLIB_DEBUG
s->bits_sent = (s->bits_sent+7) & ~7;
#endif
} | movl 0x1734(%rdi), %eax
cmpl $0x9, %eax
jl 0x591833
movb 0x1730(%rdi), %dl
leaq 0x10(%rdi), %rcx
leaq 0x28(%rdi), %rax
movq 0x10(%rdi), %rsi
movq 0x28(%rdi), %r8
leaq 0x1(%r8), %r9
movq %r9, 0x28(%rdi)
movb %dl, (%rsi,%r8)
movzbl 0x1731(%rdi), %edx
jmp 0x591846
testl %eax, %eax
jle 0x591856
movzwl 0x1730(%rdi), %edx
le... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
cm_zlib__tr_align | void ZLIB_INTERNAL _tr_align(s)
deflate_state *s;
{
send_bits(s, STATIC_TREES<<1, 3);
send_code(s, END_BLOCK, static_ltree);
#ifdef ZLIB_DEBUG
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
#endif
bi_flush(s);
} | movl 0x1734(%rdi), %eax
movl $0x2, %esi
movl $0x2, %edx
movl %eax, %ecx
shll %cl, %edx
orw 0x1730(%rdi), %dx
movw %dx, 0x1730(%rdi)
cmpl $0xe, %eax
jl 0x59195f
movq 0x10(%rdi), %rax
movq 0x28(%rdi), %rcx
leaq 0x1(%rcx), %r8
movq %r8, 0x28(%rdi)
movb %dl, (%rax,%rcx)
movb 0x1731(%rdi), %al
movq 0x10(%rdi), %rcx
movq 0x2... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
build_tree | local void build_tree(s, desc)
deflate_state *s;
tree_desc *desc; /* the tree descriptor */
{
ct_data *tree = desc->dyn_tree;
const ct_data *stree = desc->stat_desc->static_tree;
int elems = desc->stat_desc->elems;
int n, m; /* iterate over heap elements */
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq (%rsi), %rbx
movq 0x10(%rsi), %rcx
movq (%rcx), %rax
movslq 0x14(%rcx), %rbp
xorl %ecx, %ecx
movabsq $0x23d00000000, %rdx # imm = 0x23D00000000
movq %rdx, 0x14b4(%rdi)
movl $0xffffffff, %r13d # imm = 0xFFFFFF... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
kdtree::KDTree<P, 3u, P_new, P_delete, P_set, P_less>::updateBoundingBox(kdtree::KDTree<P, 3u, P_new, P_delete, P_set, P_less>::Node const*) | void updateBoundingBox(const Node * const node) {
for (int d = 0; d < dim; d++) {
if (LESS()(node->value, boundingBoxMin, d)) {
SET()(boundingBoxMin, node->value, d);
}
else if (LESS()(boundingBoxMax, node->value, d)) {
SET()(boundingBoxMax, node->value, d);
}
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq -0x2a(%rbp), %r12
leaq -0x29(%rbp), %r13
movq 0x10(%rbx), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
movl %r15d, %ecx
callq 0x35ac
testb %al, %al
je 0x3294
movq 0x8(%r14), %... | /schenker[P]KDTree/KDTree.hpp |
parse_value | static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)
{
if ((input_buffer == NULL) || (input_buffer->content == NULL))
{
return false; /* no input */
}
/* parse the different types of values */
/* null */
if (can_read(input_buffer, 4) && (strncmp((const ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x286c
movq %rsi, %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x286c
movq %rdi, (%rsp)
movq 0x8(%rbx), %rbp
movq 0x10(%rbx), %r13
leaq 0x4(%r13), %r14
cmpq %r... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
buffer_skip_whitespace | static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
{
if ((buffer == NULL) || (buffer->content == NULL))
{
return NULL;
}
while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
{
buffer->offset++;
}
if (buffer->offset == buffer->le... | testq %rdi, %rdi
je 0x29b1
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x29b1
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
cmpq %rcx, %rax
jae 0x29a5
cmpb $0x20, (%rdx,%rax)
ja 0x29a5
incq %rax
movq %rax, 0x10(%rdi)
cmpq %rax, %rcx
jne 0x2990
movq %rcx, %rax
cmpq %rcx, %rax
jne 0x29b1
decq %rax
movq %rax, 0x10(%rdi)
retq
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_GetArraySize | CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)
{
cJSON *c = array->child;
size_t i = 0;
while(c)
{
i++;
c = c->next;
}
/* FIXME: Can overflow here. Cannot be fixed without breaking the API */
return (int)i;
} | addq $0x10, %rdi
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq (%rdi), %rdi
incl %eax
testq %rdi, %rdi
jne 0x316e
retq
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_AddItemReferenceToArray | CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
{
cJSON_AddItemToArray(array, create_reference(item, &global_hooks));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x40, %edi
callq *0x4cfe(%rip) # 0x80a8
testq %rax, %rax
je 0x33f4
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movups (%r14), %xmm1
movups 0x10(%r14), %xmm2
movups 0x20... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_CreateRaw | CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if(item)
{
item->type = cJSON_Raw;
item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks);
if(!item->valuestring)
{
cJSON_Delete(item);... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x40, %edi
callq *0x478b(%rip) # 0x80a8
movq %rax, %rbx
testq %rax, %rax
je 0x3988
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, (%rbx)
movl $0x80, 0x18(%rbx)
testq %r14, ... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_CreateStringArray | CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count)
{
size_t i = 0;
cJSON *n = NULL;
cJSON *p = NULL;
cJSON *a = NULL;
if (count < 0)
{
return NULL;
}
a = cJSON_CreateArray();
for (i = 0; a && (i < (size_t)count); i++)
{
n = cJSON_Cre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x3dc8
movl %esi, %ebp
movq %rdi, %r14
movl $0x40, %edi
callq *0x435e(%rip) # 0x80a8
movq %rax, %rbx
testq %rax, %rax
je 0x3d6b
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
parse_string_should_parse_strings | static void parse_string_should_parse_strings(void)
{
assert_parse_string("\"\"", "");
assert_parse_string(
"\" !\\\"#$%&'()*+,-./\\/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_'abcdefghijklmnopqrstuvwxyz{|}~\"",
" !\"#$%&'()*+,-.//0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_'abcdefg... | pushq %rbx
leaq 0xef7(%rip), %rdi # 0x5220
leaq 0xffb(%rip), %rsi # 0x532b
callq 0x4c62
leaq 0xeed(%rip), %rdi # 0x5229
leaq 0xf4c(%rip), %rsi # 0x528f
callq 0x4c62
leaq 0xfa1(%rip), %rdi # 0x52f0
leaq 0xfb9(%rip), %rsi # 0x530f
callq 0x4c62
leaq 0x3d8e(%rip), %rbx # 0x80f0
movq... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/parse_string.c |
assert_not_parse_string | static void assert_not_parse_string(const char * const string)
{
parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
buffer.content = (const unsigned char*)string;
buffer.length = strlen(string) + sizeof("");
buffer.hooks = global_hooks;
TEST_ASSERT_FALSE_MESSAGE(parse_string(item, &buffer), "Malfor... | pushq %rbx
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, 0x38(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movq $0x0, 0x30(%rbx)
movq %rdi, (%rbx)
callq 0x2060
incq %rax
movq %rax, 0x8(%rbx)
movups 0x324c(%rip), %xmm0 # 0x80a8
movaps %xmm0, 0x20(%... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/parse_string.c |
std::function<void (QtPromisePrivate::PromiseError const&)> QtPromisePrivate::PromiseCatcher<int, std::nullptr_t, void>::create<QtPromise::QPromiseResolve<void>, QtPromise::QPromiseReject<void>>(std::nullptr_t, QtPromise::QPromiseResolve<void> const&, QtPromise::QPromiseReject<void> const&) | static std::function<void(const PromiseError&)>
create(std::nullptr_t, const TResolve&, const TReject& reject)
{
return [=](const PromiseError& error) {
// 2.2.7.4. If onRejected is not a function and promise1 is rejected,
// promise2 must be rejected with the same reason as prom... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rcx), %r14
testq %r14, %r14
je 0x1a28d
lock
incl (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movl $0x8, %edi
callq 0x5090
movq %r14, (%rax)
testq %r14, %r14
je 0x1a2db
lock
incl (%r14)
movq %rax, (%rbx)
leaq 0x61(%rip), %rax # 0x... | /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromise_p.h |
QtPromisePrivate::PromiseError::PromiseError<int>(int const&) | PromiseError(const T& value)
{
try {
throw value;
} catch (...) {
m_data = std::current_exception();
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x4, %edi
callq 0x5180
movl (%r14), %ecx
movl %ecx, (%rax)
movq 0x1179c(%rip), %rsi # 0x2dfd0
movq %rax, %rdi
xorl %edx, %edx
callq 0x51f0
movq %rax, %rdi
callq 0x5030
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5160
mov... | /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromise_p.h |
QtPromisePrivate::PromiseResolver<QList<int>>::PromiseResolver(QtPromise::QPromise<QList<int>>) | PromiseResolver(QtPromise::QPromise<T> promise) : m_d{new Data{}}
{
m_d->promise = new QtPromise::QPromise<T>{std::move(promise)};
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10, %edi
callq 0x5090
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, (%rbx)
lock
incl (%rax)
movl $0x10, %edi
callq 0x5090
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x8(%r14)
leaq 0x111e1(%rip), %rcx # 0x2db18
addq $0x10, %rcx
mo... | /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromiseresolver.h |
JacVI | static int JacVI(N_Vector v, N_Vector Jv, sunrealtype t, N_Vector y,
N_Vector fy, void* user_data, N_Vector tmp1)
{
UserData userdata = (UserData)user_data; /* access problem data */
sunindextype N = userdata->N; /* set variable shortcuts */
sunrealtype ep = userdata->ep;
sunrealt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq (%r8), %r14
movsd 0x38(%r8), %xmm0
movsd %xmm0, 0x40(%rsp)
movq %rdx, %rdi
xorl %esi, %esi
callq 0x2250
movq %rax, %rdi
callq 0x2280
movq %rax, %rbx
leaq 0xcf1(%rip), %rsi # 0x41... | /LLNL[P]sundials/examples/arkode/C_manyvector/ark_brusselator1D_manyvec.c |
Catch::Config::Config(Catch::ConfigData const&) | Config::Config( ConfigData const& data )
: m_data( data ),
m_stream( openStream() )
{
// We need to trim filter specs to avoid trouble with superfluous
// whitespace (esp. important for bdd macros, as those are manually
// aligned with whitespace).
for (auto& elem : m_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %r12
leaq 0x66c77(%rip), %rax # 0x7cbf0
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2b7ce
movq %r12, %rdi
callq 0x16174
leaq 0x118(%r12), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::isDebuggerActive() | ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
callq 0x11050
movq %rax, %rbx
movl (%rax), %ebp
leaq 0x3952b(%rip), %rsi # 0x4fe4e
leaq 0x20(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x11940
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::FatalConditionHandler::FatalConditionHandler() | FatalConditionHandler::FatalConditionHandler() {
assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
if (altStackSize == 0) {
altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
}
altStackMem = new char[altStack... | pushq %r14
pushq %rbx
pushq %rax
movb $0x0, (%rdi)
cmpq $0x0, 0x6a7f9(%rip) # 0x819b8
jne 0x17214
movq 0x6a7f8(%rip), %rbx # 0x819c0
testq %rbx, %rbx
jne 0x171ed
movl $0xfa, %edi
callq 0x11350
cmpq $0x8001, %rax # imm = 0x8001
movl $0x8000, %ebx # imm = 0x8000
cmovaeq %rax, %rbx
movq %rbx, 0... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::listTests(Catch::Config const&) | std::size_t listTests( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
if( config.hasTestFilters() )
Catch::cout() << "Matching test cases:\n";
else {
Catch::cout() << "All available test cases:\n";
}
auto matchedTestCases = filterT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
leaq 0x38712(%rip), %rcx # 0x50040
leaq 0x38721(%rip), %rsi # 0x50056
testb %al, %al
cmovneq %rcx, %rsi
movq ... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::listTestsNamesOnly(Catch::Config const&) | std::size_t listTestsNamesOnly( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
std::size_t matchedTests = 0;
std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
for( auto const& testCaseInfo : matchedTestCases... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
movq %rbx, %rdi
callq 0x17d55
movq %rsp, %r12
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x17cb1
movq (%r12), %r15
movq 0x8(%r12), %r13
xorl %... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::listTags(Catch::Config const&) | std::size_t listTags( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
if( config.hasTestFilters() )
Catch::cout() << "Tags for matching test cases:\n";
else {
Catch::cout() << "All available tags:\n";
}
std::map<std::string, TagInfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
leaq 0x38032(%rip), %rcx # 0x50098
leaq 0x3804a(%rip), %rsi # 0x500b7
testb %al, %a... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::listReporters() | std::size_t listReporters() {
Catch::cout() << "Available reporters:\n";
IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
std::size_t maxNameLen = 0;
for( auto const& factoryKvp : factories )
maxNameLen = (std::max)( maxN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq 0x68afc(%rip), %rdi # 0x80f90
leaq 0x37c38(%rip), %rsi # 0x500d3
callq 0x11530
callq 0x2aab4
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq 0x18(%rax), %rcx
movq ... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::Matchers::Floating::WithinAbsMatcher::describe[abi:cxx11]() const | std::string WithinAbsMatcher::describe() const {
return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rsi
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x2b251
leaq 0x3773e(%rip), %rsi # 0x50136
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x2c322
leaq 0x39b90(%rip), %rdx # 0x5259c
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), ... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::Matchers::Floating::WithinUlpsMatcher::match(double const&) const | bool WithinUlpsMatcher::match(double const& matchee) const {
switch (m_type) {
case FloatingPointKind::Float:
return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
case FloatingPointKind::Double:
return almostEqualUlps<double>(m... | pushq %rbx
subq $0x50, %rsp
movzbl 0x40(%rdi), %eax
cmpl $0x1, %eax
je 0x18bd2
testl %eax, %eax
jne 0x18c4d
cvtsd2ss (%rsi), %xmm0
cvtsd2ss 0x30(%rdi), %xmm1
ucomiss %xmm1, %xmm0
jp 0x18c49
movd %xmm0, %eax
movd %xmm1, %ecx
movl %ecx, %edx
xorl %eax, %edx
js 0x18c37
subl %ecx, %eax
cvtsi2ss %eax, %xmm0
andps 0x354a9(%r... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::Matchers::Floating::WithinUlpsMatcher::describe[abi:cxx11]() const | std::string WithinUlpsMatcher::describe() const {
std::stringstream ret;
ret << "is within " << m_ulps << " ULPs of ";
if (m_type == FloatingPointKind::Float) {
write(ret, static_cast<float>(m_target));
ret << 'f';
} else {
write(ret, m_target);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x113e0
leaq 0x18(%rsp), %r14
leaq 0x3742a(%rip), %rsi # 0x50136
movq %r14, %rdi
callq 0x11530
movq 0x38(%r15), %rsi
movq %rax, %rdi
callq 0x113a0
leaq 0x3748d(%rip), %rsi # 0x5... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::Matchers::Generic::Detail::finalizeDescription(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
if (desc.empty()) {
return "matches undescribed predicate";
} else {
return "matches predicate: \"" + desc + '"';
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x191e5
movq %rsi, %rdx
leaq 0x370c0(%rip), %rsi # 0x5027e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2c1f3
pushq $0x22
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c36a
leaq 0x8(%rsp), %rdi
callq 0x11a48
jmp 0x191f9
leaq 0x37074... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::Matchers::StdString::StringMatcherBase::StringMatcherBase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Matchers::StdString::CasedString const&) | StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
: m_comparator( comparator ),
m_operation( operation ) {
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r14
movb $0x0, 0x18(%rdi)
leaq 0x63cba(%rip), %rax # 0x7cf70
movq %rax, (%rdi)
leaq 0x63cd8(%rip), %rax # 0x7cf98
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
movq %rdx, %rsi
callq 0x2c38c
lea... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::startsWith(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool startsWith( std::string const& s, std::string const& prefix ) {
return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
} | movq %rsi, %rax
movq 0x8(%rsi), %rsi
cmpq %rsi, 0x8(%rdi)
jae 0x1965e
xorl %eax, %eax
retq
movq (%rax), %rax
addq %rax, %rsi
movq (%rdi), %rdx
movq %rax, %rdi
jmp 0x47a34
nop
| /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::uncaught_exceptions() | bool uncaught_exceptions() {
#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
return false;
#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
return std::uncaught_exceptions() > 0;
#else
return std::uncaught_exception();
#endif
} | jmp 0x11060
| /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::RedirectedStream::RedirectedStream(std::ostream&, std::ostream&) | RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
: m_originalStream( originalStream ),
m_redirectionStream( redirectionStream ),
m_prevBuf( m_originalStream.rdbuf() )
{
m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
} | movq %rsi, %rax
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq (%rsi), %rcx
movq -0x18(%rcx), %rsi
movq 0xe8(%rax,%rsi), %rsi
movq %rsi, 0x10(%rdi)
addq -0x18(%rcx), %rax
movq (%rdx), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rdx,%rcx), %rsi
movq %rax, %rdi
jmp 0x11990
| /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<Catch::IConfig const> const&) const | IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
auto it = m_factories.find( name );
if( it == m_factories.end() )
return nullptr;
return it->second->create( ReporterConfig( config ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x386d4
addq $0x10, %r15
cmpq %r15, %rax
je 0x1a3ec
movq 0x40(%rax), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x17400
movq (%r15), %rax
movq %rbx, %rd... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::RunContext::testGroupEnded(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Totals const&, unsigned long, unsigned long) | void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %r13
movq 0x128(%rdi), %rbx
movq %rsp, %rbp
movq %rbp, %rdi
callq 0x11710
movq %r12, 0x20(%rbp)
movq %r15, 0x28(%rbp)
movq %r13, %rdi
callq 0x1a7f2
movzbl %al, %ecx
leaq 0x30(%rsp... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::TestCaseTracking::TrackerContext::startRun() | ITracker& TrackerContext::startRun() {
m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
m_currentTracker = nullptr;
m_runState = Executing;
return *m_rootTracker;
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x35bbe(%rip), %rsi # 0x507c5
leaq 0x28(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x111f0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x11710
leaq 0x35280(%rip), %rax # 0x4fead
leaq 0x48(%rsp), %rsi
movq %rax, 0x20(%rsi)
movq $0x3817, 0x28... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::RunContext::sectionStarted(Catch::SectionInfo const&, Catch::Counts&) | bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
if (!sectionTracker.isOpen())
return false;
m_activ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x1c8(%rdi), %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x11710
movups 0x40(%r15), %xmm0
movups %xmm0, 0x20(%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x1ad48
movq %rax, %r12
lea... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::RunContext::acquireGeneratorTracker(Catch::StringRef, Catch::SourceLineInfo const&) | auto RunContext::acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
using namespace Generators;
GeneratorTracker& tracker = GeneratorTracker::acquire(m_trackerContext,
TestCaseTracking::... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x2b2d6
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x11710
movups (%rbx), %xmm0
leaq 0x20(%rsp), %rsi
movups %xmm0, 0x20(%... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
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.