name string | code string | asm string | file string |
|---|---|---|---|
prepare_new_block | static
void prepare_new_block ( EState* s )
{
Int32 i;
s->nblock = 0;
s->numZ = 0;
s->state_out_pos = 0;
BZ_INITIALISE_CRC ( s->blockCRC );
for (i = 0; i < 256; i++) s->inUse[i] = False;
s->blockNo++;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x6c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x74(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x78(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x288(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp) # imm = 0x100
jge... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzCompress | int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action )
{
Bool progress;
EState* s;
if (strm == NULL) return BZ_PARAM_ERROR;
s = strm->state;
if (s == NULL) return BZ_PARAM_ERROR;
if (s->strm != strm) return BZ_PARAM_ERROR;
preswitch:
switch (s->mode) {
case BZ_M_IDLE:
return... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x103b12
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x103d21
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x103b31
movl $0xfffffffe, -0x4(%rbp) ... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
handle_compress | static
Bool handle_compress ( bz_stream* strm )
{
Bool progress_in = False;
Bool progress_out = False;
EState* s = strm->state;
while (True) {
if (s->state == BZ_S_OUTPUT) {
progress_out |= copy_output_until_stop ( s );
if (s->state_out_pos < s->numZ) break;
if (s->mod... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x103df2
movq -0x18(%rbp), %rdi
callq 0x107570
movzbl %al, %ecx
movzbl -0xa(%rbp), %eax
orl %ec... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzCompressEnd | int BZ_API(BZ2_bzCompressEnd) ( bz_stream *strm )
{
EState* s;
if (strm == NULL) return BZ_PARAM_ERROR;
s = strm->state;
if (s == NULL) return BZ_PARAM_ERROR;
if (s->strm != strm) return BZ_PARAM_ERROR;
if (s->arr1 != NULL) BZFREE(s->arr1);
if (s->arr2 != NULL) BZFREE(s->arr2);
if (s->ftab != ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x103f1f
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x103ff3
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x103f3e
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp ... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzDecompressInit | int BZ_API(BZ2_bzDecompressInit)
( bz_stream* strm,
int verbosity,
int small )
{
DState* s;
if (!bz_config_ok()) return BZ_CONFIG_ERROR;
if (strm == NULL) return BZ_PARAM_ERROR;
if (small != 0 && small != 1) return BZ_PARAM... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
callq 0x1039e0
cmpl $0x0, %eax
jne 0x104028
movl $0xfffffff7, -0x4(%rbp) # imm = 0xFFFFFFF7
jmp 0x104199
cmpq $0x0, -0x10(%rbp)
jne 0x10403b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x104199
cmpl ... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_indexIntoF | __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
{
Int32 nb, na, mid;
nb = 0;
na = 256;
do {
mid = (nb + na) >> 1;
if (indx >= cftab[mid]) nb = mid; else na = mid;
}
while (na - nb != 1);
return nb;
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x100, -0x18(%rbp) # imm = 0x100
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
sarl %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0x104... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzDecompress | int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
{
Bool corrupt;
DState* s;
if (strm == NULL) return BZ_PARAM_ERROR;
s = strm->state;
if (s == NULL) return BZ_PARAM_ERROR;
if (s->strm != strm) return BZ_PARAM_ERROR;
while (True) {
if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10422f
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x104471
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10424e
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp ... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
unRLE_obuf_to_output_FAST | static
Bool unRLE_obuf_to_output_FAST ( DState* s )
{
UChar k1;
if (s->blockRandomised) {
while (True) {
/* try to finish existing run */
while (True) {
if (s->strm->avail_out == 0) return False;
if (s->state_out_len == 0) break;
*( (UChar*)(s->strm->n... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x14(%rax)
je 0x105802
jmp 0x105188
jmp 0x10518a
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0x1051a0
movb $0x0, -0x1(%rbp)
jmp 0x105bf5
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1051af
jmp 0x105261
movq ... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzDecompressEnd | int BZ_API(BZ2_bzDecompressEnd) ( bz_stream *strm )
{
DState* s;
if (strm == NULL) return BZ_PARAM_ERROR;
s = strm->state;
if (s == NULL) return BZ_PARAM_ERROR;
if (s->strm != strm) return BZ_PARAM_ERROR;
if (s->tt != NULL) BZFREE(s->tt);
if (s->ll16 != NULL) BZFREE(s->ll16);
if (s->ll4 != ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x105c1f
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x105d05
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x105c3e
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp ... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzWriteOpen | BZFILE* BZ_API(BZ2_bzWriteOpen)
( int* bzerror,
FILE* f,
int blockSize100k,
int verbosity,
int workFactor )
{
Int32 ret;
bzFile* bzf = NULL;
BZ_SETERR(BZ_OK);
if (f == NULL ||
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x105d43
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x105d58
movq -0x30(%rbp), %rax
movl... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzWrite | void BZ_API(BZ2_bzWrite)
( int* bzerror,
BZFILE* b,
void* buf,
int len )
{
Int32 n, n2, ret;
bzFile* bzf = (bzFile*)b;
BZ_SETERR(BZ_OK);
if (bzf == NULL || buf == NULL || len < 0)
{ BZ_SETERR(BZ_PARAM_ERROR); return; };
if (!(bz... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x105f90
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x105fa5
movq -0x30(%rbp), %rax
movl $0... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzWriteClose64 | void BZ_API(BZ2_bzWriteClose64)
( int* bzerror,
BZFILE* b,
int abandon,
unsigned int* nbytes_in_lo32,
unsigned int* nbytes_in_hi32,
unsigned int* nbytes_out_lo32,
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x10627d
cmpq $0x0, -0x8(%rbp)
je 0x106263
mov... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzReadOpen | BZFILE* BZ_API(BZ2_bzReadOpen)
( int* bzerror,
FILE* f,
int verbosity,
int small,
void* unused,
int nUnused )
{
bzFile* bzf = NULL;
int ret;
BZ_SETERR(BZ_OK);
if (f == ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x106597
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x1065ac
movq ... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzReadClose | void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
{
bzFile* bzf = (bzFile*)b;
BZ_SETERR(BZ_OK);
if (bzf == NULL)
{ BZ_SETERR(BZ_OK); return; };
if (bzf->writing)
{ BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
if (bzf->initialisedOk)
(void)BZ2_bzDecompressEnd ( &(bzf->strm) );
f... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x106839
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x10684e
movq -0x18(%rbp), %rax
movl $0x0, 0x13e8(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
copy_input_until_stop | static
Bool copy_input_until_stop ( EState* s )
{
Bool progress_in = False;
if (s->mode == BZ_M_RUNNING) {
/*-- fast track the common case --*/
while (True) {
/*-- block full? --*/
if (s->nblock >= s->nblockMAX) break;
/*-- no input? --*/
if (s->strm->avail_in == ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x1077da
jmp 0x107650
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x70(%rcx), %eax
jl 0x107665
jmp 0x1077d5
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0,... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
add_pair_to_block | static
void add_pair_to_block ( EState* s )
{
Int32 i;
UChar ch = (UChar)(s->state_in_ch);
for (i = 0; i < s->state_in_len; i++) {
BZ_UPDATE_CRC( s->blockCRC, ch );
}
s->inUse[s->state_in_ch] = True;
switch (s->state_in_len) {
case 1:
s->block[s->nblock] = (UChar)ch; s->nblock++;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
movb %al, -0xd(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x107a38
movq -0x8(%rbp), %rax
movl 0x288(%rax), %ecx
shll $0x8, %ecx
movq -0x8(%rbp), %rax
movl 0x288(%rax), %eax... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_compressBlock | void BZ2_compressBlock ( EState* s, Bool is_last_block )
{
if (s->nblock > 0) {
BZ_FINALISE_CRC ( s->blockCRC );
s->combinedCRC = (s->combinedCRC << 1) | (s->combinedCRC >> 31);
s->combinedCRC ^= s->blockCRC;
if (s->blockNo > 1) s->numZ = 0;
if (s->verbosity >= 2)
VPrintf4( "... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
jle 0x107d43
movq -0x8(%rbp), %rax
movl 0x288(%rax), %ecx
xorl $-0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x288(%rax)
movq -0x8(%rbp), %rax
movl 0x28c(%rax), %ecx
shll %ecx... | /JKorbelRA[P]CMake/Utilities/cmbzip2/compress.c |
generateMTFValues | static
void generateMTFValues ( EState* s )
{
UChar yy[256];
Int32 i, j;
Int32 zPend;
Int32 wr;
Int32 EOB;
/*
After sorting (eg, here),
s->arr1 [ 0 .. s->nblock-1 ] holds sorted order,
and
((UChar*)s->arr2) [ 0 .. s->nblock-1 ]
holds the original ... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x130(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x138(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x140(%rbp)
movq -0x8(%rbp), %rdi
ca... | /JKorbelRA[P]CMake/Utilities/cmbzip2/compress.c |
sendMTFValues | static
void sendMTFValues ( EState* s )
{
Int32 v, t, i, j, gs, ge, totc, bt, bc, iter;
Int32 nSelectors, alphaSize, minLen, maxLen, selCtr;
Int32 nGroups, nBytes;
/*--
UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
is a global since the decoder also needs it.
Int32 code[BZ_N_GROUPS][BZ_MAX_ALPHA_... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x290(%rax)
jl 0x108579
movq 0x21ea41(%rip), %rax # 0x326f90
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %edx
movq -0x8(%rbp), %rax
movl 0... | /JKorbelRA[P]CMake/Utilities/cmbzip2/compress.c |
bsFinishWrite | static
void bsFinishWrite ( EState* s )
{
while (s->bsLive > 0) {
s->zbits[s->numZ] = (UChar)(s->bsBuff >> 24);
s->numZ++;
s->bsBuff <<= 8;
s->bsLive -= 8;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x284(%rax)
jle 0x10c7dc
movq -0x8(%rbp), %rax
movl 0x280(%rax), %eax
shrl $0x18, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x74(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
mov... | /JKorbelRA[P]CMake/Utilities/cmbzip2/compress.c |
makeMaps_e | static
void makeMaps_e ( EState* s )
{
Int32 i;
s->nInUse = 0;
for (i = 0; i < 256; i++)
if (s->inUse[i]) {
s->unseqToSeq[i] = s->nInUse;
s->nInUse++;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x7c(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp) # imm = 0x100
jge 0x10c847
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, 0x80(%rax,%rcx)
je 0x10c83a
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %eax
movb %al, %dl
movq -... | /JKorbelRA[P]CMake/Utilities/cmbzip2/compress.c |
makeMaps_d | static
void makeMaps_d ( DState* s )
{
Int32 i;
s->nInUse = 0;
for (i = 0; i < 256; i++)
if (s->inUse[i]) {
s->seqToUnseq[s->nInUse] = i;
s->nInUse++;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0xc78(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp) # imm = 0x100
jge 0x110f83
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, 0xc7c(%rax,%rcx)
je 0x110f76
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmbzip2/decompress.c |
BZ2_blockSort | void BZ2_blockSort ( EState* s )
{
UInt32* ptr = s->ptr;
UChar* block = s->block;
UInt32* ftab = s->ftab;
Int32 nblock = s->nblock;
Int32 verb = s->verbosity;
Int32 wfact = s->workFactor;
UInt16* quadrant;
Int32 budget;
Int32 budgetInit;
Int32 i;
if (nblock < 100... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %eax
movl %eax... | /JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c |
fallbackSort | static
void fallbackSort ( UInt32* fmap,
UInt32* eclass,
UInt32* bhtab,
Int32 nblock,
Int32 verb )
{
Int32 ftab[257];
Int32 ftabCopy[256];
Int32 H, i, j, k, l, r, cc, cc1;
Int32 nNotDone;
Int32 nBhtab;
UChar* eclass8... | pushq %rbp
movq %rsp, %rbp
subq $0x870, %rsp # imm = 0x870
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x860(%rbp)
cmpl $0x4, -0x20(%rbp)
jl 0x111207
movq 0x215d9a(%rip), %rax # 0x326f90
movq (%rax), %... | /JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c |
mainSort | static
void mainSort ( UInt32* ptr,
UChar* block,
UInt16* quadrant,
UInt32* ftab,
Int32 nblock,
Int32 verb,
Int32* budget )
{
Int32 i, j, k, ss, sb;
Int32 runningOrder[256];
Bool bigDone[256];
Int32 ... | pushq %rbp
movq %rsp, %rbp
subq $0xd80, %rsp # imm = 0xD80
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jl 0x111a75
movq 0x21552c(%rip), %rax # 0x326f90
movq (%rax), %rd... | /JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c |
fallbackQSort3 | static
void fallbackQSort3 ( UInt32* fmap,
UInt32* eclass,
Int32 loSt,
Int32 hiSt )
{
Int32 unLo, unHi, ltLo, gtHi, n, m;
Int32 sp, lo, hi;
UInt32 med, r, r3;
Int32 stackLo[FALLBACK_QSORT_STACK_SIZE];
Int32 stackHi[FALLBACK_QSORT_STA... | pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp # imm = 0x3B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x14(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x1e0(%rbp,%rax,4)
movl -0x18(%rbp), %ecx
movslq -0x3... | /JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c |
mainQSort3 | static
void mainQSort3 ( UInt32* ptr,
UChar* block,
UInt16* quadrant,
Int32 nblock,
Int32 loSt,
Int32 hiSt,
Int32 dSt,
Int32* budget )
{
Int32 unLo, unHi, ltLo, gtHi, n, m, med;
... | pushq %rbp
movq %rsp, %rbp
subq $0x580, %rsp # imm = 0x580
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x20(%rbp), %ecx
movslq -0x44(%rbp), %ra... | /JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c |
mmed3 | static
__inline__
UChar mmed3 ( UChar a, UChar b, UChar c )
{
UChar t;
if (a > b) { t = a; a = b; b = t; };
if (b > c) {
b = c;
if (a > b) b = a;
}
return b;
} | pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movb %dil, %dl
movb %dl, -0x1(%rbp)
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movzbl -0x1(%rbp), %eax
movzbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jle 0x1136e3
movb -0x1(%rbp), %al
movb %al, -0x4(%rbp)
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x4(%rbp), %al
movb... | /JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c |
BZ2_hbMakeCodeLengths | void BZ2_hbMakeCodeLengths ( UChar *len,
Int32 *freq,
Int32 alphaSize,
Int32 maxLen )
{
/*--
Nodes and heap entries run from 1. Entry 0
for both the heap and nodes is a sentinel.
--*/
Int32 nNodes, nHeap, n1, n... | pushq %rbp
movq %rsp, %rbp
subq $0x14b0, %rsp # imm = 0x14B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x114087
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne... | /JKorbelRA[P]CMake/Utilities/cmbzip2/huffman.c |
BZ2_hbAssignCodes | void BZ2_hbAssignCodes ( Int32 *code,
UChar *length,
Int32 minLen,
Int32 maxLen,
Int32 alphaSize )
{
Int32 n, vec, i;
vec = 0;
for (n = minLen; n <= maxLen; n++) {
for (i = 0; i < alphaSize; i++)
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x1146b2
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -... | /JKorbelRA[P]CMake/Utilities/cmbzip2/huffman.c |
BZ2_hbCreateDecodeTables | void BZ2_hbCreateDecodeTables ( Int32 *limit,
Int32 *base,
Int32 *perm,
UChar *length,
Int32 minLen,
Int32 maxLen,
Int32 alphaSi... | pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x28(%rbp), %eax
jg 0x114745
movl $0... | /JKorbelRA[P]CMake/Utilities/cmbzip2/huffman.c |
lzma_crc32 | extern LZMA_API(uint32_t)
lzma_crc32(const uint8_t *buf, size_t size, uint32_t crc)
{
crc = ~crc;
#ifdef WORDS_BIGENDIAN
crc = bswap32(crc);
#endif
if (size > 8) {
// Fix the alignment, if needed. The if statement above
// ensures that this won't read past the end of buf[].
while ((uintptr_t)(buf) & 7) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpq $0x8, -0x10(%rbp)
jbe 0x114a73
jmp 0x1148d9
movq -0x8(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x11492b
movq -0x8(%rbp), %rax
movq %ra... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/crc32_fast.c |
lzma_alone_decoder_init | extern lzma_ret
lzma_alone_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
uint64_t memlimit, bool picky)
{
lzma_next_coder_init(&lzma_alone_decoder_init, next, allocator);
lzma_alone_coder *coder = next->coder;
if (coder == NULL) {
coder = lzma_alloc(sizeof(lzma_alone_coder), allocator);
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x29(%rip), %rax # 0x114af0
cmpq 0x10(%rcx), %rax
je 0x114b2c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11588... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/alone_decoder.c |
alone_decoder_memconfig | static lzma_ret
alone_decoder_memconfig(void *coder_ptr, uint64_t *memusage,
uint64_t *old_memlimit, uint64_t new_memlimit)
{
lzma_alone_coder *coder = coder_ptr;
*memusage = coder->memusage;
*old_memlimit = coder->memlimit;
if (new_memlimit != 0) {
if (new_memlimit < coder->memusage)
return LZMA_MEMLIMIT_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x20(%rbp), %rax
m... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/alone_decoder.c |
alone_encoder_init | static lzma_ret
alone_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_options_lzma *options)
{
lzma_next_coder_init(&alone_encoder_init, next, allocator);
lzma_alone_coder *coder = next->coder;
if (coder == NULL) {
coder = lzma_alloc(sizeof(lzma_alone_coder), allocator);
if (c... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x22(%rip), %rax # 0x115220
cmpq 0x10(%rcx), %rax
je 0x115255
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x115880
movq -0x10(%rbp), %rax
leaq -0x40(%rip), %rcx ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/alone_encoder.c |
alone_encode | static lzma_ret
alone_encode(void *coder_ptr, const lzma_allocator *allocator,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size, uint8_t *restrict out,
size_t *restrict out_pos, size_t out_size,
lzma_action action)
{
lzma_alone_coder *coder = coder_ptr;
while (*out_pos < out_size)
switch ... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/alone_encoder.c |
lzma_alloc | extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1)
lzma_alloc(size_t size, const lzma_allocator *allocator)
{
// Some malloc() variants return NULL if called with size == 0.
if (size == 0)
size = 1;
void *ptr;
if (allocator != NULL && allocator->alloc != NULL)
ptr = allocator->alloc(allocator-... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11560f
movq $0x1, -0x8(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x115640
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x115640
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_alloc_zero | extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1)
lzma_alloc_zero(size_t size, const lzma_allocator *allocator)
{
// Some calloc() variants return NULL if called with size == 0.
if (size == 0)
size = 1;
void *ptr;
if (allocator != NULL && allocator->alloc != NULL) {
ptr = allocator->alloc(all... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11567f
movq $0x1, -0x8(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1156c6
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1156c6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_bufcpy | extern size_t
lzma_bufcpy(const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size, uint8_t *restrict out,
size_t *restrict out_pos, size_t out_size)
{
const size_t in_avail = in_size - *in_pos;
const size_t out_avail = out_size - *out_pos;
const size_t copy_size = my_min(in_avail, out_avail);
// Ca... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq (%r... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_next_end | extern void
lzma_next_end(lzma_next_coder *next, const lzma_allocator *allocator)
{
if (next->init != (uintptr_t)(NULL)) {
// To avoid tiny end functions that simply call
// lzma_free(coder, allocator), we allow leaving next->end
// NULL and call lzma_free() here.
if (next->end != NULL)
next->end(next->code... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1158ff
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1158bd
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_next_filter_update | extern lzma_ret
lzma_next_filter_update(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_filter *reversed_filters)
{
// Check that the application isn't trying to change the Filter ID.
// End of filters is indicated with LZMA_VLI_UNKNOWN in both
// reversed_filters[0].id and next->id.
if (revers... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x11593e
movl $0xb, -0x4(%rbp)
jmp 0x11599b
movq -0x20(%rbp), %rax
cmpq $-0x1, (%rax)
jne 0x115951
movl $0x0, -0x4(%rbp... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_strm_init | extern lzma_ret
lzma_strm_init(lzma_stream *strm)
{
if (strm == NULL)
return LZMA_PROG_ERROR;
if (strm->internal == NULL) {
strm->internal = lzma_alloc(sizeof(lzma_internal),
strm->allocator);
if (strm->internal == NULL)
return LZMA_MEM_ERROR;
strm->internal->next = LZMA_NEXT_CODER_INIT;
}
memzero... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1159cf
movl $0xb, -0x4(%rbp)
jmp 0x115a96
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x115a44
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movl $0x60, %edi
callq 0x1155f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rc... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_code | extern LZMA_API(lzma_ret)
lzma_code(lzma_stream *strm, lzma_action action)
{
// Sanity checks
if ((strm->next_in == NULL && strm->avail_in != 0)
|| (strm->next_out == NULL && strm->avail_out != 0)
|| strm->internal == NULL
|| strm->internal->next.code == NULL
|| (unsigned int)(action) > LZMA_ACTION_MAX
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x115ac4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x115b0c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x115ada
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x115b0c
mov... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_get_progress | extern LZMA_API(void)
lzma_get_progress(lzma_stream *strm,
uint64_t *progress_in, uint64_t *progress_out)
{
if (strm->internal->next.get_progress != NULL) {
strm->internal->next.get_progress(strm->internal->next.coder,
progress_in, progress_out);
} else {
*progress_in = strm->total_in;
*progress_out = str... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x115f96
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx), %rdi
mo... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_memusage | extern LZMA_API(uint64_t)
lzma_memusage(const lzma_stream *strm)
{
uint64_t memusage;
uint64_t old_memlimit;
if (strm == NULL || strm->internal == NULL
|| strm->internal->next.memconfig == NULL
|| strm->internal->next.memconfig(
strm->internal->next.coder,
&memusage, &old_memlimit, 0) != LZMA_OK)
re... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x116065
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x116065
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x116065
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_memlimit_get | extern LZMA_API(uint64_t)
lzma_memlimit_get(const lzma_stream *strm)
{
uint64_t old_memlimit;
uint64_t memusage;
if (strm == NULL || strm->internal == NULL
|| strm->internal->next.memconfig == NULL
|| strm->internal->next.memconfig(
strm->internal->next.coder,
&memusage, &old_memlimit, 0) != LZMA_OK)
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1160e5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1160e5
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x1160e5
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
decoder_find | static const lzma_filter_decoder *
decoder_find(lzma_vli id)
{
for (size_t i = 0; i < ARRAY_SIZE(decoders); ++i)
if (decoders[i].id == id)
return decoders + i;
return NULL;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x9, -0x18(%rbp)
jae 0x11621a
movq -0x18(%rbp), %rcx
leaq 0x21048e(%rip), %rax # 0x326670
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x11620a
movq -0x18(%rbp), %rcx
leaq 0x210473(%rip), %rax # 0x326670... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_decoder.c |
encoder_find | static const lzma_filter_encoder *
encoder_find(lzma_vli id)
{
for (size_t i = 0; i < ARRAY_SIZE(encoders); ++i)
if (encoders[i].id == id)
return encoders + i;
return NULL;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x9, -0x18(%rbp)
jae 0x116444
leaq 0x210382(%rip), %rax # 0x326790
imulq $0x38, -0x18(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x116434
leaq 0x21036a(%rip), %rax # 0x326790
imulq $0x38, -0x18(%rbp), %rcx... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c |
lzma_raw_encoder | extern LZMA_API(lzma_ret)
lzma_raw_encoder(lzma_stream *strm, const lzma_filter *options)
{
lzma_next_strm_init(lzma_raw_coder_init, strm, options,
(lzma_filter_find)(&encoder_find), true);
strm->internal->supported_actions[LZMA_RUN] = true;
strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true;
strm->inter... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x116602
movq -0x10(%rbp), %rdi
callq 0x1159b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x11661c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11668b
jmp 0x11661e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c |
lzma_mt_block_size | extern uint64_t
lzma_mt_block_size(const lzma_filter *filters)
{
uint64_t max = 0;
for (size_t i = 0; filters[i].id != LZMA_VLI_UNKNOWN; ++i) {
const lzma_filter_encoder *const fe
= encoder_find(filters[i].id);
if (fe->block_size != NULL) {
const uint64_t size
= fe->block_size(filters[i].options);
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $-0x1, (%rax)
je 0x116750
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
ca... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c |
lzma_properties_size | extern LZMA_API(lzma_ret)
lzma_properties_size(uint32_t *size, const lzma_filter *filter)
{
const lzma_filter_encoder *const fe = encoder_find(filter->id);
if (fe == NULL) {
// Unknown filter - if the Filter ID is a proper VLI,
// return LZMA_OPTIONS_ERROR instead of LZMA_PROG_ERROR,
// because it's possible th... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1163f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1167bd
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movl $0xb, %e... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c |
lzma_properties_encode | extern LZMA_API(lzma_ret)
lzma_properties_encode(const lzma_filter *filter, uint8_t *props)
{
const lzma_filter_encoder *const fe = encoder_find(filter->id);
if (fe == NULL)
return LZMA_PROG_ERROR;
if (fe->props_encode == NULL)
return LZMA_OK;
return fe->props_encode(filter->options, props);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1163f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x116830
movl $0xb, -0x4(%rbp)
jmp 0x11685d
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x116844
movl $0x0, -0x4(%rbp)
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c |
lzma_stream_decoder_init | extern lzma_ret
lzma_stream_decoder_init(
lzma_next_coder *next, const lzma_allocator *allocator,
uint64_t memlimit, uint32_t flags)
{
lzma_next_coder_init(&lzma_stream_decoder_init, next, allocator);
if (flags & ~LZMA_SUPPORTED_FLAGS)
return LZMA_OPTIONS_ERROR;
lzma_stream_coder *coder = next->coder;
if (c... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x25(%rip), %rax # 0x116880
cmpq 0x10(%rcx), %rax
je 0x1168b8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x115880
movq -0x10(%rbp), %rax
lea... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_decoder.c |
stream_decode | static lzma_ret
stream_decode(void *coder_ptr, const lzma_allocator *allocator,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size, uint8_t *restrict out,
size_t *restrict out_pos, size_t out_size, lzma_action action)
{
lzma_stream_coder *coder = coder_ptr;
// When decoding the actual Block, i... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_decoder.c |
stream_decoder_reset | static lzma_ret
stream_decoder_reset(lzma_stream_coder *coder, const lzma_allocator *allocator)
{
// Initialize the Index hash used to verify the Index.
coder->index_hash = lzma_index_hash_init(coder->index_hash, allocator);
if (coder->index_hash == NULL)
return LZMA_MEM_ERROR;
// Reset the rest of the variables... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x158(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x135080
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x158(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x158(%rax)
jne 0x117329
movl $0x5, -0x4(%rbp)
jmp... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_decoder.c |
lzma_stream_encoder | extern LZMA_API(lzma_ret)
lzma_stream_encoder(lzma_stream *strm,
const lzma_filter *filters, lzma_check check)
{
lzma_next_strm_init(stream_encoder_init, strm, filters, check);
strm->internal->supported_actions[LZMA_RUN] = true;
strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true;
strm->internal->supported... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
jmp 0x117415
movq -0x10(%rbp), %rdi
callq 0x1159b0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x11742f
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1174ac
jmp 0x117431
movq -0x10(%rbp), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder.c |
stream_encoder_init | static lzma_ret
stream_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_filter *filters, lzma_check check)
{
lzma_next_coder_init(&stream_encoder_init, next, allocator);
if (filters == NULL)
return LZMA_PROG_ERROR;
lzma_stream_coder *coder = next->coder;
if (coder == NULL) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x25(%rip), %rax # 0x1174c0
cmpq 0x10(%rcx), %rax
je 0x1174f8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x115880
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder.c |
stream_encode | static lzma_ret
stream_encode(void *coder_ptr, const lzma_allocator *allocator,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size, uint8_t *restrict out,
size_t *restrict out_pos, size_t out_size, lzma_action action)
{
lzma_stream_coder *coder = coder_ptr;
// Main loop
while (*out_pos < out_... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder.c |
stream_encoder_end | static void
stream_encoder_end(void *coder_ptr, const lzma_allocator *allocator)
{
lzma_stream_coder *coder = coder_ptr;
lzma_next_end(&coder->block_encoder, allocator);
lzma_next_end(&coder->index_encoder, allocator);
lzma_index_end(coder->index, allocator);
for (size_t i = 0; coder->filters[i].id != LZMA_VLI_U... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x115880
movq -0x18(%rbp), %rdi
addq $0x170, %rdi # imm = 0x170
movq -0x10(%rbp), %rsi
callq 0x115880
movq ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder.c |
stream_encoder_update | static lzma_ret
stream_encoder_update(void *coder_ptr, const lzma_allocator *allocator,
const lzma_filter *filters,
const lzma_filter *reversed_filters)
{
lzma_stream_coder *coder = coder_ptr;
if (coder->sequence <= SEQ_BLOCK_INIT) {
// There is no incomplete Block waiting to be finished,
// thus we can chan... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x1, (%rax)
ja 0x117c5b
movq -0x30(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder.c |
block_encoder_init | static lzma_ret
block_encoder_init(lzma_stream_coder *coder, const lzma_allocator *allocator)
{
// Prepare the Block options. Even though Block encoder doesn't need
// compressed_size, uncompressed_size, and header_size to be
// initialized, it is a good idea to do it here, because this way
// we catch if someone g... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $-0x1, 0x60(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x68(%rax)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x131840
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x117d66
movl -0x1c(%rbp), %eax
mo... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder.c |
lzma_stream_encoder_mt | extern LZMA_API(lzma_ret)
lzma_stream_encoder_mt(lzma_stream *strm, const lzma_mt *options)
{
lzma_next_strm_init(stream_encoder_mt_init, strm, options);
strm->internal->supported_actions[LZMA_RUN] = true;
// strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true;
strm->internal->supported_actions[LZMA_FULL_FLU... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x117da2
movq -0x10(%rbp), %rdi
callq 0x1159b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x117dbc
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x117e2a
jmp 0x117dbe
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
stream_encoder_mt_init | static lzma_ret
stream_encoder_mt_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_mt *options)
{
lzma_next_coder_init(&stream_encoder_mt_init, next, allocator);
// Get the filter chain.
lzma_options_easy easy;
const lzma_filter *filters;
uint64_t block_size;
uint64_t outbuf_size_max;
r... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x22(%rip), %rax # 0x117e40
cmpq 0x10(%rcx), %rax
je 0x117e75
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x115880
movq -0x10(%rbp), %rax
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
lzma_stream_encoder_mt_memusage | extern LZMA_API(uint64_t)
lzma_stream_encoder_mt_memusage(const lzma_mt *options)
{
lzma_options_easy easy;
const lzma_filter *filters;
uint64_t block_size;
uint64_t outbuf_size_max;
if (get_options(options, &easy, &filters, &block_size,
&outbuf_size_max) != LZMA_OK)
return UINT64_MAX;
// Memory usage of t... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
leaq -0xe0(%rbp), %rcx
leaq -0xe8(%rbp), %r8
callq 0x1185c0
cmpl $0x0, %eax
je 0x118466
movq $-0x1, -0x8(%rbp)
jmp 0x1185a7
movq -0x10(%rbp), %rax
movl 0x4(%r... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
get_options | static lzma_ret
get_options(const lzma_mt *options, lzma_options_easy *opt_easy,
const lzma_filter **filters, uint64_t *block_size,
uint64_t *outbuf_size_max)
{
// Validate some of the options.
if (options == NULL)
return LZMA_PROG_ERROR;
if (options->flags != 0 || options->threads == 0
|| options->threads... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1185ef
movl $0xb, -0x4(%rbp)
jmp 0x11872f
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x11860f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
mythread_cond_init | static inline int
mythread_cond_init(mythread_cond *mycond)
{
#ifdef HAVE_CLOCK_GETTIME
// NOTE: HAVE_DECL_CLOCK_MONOTONIC is always defined to 0 or 1.
# if defined(HAVE_PTHREAD_CONDATTR_SETCLOCK) && HAVE_DECL_CLOCK_MONOTONIC
struct timespec ts;
pthread_condattr_t condattr;
// POSIX doesn't seem to *require* that ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a50
addq $0x10, %rsp
popq %rbp
retq
nop
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/mythread.h |
stream_encoder_mt_end | static void
stream_encoder_mt_end(void *coder_ptr, const lzma_allocator *allocator)
{
lzma_stream_coder *coder = coder_ptr;
// Threads must be killed before the output queue can be freed.
threads_end(coder, allocator);
lzma_outq_end(&coder->outq, allocator);
for (size_t i = 0; coder->filters[i].id != LZMA_VLI_UN... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x118f10
movq -0x18(%rbp), %rdi
addq $0x100, %rdi # imm = 0x100
movq -0x10(%rbp), %rsi
callq 0x135be0
movq $0x0, -0x20(%rbp... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
get_progress | static void
get_progress(void *coder_ptr, uint64_t *progress_in, uint64_t *progress_out)
{
lzma_stream_coder *coder = coder_ptr;
// Lock coder->mutex to prevent finishing threads from moving their
// progress info from the worker_thread structure to lzma_stream_coder.
mythread_sync(coder->mutex) {
*progress_in =... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x118d70
movq -0x20(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x119310
xorl %eax, %eax
movl %ea... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
threads_end | static void
threads_end(lzma_stream_coder *coder, const lzma_allocator *allocator)
{
for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
mythread_sync(coder->threads[i].mutex) {
coder->threads[i].state = THR_EXIT;
mythread_cond_signal(&coder->threads[i].cond);
}
}
for (uint32_t i = 0; i < coder->t... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x144(%rcx), %eax
jae 0x119025
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x118f72
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rdi
movl -0x14(%rbp), %eax
i... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
stream_encode_in | static lzma_ret
stream_encode_in(lzma_stream_coder *coder, const lzma_allocator *allocator,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size, lzma_action action)
{
while (*in_pos < in_size
|| (coder->thr != NULL && action != LZMA_RUN)) {
if (coder->thr == NULL) {
// Get a new thread.
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpq -0x30(%rbp), %rcx
movb %al, -0x59(%rbp)
jb 0x119405
movq -0x10(%rbp), %rcx
xor... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
wait_for_work | static bool
wait_for_work(lzma_stream_coder *coder, mythread_condtime *wait_abs,
bool *has_blocked, bool has_input)
{
if (coder->timeout != 0 && !*has_blocked) {
// Every time when stream_encode_mt() is called via
// lzma_code(), *has_blocked starts as false. We set it
// to true here and calculate the absolut... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x130(%rax)
je 0x1196d6
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x1196d6
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
get_thread | static lzma_ret
get_thread(lzma_stream_coder *coder, const lzma_allocator *allocator)
{
// If there are no free output subqueues, there is no
// point to try getting a thread.
if (!lzma_outq_has_buf(&coder->outq))
return LZMA_OK;
// If there is a free structure on the stack, use it.
mythread_sync(coder->mutex) ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x100, %rdi # imm = 0x100
callq 0x119ab0
testb $0x1, %al
jne 0x119860
movl $0x0, -0x4(%rbp)
jmp 0x119a52
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x119884
movq -0x10(%rbp), %rdi
addq... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
initialize_new_thread | static lzma_ret
initialize_new_thread(lzma_stream_coder *coder,
const lzma_allocator *allocator)
{
worker_thread *thr = &coder->threads[coder->threads_initialized];
thr->in = lzma_alloc(coder->block_size, allocator);
if (thr->in == NULL)
return LZMA_MEM_ERROR;
if (mythread_mutex_init(&thr->mutex))
goto erro... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x144(%rcx), %ecx
imulq $0x1c0, %rcx, %rcx # imm = 0x1C0
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
mythread_create | static inline int
mythread_create(mythread *thread, void *(*func)(void *arg), void *arg)
{
sigset_t old;
sigset_t all;
sigfillset(&all);
mythread_sigmask(SIG_SETMASK, &all, &old);
const int ret = pthread_create(thread, NULL, func, arg);
mythread_sigmask(SIG_SETMASK, &old, NULL);
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x10fb0
movl $0x2, %edi
leaq -0x118(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x11a0c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rc... | /JKorbelRA[P]CMake/Utilities/cmliblzma/common/mythread.h |
worker_start | static MYTHREAD_RET_TYPE
worker_start(void *thr_ptr)
{
worker_thread *thr = thr_ptr;
worker_state state = THR_IDLE; // Init to silence a warning
while (true) {
// Wait for work.
mythread_sync(thr->mutex) {
while (true) {
// The thread is already idle so if we are
// requested to stop, just set the st... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x119d2f
movq -0x10(%rbp), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x119310
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x11... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
mythread_sigmask | static inline void
mythread_sigmask(int how, const sigset_t *restrict set,
sigset_t *restrict oset)
{
#ifdef __VMS
(void)how;
(void)set;
(void)oset;
#else
int ret = pthread_sigmask(how, set, oset);
assert(ret == 0);
(void)ret;
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10410
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x11a0ee
jmp 0x11a10d
leaq 0x1ab5bc(%rip), %rdi # 0x2c56b1
leaq 0x1ab5be(... | /JKorbelRA[P]CMake/Utilities/cmliblzma/common/mythread.h |
worker_encode | static worker_state
worker_encode(worker_thread *thr, worker_state state)
{
assert(thr->progress_in == 0);
assert(thr->progress_out == 0);
// Set the Block options.
thr->block_options = (lzma_block){
.version = 0,
.check = thr->coder->stream_flags.check,
.compressed_size = thr->coder->outq.buf_size_max,
.u... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x11a190
jmp 0x11a1af
leaq 0x1ab799(%rip), %rdi # 0x2c5930
leaq 0x1ab437(%rip), %rsi # 0x2c55d5
movl $0xc9, %edx
leaq 0x1ab79c(%rip), %rcx... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
worker_error | static void
worker_error(worker_thread *thr, lzma_ret ret)
{
assert(ret != LZMA_OK);
assert(ret != LZMA_STREAM_END);
mythread_sync(thr->coder->mutex) {
if (thr->coder->thread_error == LZMA_OK)
thr->coder->thread_error = ret;
mythread_cond_signal(&thr->coder->cond);
}
return;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x11a7f7
jmp 0x11a816
leaq 0x1ab1cd(%rip), %rdi # 0x2c59cb
leaq 0x1aadd0(%rip), %rsi # 0x2c55d5
movl $0xb8, %edx
leaq 0x1ab1c9(%rip), %rcx # 0x2c59da
callq 0x103e0
cmpl $0x1, -0xc(%rbp)
je 0x11a81e
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
mythread_condtime_set | static inline void
mythread_condtime_set(mythread_condtime *condtime, const mythread_cond *cond,
uint32_t timeout_ms)
{
condtime->tv_sec = timeout_ms / 1000;
condtime->tv_nsec = (timeout_ms % 1000) * 1000000;
#ifdef HAVE_CLOCK_GETTIME
struct timespec now;
int ret = clock_gettime(cond->clk_id, &now);
assert(ret ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/common/mythread.h |
lzma_stream_header_decode | extern LZMA_API(lzma_ret)
lzma_stream_header_decode(lzma_stream_flags *options, const uint8_t *in)
{
// Magic
if (memcmp(in, lzma_header_magic, sizeof(lzma_header_magic)) != 0)
return LZMA_FORMAT_ERROR;
// Verify the CRC32 so we can distinguish between corrupt
// and unsupported files.
const uint32_t crc = lzma... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1ab02f(%rip), %rsi # 0x2c5b9a
movl $0x6, %edx
callq 0x11b20
cmpl $0x0, %eax
je 0x11ab83
movl $0x7, -0x4(%rbp)
jmp 0x11abf6
movq -0x18(%rbp), %rdi
addq $0x6, %rdi
movl $0x2, %esi
xorl %edx, %edx
cal... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_decoder.c |
read32le | static inline uint32_t
read32le(const uint8_t *buf)
{
#if !defined(WORDS_BIGENDIAN) || defined(TUKLIB_FAST_UNALIGNED_ACCESS)
uint32_t num = read32ne(buf);
return conv32le(num);
#else
uint32_t num = (uint32_t)buf[0];
num |= (uint32_t)buf[1] << 8;
num |= (uint32_t)buf[2] << 16;
num |= (uint32_t)buf[3] << 24;
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11ad70
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
stream_flags_decode | static bool
stream_flags_decode(lzma_stream_flags *options, const uint8_t *in)
{
// Reserved bits must be unset.
if (in[0] != 0x00 || (in[1] & 0xF0))
return true;
options->version = 0;
options->check = in[1] & 0x0F;
return false;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x11ac5a
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0xf0, %eax
cmpl $0x0, %eax
je 0x11ac60
movb $0x1, -0x1(%rbp)
jmp 0x11ac80
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_decoder.c |
lzma_stream_footer_decode | extern LZMA_API(lzma_ret)
lzma_stream_footer_decode(lzma_stream_flags *options, const uint8_t *in)
{
// Magic
if (memcmp(in + sizeof(uint32_t) * 2 + LZMA_STREAM_FLAGS_SIZE,
lzma_footer_magic, sizeof(lzma_footer_magic)) != 0)
return LZMA_FORMAT_ERROR;
// CRC32
const uint32_t crc = lzma_crc32(in + sizeof(uint32... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
addq $0x2, %rax
leaq 0x1aaeed(%rip), %rcx # 0x2c5ba0
movw (%rcx), %cx
movw (%rax), %ax
subw %cx, %ax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x11acd3
movl $0x7, -0x4(%rbp)
jmp 0x11ad... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_decoder.c |
read32ne | static inline uint32_t
read32ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint32_t *)buf;
#else
uint32_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
lzma_stream_header_encode | extern LZMA_API(lzma_ret)
lzma_stream_header_encode(const lzma_stream_flags *options, uint8_t *out)
{
assert(sizeof(lzma_header_magic) + LZMA_STREAM_FLAGS_SIZE
+ 4 == LZMA_STREAM_HEADER_SIZE);
if (options->version != 0)
return LZMA_OPTIONS_ERROR;
// Magic
memcpy(out, lzma_header_magic, sizeof(lzma_header_mag... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x11adb2
movl $0x8, -0x4(%rbp)
jmp 0x11ae1b
movq -0x18(%rbp), %rax
leaq 0x1aaddd(%rip), %rcx # 0x2c5b9a
movl (%rcx), %edx
movl %edx, (%rax)
movw 0x4(%rcx), %cx
movw %cx, 0x4(%rax)
mov... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_encoder.c |
write32ne | static inline void
write32ne(uint8_t *buf, uint32_t num)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
*(uint32_t *)buf = num;
#else
memcpy(buf, &num, sizeof(num));
#endif
return;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
lzma_stream_footer_encode | extern LZMA_API(lzma_ret)
lzma_stream_footer_encode(const lzma_stream_flags *options, uint8_t *out)
{
assert(2 * 4 + LZMA_STREAM_FLAGS_SIZE + sizeof(lzma_footer_magic)
== LZMA_STREAM_HEADER_SIZE);
if (options->version != 0)
return LZMA_OPTIONS_ERROR;
// Backward Size
if (!is_backward_size_valid(options))
r... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x11aeb5
movl $0x8, -0x4(%rbp)
jmp 0x11af46
movq -0x10(%rbp), %rdi
callq 0x11af50
testb $0x1, %al
jne 0x11aecb
movl $0xb, -0x4(%rbp)
jmp 0x11af46
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
m... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_encoder.c |
is_backward_size_valid | static inline bool
is_backward_size_valid(const lzma_stream_flags *options)
{
return options->backward_size >= LZMA_BACKWARD_SIZE_MIN
&& options->backward_size <= LZMA_BACKWARD_SIZE_MAX
&& (options->backward_size & 3) == 0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x4, 0x8(%rcx)
movb %al, -0x9(%rbp)
jb 0x11af97
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movabsq $0x400000000, %rdx # imm = 0x400000000
cmpq %rdx, 0x8(%rcx)
movb %al, -0x9(%rbp)
ja 0x11af97
movq -0x8(%rbp), %rax
movq 0x8(%rax... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_common.h |
lzma_delta_coder_init | extern lzma_ret
lzma_delta_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_filter_info *filters)
{
// Allocate memory for the decoder if needed.
lzma_delta_coder *coder = next->coder;
if (coder == NULL) {
coder = lzma_alloc(sizeof(lzma_delta_coder), allocator);
if (coder == NULL)
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x11b03a
movq -0x18(%rbp), %rsi
movl $0x158, %edi # imm = 0x158
callq 0x1155f0
movq %rax, -0x28(%rbp)
cmp... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_common.c |
lzma_delta_coder_memusage | extern uint64_t
lzma_delta_coder_memusage(const void *options)
{
const lzma_options_delta *opt = options;
if (opt == NULL || opt->type != LZMA_DELTA_TYPE_BYTE
|| opt->dist < LZMA_DELTA_DIST_MIN
|| opt->dist > LZMA_DELTA_DIST_MAX)
return UINT64_MAX;
return sizeof(lzma_delta_coder);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11b137
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x11b137
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jb 0x11b137
movq -0x18(%rbp), %rax
cmpl $0x100, 0x4(%rax) # imm = 0x100
jbe 0x11b141
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_common.c |
delta_decode | static lzma_ret
delta_decode(void *coder_ptr, const lzma_allocator *allocator,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size, uint8_t *restrict out,
size_t *restrict out_pos, size_t out_size, lzma_action action)
{
lzma_delta_coder *coder = coder_ptr;
assert(coder->next.code != NULL);
co... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_decoder.c |
lzma_delta_props_decode | extern lzma_ret
lzma_delta_props_decode(void **options, const lzma_allocator *allocator,
const uint8_t *props, size_t props_size)
{
if (props_size != 1)
return LZMA_OPTIONS_ERROR;
lzma_options_delta *opt
= lzma_alloc(sizeof(lzma_options_delta), allocator);
if (opt == NULL)
return LZMA_MEM_ERROR;
opt->typ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
je 0x11b298
movl $0x8, -0x4(%rbp)
jmp 0x11b2e7
movq -0x18(%rbp), %rsi
movl $0x28, %edi
callq 0x1155f0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x11b2ba
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_decoder.c |
delta_encode | static lzma_ret
delta_encode(void *coder_ptr, const lzma_allocator *allocator,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size, uint8_t *restrict out,
size_t *restrict out_pos, size_t out_size, lzma_action action)
{
lzma_delta_coder *coder = coder_ptr;
lzma_ret ret;
if (coder->next.code =... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_encoder.c |
delta_encoder_update | static lzma_ret
delta_encoder_update(void *coder_ptr, const lzma_allocator *allocator,
const lzma_filter *filters_null lzma_attribute((__unused__)),
const lzma_filter *reversed_filters)
{
lzma_delta_coder *coder = coder_ptr;
// Delta doesn't and will never support changing the options in
// the middle of encodi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x10, %rdx
callq 0x115910
addq $0x30, %rsp
popq %rbp
retq
nopl (%... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_encoder.c |
copy_and_encode | static void
copy_and_encode(lzma_delta_coder *coder,
const uint8_t *restrict in, uint8_t *restrict out, size_t size)
{
const size_t distance = coder->distance;
for (size_t i = 0; i < size; ++i) {
const uint8_t tmp = coder->history[
(distance + coder->pos) & 0xFF];
coder->history[coder->pos-- & 0xFF] = in[i... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x11b6a8
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_encoder.c |
lzma_lz_decoder_init | extern lzma_ret
lzma_lz_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_filter_info *filters,
lzma_ret (*lz_init)(lzma_lz_decoder *lz,
const lzma_allocator *allocator, const void *options,
lzma_lz_options *lz_options))
{
// Allocate the base structure if it isn't already alloc... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x11b86f
movq -0x18(%rbp), %rsi
movl $0x10b8, %edi # imm = 0x10B8
callq 0x1155f0
mo... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_decoder.c |
lz_decode | static lzma_ret
lz_decode(void *coder_ptr, const lzma_allocator *allocator,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size, uint8_t *restrict out,
size_t *restrict out_pos, size_t out_size,
lzma_action action)
{
lzma_coder *coder = coder_ptr;
if (coder->next.code == NULL)
return decode... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_decoder.c |
lz_decoder_end | static void
lz_decoder_end(void *coder_ptr, const lzma_allocator *allocator)
{
lzma_coder *coder = coder_ptr;
lzma_next_end(&coder->next, allocator);
lzma_free(coder->dict.buf, allocator);
if (coder->lz.end != NULL)
coder->lz.end(coder->lz.coder, allocator);
else
lzma_free(coder->lz.coder, allocator);
lzma... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
movq -0x10(%rbp), %rsi
callq 0x115880
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1156f0
movq -0x18(%rbp), %rax
cmpq $... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_decoder.c |
decode_buffer | static lzma_ret
decode_buffer(lzma_coder *coder,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size, uint8_t *restrict out,
size_t *restrict out_pos, size_t out_size)
{
while (true) {
// Wrap the dictionary if needed.
if (coder->dict.pos == coder->dict.size)
coder->dict.pos = 0;
// Sto... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x11be32
movq -0x10(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_decoder.c |
lzma_lzma2_props_decode | extern lzma_ret
lzma_lzma2_props_decode(void **options, const lzma_allocator *allocator,
const uint8_t *props, size_t props_size)
{
if (props_size != 1)
return LZMA_OPTIONS_ERROR;
// Check that reserved bits are unset.
if (props[0] & 0xC0)
return LZMA_OPTIONS_ERROR;
// Decode the dictionary size.
if (props... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
je 0x11c17b
movl $0x8, -0x4(%rbp)
jmp 0x11c23e
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x11c198
movl $0x8, -0x4(%rbp)
jmp ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma2_decoder.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.