name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
bignSeedInc | static void bignSeedInc(octet seed[8])
{
register word carry;
size_t pos;
ASSERT(memIsValid(seed, 8));
for (carry = 1, pos = 0; pos < 8; ++pos)
carry += seed[pos], seed[pos] = (octet)carry, carry >>= 8;
carry = 0;
} | pushq $0x1
popq %rax
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x2c78c
movzbl (%rdi,%rcx), %edx
addq %rdx, %rax
movb %al, (%rdi,%rcx)
shrq $0x8, %rax
incq %rcx
jmp 0x2c773
retq
| /agievich[P]bee2/src/crypto/bign/bign_params.c |
ecpDetIsZero | bool_t ecpDetIsZero(const word a[], const word b[], const word p[], size_t n,
void* stack)
{
// переменные в stack
word* t1 = (word*)stack;
word* t2 = t1 + n;
stack = t2 + n;
// t1 <- 4 A^3
zzSqrMod(t1, a, p, n, stack);
zzMulMod(t1, t1, a, p, n, stack);
zzMulWMod(t1, t1, 4, p, n, stack);
// t2 <- 27 B^2
zzSqrMod(t2, b, p, n, stack);
zzMulWMod(t2, t2, 27, p, n, stack);
// t1 <- t1 + t2 [4 A^3 + 27 B^2 -- дискриминант]
zzAddMod(t1, t1, t2, p, n);
// t1 == 0?
return wwIsZero(t1, n);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, (%rsp)
movq %rdi, %rbp
leaq (%r8,%rcx,8), %r12
leaq (%r12,%rcx,8), %r13
movq %r8, %rdi
movq %rbp, %rsi
movq %r13, %r8
callq 0xe030
movq %r14, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0xe8e0
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0xfd40
movq %r12, %rdi
movq (%rsp), %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0xe030
pushq $0x1b
popq %rdx
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0xfd40
movq %r14, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0xfff0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xffc0
| /agievich[P]bee2/src/crypto/bign/bign_params.c |
ecpDetIsZero_deep | size_t ecpDetIsZero_deep(size_t n)
{
return O_OF_W(2 * n) +
utilMax(3,
zzSqrMod_deep(n),
zzMulMod_deep(n),
zzMulWMod_deep(n)
);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %r12
shlq $0x4, %r12
callq 0xea60
movq %rax, %r14
movq %rbx, %rdi
callq 0xe0b0
movq %rax, %r15
movq %rbx, %rdi
callq 0xf500
pushq $0x3
popq %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xe320
addq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/crypto/bign/bign_params.c |
ecpMOVIsMet | bool_t ecpMOVIsMet(const word q[], const word p[], size_t n,
size_t threshold, void* stack)
{
// переменные в stack
word* t1 = (word*)stack;
word* t2 = t1 + n;
stack = t2 + n;
// t1, t2 <- p mod q
ASSERT(threshold > 0);
zzMod(t1, p, n, q, n, stack);
wwCopy(t2, t1, n);
// p mod q == 1?
if (wwCmpW(t2, n, 1) == 0)
return FALSE;
while (--threshold)
{
// p^i mod q == 1?
zzMulMod(t2, t2, t1, q, n, stack);
if (wwCmpW(t2, n, 1) == 0)
return FALSE;
}
return TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
leaq (%r8,%rdx,8), %r13
leaq (%r13,%rdx,8), %rbp
movq %r8, %rdi
movq %r12, %rcx
movq %rdx, %r8
movq %rbp, %r9
callq 0xfc00
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xe5c0
pushq $0x1
popq %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0xe3b0
xorl %ecx, %ecx
testl %eax, %eax
je 0x2c91c
decq %r14
je 0x2c919
movq %r13, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbp, %r9
callq 0xe8e0
movq %r13, %rdi
movq %r15, %rsi
pushq $0x1
popq %rdx
callq 0xe3b0
testl %eax, %eax
jne 0x2c8e7
xorl %ecx, %ecx
jmp 0x2c91c
pushq $0x1
popq %rcx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/crypto/bign/bign_params.c |
bignParamsGen | err_t bignParamsGen(bign_params* params, bign_pgen_calc_q calc_q,
bign_pgen_on_seed on_seed, void* state)
{
err_t code;
size_t no, n;
// состояние (буферы могут пересекаться)
void* st;
word* p; /* [n] */
word* a; /* [n] */
word* b; /* [W_OF_B(512)] B / [n] b */
word* q; /* [n] */
word* yG; /* [n] */
octet* seed; /* [8] */
octet* hash_state; /* [beltHash_keep] */
void* stack;
// проверить входные данные
if (!memIsValid(params, sizeof(bign_params)) ||
!calc_q)
return ERR_BAD_INPUT;
// проверить уровень стойкости
if (params->l != 128 && params->l != 192 && params->l != 256)
return ERR_BAD_PARAMS;
// размерности
no = O_OF_B(2 * params->l);
n = W_OF_B(2 * params->l);
// проверить params:
// - p -- 2l-битовое число?
// - p mod 4 == 3?
// - 0 < a < p?
// - неиспользуемые октеты p и a обнулены?
if (params->p[0] % 4 != 3 || params->p[no - 1] < 128 ||
memIsZero(params->a, no) ||
memCmpRev(params->a, params->p, no) >= 0 ||
!memIsZero(params->p + no, sizeof(params->p) - no) ||
!memIsZero(params->a + no, sizeof(params->a) - no))
return ERR_BAD_PARAMS;
// создать состояние
st = blobCreate(bignParamsGen_deep(n));
if (st == 0)
return ERR_OUTOFMEMORY;
// раскладка состояния
p = (word*)st;
a = p + n;
b = a + n;
q = yG = b + n;
seed = (octet*)(q + n);
hash_state = seed + 8;
stack = hash_state + beltHash_keep();
ASSERT((octet*)b + 64 <= seed);
// загрузить и проверить p
wwFrom(p, params->p, no);
ASSERT(wwBitSize(p, n) == params->l * 2);
ASSERT(wwGetBits(p, 0, 2) == 3);
if (!priIsPrime(p, n, stack))
{
blobClose(st);
return ERR_BAD_PARAMS;
}
// загрузить a
wwFrom(a, params->a, no);
ASSERT(!wwIsZero(a, n));
ASSERT(wwCmp(a, p, n) < 0);
// загрузить seed
memCopy(seed, params->seed, 8);
// цикл генерации
while (1)
{
// обработать seed
memCopy(params->seed, seed, 8);
if (on_seed)
{
code = on_seed(params, state);
ERR_CALL_HANDLE(code, blobClose(st));
}
// belt-hash(p || a ||..)
beltHashStart(hash_state);
beltHashStepH(params->p, no, hash_state);
beltHashStepH(params->a, no, hash_state);
memCopy(stack, hash_state, beltHash_keep());
// belt-hash(..seed)
beltHashStepH(params->seed, 8, hash_state);
// belt-hash(..seed + 1)
bignSeedInc(seed);
beltHashStepH(seed, 8, stack);
// B <- belt-hash(p || a || seed) || belt-hash(p || a || seed + 1)
beltHashStepG((octet*)b, hash_state);
beltHashStepG((octet*)b + 32, stack);
// b <- B \mod p
wwFrom(b, b, 64);
zzMod(b, b, W_OF_O(64), p, n, stack);
// проверить b
if (ecpDetIsZero(a, b, p, n, stack) ||
zzJacobi(b, n, p, n, stack) != 1)
continue;
// сохранить b
wwTo(params->b, no, b);
memSetZero(params->b + no, sizeof(params->b) - no);
// вычиcлить q
code = calc_q(params, state);
if (code == ERR_NO_RESULT)
continue;
ERR_CALL_HANDLE(code, blobClose(st));
// загрузить и проверить q
wwFrom(q, params->q, no);
if (wwBitSize(q, n) == params->l * 2 &&
!wwEq(q, p, n) &&
priIsPrime(q, n, stack) &&
ecpMOVIsMet(q, p, n, 50, stack))
break;
}
// сохранить q
memSetZero(params->q + no, sizeof(params->q) - no);
// вычислить yG = b^{(p + 1) / 4} mod p
wwCopy(a, p, n);
zzAddW2(a, n, 1);
ASSERT(!wwIsZero(a, n));
wwShLo(a, n, 2);
zzPowerMod(yG, b, n, a, n, p, stack);
// сохранить yG
wwTo(params->yG, no, yG);
memSetZero(params->yG + no, sizeof(params->yG) - no);
// завершение
blobClose(st);
return code;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl $0x150, %esi # imm = 0x150
callq 0xeeb0
pushq $0x6d
popq %rbp
testq %r13, %r13
je 0x2ca15
testl %eax, %eax
je 0x2ca15
movq (%rbx), %r14
movl $0x1f6, %ebp # imm = 0x1F6
cmpq $0x80, %r14
je 0x2c9be
cmpq $0x100, %r14 # imm = 0x100
je 0x2c9be
cmpq $0xc0, %r14
jne 0x2ca15
movb 0x8(%rbx), %al
notb %al
testb $0x3, %al
jne 0x2ca15
movq %r15, 0x40(%rsp)
leaq 0x7(,%r14,2), %r15
shrq $0x3, %r15
leaq 0x8(%rbx), %rax
cmpb $0x0, -0x1(%r15,%rax)
jns 0x2ca15
movq %r12, 0x70(%rsp)
movq %rax, 0x38(%rsp)
leaq 0x48(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xfe60
testl %eax, %eax
jne 0x2ca15
movq %r12, %rdi
movq 0x38(%rsp), %rsi
movq %r15, %rdx
callq 0xe580
testl %eax, %eax
js 0x2ca29
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, 0x58(%rsp)
movq 0x38(%rsp), %rax
leaq (%rax,%r15), %rdi
pushq $0x40
popq %r12
subq %r15, %r12
movq %r12, %rsi
callq 0xfe60
testl %eax, %eax
je 0x2ca15
movq %r15, 0x8(%rsp)
movq 0x58(%rsp), %rax
leaq (%rax,%r15), %rdi
movq %r12, 0x48(%rsp)
movq %r12, %rsi
callq 0xfe60
testl %eax, %eax
je 0x2ca15
leaq 0x3f(,%r14,2), %r15
shrq $0x6, %r15
movq %r15, %r14
shlq $0x5, %r14
xorl %eax, %eax
callq 0xe560
movq %rax, %rbp
addq %r14, %rbp
xorl %eax, %eax
callq 0xe560
movq %rax, %r14
movq %r15, %rdi
callq 0xeca0
movq %rax, %r12
movq %r15, %rdi
callq 0xfbf0
movq %rax, 0x20(%rsp)
movq %r15, %rdi
callq 0xed00
movq %rax, 0x30(%rsp)
movq %r15, %rdi
movq %r15, %rsi
callq 0xfab0
pushq $0x5
popq %rdi
movq %r14, %rsi
movq %r12, %rdx
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xe320
leaq (%rax,%rbp), %rdi
addq $0x8, %rdi
callq 0xf190
testq %rax, %rax
je 0x2ce91
movq %rax, %rbp
leaq (%rax,%r15,8), %rax
movq %rax, 0x50(%rsp)
leaq (%rax,%r15,8), %r12
leaq (%r12,%r15,8), %rax
movq %rax, 0x68(%rsp)
leaq (%rax,%r15,8), %r14
xorl %eax, %eax
callq 0xe560
movq %r14, 0x20(%rsp)
addq %rax, %r14
addq $0x8, %r14
movq %rbp, %rdi
movq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xf540
movq %rbp, 0x18(%rsp)
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, 0x28(%rsp)
movq %r14, %rdx
callq 0xff80
testl %eax, %eax
je 0x2ce9d
movq %r15, 0x10(%rsp)
movq 0x68(%rsp), %r14
leaq (%r14,%r15,8), %rax
addq $0x8, %rax
movq %rax, 0x90(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0xf540
leaq 0x148(%rbx), %rsi
pushq $0x8
popq %rdx
movq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %rsi, 0x30(%rsp)
callq 0xe970
leaq 0x20(%r12), %rax
movq %rax, 0x88(%rsp)
leaq 0x88(%rbx), %rax
movq %rax, 0x80(%rsp)
leaq 0x88(%rbx,%r15), %rax
movq %rax, 0x78(%rsp)
leaq 0xc8(%rbx), %rax
movq %rax, 0x60(%rsp)
movq %r12, %r15
movq %rbp, %r14
movq 0x30(%rsp), %rdi
movq %r14, %rsi
pushq $0x8
popq %rdx
callq 0xe970
cmpq $0x0, 0x70(%rsp)
je 0x2cc0c
movq %rbx, %rdi
movq 0x40(%rsp), %rsi
callq *0x70(%rsp)
testl %eax, %eax
jne 0x2ce99
movq 0x90(%rsp), %rbp
movq %rbp, %rdi
callq 0xe5d0
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
movq %rbp, %rdx
callq 0xe360
movq 0x58(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xe360
xorl %eax, %eax
callq 0xe560
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0xe970
movq 0x30(%rsp), %rdi
pushq $0x8
popq %r12
movq %r12, %rsi
movq %rbp, %rdx
callq 0xe360
movq 0x20(%rsp), %rdi
callq 0x2c76e
movq 0x20(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe360
movq %r15, %rdi
movq %rbp, %rsi
callq 0xf1f0
movq 0x88(%rsp), %rdi
movq %r14, %rsi
callq 0xf1f0
movq %r15, %rdi
movq %r15, %rsi
pushq $0x40
popq %rdx
callq 0xf540
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq 0x18(%rsp), %r12
movq %r12, %rcx
movq 0x10(%rsp), %rbp
movq %rbp, %r8
movq %r14, %r9
callq 0xfc00
movq 0x50(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq 0x68(%rsp), %r12
movq %rbp, %rcx
movq %r14, %r8
movq 0x20(%rsp), %r14
callq 0xf2e0
testl %eax, %eax
jne 0x2cbe0
movq %r15, %rdi
movq 0x10(%rsp), %rcx
movq %rcx, %rsi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %r8
callq 0xeb60
cmpl $0x1, %eax
jne 0x2cbe0
movq 0x80(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0xf300
movq 0x78(%rsp), %rdi
xorl %esi, %esi
movq 0x48(%rsp), %rdx
callq 0xf710
movq %rbx, %rdi
movq 0x40(%rsp), %rsi
callq *%r13
cmpl $0x76, %eax
je 0x2cbe0
movl %eax, %ebp
testl %eax, %eax
jne 0x2cea2
movq %r12, %rdi
movq 0x60(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xf540
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0xeb10
movq (%rbx), %rcx
addq %rcx, %rcx
cmpq %rcx, %rax
jne 0x2cbe0
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xf520
testl %eax, %eax
jne 0x2cbe0
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xff80
testl %eax, %eax
je 0x2cbe0
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
pushq $0x32
popq %rcx
movq 0x28(%rsp), %r8
callq 0xfc60
testl %eax, %eax
je 0x2cbe0
movq %r15, 0x40(%rsp)
movq 0x60(%rsp), %rdi
addq 0x8(%rsp), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
movq 0x48(%rsp), %rdx
callq 0xf710
movq %r12, %r14
movq 0x50(%rsp), %r12
movq %r12, %rdi
movq 0x18(%rsp), %r13
movq %r13, %rsi
movq 0x10(%rsp), %r15
movq %r15, %rdx
callq 0xe5c0
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xeb00
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xf9a0
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq 0x40(%rsp), %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r13, %r9
callq 0xf1c0
leaq 0x108(%rbx), %rdi
movq 0x8(%rsp), %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0xf300
leaq (%rbx,%r15), %rdi
addq $0x108, %rdi # imm = 0x108
xorl %esi, %esi
movq 0x48(%rsp), %rdx
callq 0xf710
jmp 0x2cea2
pushq $0x6e
popq %rbp
jmp 0x2ca15
movl %eax, %ebp
jmp 0x2cea2
movl $0x1f6, %ebp # imm = 0x1F6
movq 0x18(%rsp), %rdi
callq 0xe920
jmp 0x2ca15
| /agievich[P]bee2/src/crypto/bign/bign_params.c |
bignParamsEnc | err_t bignParamsEnc(octet der[], size_t* count, const bign_params* params)
{
size_t len;
if (!memIsValid(params, sizeof(bign_params)) ||
!memIsValid(count, O_PER_S) ||
!memIsNullOrValid(der, *count))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
len = bignParamsEnc_internal(0, params);
if (len == SIZE_MAX)
return ERR_BAD_PARAMS;
if (der)
{
if (*count < len)
return ERR_OUTOFMEMORY;
len = bignParamsEnc_internal(der, params);
ASSERT(len != SIZE_MAX);
}
*count = len;
return ERR_OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl $0x150, %esi # imm = 0x150
movq %rdx, %rdi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2cf38
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2cf38
testq %r15, %r15
je 0x2cef8
movq (%rbx), %rsi
movq %r15, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2cf38
movq %r14, %rdi
callq 0x101d0
movl $0x1f6, %ebp # imm = 0x1F6
testl %eax, %eax
je 0x2cf38
xorl %edi, %edi
movq %r14, %rsi
callq 0x2cf45
cmpq $-0x1, %rax
je 0x2cf38
testq %r15, %r15
je 0x2cf33
cmpq %rax, (%rbx)
jae 0x2cf28
pushq $0x6e
popq %rbp
jmp 0x2cf38
movq %r15, %rdi
movq %r14, %rsi
callq 0x2cf45
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/crypto/bign/bign_params.c |
bignParamsEnc_internal | static size_t bignParamsEnc_internal(octet der[], const bign_params* params)
{
der_anchor_t ParamSeq[1];
der_anchor_t FieldSeq[1];
der_anchor_t CurveSeq[1];
size_t count = 0;
// начать кодирование...
derEncStep(derSEQEncStart(ParamSeq, der, count), der, count);
// ...version...
derEncStep(derSIZEEnc(der, 1), der, count);
// ...FieldID...
derEncStep(derSEQEncStart(FieldSeq, der, count), der, count);
derEncStep(derOIDEnc(der, oid_bign_primefield), der, count);
derEncStep(derUINTEnc(der, params->p, params->l / 4), der, count);
derEncStep(derSEQEncStop(der, count, FieldSeq), der, count);
// ...Curve...
derEncStep(derSEQEncStart(CurveSeq, der, count), der, count);
derEncStep(derOCTEnc(der, params->a, params->l / 4), der, count);
derEncStep(derOCTEnc(der, params->b, params->l / 4), der, count);
derEncStep(derBITEnc(der, params->seed, 64), der, count);
derEncStep(derSEQEncStop(der, count, CurveSeq), der, count);
// ...base...
derEncStep(derOCTEnc(der, params->yG, params->l / 4), der, count);
// ...order...
derEncStep(derUINTEnc(der, params->q, params->l / 4), der, count);
// ...завершить кодирование
derEncStep(derSEQEncStop(der, count, ParamSeq), der, count);
// возвратить длину DER-кода
return count;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x40(%rsp), %rdi
pushq $0x30
popq %rcx
movq %r12, %rsi
xorl %edx, %edx
callq 0xf200
movq %rax, %r13
leaq (%r12,%rax), %rbx
testq %r12, %r12
cmoveq %r12, %rbx
pushq $0x2
popq %r12
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %r12d, %esi
callq 0xe1c0
movq %rax, %rbp
leaq (%rbx,%rax), %r15
testq %rbx, %rbx
cmoveq %rbx, %r15
addq %r13, %rbp
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
pushq $0x30
popq %rcx
callq 0xf200
movq %rax, %rbx
leaq (%r15,%rax), %r13
testq %r15, %r15
cmoveq %r15, %r13
addq %rbp, %rbx
leaq 0x22459(%rip), %rsi # 0x4f420
movq %r13, %rdi
callq 0xe5f0
movq %rax, %r15
leaq (%rax,%r13), %rbp
testq %r13, %r13
cmoveq %r13, %rbp
addq %rbx, %r15
leaq 0x8(%r14), %rdx
movq (%r14), %rcx
shrq $0x2, %rcx
movq %rbp, %rdi
movl %r12d, %esi
callq 0xe4c0
movq %rax, %rbx
leaq (%rax,%rbp), %r13
testq %rbp, %rbp
cmoveq %rbp, %r13
addq %r15, %rbx
movq %r13, %rdi
movq %rbx, %rsi
leaq 0x20(%rsp), %rdx
callq 0xf770
movq %rax, %r15
leaq (%rax,%r13), %rbp
testq %r13, %r13
cmoveq %r13, %rbp
addq %rbx, %r15
movq %rsp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
pushq $0x30
popq %rcx
callq 0xf200
movq %rax, %rbx
leaq (%rax,%rbp), %r13
testq %rbp, %rbp
cmoveq %rbp, %r13
addq %r15, %rbx
leaq 0x48(%r14), %rdx
movq (%r14), %rcx
shrq $0x2, %rcx
pushq $0x4
popq %r15
movq %r13, %rdi
movl %r15d, %esi
callq 0xe720
movq %rax, %rbp
leaq (%rax,%r13), %r12
testq %r13, %r13
cmoveq %r13, %r12
addq %rbx, %rbp
leaq 0x88(%r14), %rdx
movq (%r14), %rcx
shrq $0x2, %rcx
movq %r12, %rdi
movl %r15d, %esi
callq 0xe720
movq %rax, %rbx
leaq (%r12,%rax), %r13
testq %r12, %r12
cmoveq %r12, %r13
addq %rbp, %rbx
leaq 0x148(%r14), %rdx
pushq $0x3
popq %rsi
pushq $0x40
popq %rcx
movq %r13, %rdi
callq 0xf270
movq %rax, %r12
leaq (%rax,%r13), %rbp
testq %r13, %r13
cmoveq %r13, %rbp
addq %rbx, %r12
movq %rbp, %rdi
movq %r12, %rsi
movq %rsp, %rdx
callq 0xf770
movq %rax, %rbx
leaq (%rax,%rbp), %r13
testq %rbp, %rbp
cmoveq %rbp, %r13
addq %r12, %rbx
leaq 0x108(%r14), %rdx
movq (%r14), %rcx
shrq $0x2, %rcx
movq %r13, %rdi
movl %r15d, %esi
callq 0xe720
movq %rax, %r15
leaq (%rax,%r13), %r12
testq %r13, %r13
cmoveq %r13, %r12
addq %rbx, %r15
movq (%r14), %rcx
addq $0xc8, %r14
shrq $0x2, %rcx
movq %r12, %rdi
pushq $0x2
popq %rsi
movq %r14, %rdx
callq 0xe4c0
movq %rax, %rbx
leaq (%r12,%rax), %rdi
testq %r12, %r12
cmoveq %r12, %rdi
addq %r15, %rbx
movq %rbx, %rsi
leaq 0x40(%rsp), %rdx
callq 0xf770
addq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/crypto/bign/bign_params.c |
bignParamsDec | err_t bignParamsDec(bign_params* params, const octet der[], size_t count)
{
size_t len;
if (!memIsValid(params, sizeof(bign_params)) ||
!memIsValid(der, count))
return ERR_BAD_INPUT;
len = bignParamsDec_internal(params, der, count);
if (len == SIZE_MAX || len != count)
return ERR_BAD_FORMAT;
return ERR_OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x150, %esi # imm = 0x150
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2d440
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2d440
movq $0x20, (%rsp)
xorl %ebp, %ebp
movl $0x150, %edx # imm = 0x150
movq %r15, %rdi
xorl %esi, %esi
callq 0xf710
leaq 0x50(%rsp), %rdi
pushq $0x30
popq %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf3e0
pushq $-0x1
popq %rcx
cmpq $-0x1, %rax
je 0x2d42e
movq %rax, %r12
movq %rbx, %r13
subq %rax, %r13
addq %r14, %r12
pushq $0x2
popq %rdx
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r13, %rsi
callq 0xfb10
cmpq $-0x1, %rax
je 0x2d42b
subq %rax, %r13
addq %rax, %r12
leaq 0x30(%rsp), %rdi
pushq $0x30
popq %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0xf3e0
cmpq $-0x1, %rax
je 0x2d42b
subq %rax, %r13
addq %rax, %r12
leaq 0x221f7(%rip), %rdx # 0x4f420
movq %r12, %rdi
movq %r13, %rsi
callq 0xe150
cmpq $-0x1, %rax
je 0x2d42b
addq %rax, %r12
subq %rax, %r13
movq %rsp, %rsi
pushq $0x2
popq %r8
xorl %edi, %edi
movq %r12, %rdx
movq %r13, %rcx
callq 0xf9e0
cmpq $-0x1, %rax
je 0x2d42b
movq (%rsp), %rax
leaq -0x20(%rax), %rcx
cmpq $0x20, %rcx
ja 0x2d42b
movabsq $0x100010001, %rdx # imm = 0x100010001
btq %rcx, %rdx
jae 0x2d42b
shlq $0x2, %rax
movq %rax, (%r15)
leaq 0x8(%r15), %rdi
movq %rsp, %rsi
pushq $0x2
popq %r8
movq %r12, %rdx
movq %r13, %rcx
callq 0xf9e0
cmpq $-0x1, %rax
je 0x2d42b
movq %rax, 0x8(%rsp)
addq %rax, %r12
leaq 0x30(%rsp), %rsi
movq %r12, %rdi
callq 0xff20
cmpq $-0x1, %rax
je 0x2d42b
movq 0x8(%rsp), %rcx
addq %rax, %rcx
subq %rcx, %r13
addq %rax, %r12
leaq 0x10(%rsp), %rdi
pushq $0x30
popq %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0xf3e0
cmpq $-0x1, %rax
je 0x2d42b
subq %rax, %r13
addq %rax, %r12
leaq 0x48(%r15), %rdi
movq (%rsp), %r8
pushq $0x4
popq %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0xeb40
cmpq $-0x1, %rax
je 0x2d42b
subq %rax, %r13
addq %rax, %r12
leaq 0x88(%r15), %rdi
movq (%rsp), %r8
pushq $0x4
popq %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0xeb40
cmpq $-0x1, %rax
je 0x2d42b
subq %rax, %r13
addq %rax, %r12
leaq 0x148(%r15), %rdi
pushq $0x3
popq %rcx
pushq $0x40
popq %r8
movq %r12, %rsi
movq %r13, %rdx
callq 0xef70
cmpq $-0x1, %rax
je 0x2d42b
movq %rax, 0x8(%rsp)
addq %rax, %r12
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0xff20
cmpq $-0x1, %rax
je 0x2d42b
movq 0x8(%rsp), %rcx
addq %rax, %rcx
subq %rcx, %r13
addq %rax, %r12
leaq 0x108(%r15), %rdi
movq (%rsp), %r8
pushq $0x4
popq %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0xeb40
cmpq $-0x1, %rax
je 0x2d42b
subq %rax, %r13
addq %rax, %r12
addq $0xc8, %r15
movq (%rsp), %r8
pushq $0x2
popq %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xe520
cmpq $-0x1, %rax
je 0x2d42b
subq %rax, %r13
addq %rax, %r12
pushq $0x2
popq %rdx
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r13, %rsi
callq 0xfb10
xorl %r15d, %r15d
cmpq $-0x1, %rax
cmovneq %rax, %r15
addq %r12, %r15
leaq 0x50(%rsp), %rsi
movq %r15, %rdi
callq 0xff20
cmpq $-0x1, %rax
pushq $-0x1
popq %rcx
je 0x2d42e
addq %rax, %r15
subq %r14, %r15
movq %r15, %rcx
jmp 0x2d42e
pushq $-0x1
popq %rcx
cmpq %rbx, %rcx
movl $0x132, %eax # imm = 0x132
cmovnel %eax, %ebp
cmpq $-0x1, %rcx
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| /agievich[P]bee2/src/crypto/bign/bign_params.c |
bignSign | err_t bignSign(octet sig[], const bign_params* params, const octet oid_der[],
size_t oid_len, const octet hash[], const octet privkey[], gen_i rng,
void* rng_state)
{
err_t code;
size_t no, n;
// состояние (буферы могут пересекаться)
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* k; /* [n] одноразовый личный ключ */
word* R; /* [2n] точка R */
word* s0; /* [n/2] первая часть подписи */
word* s1; /* [n] вторая часть подписи */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// проверить oid_der
if (oid_len == SIZE_MAX || oidFromDER(0, oid_der, oid_len) == SIZE_MAX)
return ERR_BAD_OID;
// проверить rng
if (rng == 0)
return ERR_BAD_RNG;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignSign_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
ASSERT(n % 2 == 0);
// проверить входные указатели
if (!memIsValid(hash, no) ||
!memIsValid(privkey, no) ||
!memIsValid(sig, no + no / 2) ||
!memIsDisjoint2(hash, no, sig, no + no / 2))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = s1 = objEnd(ec, word);
k = d + n;
R = k + n;
s0 = R + n + n / 2;
stack = (octet*)(R + 2 * n);
// загрузить d
wwFrom(d, privkey, no);
if (wwIsZero(d, n) || wwCmp(d, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// сгенерировать k с помощью rng
if (!zzRandNZMod(k, ec->order, n, rng, rng_state))
{
blobClose(state);
return ERR_BAD_RNG;
}
// R <- k G
if (!ecMulA(R, ec->base, ec, k, n, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
qrTo((octet*)R, ecX(R), ec->f, stack);
// s0 <- belt-hash(oid || R || H) mod 2^l
beltHashStart(stack);
beltHashStepH(oid_der, oid_len, stack);
beltHashStepH(R, no, stack);
beltHashStepH(hash, no, stack);
beltHashStepG2(sig, no / 2, stack);
wwFrom(s0, sig, no / 2);
// R <- (s0 + 2^l) d
zzMul(R, s0, n / 2, d, n, stack);
R[n + n / 2] = zzAdd(R + n / 2, R + n / 2, d, n);
// s1 <- R mod q
zzMod(s1, R, n + n / 2 + 1, ec->order, n, stack);
// s1 <- (k - s1 - H) mod q
zzSubMod(s1, k, s1, ec->order, n);
wwFrom(k, hash, no);
zzSubMod(s1, s1, k, ec->order, n);
// выгрузить s1
wwTo(sig + no / 2, no, s1);
// все нормально
blobClose(state);
return ERR_OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
movl $0x150, %esi # imm = 0x150
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2d79d
movq %rbx, %rdi
callq 0x101d0
testl %eax, %eax
je 0x2d7a3
movq %r15, 0x18(%rsp)
movl $0x12d, %r15d # imm = 0x12D
cmpq $-0x1, %rbp
je 0x2d7d1
xorl %edi, %edi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xe710
cmpq $-0x1, %rax
je 0x2d7d1
cmpq $0x0, 0x80(%rsp)
je 0x2d7ab
movq (%rbx), %rdi
leaq 0x305(%rip), %rsi # 0x2d7e3
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2d7b3
movq %rax, %rdi
movq %rbx, %rsi
movq %rax, (%rsp)
callq 0xf290
movl %eax, %r15d
movq (%rsp), %rbx
testl %eax, %eax
jne 0x2d7c9
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x38(%rax), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeeb0
pushq $0x6d
popq %r15
testl %eax, %eax
je 0x2d7c5
movq %r12, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2d7c5
movq %rbx, %rax
shrq %rax
movq %rax, 0x28(%rsp)
leaq (%rax,%rbx), %rsi
movq %rbx, 0x10(%rsp)
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %rsi, 0x8(%rsp)
callq 0xeeb0
testl %eax, %eax
je 0x2d7c5
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
movq 0x8(%rsp), %rcx
callq 0x10140
testl %eax, %eax
movq (%rsp), %rbx
je 0x2d7c9
movq (%rbx), %r15
addq %rbx, %r15
movq %r15, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
callq 0xf540
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq 0x30(%rsp), %r12
movq %r12, %rsi
callq 0xffc0
movl $0x1f8, %r15d # imm = 0x1F8
testl %eax, %eax
jne 0x2d7c9
movq 0x38(%rbx), %rsi
movq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0xf1b0
testl %eax, %eax
jns 0x2d7c9
movq 0x88(%rsp), %r8
movq 0x30(%rsp), %r15
movq 0x8(%rsp), %rax
leaq (%rax,%r15,8), %r12
movq 0x38(%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq 0x80(%rsp), %rcx
callq 0xfc40
testl %eax, %eax
je 0x2d7b7
movq %rbx, %rdx
movq %r15, %rbx
movq %r12, %rcx
leaq (%r12,%r15,8), %r12
shlq $0x4, %r15
addq %r12, %r15
movq 0x30(%rdx), %rsi
movq %r12, %rdi
movq %rcx, 0x40(%rsp)
movq %rbx, %r8
movq %r15, %r9
callq 0xff30
testl %eax, %eax
je 0x2d7bf
leaq (%r12,%rbx,8), %rax
movq %rbx, %rcx
shrq %rcx
movq %rcx, 0x38(%rsp)
leaq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
movq 0x18(%rax), %rdx
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq *0x48(%rdx)
movq %r15, %rdi
callq 0xe5d0
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xe360
movq %r12, %rdi
movq 0x10(%rsp), %r13
movq %r13, %rsi
movq %r15, %rdx
callq 0xe360
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe360
movq 0x18(%rsp), %r13
movq %r13, %rdi
movq 0x28(%rsp), %rbp
movq %rbp, %rsi
movq %r15, %rdx
callq 0xfa20
movq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xf540
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %r13
movq %r13, %rdx
movq 0x8(%rsp), %rbp
movq %rbp, %rcx
movq %rbx, %r8
movq %r15, %r9
callq 0xe240
leaq (%r12,%r13,8), %rdi
movq %rdi, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0xf610
leaq (%rbx,%r13), %rcx
movq %rax, (%r12,%rcx,8)
leaq (%rbx,%r13), %rdx
incq %rdx
movq (%rsp), %r13
movq 0x38(%r13), %rcx
movq %rbp, %rdi
movq %r12, %rsi
movq %rbx, %r8
movq %r15, %r9
callq 0xfc00
movq 0x38(%r13), %rcx
movq %rbp, %rdi
movq 0x40(%rsp), %r15
movq %r15, %rsi
movq %rbp, %rdx
movq %rbx, %r8
callq 0xec10
movq %r15, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %r14
movq %r14, %rdx
callq 0xf540
movq 0x38(%r13), %rcx
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %r8
callq 0xec10
movq 0x18(%rsp), %rdi
addq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xf300
xorl %r15d, %r15d
movq %r13, %rbx
jmp 0x2d7c9
pushq $0x6d
popq %r15
jmp 0x2d7d1
movl $0x1f6, %r15d # imm = 0x1F6
jmp 0x2d7d1
movl $0x130, %r15d # imm = 0x130
jmp 0x2d7d1
pushq $0x6e
jmp 0x2d79f
movl $0x130, %r15d # imm = 0x130
jmp 0x2d7c9
movl $0x1f6, %r15d # imm = 0x1F6
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0xe920
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/crypto/bign/bign_sign.c |
bignSign2 | err_t bignSign2(octet sig[], const bign_params* params, const octet oid_der[],
size_t oid_len, const octet hash[], const octet privkey[], const void* t,
size_t t_len)
{
err_t code;
size_t no, n;
// состояние (буферы могут пересекаться)
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* k; /* [n] одноразовый личный ключ */
word* R; /* [2n] точка R */
word* s0; /* [n/2] первая часть подписи */
word* s1; /* [n] вторая часть подписи */
octet* hash_state; /* [beltHash_keep] состояние хэширования */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// проверить oid_der
if (oid_len == SIZE_MAX || oidFromDER(0, oid_der, oid_len) == SIZE_MAX)
return ERR_BAD_OID;
// проверить t
if (!memIsNullOrValid(t, t_len))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignSign2_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
ASSERT(n % 2 == 0);
// проверить входные указатели
if (!memIsValid(hash, no) ||
!memIsValid(privkey, no) ||
!memIsValid(sig, no + no / 2) ||
!memIsDisjoint2(hash, no, sig, no + no / 2))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = s1 = objEnd(ec, word);
k = d + n;
R = k + n;
s0 = R + n + n / 2;
hash_state = (octet*)(R + 2 * n);
stack = hash_state + beltHash_keep();
// загрузить d
wwFrom(d, privkey, no);
if (wwIsZero(d, n) || wwCmp(d, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// хэшировать oid
beltHashStart(hash_state);
beltHashStepH(oid_der, oid_len, hash_state);
// сгенерировать k по алгоритму 6.3.3
{
// theta <- belt-hash(oid || d || t)
memCopy(stack, hash_state, beltHash_keep());
beltHashStepH(privkey, no, stack);
if (t != 0)
beltHashStepH(t, t_len, stack);
beltHashStepG(stack, stack);
// инициализировать beltWBL ключом theta
beltWBLStart(stack, stack, 32);
// k <- H
memCopy(k, hash, no);
// k <- beltWBL(k, theta) пока k \notin {1,..., q - 1}
while (1)
{
beltWBLStepE(k, no, stack);
wwFrom(k, k, no);
if (!wwIsZero(k, n) && wwCmp(k, ec->order, n) < 0)
break;
wwTo(k, no, k);
}
}
// R <- k G
if (!ecMulA(R, ec->base, ec, k, n, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
qrTo((octet*)R, ecX(R), ec->f, stack);
// s0 <- belt-hash(oid || R || H) mod 2^l
beltHashStepH(R, no, hash_state);
beltHashStepH(hash, no, hash_state);
beltHashStepG2(sig, no / 2, hash_state);
wwFrom(s0, sig, no / 2);
// R <- (s0 + 2^l) d
zzMul(R, s0, n / 2, d, n, stack);
R[n + n / 2] = zzAdd(R + n / 2, R + n / 2, d, n);
// s1 <- R mod q
zzMod(s1, R, n + n / 2 + 1, ec->order, n, stack);
// s1 <- (k - s1 - H) mod q
zzSubMod(s1, k, s1, ec->order, n);
wwFrom(k, hash, no);
zzSubMod(s1, s1, k, ec->order, n);
// выгрузить s1
wwTo(sig + no / 2, no, s1);
// все нормально
blobClose(state);
return ERR_OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbp
movq %r8, 0x10(%rsp)
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
movl $0x150, %esi # imm = 0x150
movq %rbx, %rdi
callq 0xeeb0
pushq $0x6d
popq %r14
testl %eax, %eax
je 0x2d932
movq %rbx, %rdi
callq 0x101d0
testl %eax, %eax
je 0x2d937
movq %r13, 0x38(%rsp)
movl $0x12d, %r13d # imm = 0x12D
cmpq $-0x1, %r12
je 0x2d93d
xorl %edi, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe710
cmpq $-0x1, %rax
je 0x2d93d
movq 0xa8(%rsp), %rsi
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x2d8f7
callq 0xeeb0
movl %r14d, %r13d
testl %eax, %eax
je 0x2d93d
movq (%rbx), %rdi
leaq 0x3c7(%rip), %rsi # 0x2dcc8
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2d94f
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf290
movl %eax, %r13d
testl %eax, %eax
je 0x2d955
movq %r14, %rdi
callq 0xe920
jmp 0x2d93d
movl %r14d, %r13d
jmp 0x2d93d
movl $0x1f6, %r13d # imm = 0x1F6
movl %r13d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6e
popq %r13
jmp 0x2d93d
movq 0x18(%r14), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x38(%rax), %rbx
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xeeb0
pushq $0x6d
popq %r13
testl %eax, %eax
je 0x2d928
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2d928
movq %r14, 0x8(%rsp)
movq %rbx, %rax
shrq %rax
movq %rax, 0x48(%rsp)
movq %rbx, 0x20(%rsp)
addq %rax, %rbx
movq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2db6c
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10140
testl %eax, %eax
movq 0x8(%rsp), %r14
je 0x2d928
movq (%r14), %rbx
addq %r14, %rbx
xorl %eax, %eax
callq 0xe560
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq 0x20(%rsp), %rdx
callq 0xf540
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0xffc0
movl $0x1f8, %r13d # imm = 0x1F8
testl %eax, %eax
jne 0x2d928
movq 0x38(%r14), %rsi
movq %rbx, %rdi
movq 0x28(%rsp), %rdx
callq 0xf1b0
testl %eax, %eax
jns 0x2d928
movq 0x28(%rsp), %rax
movq %rbx, 0x58(%rsp)
leaq (%rbx,%rax,8), %r13
leaq (,%rax,8), %rcx
addq %r13, %rcx
leaq (%rcx,%rax,8), %rdx
movq %rdx, 0x30(%rsp)
movq %rax, %rdx
shrq %rdx
movq %rdx, 0x40(%rsp)
movq %rax, %rbx
shlq $0x4, %rbx
movq %rcx, 0x60(%rsp)
addq %rcx, %rbx
addq %rbx, 0x18(%rsp)
movq %rbx, %rdi
callq 0xe5d0
movq %r15, %rdi
movq 0x18(%rsp), %r15
movq %r12, %rsi
movq %rbx, %rdx
callq 0xe360
xorl %eax, %eax
callq 0xe560
movq %r15, %rdi
movq %rbx, 0x50(%rsp)
movq %rbx, %rsi
movq %rax, %rdx
callq 0xe970
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
movq %rsi, %rbx
movq %r15, %rdx
callq 0xe360
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x2dad8
movq 0xa8(%rsp), %rsi
movq %r15, %rdx
callq 0xe360
movq 0x40(%rsp), %rax
movq 0x30(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, 0x30(%rsp)
movq %r15, %rdi
movq %r15, %rsi
callq 0xf1f0
pushq $0x20
popq %rdx
movq %r15, %rdi
movq %r15, %rsi
callq 0xf570
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0xe970
movq 0x28(%rsp), %rbp
movq 0x60(%rsp), %r12
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf910
movq %r13, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xf540
movq %r13, %rdi
movq %rbp, %rsi
callq 0xffc0
testl %eax, %eax
jne 0x2db5c
movq 0x38(%r14), %rsi
movq %r13, %rdi
movq %rbp, %rdx
callq 0xf1b0
testl %eax, %eax
js 0x2db76
movq %r13, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xf300
jmp 0x2db1e
movq 0x8(%rsp), %r14
jmp 0x2d928
movq 0x30(%r14), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq %r15, %r9
callq 0xff30
testl %eax, %eax
je 0x2dcbd
movq 0x18(%r14), %rdx
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq *0x48(%rdx)
movq %r12, %rdi
movq %rbx, %rsi
movq 0x50(%rsp), %r14
movq %r14, %rdx
callq 0xe360
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe360
movq 0x38(%rsp), %rdi
movq %r12, %rbx
movq %rdi, %r12
movq 0x48(%rsp), %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0xfa20
movq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xf540
movq %rbx, %rdi
movq %r14, %rsi
movq 0x40(%rsp), %r15
movq %r15, %rdx
movq 0x58(%rsp), %r12
movq %r12, %rcx
movq %rbp, %r8
movq 0x18(%rsp), %r9
callq 0xe240
leaq (%rbx,%r15,8), %rdi
movq %rdi, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0xf610
leaq (%r15,%rbp), %rcx
movq %rax, (%rbx,%rcx,8)
leaq (%r15,%rbp), %rdx
incq %rdx
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %r8
movq 0x18(%rsp), %r9
callq 0xfc00
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %r8
callq 0xec10
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %r14
movq 0x20(%rsp), %r15
movq %r15, %rdx
callq 0xf540
movq 0x38(%r14), %rcx
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %r8
callq 0xec10
movq 0x38(%rsp), %rdi
addq 0x48(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xf300
xorl %r13d, %r13d
jmp 0x2d928
movl $0x1f6, %r13d # imm = 0x1F6
jmp 0x2d928
| /agievich[P]bee2/src/crypto/bign/bign_sign.c |
bignVerify | err_t bignVerify(const bign_params* params, const octet oid_der[],
size_t oid_len, const octet hash[], const octet sig[], const octet pubkey[])
{
err_t code;
size_t no, n;
// состояние (буферы могут пересекаться)
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* Q; /* [2n] открытый ключ */
word* R; /* [2n] точка R */
word* H; /* [n] хэш-значение */
word* s0; /* [n / 2 + 1] первая часть подписи */
word* s1; /* [n] вторая часть подписи */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (!bignIsOperable(params))
return ERR_BAD_PARAMS;
// проверить oid_der
if (oid_len == SIZE_MAX || oidFromDER(0, oid_der, oid_len) == SIZE_MAX)
return ERR_BAD_OID;
// создать состояние
state = blobCreate(bignStart_keep(params->l, bignVerify_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bignStart(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
no = ec->f->no;
n = ec->f->n;
ASSERT(n % 2 == 0);
// проверить входные указатели
if (!memIsValid(hash, no) ||
!memIsValid(sig, no + no / 2) ||
!memIsValid(pubkey, 2 * no))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
Q = R = objEnd(ec, word);
H = s0 = Q + 2 * n;
s1 = H + n;
stack = (octet*)(s1 + n);
// загрузить Q
if (!qrFrom(ecX(Q), pubkey, ec->f, stack) ||
!qrFrom(ecY(Q, n), pubkey + no, ec->f, stack))
{
blobClose(state);
return ERR_BAD_PUBKEY;
}
// загрузить и проверить s1
wwFrom(s1, sig + no / 2, no);
if (wwCmp(s1, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_SIG;
}
// s1 <- (s1 + H) mod q
wwFrom(H, hash, no);
if (wwCmp(H, ec->order, n) >= 0)
{
zzSub2(H, ec->order, n);
// 2^{l - 1} < q < 2^l, H < 2^l => H - q < q
ASSERT(wwCmp(H, ec->order, n) < 0);
}
zzAddMod(s1, s1, H, ec->order, n);
// загрузить s0
wwFrom(s0, sig, no / 2);
s0[n / 2] = 1;
// R <- s1 G + (s0 + 2^l) Q
if (!ecAddMulA(R, ec, stack, 2, ec->base, s1, n, Q, s0, n / 2 + 1))
{
blobClose(state);
return ERR_BAD_SIG;
}
qrTo((octet*)R, ecX(R), ec->f, stack);
// s0 == belt-hash(oid || R || H) mod 2^l?
beltHashStart(stack);
beltHashStepH(oid_der, oid_len, stack);
beltHashStepH(R, no, stack);
beltHashStepH(hash, no, stack);
code = beltHashStepV2(sig, no / 2, stack) ? ERR_OK : ERR_BAD_SIG;
// завершение
blobClose(state);
return code;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x150, %esi # imm = 0x150
callq 0xeeb0
testl %eax, %eax
je 0x2e059
movq %rbx, %rdi
callq 0x101d0
testl %eax, %eax
je 0x2e05e
movq %rbp, 0x10(%rsp)
movl $0x12d, %ebp # imm = 0x12D
cmpq $-0x1, %r15
je 0x2e076
xorl %edi, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0xe710
cmpq $-0x1, %rax
je 0x2e076
movq (%rbx), %rdi
leaq 0x29f(%rip), %rsi # 0x2e087
callq 0xf410
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2e065
movq %rax, %rbp
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf290
movq %rbp, %rbx
movl %eax, %ebp
testl %eax, %eax
jne 0x2e06e
movq %rbx, 0x38(%rsp)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rcx
movq %rcx, (%rsp)
movq 0x38(%rax), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2e069
movq %rbx, %rax
shrq %rax
movq %rax, 0x30(%rsp)
leaq (%rax,%rbx), %rsi
movq 0x10(%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2e069
leaq (%rbx,%rbx), %rsi
movq %r13, %rdi
callq 0xeeb0
testl %eax, %eax
movq %rbx, %rax
movq 0x38(%rsp), %rbx
je 0x2e06e
movq %rax, 0x8(%rsp)
movq (%rbx), %rdi
addq %rbx, %rdi
movq (%rsp), %rcx
movq %rcx, %rax
shlq $0x4, %rax
addq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
leaq (%rax,%rcx,8), %rcx
movq 0x18(%rbx), %rdx
movq %rdi, 0x40(%rsp)
movq %r13, %rsi
movq %rcx, 0x28(%rsp)
callq *0x40(%rdx)
movl $0x1f9, %ebp # imm = 0x1F9
testl %eax, %eax
je 0x2e06e
movq 0x18(%rbx), %rdx
movq 0x40(%rsp), %rax
movq (%rsp), %rcx
leaq (%rax,%rcx,8), %rdi
addq 0x8(%rsp), %r13
movq %r13, %rsi
movq 0x28(%rsp), %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x2e06e
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
leaq (%rax,%rcx), %rsi
movq 0x20(%rsp), %r13
movq %r13, %rdi
movq 0x8(%rsp), %rdx
callq 0xf540
movq 0x38(%rbx), %rsi
movq %r13, %rdi
movq (%rsp), %rdx
callq 0xf1b0
movl $0x1fe, %ebp # imm = 0x1FE
testl %eax, %eax
jns 0x2e06e
movq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0xf540
movq 0x38(%rbx), %rsi
movq %r13, %rdi
movq (%rsp), %r13
movq %r13, %rdx
callq 0xf1b0
testl %eax, %eax
js 0x2df70
movq 0x38(%rbx), %rsi
movq 0x18(%rsp), %rdi
movq %r13, %rdx
callq 0xee10
movq 0x38(%rbx), %rcx
movq 0x20(%rsp), %rdi
movq %rdi, %rsi
movq %r13, %r8
movq 0x18(%rsp), %r13
movq %r13, %rdx
callq 0xfff0
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0xf540
movq (%rsp), %r11
movq %r11, %r10
shrq %r10
movq $0x1, (%r13,%r10,8)
movq 0x30(%rbx), %r8
incq %r10
pushq $0x2
popq %rcx
movq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %r9
xorl %eax, %eax
pushq %r10
pushq %r13
movq %rdi, %r13
pushq %rdi
pushq %r11
callq 0xe220
addq $0x20, %rsp
testl %eax, %eax
je 0x2e06e
movq 0x18(%rbx), %rdx
movq %r13, %rdi
movq %r13, %rsi
movq 0x28(%rsp), %rbp
movq %rbp, %rcx
callq *0x48(%rdx)
movq %rbp, %rdi
callq 0xe5d0
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0xe360
movq %r13, %rdi
movq 0x8(%rsp), %r15
movq %r15, %rsi
movq %rbp, %rdx
callq 0xe360
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0xe360
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rbp, %rdx
callq 0xe3a0
testl %eax, %eax
movl $0x1fe, %eax # imm = 0x1FE
movl $0x0, %ebp
cmovel %eax, %ebp
jmp 0x2e06e
pushq $0x6d
popq %rbp
jmp 0x2e076
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2e076
pushq $0x6e
jmp 0x2e05b
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0xe920
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/crypto/bign/bign_sign.c |
bign96ParamsStd | err_t bign96ParamsStd(bign_params* params, const char* name)
{
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (strEq(name, _curve96v1_name))
{
params->l = 96;
memCopy(params->p, _curve96v1_p, 24);
memCopy(params->a, _curve96v1_a, 24);
memCopy(params->seed, _curve96v1_seed, 8);
memCopy(params->b, _curve96v1_b, 24);
memCopy(params->q, _curve96v1_q, 24);
memCopy(params->yG, _curve96v1_yG, 24);
return ERR_OK;
}
return ERR_FILE_NOT_FOUND;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x150, %esi # imm = 0x150
callq 0xeeb0
testl %eax, %eax
je 0x2e1be
leaq 0x21329(%rip), %rsi # 0x4f440
movq %r14, %rdi
callq 0xebd0
movl %eax, %ecx
movl $0xca, %eax
testl %ecx, %ecx
jne 0x2e1c1
movq $0x60, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x21320(%rip), %rsi # 0x4f460
pushq $0x18
popq %r14
movq %r14, %rdx
callq 0xe970
leaq 0x48(%rbx), %rdi
leaq 0x21329(%rip), %rsi # 0x4f480
movq %r14, %rdx
callq 0xe970
leaq 0x148(%rbx), %rdi
leaq 0x2132b(%rip), %rsi # 0x4f498
pushq $0x8
popq %rdx
callq 0xe970
leaq 0x88(%rbx), %rdi
leaq 0x2131d(%rip), %rsi # 0x4f4a0
movq %r14, %rdx
callq 0xe970
leaq 0xc8(%rbx), %rdi
leaq 0x21327(%rip), %rsi # 0x4f4c0
movq %r14, %rdx
callq 0xe970
addq $0x108, %rbx # imm = 0x108
leaq 0x21331(%rip), %rsi # 0x4f4e0
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe970
xorl %eax, %eax
jmp 0x2e1c1
pushq $0x6d
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/crypto/bign96.c |
bign96Start_keep | size_t bign96Start_keep(bign96_deep_i deep)
{
// размерности
size_t n = W_OF_B(192);
size_t f_keep = gfpCreate_keep(24);
size_t f_deep = gfpCreate_deep(24);
size_t ec_d = 3;
size_t ec_keep = ecpCreateJ_keep(n);
size_t ec_deep = ecpCreateJ_deep(n, f_deep);
// расчет
return f_keep + ec_keep +
utilMax(3,
ec_deep,
ecCreateGroup_deep(f_deep),
deep ? deep(n, f_deep, ec_d, ec_deep) : 0);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
pushq $0x18
popq %rbx
movq %rbx, %rdi
callq 0x10050
movq %rax, %r14
movq %rbx, %rdi
callq 0xefd0
movq %rax, %rbp
pushq $0x3
popq %r12
movq %r12, %rdi
callq 0x10180
movq %rax, %rbx
movq %r12, %rdi
movq %rbp, %rsi
callq 0xfb00
movq %rax, %r12
movq %rbp, %rdi
callq 0xf6a0
movq %rax, %r13
testq %r15, %r15
je 0x2e231
pushq $0x3
popq %rdi
movq %rbp, %rsi
movq %rdi, %rdx
movq %r12, %rcx
callq *%r15
movq %rax, %rcx
jmp 0x2e233
xorl %ecx, %ecx
addq %r14, %rbx
pushq $0x3
popq %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0xe320
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/crypto/bign96.c |
bign96ParamsVal | err_t bign96ParamsVal(const bign_params* params)
{
err_t code;
size_t n;
// состояние (буферы могут пересекаться)
void* state;
ec_o* ec; /* описание эллиптической кривой */
octet* hash_state; /* [beltHash_keep] состояние хэширования */
octet* hash_data; /* [8] данные хэширования */
word* B; /* [W_OF_B(512)] переменная B */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (params->l != 96)
return ERR_BAD_PARAMS;
// создать состояние
state = blobCreate(bign96Start_keep(bign96ParamsVal_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bign96Start(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
n = ec->f->n;
// раскладка состояния
hash_state = objEnd(ec, octet);
hash_data = hash_state + beltHash_keep();
B = (word*)hash_data;
stack = hash_data + O_OF_B(512);
// belt-hash(p..)
beltHashStart(hash_state);
beltHashStepH(params->p, 24, hash_state);
// belt-hash(..a..)
beltHashStepH(params->a, 24, hash_state);
memCopy(stack, hash_state, beltHash_keep());
// belt-hash(..seed)
memCopy(hash_data, params->seed, 8);
beltHashStepH(hash_data, 8, hash_state);
// belt-hash(..seed + 1)
wwFrom(B, hash_data, 8);
zzAddW2(B, W_OF_O(8), 1);
wwTo(hash_data, 8, B);
beltHashStepH(hash_data, 8, stack);
// B <- belt-hash(p || a || seed) || belt-hash(p || a || seed + 1)
beltHashStepG(hash_data, hash_state);
beltHashStepG(hash_data + 32, stack);
wwFrom(B, hash_data, 64);
// B <- B \mod p
zzMod(B, B, W_OF_O(64), ec->f->mod, n, stack);
wwTo(B, 64, B);
// проверить условия алгоритма 6.1.4
if (qrFrom(B, (octet*)B, ec->f, stack) &&
wwEq(B, ec->B, n) &&
!wwIsZero(ec->B, n) &&
ecpIsValid(ec, stack) &&
ecpIsSafeGroup(ec, 50, stack) &&
zzJacobi(ec->B, n, ec->f->mod, n, stack) == 1)
{
// B <- b^{(p + 1) / 4} = \sqrt{b} mod p
wwCopy(B, ec->f->mod, n);
zzAddW2(B, n, 1);
wwShLo(B, n, 2);
qrPower(B, ec->B, B, n, ec->f, stack);
// оставшиеся условия
if (!wwEq(B, ecY(ec->base, n), n) ||
!ecHasOrderA(ec->base, ec, ec->order, n, stack))
code = ERR_BAD_PARAMS;
}
else
code = ERR_BAD_PARAMS;
// завершение
blobClose(state);
return code;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
movl $0x150, %esi # imm = 0x150
callq 0xeeb0
testl %eax, %eax
je 0x2e3d0
movl $0x1f6, %ebp # imm = 0x1F6
cmpq $0x60, (%r13)
jne 0x2e3d7
leaq 0x293(%rip), %rdi # 0x2e633
callq 0xf4e0
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2e3d4
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
callq 0xe690
movl %eax, %ebp
testl %eax, %eax
je 0x2e3e8
movq %rbx, %rdi
callq 0xe920
jmp 0x2e3d7
pushq $0x6d
jmp 0x2e3d6
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
movq (%rbx), %rbp
addq %rbx, %rbp
xorl %eax, %eax
callq 0xe560
movq %rax, 0x8(%rsp)
leaq (%rax,%rbp), %r12
leaq (%rax,%rbp), %r14
addq $0x40, %r14
movq %rbp, %rdi
callq 0xe5d0
leaq 0x8(%r13), %rdi
pushq $0x18
popq %r15
movq %r15, %rsi
movq %rbp, %rdx
callq 0xe360
leaq 0x48(%r13), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0xe360
xorl %eax, %eax
callq 0xe560
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0xe970
addq $0x148, %r13 # imm = 0x148
pushq $0x8
popq %r15
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe970
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0xe360
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xf540
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %rdx, %rsi
callq 0xeb00
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xf300
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe360
movq %r12, %rdi
movq %rbp, %rsi
callq 0xf1f0
movq 0x8(%rsp), %rax
leaq (%rax,%rbp), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0xf1f0
pushq $0x40
popq %r13
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xf540
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rcx
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x10(%rsp), %r15
movq %r15, %r8
movq %r14, %r9
callq 0xfc00
movq %r12, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xf300
movq 0x18(%rbx), %rdx
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq *0x40(%rdx)
movl $0x1f6, %ebp # imm = 0x1F6
testl %eax, %eax
je 0x2e3c6
movq 0x28(%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0xf520
testl %eax, %eax
je 0x2e3c6
movq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0xffc0
testl %eax, %eax
jne 0x2e3c6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xed30
testl %eax, %eax
je 0x2e3c6
pushq $0x32
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xf880
testl %eax, %eax
je 0x2e3c6
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rdi
movq 0x18(%rax), %rdx
movq %r15, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0xeb60
cmpl $0x1, %eax
jne 0x2e3c6
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0xe5c0
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xeb00
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xf9a0
movq 0x18(%rbx), %r8
movq 0x28(%rbx), %rsi
movq %r12, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r9
callq 0xf6f0
leaq (,%r15,8), %rsi
addq 0x30(%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0xf520
testl %eax, %eax
je 0x2e629
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rdx
movq %rbx, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0xe4d0
xorl %ebp, %ebp
testl %eax, %eax
jne 0x2e3c6
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2e3c6
| /agievich[P]bee2/src/crypto/bign96.c |
bign96KeypairVal | err_t bign96KeypairVal(const bign_params* params, const octet privkey[24],
const octet pubkey[48])
{
err_t code;
size_t n;
// состояние
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* Q; /* [2n] открытый ключ */
void* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (params->l != 96)
return ERR_BAD_PARAMS;
// создать состояние
state = blobCreate(bign96Start_keep(bign96KeypairVal_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bign96Start(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
n = ec->f->n;
// проверить входные указатели
if (!memIsValid(privkey, 24) || !memIsValid(pubkey, 48))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = objEnd(ec, word);
Q = d + n;
stack = Q + 2 * n;
// d <- privkey
wwFrom(d, privkey, 24);
// 0 < d < q?
wwFrom(Q, params->q, 24);
if (wwIsZero(d, n) || wwCmp(d, Q, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// Q <- d G
if (ecMulA(Q, ec->base, ec, d, n, stack))
{
// Q == pubkey?
wwTo(Q, 48, Q);
if (!memEq(Q, pubkey, 48))
code = ERR_BAD_PUBKEY;
}
else
code = ERR_BAD_PARAMS;
// завершение
blobClose(state);
return code;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movl $0x150, %esi # imm = 0x150
callq 0xeeb0
testl %eax, %eax
je 0x2e8fc
movl $0x1f6, %ebp # imm = 0x1F6
cmpq $0x60, (%r15)
jne 0x2e903
leaq 0x140(%rip), %rdi # 0x2ea0c
callq 0xf4e0
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2e900
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xe690
movl %eax, %ebp
testl %eax, %eax
je 0x2e914
movq %r14, %rdi
callq 0xe920
jmp 0x2e903
pushq $0x6d
jmp 0x2e902
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rax
movq 0x30(%rax), %r13
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2e8f2
movq %r13, (%rsp)
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2e8f2
movq (%r14), %r13
addq %r14, %r13
movq (%rsp), %rbp
leaq (,%rbp,8), %rax
addq %r13, %rax
pushq $0x18
popq %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %r12
callq 0xf540
addq $0xc8, %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %r15
pushq $0x18
popq %rdx
callq 0xf540
movq %r13, %rdi
movq %rbp, %rsi
callq 0xffc0
movl $0x1f8, %ebp # imm = 0x1F8
testl %eax, %eax
jne 0x2e8f2
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xf1b0
testl %eax, %eax
jns 0x2e8f2
movq (%rsp), %r8
movq %r8, %r9
shlq $0x4, %r9
addq %r12, %r9
movq 0x30(%r14), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %r13, %rcx
callq 0xff30
testl %eax, %eax
je 0x2ea02
pushq $0x30
popq %r15
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xf300
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf140
xorl %ecx, %ecx
testl %eax, %eax
movl $0x1f9, %ebp # imm = 0x1F9
cmovnel %ecx, %ebp
jmp 0x2e8f2
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2e8f2
| /agievich[P]bee2/src/crypto/bign96.c |
bign96PubkeyCalc | err_t bign96PubkeyCalc(octet pubkey[48], const bign_params* params,
const octet privkey[24])
{
err_t code;
size_t n;
// состояние
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* Q; /* [2n] открытый ключ */
void* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (params->l != 96)
return ERR_BAD_PARAMS;
// создать состояние
state = blobCreate(bign96Start_keep(bign96PubkeyCalc_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bign96Start(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
n = ec->f->n;
// проверить входные указатели
if (!memIsValid(privkey, 24) || !memIsValid(pubkey, 48))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = objEnd(ec, word);
Q = d + n;
stack = Q + 2 * n;
// загрузить d
wwFrom(d, privkey, 24);
if (wwIsZero(d, n) || wwCmp(d, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// Q <- d G
if (ecMulA(Q, ec->base, ec, d, n, stack))
{
// выгрузить открытый ключ
qrTo(pubkey, ecX(Q), ec->f, stack);
qrTo(pubkey + 24, ecY(Q, n), ec->f, stack);
}
else
code = ERR_BAD_PARAMS;
// завершение
blobClose(state);
return code;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movl $0x150, %esi # imm = 0x150
movq %r15, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2eb96
movl $0x1f6, %ebp # imm = 0x1F6
cmpq $0x60, (%r15)
jne 0x2eb9d
leaq 0x11e(%rip), %rdi # 0x2ec84
callq 0xf4e0
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2eb9a
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xe690
movl %eax, %ebp
testl %eax, %eax
je 0x2ebae
movq %r14, %rdi
callq 0xe920
jmp 0x2eb9d
pushq $0x6d
jmp 0x2eb9c
pushq $0x6e
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rax
movq 0x30(%rax), %r15
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2eb8c
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2eb8c
movq (%r14), %r13
addq %r14, %r13
pushq $0x18
popq %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0xf540
movq %r13, %rdi
movq %r15, %rsi
callq 0xffc0
movl $0x1f8, %ebp # imm = 0x1F8
testl %eax, %eax
jne 0x2eb8c
movq 0x38(%r14), %rsi
movq %r13, %rdi
movq %r15, %rdx
callq 0xf1b0
testl %eax, %eax
jns 0x2eb8c
leaq (,%r15,8), %rbp
addq %r13, %rbp
movq %r15, %r12
shlq $0x4, %r12
addq %rbp, %r12
movq 0x30(%r14), %rsi
movq %rbp, %rdi
movq %r14, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0xff30
testl %eax, %eax
je 0x2ec7a
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rcx
callq *0x48(%rdx)
movq 0x18(%r14), %rdx
addq $0x18, %rbx
leaq (,%r15,8), %rsi
addq %rbp, %rsi
movq %rbx, %rdi
movq %r12, %rcx
callq *0x48(%rdx)
xorl %ebp, %ebp
jmp 0x2eb8c
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2eb8c
| /agievich[P]bee2/src/crypto/bign96.c |
bign96Sign | err_t bign96Sign(octet sig[34], const bign_params* params,
const octet oid_der[], size_t oid_len, const octet hash[24],
const octet privkey[24], gen_i rng, void* rng_state)
{
err_t code;
size_t n;
// состояние (буферы могут пересекаться)
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* k; /* [n] одноразовый личный ключ */
word* R; /* [2n] точка R */
word* s0; /* [W_OF_O(13)] первая часть подписи */
word* s1; /* [n] вторая часть подписи */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (params->l != 96)
return ERR_BAD_PARAMS;
// проверить oid_der
if (oid_len == SIZE_MAX || oidFromDER(0, oid_der, oid_len) == SIZE_MAX)
return ERR_BAD_OID;
// проверить rng
if (rng == 0)
return ERR_BAD_RNG;
// создать состояние
state = blobCreate(bign96Start_keep(bign96Sign_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bign96Start(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
n = ec->f->n;
// проверить входные указатели
if (!memIsValid(hash, 24) ||
!memIsValid(privkey, 24) ||
!memIsValid(sig, 34) ||
!memIsDisjoint2(hash, 24, sig, 34))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = s1 = objEnd(ec, word);
k = d + n;
R = k + n;
s0 = R + n + W_OF_O(13);
stack = (octet*)(s0 + W_OF_O(13));
// загрузить d
wwFrom(d, privkey, 24);
if (wwIsZero(d, n) || wwCmp(d, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// сгенерировать k с помощью rng
if (!zzRandNZMod(k, ec->order, n, rng, rng_state))
{
blobClose(state);
return ERR_BAD_RNG;
}
// R <- k G
if (!ecMulA(R, ec->base, ec, k, n, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
qrTo((octet*)R, ecX(R), ec->f, stack);
// s0 <- belt-hash(oid || R || H) mod 2^80 + 2^l
beltHashStart(stack);
beltHashStepH(oid_der, oid_len, stack);
beltHashStepH(R, 24, stack);
beltHashStepH(hash, 24, stack);
beltHashStepG2(sig, 10, stack);
sig[10] = sig[11] = 0, sig[12] = 0x80;
wwFrom(s0, sig, 13);
// R <- (s0 + 2^l) d
zzMul(R, s0, W_OF_O(13), d, n, stack);
// s1 <- R mod q
zzMod(s1, R, n + W_OF_O(13), ec->order, n, stack);
// s1 <- (k - s1 - H) mod q
zzSubMod(s1, k, s1, ec->order, n);
wwFrom(k, hash, 24);
zzSubMod(s1, s1, k, ec->order, n);
// выгрузить s1
wwTo(sig + 10, 24, s1);
// все нормально
blobClose(state);
return ERR_OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x150, %esi # imm = 0x150
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2ef9b
movq %r14, 0x10(%rsp)
movl $0x1f6, %r14d # imm = 0x1F6
cmpq $0x60, (%rbx)
jne 0x2ef9f
movl $0x12d, %r14d # imm = 0x12D
cmpq $-0x1, %r13
je 0x2ef9f
xorl %edi, %edi
movq %rbp, %rsi
movq %r13, %rdx
callq 0xe710
cmpq $-0x1, %rax
je 0x2ef9f
cmpq $0x0, 0x80(%rsp)
je 0x2efb1
leaq 0x2b9(%rip), %rdi # 0x2efdc
callq 0xf4e0
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2efb9
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe690
movq %r14, %rbx
movl %eax, %r14d
testl %eax, %eax
jne 0x2efc2
movq %rbx, 0x8(%rsp)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rbx
pushq $0x18
popq %rsi
movq 0x10(%rsp), %rdi
callq 0xeeb0
pushq $0x6d
popq %r14
testl %eax, %eax
je 0x2efbd
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2efbd
pushq $0x22
popq %rsi
movq %r15, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2efbd
movq %rbx, 0x28(%rsp)
pushq $0x18
popq %rsi
pushq $0x22
popq %rcx
movq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0x10140
testl %eax, %eax
movq 0x8(%rsp), %rbx
je 0x2efc2
movq (%rbx), %r14
addq %rbx, %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xf540
movq %r14, 0x18(%rsp)
movq %r14, %rdi
movq 0x28(%rsp), %r12
movq %r12, %rsi
callq 0xffc0
movl $0x1f8, %r14d # imm = 0x1F8
testl %eax, %eax
jne 0x2efc2
movq 0x38(%rbx), %rsi
movq 0x18(%rsp), %rdi
movq %r12, %rdx
callq 0xf1b0
testl %eax, %eax
jns 0x2efc2
movq 0x88(%rsp), %r8
movq 0x28(%rsp), %r14
movq 0x18(%rsp), %rax
leaq (%rax,%r14,8), %r12
movq 0x38(%rbx), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq 0x80(%rsp), %rcx
callq 0xfc40
testl %eax, %eax
je 0x2efcc
leaq (%r12,%r14,8), %rdi
movq %r12, %rcx
leaq (%rdi,%r14,8), %r12
addq $0x20, %r12
movq 0x30(%rbx), %rsi
movq %rdi, 0x20(%rsp)
movq %rbx, %rdx
movq %rcx, 0x40(%rsp)
movq %r14, %r8
movq %r12, %r9
callq 0xff30
testl %eax, %eax
je 0x2efd4
movq 0x20(%rsp), %rdi
leaq (%rdi,%r14,8), %rax
addq $0x10, %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rbx), %rdx
movq %rdi, %rsi
movq %r12, %rcx
callq *0x48(%rdx)
movq %r12, %rdi
callq 0xe5d0
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xe360
pushq $0x18
popq %rbp
movq 0x20(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xe360
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xe360
pushq $0xa
popq %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xfa20
leaq 0xa(%r15), %rax
movq %rax, 0x38(%rsp)
andw $0x0, 0xa(%r15)
movb $-0x80, 0xc(%r15)
pushq $0xd
popq %rdx
movq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xf540
pushq $0x2
popq %rdx
movq %r13, %rdi
movq %rbp, %rsi
movq 0x18(%rsp), %r15
movq %r15, %rcx
movq %r14, %r8
movq %r12, %r9
callq 0xe240
leaq 0x2(%r14), %rdx
movq 0x38(%rbx), %rcx
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %r8
movq %r12, %r9
callq 0xfc00
movq 0x38(%rbx), %rcx
movq %r15, %rdi
movq 0x40(%rsp), %r12
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %r8
callq 0xec10
movq %r12, %rdi
movq 0x10(%rsp), %rsi
pushq $0x18
popq %r13
movq %r13, %rdx
callq 0xf540
movq 0x38(%rbx), %rcx
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %r8
callq 0xec10
movq 0x38(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xf300
xorl %r14d, %r14d
jmp 0x2efc2
pushq $0x6d
popq %r14
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x130, %r14d # imm = 0x130
jmp 0x2ef9f
pushq $0x6e
jmp 0x2ef9d
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xe920
jmp 0x2ef9f
movl $0x130, %r14d # imm = 0x130
jmp 0x2efc2
movl $0x1f6, %r14d # imm = 0x1F6
jmp 0x2efc2
| /agievich[P]bee2/src/crypto/bign96.c |
bign96Sign_deep | static size_t bign96Sign_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
return O_OF_W(3 * n + 2 * W_OF_O(13)) +
utilMax(4,
beltHash_keep(),
ecMulA_deep(n, ec_d, ec_deep, n),
zzMul_deep(W_OF_O(13), n),
zzMod_deep(n + W_OF_O(13), n));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
imulq $0x18, %rdi, %r13
xorl %eax, %eax
callq 0xe560
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0xfa10
movq %rax, %rbx
pushq $0x2
popq %rdi
movq %r15, %rsi
callq 0xfe10
movq %rax, %r14
leaq 0x2(%r15), %rdi
movq %r15, %rsi
callq 0xe7f0
pushq $0x4
popq %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xe320
addq %r13, %rax
addq $0x20, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/crypto/bign96.c |
bign96Sign2 | err_t bign96Sign2(octet sig[34], const bign_params* params,
const octet oid_der[], size_t oid_len, const octet hash[24],
const octet privkey[24], const void* t, size_t t_len)
{
err_t code;
size_t n;
u32 round = 1;
// состояние (буферы могут пересекаться)
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* d; /* [n] личный ключ */
word* k; /* [n] одноразовый личный ключ */
word* R; /* [2n] точка R */
word* s0; /* [W_OF_O(13)] первая часть подписи */
word* s1; /* [n] вторая часть подписи */
octet* hash_state; /* [beltHash_keep] состояние хэширования */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (params->l != 96)
return ERR_BAD_PARAMS;
// проверить oid_der
if (oid_len == SIZE_MAX || oidFromDER(0, oid_der, oid_len) == SIZE_MAX)
return ERR_BAD_OID;
// проверить t
if (!memIsNullOrValid(t, t_len))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(bign96Start_keep(bign96Sign2_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bign96Start(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
n = ec->f->n;
// проверить входные указатели
if (!memIsValid(hash, 24) ||
!memIsValid(privkey, 24) ||
!memIsValid(sig, 34) ||
!memIsDisjoint2(hash, 24, sig, 34))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
d = s1 = objEnd(ec, word);
k = d + n;
R = k + n;
s0 = R + n + W_OF_O(13);
hash_state = (octet*)(s0 + W_OF_O(13));
stack = hash_state + beltHash_keep();
// загрузить d
wwFrom(d, privkey, 24);
if (wwIsZero(d, n) || wwCmp(d, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// хэшировать oid
beltHashStart(hash_state);
beltHashStepH(oid_der, oid_len, hash_state);
// сгенерировать k по алгоритму 6.3.3
{
// theta <- belt-hash(oid || d || t)
memCopy(stack, hash_state, beltHash_keep());
beltHashStepH(privkey, 24, stack);
if (t != 0)
beltHashStepH(t, t_len, stack);
beltHashStepG(stack, stack);
beltKeyExpand2((u32*)stack, stack, 32);
// k <- H
memCopy(k, hash, 24);
// k <- belt32Block(k, theta) пока k \notin {1,..., q - 1}
while (1)
{
belt32BlockEncr((octet*)k, (u32*)stack, &round);
wwFrom(k, k, 24);
if (!wwIsZero(k, n) && wwCmp(k, ec->order, n) < 0)
break;
wwTo(k, 24, k);
}
}
// R <- k G
if (!ecMulA(R, ec->base, ec, k, n, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
qrTo((octet*)R, ecX(R), ec->f, stack);
// s0 <- belt-hash(oid || R || H) mod 2^80 + 2^l
beltHashStepH(R, 24, hash_state);
beltHashStepH(hash, 24, hash_state);
beltHashStepG2(sig, 10, hash_state);
sig[10] = sig[11] = 0, sig[12] = 0x80;
wwFrom(s0, sig, 13);
// R <- (s0 + 2^96) d
zzMul(R, s0, W_OF_O(13), d, n, stack);
// s1 <- R mod q
zzMod(s1, R, n + W_OF_O(13), ec->order, n, stack);
// s1 <- (k - s1 - H) mod q
zzSubMod(s1, k, s1, ec->order, n);
wwFrom(k, hash, 24);
zzSubMod(s1, s1, k, ec->order, n);
// выгрузить s1
wwTo(sig + 10, 24, s1);
// все нормально
blobClose(state);
return ERR_OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r12
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x38(%rsp)
movl $0x150, %esi # imm = 0x150
movq %rbx, %rdi
callq 0xeeb0
pushq $0x6d
popq %r15
testl %eax, %eax
je 0x2f118
movq %rbp, 0x20(%rsp)
movl $0x1f6, %ebp # imm = 0x1F6
cmpq $0x60, (%rbx)
jne 0x2f11b
movl $0x12d, %ebp # imm = 0x12D
cmpq $-0x1, %r13
je 0x2f11b
xorl %edi, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0xe710
cmpq $-0x1, %rax
je 0x2f11b
movq 0xb8(%rsp), %rsi
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x2f0db
callq 0xeeb0
movl %r15d, %ebp
testl %eax, %eax
je 0x2f11b
leaq 0x464(%rip), %rdi # 0x2f546
callq 0xf4e0
movq %rax, %rdi
callq 0xf190
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2f12c
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xe690
movl %eax, %ebp
testl %eax, %eax
je 0x2f131
movq 0x8(%rsp), %rdi
callq 0xe920
jmp 0x2f11b
movl %r15d, %ebp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6e
popq %rbp
jmp 0x2f11b
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rbx
pushq $0x18
popq %rsi
movq 0x20(%rsp), %rdi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2f10c
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2f10c
movq %rbx, 0x10(%rsp)
pushq $0x22
popq %rsi
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2f10c
pushq $0x18
popq %rsi
pushq $0x22
popq %rcx
movq 0x20(%rsp), %rdi
movq %rbx, %rdx
callq 0x10140
testl %eax, %eax
je 0x2f10c
movq 0x8(%rsp), %rax
movq (%rax), %r15
addq %rax, %r15
xorl %eax, %eax
callq 0xe560
movq %rax, 0x18(%rsp)
pushq $0x18
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xf540
movq %r15, %rdi
movq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0xffc0
movl $0x1f8, %ebp # imm = 0x1F8
testl %eax, %eax
jne 0x2f10c
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xf1b0
testl %eax, %eax
jns 0x2f10c
movq 0x10(%rsp), %rcx
movq %r15, 0x50(%rsp)
leaq (%r15,%rcx,8), %rbp
leaq (,%rcx,8), %rdx
addq %rbp, %rdx
leaq (%rdx,%rcx,8), %rax
movq %rdx, 0x28(%rsp)
leaq 0x20(%rdx,%rcx,8), %r15
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax), %rbx
addq $0x20, %rbx
movq %r15, %rdi
callq 0xe5d0
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xe360
xorl %eax, %eax
callq 0xe560
movq %rbx, %rdi
movq %r15, 0x48(%rsp)
movq %r15, %rsi
movq %rax, %rdx
callq 0xe970
pushq $0x18
popq %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0xe360
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x2f282
movq 0xb8(%rsp), %rsi
movq %rbx, %rdx
callq 0xe360
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
addq $0x10, %rax
movq %rax, 0x40(%rsp)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xf1f0
pushq $0x20
popq %rdx
movq %rbx, %rdi
movq %rbx, 0x30(%rsp)
movq %rbx, %rsi
callq 0xed10
pushq $0x18
popq %r14
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0xe970
leaq 0x8(%rbp), %rax
movq %rax, 0x70(%rsp)
leaq 0xc(%rbp), %rax
movq %rax, 0x18(%rsp)
leaq 0x10(%rbp), %rax
movq %rax, 0x68(%rsp)
leaq 0x14(%rbp), %rax
movq %rax, 0x60(%rsp)
leaq 0x4(%rbp), %rax
movq %rax, 0x58(%rsp)
pushq $0x1
popq %rbx
movq 0x70(%rsp), %r12
movq 0x68(%rsp), %r13
movq %rbp, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0xe940
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq %r13, %rdx
movq 0x60(%rsp), %r15
movq %r15, %rcx
movq 0x30(%rsp), %r14
movq %r14, %r8
callq 0xef20
movl 0x8(%rbp), %eax
xorl %ebx, %eax
movl %eax, 0x8(%rbp)
xorl %eax, (%rbp)
movl 0xc(%rbp), %eax
xorl %eax, 0x4(%rbp)
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq 0x58(%rsp), %r15
movq %r15, %rcx
movq %r14, %r8
callq 0xef20
leal 0x1(%rbx), %eax
xorl 0x10(%rbp), %eax
movl %eax, 0x10(%rbp)
xorl %eax, 0x8(%rbp)
movl 0x14(%rbp), %eax
xorl %eax, 0xc(%rbp)
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq 0x18(%rsp), %rcx
movq %r14, %r8
pushq $0x18
popq %r14
callq 0xef20
addl $0x2, %ebx
movl (%rbp), %eax
xorl %ebx, %eax
movl %eax, (%rbp)
xorl %eax, 0x10(%rbp)
movl 0x4(%rbp), %eax
xorl %eax, 0x14(%rbp)
movq %rbp, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xf6c0
movq %rbp, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0xf540
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0xffc0
testl %eax, %eax
jne 0x2f3e4
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
movq %rbp, %rdi
movq 0x10(%rsp), %rdx
callq 0xf1b0
testl %eax, %eax
js 0x2f3f9
movq %rbp, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xf300
incl %ebx
jmp 0x2f305
movq 0x8(%rsp), %rdx
movq 0x30(%rdx), %rsi
movq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rcx
movq 0x10(%rsp), %r15
movq %r15, %r8
movq 0x30(%rsp), %r14
movq %r14, %r9
callq 0xff30
testl %eax, %eax
je 0x2f53c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq *0x48(%rdx)
pushq $0x18
popq %r13
movq %r12, %rdi
movq %r13, %rsi
movq 0x48(%rsp), %rbx
movq %rbx, %rdx
callq 0xe360
movq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xe360
pushq $0xa
popq %rsi
movq 0x38(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rdx
callq 0xfa20
movq %r15, %rbx
leaq 0xa(%r13), %rax
movq %rax, 0x18(%rsp)
andw $0x0, 0xa(%r13)
movb $-0x80, 0xc(%r13)
pushq $0xd
popq %rdx
movq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xf540
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
movq 0x50(%rsp), %r13
movq %r13, %rcx
movq %rbx, %r8
movq %r14, %r9
callq 0xe240
leaq 0x2(%rbx), %rdx
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %r8
movq %r14, %r9
callq 0xfc00
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movq %r13, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rbx, %r8
callq 0xec10
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
pushq $0x18
popq %r14
movq %r14, %rdx
callq 0xf540
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movq %r13, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %r8
callq 0xec10
movq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xf300
xorl %ebp, %ebp
jmp 0x2f10c
movl $0x1f6, %ebp # imm = 0x1F6
jmp 0x2f10c
| /agievich[P]bee2/src/crypto/bign96.c |
bign96Sign2_deep | static size_t bign96Sign2_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
return O_OF_W(3 * n + 2 * W_OF_O(13)) +
beltHash_keep() +
utilMax(6,
beltHash_keep(),
32,
beltKWP_keep(),
ecMulA_deep(n, ec_d, ec_deep, n),
zzMul_deep(W_OF_O(13), n),
zzMod_deep(n + W_OF_O(13), n));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %rbp
movq %rdi, %r14
imulq $0x18, %rdi, %r15
xorl %eax, %eax
callq 0xe560
movq %rax, %rbx
addq %r15, %rbx
xorl %eax, %eax
callq 0xe560
movq %rax, %r15
xorl %eax, %eax
callq 0xf030
movq %rax, %r12
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xfa10
movq %rax, %r13
pushq $0x2
popq %rdi
movq %r14, %rsi
callq 0xfe10
movq %rax, %rbp
leaq 0x2(%r14), %rdi
movq %r14, %rsi
callq 0xe7f0
movq %rax, (%rsp)
pushq $0x6
popq %rdi
pushq $0x20
popq %rdx
movq %r15, %rsi
movq %r12, %rcx
movq %r13, %r8
movq %rbp, %r9
xorl %eax, %eax
callq 0xe320
addq %rbx, %rax
addq $0x20, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/crypto/bign96.c |
bign96Verify | err_t bign96Verify(const bign_params* params, const octet oid_der[],
size_t oid_len, const octet hash[24], const octet sig[34],
const octet pubkey[48])
{
err_t code;
size_t n;
// состояние (буферы могут пересекаться)
void* state;
ec_o* ec; /* описание эллиптической кривой */
word* Q; /* [2n] открытый ключ */
word* R; /* [2n] точка R */
word* H; /* [n] хэш-значение */
word* s0; /* [W_OF_O(13)] первая часть подписи */
word* s1; /* [n] вторая часть подписи */
octet* stack;
// проверить params
if (!memIsValid(params, sizeof(bign_params)))
return ERR_BAD_INPUT;
if (params->l != 96)
return ERR_BAD_PARAMS;
// проверить oid_der
if (oid_len == SIZE_MAX || oidFromDER(0, oid_der, oid_len) == SIZE_MAX)
return ERR_BAD_OID;
// создать состояние
state = blobCreate(bign96Start_keep(bign96Verify_deep));
if (state == 0)
return ERR_OUTOFMEMORY;
// старт
code = bign96Start(state, params);
ERR_CALL_HANDLE(code, blobClose(state));
ec = (ec_o*)state;
// размерности
n = ec->f->n;
// проверить входные указатели
if (!memIsValid(hash, 24) ||
!memIsValid(sig, 34) ||
!memIsValid(pubkey, 48))
{
blobClose(state);
return ERR_BAD_INPUT;
}
// раскладка состояния
Q = R = objEnd(ec, word);
H = s0 = Q + 2 * n;
s1 = H + n;
stack = (octet*)(s1 + n);
// загрузить Q
if (!qrFrom(ecX(Q), pubkey, ec->f, stack) ||
!qrFrom(ecY(Q, n), pubkey + 24, ec->f, stack))
{
blobClose(state);
return ERR_BAD_PUBKEY;
}
// загрузить и проверить s1
wwFrom(s1, sig + 10, 24);
if (wwCmp(s1, ec->order, n) >= 0)
{
blobClose(state);
return ERR_BAD_SIG;
}
// s1 <- (s1 + H) mod q
wwFrom(H, hash, 24);
if (wwCmp(H, ec->order, n) >= 0)
{
zzSub2(H, ec->order, n);
// 2^{l - 1} < q < 2^l, H < 2^l => H - q < q
ASSERT(wwCmp(H, ec->order, n) < 0);
}
zzAddMod(s1, s1, H, ec->order, n);
// загрузить s0
memCopy(s0, sig, 10);
((octet*)s0)[10] = ((octet*)s0)[11] = 0, ((octet*)s0)[12] = 0x80;
wwFrom(s0, s0, 13);
// R <- s1 G + (s0 + 2^l) Q
if (!ecAddMulA(R, ec, stack, 2, ec->base, s1, n, Q, s0, (size_t)W_OF_O(13)))
{
blobClose(state);
return ERR_BAD_SIG;
}
qrTo((octet*)R, ecX(R), ec->f, stack);
// s0 == belt-hash(oid || R || H) mod 2^80?
beltHashStart(stack);
beltHashStepH(oid_der, oid_len, stack);
beltHashStepH(R, 24, stack);
beltHashStepH(hash, 24, stack);
code = beltHashStepV2(sig, 10, stack) ? ERR_OK : ERR_BAD_SIG;
// завершение
blobClose(state);
return code;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r13
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x150, %esi # imm = 0x150
callq 0xeeb0
testl %eax, %eax
je 0x2f89c
movq %rbp, 0x8(%rsp)
movl $0x1f6, %ebp # imm = 0x1F6
cmpq $0x60, (%rbx)
jne 0x2f89f
movl $0x12d, %ebp # imm = 0x12D
cmpq $-0x1, %r15
je 0x2f89f
xorl %edi, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0xe710
cmpq $-0x1, %rax
je 0x2f89f
leaq 0x270(%rip), %rdi # 0x2f8c3
callq 0xf4e0
movq %rax, %rdi
callq 0xf190
testq %rax, %rax
je 0x2f8b0
movq %rax, %rbp
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe690
movq %rbp, %rbx
movl %eax, %ebp
testl %eax, %eax
jne 0x2f8b9
movq %rbx, 0x20(%rsp)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rbx
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x2f8b4
pushq $0x22
popq %rsi
movq 0x8(%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2f8b4
movq %rbx, (%rsp)
pushq $0x30
popq %rsi
movq %r13, %rdi
callq 0xeeb0
testl %eax, %eax
movq 0x20(%rsp), %rbx
je 0x2f8b9
movq (%rbx), %rdi
addq %rbx, %rdi
movq (%rsp), %rcx
movq %rcx, %rax
shlq $0x4, %rax
addq %rdi, %rax
movq %rax, 0x30(%rsp)
leaq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
leaq (%rax,%rcx,8), %rcx
movq 0x18(%rbx), %rdx
movq %rdi, 0x28(%rsp)
movq %r13, %rsi
movq %rcx, 0x18(%rsp)
callq *0x40(%rdx)
movl $0x1f9, %ebp # imm = 0x1F9
testl %eax, %eax
je 0x2f8b9
movq 0x18(%rbx), %rdx
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
leaq (%rax,%rcx,8), %rdi
addq $0x18, %r13
movq %r13, %rsi
movq 0x18(%rsp), %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x2f8b9
movq 0x8(%rsp), %rax
leaq 0xa(%rax), %rsi
pushq $0x18
popq %rdx
movq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0xf540
movq 0x38(%rbx), %rsi
movq %r13, %rdi
movq (%rsp), %rdx
callq 0xf1b0
movl $0x1fe, %ebp # imm = 0x1FE
testl %eax, %eax
jns 0x2f8b9
pushq $0x18
popq %rdx
movq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0xf540
movq 0x38(%rbx), %rsi
movq %r13, %rdi
movq (%rsp), %rdx
callq 0xf1b0
testl %eax, %eax
js 0x2f7b4
movq 0x38(%rbx), %rsi
movq %r13, %rdi
movq (%rsp), %rdx
callq 0xee10
movq 0x38(%rbx), %rcx
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
movq %r13, %rdx
movq (%rsp), %r8
callq 0xfff0
pushq $0xa
popq %rdx
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0xe970
andw $0x0, 0xa(%r13)
movb $-0x80, 0xc(%r13)
pushq $0xd
popq %rdx
movq %r13, %rdi
movq %r13, %rsi
callq 0xf540
movq 0x30(%rbx), %r8
pushq $0x2
popq %rcx
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %r9
xorl %eax, %eax
pushq $0x2
pushq %r13
movq %rdi, %r13
pushq %rdi
pushq 0x18(%rsp)
callq 0xe220
addq $0x20, %rsp
testl %eax, %eax
je 0x2f8b9
movq 0x18(%rbx), %rdx
movq %r13, %rbp
movq %r13, %rdi
movq %r13, %rsi
movq 0x18(%rsp), %r13
movq %r13, %rcx
callq *0x48(%rdx)
movq %r13, %rdi
callq 0xe5d0
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xe360
pushq $0x18
popq %r15
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xe360
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xe360
pushq $0xa
popq %rsi
movq 0x8(%rsp), %rdi
movq %r13, %rdx
callq 0xe3a0
testl %eax, %eax
movl $0x1fe, %eax # imm = 0x1FE
movl $0x0, %ebp
cmovel %eax, %ebp
jmp 0x2f8b9
pushq $0x6d
popq %rbp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6e
jmp 0x2f89e
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0xe920
jmp 0x2f89f
| /agievich[P]bee2/src/crypto/bign96.c |
bpkiPrivkeyWrap | err_t bpkiPrivkeyWrap(octet epki[], size_t* epki_len, const octet privkey[],
size_t privkey_len, const octet pwd[], size_t pwd_len,
const octet salt[8], size_t iter)
{
size_t pki_len, edata_len, count;
octet* key;
err_t code;
// проверить входные данные
if (iter < 10000)
return ERR_BAD_INPUT;
if (privkey_len != 32 && privkey_len != 24 && privkey_len != 48 &&
privkey_len != 64)
return ERR_BAD_PRIVKEY;
// определить длину epki
pki_len = bpkiPrivkeyEnc(0, privkey, privkey_len);
if (pki_len == SIZE_MAX)
return ERR_BAD_FORMAT;
edata_len = pki_len + 16;
count = bpkiEdataEnc(0, 0, edata_len, 0, iter);
if (count == SIZE_MAX)
return ERR_BAD_FORMAT;
if (epki_len)
{
if (!memIsValid(epki_len, O_PER_S))
return ERR_BAD_INPUT;
*epki_len = count;
}
if (!epki)
return ERR_OK;
// проверить указатели
if (!memIsValid(privkey, privkey_len) ||
!memIsValid(epki, count) ||
!memIsValid(pwd, pwd_len) ||
!memIsValid(salt, 8))
return ERR_BAD_INPUT;
// сгенерировать ключ
key = (octet*)blobCreate(32);
if (!key)
return ERR_OUTOFMEMORY;
code = beltPBKDF2(key, pwd, pwd_len, iter, salt, 8);
ERR_CALL_HANDLE(code, blobClose(key));
// кодировать pki
pki_len = bpkiPrivkeyEnc(epki + count - pki_len, privkey, privkey_len);
code = pki_len != SIZE_MAX ? ERR_OK : ERR_BAD_PRIVKEY;
ERR_CALL_HANDLE(code, (memWipe(epki, count), blobClose(key)));
// зашифровать pki
code = beltKWPWrap(epki + count - pki_len - 16,
epki + count - pki_len, pki_len, 0, key, 32);
ERR_CALL_HANDLE(code, (memWipe(epki, count), blobClose(key)));
// кодировать edata и epki
count = bpkiEdataEnc(epki, epki + count - edata_len, edata_len,
salt, iter);
code = count != SIZE_MAX ? ERR_OK : ERR_BAD_FORMAT;
ERR_CALL_HANDLE(code, (memWipe(epki, count), blobClose(key)));
// все нормально
blobClose(key);
return ERR_OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $0x6d
popq %rax
cmpq $0x2710, 0x68(%rsp) # imm = 0x2710
jae 0x2f954
movl %eax, %r14d
jmp 0x2fb32
movq %rcx, %r12
movq %rdi, 0x18(%rsp)
leaq -0x18(%rcx), %rax
rolq $0x3d, %rax
movl $0x1f8, %r14d # imm = 0x1F8
cmpq $0x5, %rax
ja 0x2fb32
movq %r9, 0x8(%rsp)
pushq $0x2b
popq %rcx
btq %rax, %rcx
jae 0x2fb32
movq %r8, %rbp
movq %rdx, %r13
movq %rsi, %r15
xorl %edi, %edi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x2fb70
movl $0x132, %r14d # imm = 0x132
cmpq $-0x1, %rax
je 0x2fb32
movq %rax, %rbx
leaq 0x10(%rax), %rdx
xorl %edi, %edi
xorl %esi, %esi
movq %rdx, 0x20(%rsp)
xorl %ecx, %ecx
movq 0x68(%rsp), %r8
callq 0x2fcc4
movq %rax, 0x10(%rsp)
cmpq $-0x1, %rax
je 0x2fb32
testq %r15, %r15
movq 0x18(%rsp), %r14
je 0x2f9fc
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x2fb27
movq 0x10(%rsp), %rax
movq %rax, (%r15)
testq %r14, %r14
je 0x2fb2f
movq %r13, %rdi
movq %r12, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2fb27
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2fb27
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
callq 0xeeb0
testl %eax, %eax
je 0x2fb27
movq 0x60(%rsp), %rdi
pushq $0x8
popq %rsi
callq 0xeeb0
pushq $0x6d
popq %rcx
movl %ecx, %r14d
testl %eax, %eax
je 0x2fb32
pushq $0x20
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x2fb44
movq %rax, %r15
pushq $0x8
popq %r9
movq %rax, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq 0x60(%rsp), %r8
callq 0xff10
movl %eax, %r14d
testl %eax, %eax
jne 0x2fb66
movq %r15, 0x8(%rsp)
movq 0x10(%rsp), %rbp
addq 0x18(%rsp), %rbp
movq %rbp, %r15
subq %rbx, %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2fb70
cmpq $-0x1, %rax
je 0x2fb4a
subq %rax, %rbp
leaq -0x10(%rbp), %rdi
xorl %r14d, %r14d
pushq $0x20
popq %r9
movq %rbp, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
movq 0x8(%rsp), %r8
callq 0xf170
movl %eax, %ebx
testl %eax, %eax
jne 0x2fb4f
addq $-0x10, %r15
movq 0x18(%rsp), %rdi
movq %r15, %rsi
movq 0x20(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %r8
callq 0x2fcc4
cmpq $-0x1, %rax
movq 0x8(%rsp), %r15
jne 0x2fb66
movl $0x132, %ebx # imm = 0x132
pushq $-0x1
popq %rax
movq %rax, 0x10(%rsp)
jmp 0x2fb4f
pushq $0x6d
popq %rax
jmp 0x2f94c
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6e
popq %r14
jmp 0x2fb32
movl $0x1f8, %ebx # imm = 0x1F8
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf560
movl %ebx, %r14d
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe920
jmp 0x2fb32
| /agievich[P]bee2/src/crypto/bpki.c |
bpkiCSRRewrap | err_t bpkiCSRRewrap(octet csr[], size_t csr_len, const octet privkey[],
size_t privkey_len)
{
err_t code;
size_t count;
bpki_csr_info_t ci[1];
bign_params params[1];
octet oid_der[16];
size_t oid_len = sizeof(oid_der);
octet* hash;
// входной контроль
if (privkey_len != 32)
return ERR_NOT_IMPLEMENTED;
if (!memIsValid(csr, csr_len) || !memIsValid(privkey, 32))
return ERR_BAD_INPUT;
// разобрать запрос
count = bpkiCSRDec(ci, csr, csr_len);
if (count == SIZE_MAX || count != csr_len)
return ERR_BAD_FORMAT;
// загрузить стандартные параметры
code = bignParamsStd(params, oid_bign_curve256v1);
ERR_CALL_CHECK(code);
// сгенерировать открытый ключ
code = bignPubkeyCalc(csr + ci->pubkey_offset, params, privkey);
ERR_CALL_CHECK(code);
// получить случайные числа
if (rngIsValid())
rngStepR(csr + ci->sig_offset, 48, 0);
// кодировать идентификатор алгоритма хэширования
code = bignOidToDER(oid_der, &oid_len, oid_belt_hash);
ERR_CALL_CHECK(code);
// хэшировать
if (!(hash = blobCreate(32)))
return ERR_OUTOFMEMORY;
code = beltHash(hash, csr + ci->body_offset, ci->body_len);
ERR_CALL_HANDLE(code, blobClose(hash));
// подписать
code = bignSign2(csr + ci->sig_offset, params, oid_der, oid_len,
hash, privkey, csr + ci->sig_offset, 48);
// завершить
blobClose(hash);
return code;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq $0x10, 0x8(%rsp)
cmpq $0x20, %rcx
jne 0x30e56
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0xeeb0
pushq $0x6d
popq %rbp
testl %eax, %eax
je 0x30e59
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0xeeb0
testl %eax, %eax
je 0x30e59
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x30ecb
cmpq $-0x1, %rax
sete %cl
cmpq %r15, %rax
setne %al
movl $0x132, %ebp # imm = 0x132
orb %cl, %al
jne 0x30e59
leaq 0x1e70c(%rip), %rsi # 0x4f500
leaq 0x40(%rsp), %rdi
callq 0xf950
testl %eax, %eax
jne 0x30e52
movq 0x20(%rsp), %rdi
addq %rbx, %rdi
leaq 0x40(%rsp), %rsi
movq %r14, %rdx
callq 0xfed0
testl %eax, %eax
jne 0x30e52
xorl %eax, %eax
callq 0xec20
testl %eax, %eax
je 0x30e38
movq 0x28(%rsp), %rdi
addq %rbx, %rdi
pushq $0x30
popq %rsi
xorl %edx, %edx
callq 0x10110
leaq 0x1e6e1(%rip), %rdx # 0x4f520
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe5a0
testl %eax, %eax
je 0x30e69
movl %eax, %ebp
jmp 0x30e59
pushq $0x77
popq %rbp
movl %ebp, %eax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0xf190
testq %rax, %rax
je 0x30ec7
movq %rax, %r15
movq 0x10(%rsp), %rsi
addq %rbx, %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0xf660
movl %eax, %ebp
testl %eax, %eax
jne 0x30ebd
addq 0x28(%rsp), %rbx
movq 0x8(%rsp), %rcx
leaq 0x40(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %r8
movq %r14, %r9
pushq $0x30
pushq %rbx
callq 0xf440
popq %rcx
popq %rdx
movl %eax, %ebp
movq %r15, %rdi
callq 0xe920
jmp 0x30e59
pushq $0x6e
jmp 0x30e58
| /agievich[P]bee2/src/crypto/bpki.c |
stb99ParamsVal | err_t stb99ParamsVal(const stb99_params* params)
{
size_t n, no;
size_t m, mo;
// состояние
void* state;
word* p;
word* q;
word* t;
word* d;
word* a;
qr_o* qr;
void* stack;
// проверить указатели
if (!memIsValid(params, sizeof(stb99_params)))
return ERR_BAD_INPUT;
// проверить размерности
for (n = 0; n < COUNT_OF(_ls); ++n)
if (_ls[n] == params->l)
break;
if (n == COUNT_OF(_ls) || _rs[n] != params->r)
return ERR_BAD_PARAMS;
// размерности
n = W_OF_B(params->l), no = O_OF_B(params->l);
m = W_OF_B(params->r), mo = O_OF_B(params->r);
// создать состояние
state = blobCreate(
O_OF_W(3 * n + 1) + zmMontCreate_keep(no) +
utilMax(4,
priIsPrime_deep(n),
zzDiv_deep(n, m),
zmMontCreate_deep(no),
qrPower_deep(n, n - m + 1, zmMontCreate_deep(no))));
if (state == 0)
return ERR_OUTOFMEMORY;
// раскладка состояния
p = d = (word*)state;
q = p + n;
t = q + m;
a = t + n - m + 1;
qr = (qr_o*)(a + n);
stack = (octet*)qr + zmMontCreate_keep(no);
// p -- l-битовое простое?
wwFrom(p, params->p, no);
if (!memIsZero(params->p + no, sizeof(params->p) - no) ||
wwBitSize(p, n) != params->l || !priIsPrime(p, n, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// q -- r-битовое простое?
wwFrom(q, params->q, mo);
if (!memIsZero(params->q + mo, sizeof(params->q) - mo) ||
wwBitSize(q, m) != params->r || !priIsPrime(q, m, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// t <- (p - 1) div q
zzSubW2(p, n, 1);
zzDiv(t, p, p, n, q, m, stack);
// q | p - 1?
if (!wwIsZero(p, m))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// построить кольцо Монтгомери
zmMontCreate(qr, params->p, no, params->l + 2, stack);
// загрузить d
if (!memIsZero(params->d + no, sizeof(params->d) - no) ||
!qrFrom(d, params->d, qr, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// d <- d^((p - 1)/q) \neq e?
qrPower(d, d, t, n - m + 1, qr, stack);
if (qrIsUnity(d, qr))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// a == params->a?
wwFrom(a, params->a, no);
if (!memIsZero(params->a + no, sizeof(params->a) - no) ||
!wwEq(a, d, n))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// все нормально
blobClose(state);
return ERR_OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl $0x3d0, %esi # imm = 0x3D0
callq 0xeeb0
testl %eax, %eax
je 0x399a9
movq (%rbx), %r14
xorl %eax, %eax
leaq 0x17152(%rip), %rcx # 0x50ae0
movl $0x1f6, %ebp # imm = 0x1F6
cmpq $0x50, %rax
je 0x39ce7
cmpq %r14, (%rax,%rcx)
je 0x399b1
addq $0x8, %rax
jmp 0x39993
pushq $0x6d
popq %rbp
jmp 0x39ce7
leaq 0x17178(%rip), %rcx # 0x50b30
movq (%rax,%rcx), %rax
cmpq 0x8(%rbx), %rax
jne 0x39ce7
leaq 0x3f(%r14), %r15
shrq $0x6, %r15
addq $0x7, %r14
shrq $0x3, %r14
movq %rax, 0x20(%rsp)
leaq 0x3f(%rax), %r13
shrq $0x6, %r13
imulq $0x18, %r15, %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0xeda0
movq %rax, %rbp
movq %r15, %rdi
callq 0xeca0
movq %rax, 0x38(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0xeba0
movq %rax, 0x18(%rsp)
movq %r14, %rdi
callq 0xe6f0
movq %rax, 0x30(%rsp)
movq %r15, %r12
movq %r13, 0x50(%rsp)
subq %r13, %r12
incq %r12
movq %r14, %rdi
callq 0xe6f0
movq %r15, 0x28(%rsp)
movq %r15, %rdi
movq %r12, 0x48(%rsp)
movq %r12, %rsi
movq %rax, %rdx
callq 0xfb90
pushq $0x4
popq %rdi
movq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xe320
addq 0x10(%rsp), %rbp
leaq (%rax,%rbp), %rdi
addq $0x8, %rdi
callq 0xf190
testq %rax, %rax
je 0x39cf8
movq %rax, %r13
movq %r14, %rdi
callq 0xeda0
movq %rax, %r15
leaq 0x10(%rbx), %rsi
movq %r13, %rdi
movq %rsi, 0x38(%rsp)
movq %r14, %rdx
callq 0xf540
leaq (%rbx,%r14), %rdi
addq $0x10, %rdi
movl $0x134, %r12d # imm = 0x134
subq %r14, %r12
movq %r12, %rsi
callq 0xfe60
movl $0x1f6, %ebp # imm = 0x1F6
testl %eax, %eax
je 0x39cdf
movq %r15, 0x10(%rsp)
movq %r13, %rdi
movq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0xeb10
cmpq (%rbx), %rax
jne 0x39cdf
leaq (,%r15,8), %rax
addq %r13, %rax
movq %rax, 0x18(%rsp)
leaq (%rax,%r15,8), %rax
leaq (%rax,%r15,8), %rax
addq $0x8, %rax
movq 0x10(%rsp), %rdx
movq %rax, 0x30(%rsp)
addq %rax, %rdx
movq %r13, %rdi
movq %r15, %rsi
movq %rdx, 0x10(%rsp)
callq 0xff80
testl %eax, %eax
je 0x39cdf
movq 0x20(%rsp), %r15
addq $0x7, %r15
shrq $0x3, %r15
leaq 0x144(%rbx), %rsi
movq 0x18(%rsp), %rdi
movq %r15, %rdx
callq 0xf540
leaq (%rbx,%r15), %rdi
addq $0x144, %rdi # imm = 0x144
pushq $0x21
popq %rsi
subq %r15, %rsi
callq 0xfe60
testl %eax, %eax
je 0x39cdf
movq %r12, 0x40(%rsp)
movq 0x18(%rsp), %r15
movq %r15, %rdi
movq 0x50(%rsp), %r12
movq %r12, %rsi
callq 0xeb10
cmpq 0x8(%rbx), %rax
jne 0x39cdf
movq %r15, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
callq 0xff80
testl %eax, %eax
je 0x39cdf
leaq (%r15,%r12,8), %rax
movq %rax, 0x20(%rsp)
pushq $0x1
popq %rdx
movq %r13, %rdi
movq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0xfb20
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq 0x18(%rsp), %r8
movq %r12, %r9
callq 0xf7a0
movq %r13, %rdi
movq %r12, %rsi
callq 0xffc0
testl %eax, %eax
je 0x39cdf
movq (%rbx), %rcx
addq $0x2, %rcx
movq 0x30(%rsp), %r15
movq %r15, %rdi
movq 0x38(%rsp), %rsi
movq %r14, %rdx
movq 0x10(%rsp), %r8
callq 0xf250
leaq (%rbx,%r14), %rdi
addq $0x299, %rdi # imm = 0x299
movq 0x40(%rsp), %rsi
callq 0xfe60
testl %eax, %eax
je 0x39cdf
leaq 0x299(%rbx), %rsi
movq %r13, %rdi
movq %r15, %rdx
movq 0x10(%rsp), %rcx
callq *0x40(%r15)
testl %eax, %eax
je 0x39cdf
movq %r13, %rdi
movq %r13, %rsi
movq 0x20(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
callq 0xf6f0
movq 0x20(%r15), %rsi
movq 0x30(%r15), %rdx
movq %r13, %rdi
callq 0xf520
testl %eax, %eax
jne 0x39cdf
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %r15
leaq (%rax,%r15,8), %r12
addq $0x8, %r12
leaq 0x165(%rbx), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0xf540
leaq (%rbx,%r14), %rdi
addq $0x165, %rdi # imm = 0x165
movq 0x40(%rsp), %rsi
callq 0xfe60
testl %eax, %eax
je 0x39cdf
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xf520
xorl %ecx, %ecx
testl %eax, %eax
movl $0x1f6, %ebp # imm = 0x1F6
cmovnel %ecx, %ebp
movq %r13, %rdi
callq 0xe920
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6e
jmp 0x399ab
nop
| /agievich[P]bee2/src/crypto/stb99.c |
pfokMTI | err_t pfokMTI(octet sharekey[], const pfok_params* params,
const octet privkey[], const octet privkey1[],
const octet pubkey[], const octet pubkey1[])
{
size_t n, no;
size_t m, mo;
// состояние
void* state;
word* x; /* [m] личный ключ */
word* u; /* [m] одноразовый личный ключ */
word* y; /* [n] открытый ключ визави */
word* v; /* [n] одноразовый открытый ключ визави */
qr_o* qr; /* описание кольца Монтгомери */
void* stack;
// проверить params
if (!memIsValid(params, sizeof(pfok_params)))
return ERR_BAD_INPUT;
// работоспособные параметры?
if (!pfokParamsIsOperable(params))
return ERR_BAD_PARAMS;
// размерности
n = W_OF_B(params->l), no = O_OF_B(params->l);
m = W_OF_B(params->r), mo = O_OF_B(params->r);
// проверить остальные входные данные
if (!memIsValid(privkey, mo) ||
!memIsValid(privkey1, mo) ||
!memIsValid(pubkey, no) ||
!memIsValid(pubkey1, no) ||
!memIsValid(sharekey, O_OF_B(params->n)))
return ERR_BAD_INPUT;
// создать состояние
state = blobCreate(
2 * O_OF_W(n) + 2 * O_OF_W(m) + zmMontCreate_keep(no) +
utilMax(2,
zmMontCreate_deep(no),
qrPower_deep(n, n, zmMontCreate_deep(no))));
if (state == 0)
return ERR_OUTOFMEMORY;
// раскладка состояния
x = (word*)state;
u = x + m;
y = u + m;
v = y + n;
qr = (qr_o*)(v + n);
stack = (octet*)qr + zmMontCreate_keep(no);
// построить кольцо Монтгомери
zmMontCreate(qr, params->p, no, params->l + 2, stack);
// x <- privkey, u <- privkey1
wwFrom(x, privkey, mo);
wwFrom(u, privkey1, mo);
if (wwGetBits(x, params->r, B_OF_W(m) - params->r) != 0 ||
wwGetBits(u, params->r, B_OF_W(m) - params->r) != 0)
{
blobClose(state);
return ERR_BAD_PRIVKEY;
}
// y <- pubkey, v <- pubkey1
wwFrom(y, pubkey, no);
wwFrom(v, pubkey1, no);
if (wwIsZero(y, n) || wwCmp(y, qr->mod, n) >= 0 ||
wwIsZero(v, n) || wwCmp(v, qr->mod, n) >= 0)
{
blobClose(state);
return ERR_BAD_PUBKEY;
}
// y <- y^u, v <- v^x
qrPower(y, y, u, m, qr, stack);
qrPower(v, v, x, m, qr, stack);
// выгрузить открытый ключ
qrTo((octet*)y, y, qr, stack);
qrTo((octet*)v, v, qr, stack);
memCopy(sharekey, y, O_OF_B(params->n));
memXor2(sharekey, v, O_OF_B(params->n));
if (params->n % 8)
sharekey[params->n / 8] &= (octet)255 >> (8 - params->n % 8);
// все нормально
blobClose(state);
return ERR_OK;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbp
movq %r8, 0x58(%rsp)
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2f8, %esi # imm = 0x2F8
movq %r14, %rdi
callq 0xeeb0
pushq $0x6d
popq %r12
testl %eax, %eax
je 0x3b451
movq %r14, %rdi
callq 0x3a8bb
testl %eax, %eax
je 0x3b44b
movq %rbp, 0x50(%rsp)
movq %rbx, 0x28(%rsp)
movq (%r14), %rbx
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x7(%rax), %rbp
shrq $0x3, %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x3b451
movq %r15, %rdi
movq %rbp, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x3b451
movq %r15, 0x20(%rsp)
leaq 0x7(%rbx), %r15
shrq $0x3, %r15
movq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x3b451
movq 0x50(%rsp), %rdi
movq %r15, 0x18(%rsp)
movq %r15, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x3b451
movq 0x10(%r14), %rsi
addq $0x7, %rsi
shrq $0x3, %rsi
movq 0x28(%rsp), %rdi
callq 0xeeb0
testl %eax, %eax
je 0x3b451
movq %rbx, %r15
addq $0x3f, %r15
shrq $0x6, %r15
movq 0x8(%rsp), %rax
addq $0x3f, %rax
movq %rax, 0x8(%rsp)
shrq $0x6, %rax
movq %rax, 0x48(%rsp)
leaq (%rax,%r15), %r12
shlq $0x4, %r12
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0xeda0
addq %rax, %r12
movq %rbx, %rdi
callq 0xe6f0
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0xe6f0
movq %r15, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xfb90
pushq $0x2
popq %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe320
addq %rax, %r12
movq %r12, %rdi
callq 0xf190
testq %rax, %rax
je 0x3b463
movq %rax, %rbx
movq 0x48(%rsp), %rax
leaq (%rbx,%rax,8), %rcx
movq %rcx, 0x10(%rsp)
leaq (%rcx,%rax,8), %rax
movq %rax, 0x38(%rsp)
leaq (%rax,%r15,8), %rax
movq %r15, 0x60(%rsp)
movq %rax, 0x40(%rsp)
leaq (%rax,%r15,8), %r15
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xeda0
addq %r15, %rax
leaq 0x18(%r14), %rsi
movq (%r14), %rcx
addq $0x2, %rcx
movq %r15, 0x30(%rsp)
movq %r15, %rdi
movq %rax, %r15
movq %r12, %rdx
movq %rax, %r8
callq 0xf250
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xf540
movq 0x10(%rsp), %rdi
movq %rdi, %r13
movq 0x20(%rsp), %rsi
movq %rbp, %rdx
callq 0xf540
movq 0x8(%r14), %rsi
movq 0x8(%rsp), %rbp
andq $-0x40, %rbp
movq %rbp, %rdx
subq %rsi, %rdx
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0xfcc0
movl $0x1f8, %r12d # imm = 0x1F8
testq %rax, %rax
jne 0x3b43f
movq %rbp, %rdx
movq %r15, 0x20(%rsp)
movq 0x60(%rsp), %rbx
movq 0x8(%r14), %rsi
subq %rsi, %rdx
movq %r13, %rdi
callq 0xfcc0
testq %rax, %rax
jne 0x3b43f
movq 0x38(%rsp), %rbp
movq %rbp, %rdi
movq 0x58(%rsp), %rsi
movq 0x18(%rsp), %r12
movq %r12, %rdx
callq 0xf540
movq 0x40(%rsp), %r15
movq %r15, %rdi
movq 0x50(%rsp), %rsi
movq %r12, %rdx
callq 0xf540
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xffc0
movl $0x1f9, %r12d # imm = 0x1F9
testl %eax, %eax
jne 0x3b43f
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rsi
movq %rbp, %rdi
movq %rbx, %rdx
callq 0xf1b0
testl %eax, %eax
jns 0x3b43f
movq %r15, %rdi
movq %rbx, %rsi
callq 0xffc0
testl %eax, %eax
jne 0x3b43f
movq 0x18(%r15,%rbx,8), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xf1b0
testl %eax, %eax
movq 0x10(%rsp), %rdx
jns 0x3b43f
movq 0x38(%rsp), %rbp
movq %rbp, %rdi
movq %rbp, %rsi
movq 0x48(%rsp), %r13
movq %r13, %rcx
movq 0x30(%rsp), %r15
movq %r15, %r8
movq 0x20(%rsp), %rbx
movq %rbx, %r9
callq 0xf6f0
movq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0xf6f0
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq *0x48(%r15)
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq *0x48(%r15)
movq 0x10(%r14), %rdx
addq $0x7, %rdx
shrq $0x3, %rdx
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xe970
movq 0x10(%r14), %rdx
addq $0x7, %rdx
shrq $0x3, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf0b0
movq 0x10(%r14), %rax
xorl %r12d, %r12d
movq %rax, %rdx
andq $0x7, %rdx
je 0x3b43f
movb $0x8, %cl
subb %dl, %cl
movl $0xff, %edx
shrl %cl, %edx
shrq $0x3, %rax
movq 0x28(%rsp), %rcx
andb %dl, (%rcx,%rax)
movq 0x8(%rsp), %rdi
callq 0xe920
jmp 0x3b451
movl $0x1f6, %r12d # imm = 0x1F6
movl %r12d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x6e
popq %r12
jmp 0x3b451
nopl (%rax)
| /agievich[P]bee2/src/crypto/pfok.c |
ecIsOperable2 | bool_t ecIsOperable2(const ec_o* ec)
{
return objIsOperable2(ec) &&
objKeep(ec) >= sizeof(ec_o) &&
objPCount(ec) == 6 &&
objOCount(ec) == 1 &&
wwIsValid(ec->A, ec->f->n) &&
wwIsValid(ec->B, ec->f->n) &&
ec->d >= 3 &&
ec->froma != 0 &&
ec->toa != 0 &&
ec->neg != 0 &&
ec->add != 0 &&
ec->adda != 0 &&
ec->sub != 0 &&
ec->suba != 0 &&
ec->dbl != 0 &&
ec->dbla != 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xe7d0
xorl %ebx, %ebx
testl %eax, %eax
je 0x3b52c
cmpq $0xb0, (%r14)
jb 0x3b52c
cmpq $0x6, 0x8(%r14)
jne 0x3b52c
cmpq $0x1, 0x10(%r14)
jne 0x3b52c
movq 0x18(%r14), %rax
movq 0x20(%r14), %rdi
movq 0x30(%rax), %rsi
shlq $0x3, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x3b52c
movq 0x18(%r14), %rax
movq 0x28(%r14), %rdi
movq 0x30(%rax), %rsi
shlq $0x3, %rsi
callq 0xeeb0
testl %eax, %eax
je 0x3b52c
cmpq $0x3, 0x48(%r14)
jb 0x3b52c
cmpq $0x0, 0x58(%r14)
je 0x3b52c
cmpq $0x0, 0x60(%r14)
je 0x3b52c
cmpq $0x0, 0x68(%r14)
je 0x3b52c
cmpq $0x0, 0x70(%r14)
je 0x3b52c
cmpq $0x0, 0x78(%r14)
je 0x3b52c
cmpq $0x0, 0x80(%r14)
je 0x3b52c
cmpq $0x0, 0x88(%r14)
je 0x3b52c
cmpq $0x0, 0x90(%r14)
je 0x3b52c
xorl %ebx, %ebx
cmpq $0x0, 0x98(%r14)
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /agievich[P]bee2/src/math/ec.c |
ecCreateGroup | bool_t ecCreateGroup(ec_o* ec, const octet xbase[], const octet ybase[],
const octet order[], size_t order_len, u32 cofactor, void* stack)
{
ASSERT(ecIsOperable(ec));
ASSERT(memIsValid(order, order_len));
ASSERT(memIsNullOrValid(xbase, ec->f->no));
ASSERT(memIsNullOrValid(ybase, ec->f->no));
// корректное описание?
order_len = memNonZeroSize(order, order_len);
if (order_len == 0 ||
W_OF_O(order_len) > ec->f->n + 1 ||
cofactor == 0 ||
(u32)(word)cofactor != cofactor)
return FALSE;
// установить базовую точку
if (xbase == 0)
qrSetZero(ecX(ec->base), ec->f);
else if (!qrFrom(ecX(ec->base), xbase, ec->f, stack))
return FALSE;
if (ybase == 0)
qrSetZero(ecY(ec->base, ec->f->n), ec->f);
else if (!qrFrom(ecY(ec->base, ec->f->n), ybase, ec->f, stack))
return FALSE;
// установить порядок и кофактор
wwFrom(ec->order, order, order_len);
wwSetZero(ec->order + W_OF_O(order_len),
ec->f->n + 1 - W_OF_O(order_len));
ec->cofactor = (word)cofactor;
// все нормально
return TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r13d
movq %rcx, %r14
movq %rdx, 0x10(%rsp)
movq %rsi, %rbp
movq %rdi, %rbx
movq %rcx, %rdi
movq %r8, %rsi
callq 0xf8d0
xorl %r12d, %r12d
testq %rax, %rax
je 0x3b680
testl %r13d, %r13d
je 0x3b680
movq %rax, %r15
movl %r13d, 0xc(%rsp)
leaq 0x7(%rax), %r13
shrq $0x3, %r13
movq 0x18(%rbx), %rdx
movq 0x30(%rdx), %rsi
leaq 0x1(%rsi), %rax
cmpq %rax, %r13
ja 0x3b680
movq 0x50(%rsp), %rcx
testq %rbp, %rbp
je 0x3b5fa
movq 0x30(%rbx), %rdi
movq %rbp, %rsi
movq %rcx, %rbp
callq *0x40(%rdx)
testl %eax, %eax
jne 0x3b606
jmp 0x3b680
movq %rcx, %rbp
movq 0x30(%rbx), %rdi
callq 0xfe90
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x3b62c
movq 0x18(%rbx), %rdx
movq 0x30(%rdx), %rdi
shlq $0x3, %rdi
addq 0x30(%rbx), %rdi
movq %rbp, %rcx
callq *0x40(%rdx)
testl %eax, %eax
jne 0x3b645
jmp 0x3b680
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rsi
leaq (,%rsi,8), %rdi
addq 0x30(%rbx), %rdi
callq 0xfe90
movl 0xc(%rsp), %r12d
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf540
leaq (,%r13,8), %rdi
addq 0x38(%rbx), %rdi
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rsi
subq %r13, %rsi
incq %rsi
callq 0xfe90
movq %r12, 0x50(%rbx)
pushq $0x1
popq %r12
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/math/ec.c |
ecIsOperableGroup | bool_t ecIsOperableGroup(const ec_o* ec)
{
ASSERT(ecIsOperable(ec));
return wwIsValid(ec->base, 2 * ec->f->n) &&
wwIsValid(ec->order, ec->f->n + 1) &&
!wwIsZero(ec->order, ec->f->n + 1) &&
ec->cofactor != 0;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x30(%rdi), %rdi
movq 0x30(%rax), %rsi
shlq $0x4, %rsi
callq 0xeeb0
xorl %ebp, %ebp
testl %eax, %eax
je 0x3b6f7
movq 0x18(%rbx), %rax
movq 0x38(%rbx), %rdi
movq 0x30(%rax), %rax
leaq 0x8(,%rax,8), %rsi
callq 0xeeb0
testl %eax, %eax
je 0x3b6f7
movq 0x18(%rbx), %rax
movq 0x38(%rbx), %rdi
movq 0x30(%rax), %rsi
incq %rsi
callq 0xffc0
testl %eax, %eax
jne 0x3b6f7
xorl %ebp, %ebp
cmpq $0x0, 0x50(%rbx)
setne %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /agievich[P]bee2/src/math/ec.c |
ecMulA_deep | size_t ecMulA_deep(size_t n, size_t ec_d, size_t ec_deep, size_t m)
{
const size_t naf_width = ecNAFWidth(B_OF_W(m));
const size_t naf_count = SIZE_1 << (naf_width - 2);
return O_OF_W(2 * m + 1) +
O_OF_W(ec_d * n) +
O_OF_W(ec_d * n * naf_count) +
ec_deep;
} | movq %rcx, %rax
shlq $0x6, %rcx
cmpq $0x14f, %rcx # imm = 0x14F
jbe 0x3b9f5
pushq $0x4
jmp 0x3b9fd
cmpq $0x77, %rcx
jbe 0x3ba00
pushq $0x3
popq %rcx
jmp 0x3ba0b
cmpq $0x1, %rcx
pushq $0x2
popq %rcx
sbbq $0x0, %rcx
shlq $0x4, %rax
imulq %rdi, %rsi
movq %rsi, %rdi
shlq %cl, %rdi
addq %rsi, %rdi
addq %rax, %rdx
leaq (%rdx,%rdi,8), %rax
addq $0x8, %rax
retq
| /agievich[P]bee2/src/math/ec.c |
ecAddMulA_deep | size_t ecAddMulA_deep(size_t n, size_t ec_d, size_t ec_deep, size_t k, ...)
{
size_t i, ret;
va_list marker;
ret = O_OF_W(ec_d * n);
ret += 4 * sizeof(size_t) * k;
ret += 2 * sizeof(word**) * k;
va_start(marker, k);
for (i = 0; i < k; ++i)
{
size_t m = va_arg(marker, size_t);
size_t naf_width = ecNAFWidth(B_OF_W(m));
size_t naf_count = SIZE_1 << (naf_width - 2);
ret += O_OF_W(2 * m + 1);
ret += O_OF_W(ec_d * n * naf_count);
}
va_end(marker);
ret += ec_deep;
return ret;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r10
leaq -0x60(%rsp), %r11
movq %r8, 0x20(%r11)
movq %r9, 0x28(%r11)
testb %al, %al
je 0x3c004
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
imulq %rsi, %rdi
imulq $0x30, %rcx, %rax
leaq (%rax,%rdi,8), %rax
movq %r11, -0x70(%rsp)
leaq 0x80(%rsp), %rcx
movq %rcx, -0x78(%rsp)
movabsq $0x3000000020, %rsi # imm = 0x3000000020
movq %rsi, -0x80(%rsp)
movl $0x20, %esi
movabsq $0x4, %r8
movabsq $0x3, %r9
movabsq $0x2, %rbx
subq $0x1, %r10
jb 0x3c0bd
cmpl $0x28, %esi
ja 0x3c070
movq %rcx, %r14
movl %esi, %ecx
addq %r11, %rcx
addl $0x8, %esi
movl %esi, -0x80(%rsp)
jmp 0x3c079
leaq 0x8(%rcx), %r14
movq %r14, -0x78(%rsp)
movq (%rcx), %r15
movq %r15, %r12
shlq $0x6, %r12
movq %r8, %rcx
cmpq $0x14f, %r12 # imm = 0x14F
ja 0x3c0a3
movq %r9, %rcx
cmpq $0x77, %r12
ja 0x3c0a3
cmpq $0x1, %r12
movq %rbx, %rcx
sbbq $0x0, %rcx
movq %rdi, %r12
shlq %cl, %r12
shlq $0x4, %r15
addq %r15, %rax
leaq (%rax,%r12,8), %rax
addq $0x8, %rax
movq %r14, %rcx
jmp 0x3c054
addq %rdx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/math/ec.c |
ec2CreateLD | bool_t ec2CreateLD(ec_o* ec, const qr_o* f, const octet A[], const octet B[],
void* stack)
{
ASSERT(memIsValid(ec, sizeof(ec_o)));
ASSERT(gf2IsOperable(f));
ASSERT(memIsValid(A, f->no));
ASSERT(memIsValid(B, f->no));
// обнулить
memSetZero(ec, sizeof(ec_o));
// зафикисровать размерности
ec->d = 3;
// запомнить базовое поле
ec->f = f;
// сохранить коэффициенты
ec->A = (word*)ec->descr;
ec->B = ec->A + f->n;
if (!qrFrom(ec->A, A, ec->f, stack) || !qrFrom(ec->B, B, ec->f, stack))
return FALSE;
// подготовить буферы для описания группы точек
ec->base = ec->B + f->n;
ec->order = ec->base + 2 * f->n;
// настроить интерфейсы
ec->froma = ec2FromALD;
ec->toa = ec2ToALD;
ec->neg = ec2NegLD;
ec->add = ec2AddLD;
ec->adda = ec2AddALD;
ec->sub = ec2SubLD;
ec->suba = ec2SubALD;
ec->dbl = ec2DblLD;
ec->dbla = ec2DblALD;
ec->deep = utilMax(8,
ec2ToALD_deep(f->n, f->deep),
ec2NegLD_deep(f->n, f->deep),
ec2AddLD_deep(f->n, f->deep),
ec2AddALD_deep(f->n, f->deep),
ec2SubLD_deep(f->n, f->deep),
ec2SubALD_deep(f->n, f->deep),
ec2DblLD_deep(f->n, f->deep),
ec2DblALD_deep(f->n, f->deep));
// настроить заголовок
ec->hdr.keep = sizeof(ec_o) + O_OF_W(5 * f->n + 1);
ec->hdr.p_count = 6;
ec->hdr.o_count = 1;
// все нормально
return TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movl $0xb0, %edx
xorl %esi, %esi
callq 0xf710
movq $0x3, 0x48(%rbx)
movq %r14, 0x18(%rbx)
leaq 0xb0(%rbx), %rdi
movq %rdi, 0x20(%rbx)
movq 0x30(%r14), %rax
leaq 0xb0(%rbx,%rax,8), %rax
movq %rax, 0x28(%rbx)
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq *0x40(%r14)
testl %eax, %eax
je 0x3c28f
movq 0x18(%rbx), %rdx
movq 0x28(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rcx
callq *0x40(%rdx)
testl %eax, %eax
je 0x3c28f
movq 0x30(%r14), %rax
shlq $0x3, %rax
addq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
movq 0x30(%r14), %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rcx, 0x38(%rbx)
leaq 0x131(%rip), %rax # 0x3c2a0
movq %rax, 0x58(%rbx)
leaq 0x183(%rip), %rax # 0x3c2fd
movq %rax, 0x60(%rbx)
leaq 0x227(%rip), %rax # 0x3c3ac
movq %rax, 0x68(%rbx)
leaq 0x27e(%rip), %rax # 0x3c40e
movq %rax, 0x70(%rbx)
leaq 0x65b(%rip), %rax # 0x3c7f6
movq %rax, 0x78(%rbx)
leaq 0x9dc(%rip), %rax # 0x3cb82
movq %rax, 0x80(%rbx)
leaq 0xa8b(%rip), %rax # 0x3cc3f
movq %rax, 0x88(%rbx)
leaq 0xaf2(%rip), %rax # 0x3ccb4
movq %rax, 0x90(%rbx)
leaq 0xcf3(%rip), %rax # 0x3cec3
movq %rax, 0x98(%rbx)
movq 0x30(%r14), %rdi
movq 0x88(%r14), %rsi
leaq (%rsi,%rdi,8), %r15
callq 0x3d042
movq %rax, (%rsp)
movq 0x30(%r14), %rdi
movq 0x88(%r14), %rsi
callq 0x3d05e
movq %rax, %r13
movq 0x30(%r14), %rdi
movq 0x88(%r14), %rsi
callq 0x3d079
movq %rax, %rbp
movq 0x30(%r14), %rdi
movq 0x88(%r14), %rsi
callq 0x3d0a4
movq %rax, %r10
movq 0x30(%r14), %r12
movq 0x88(%r14), %rcx
leaq (%rcx,%r12,8), %r11
shlq $0x4, %r12
addq %rcx, %r12
subq $0x8, %rsp
pushq $0x8
popq %rdi
movq %r15, %rsi
movq %r15, %rdx
movq 0x8(%rsp), %rcx
movq %r13, %r8
movq %rbp, %r9
xorl %eax, %eax
pushq %r11
pushq %r12
pushq %r10
callq 0xe320
addq $0x20, %rsp
movq %rax, 0xa8(%rbx)
imulq $0x28, 0x30(%r14), %rax
addq $0xb8, %rax
movq %rax, (%rbx)
movq $0x6, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/math/ec2.c |
ec2ToALD | static bool_t ec2ToALD(word b[], const word a[], const ec_o* ec, void* stack)
{
const size_t n = ec->f->n;
// переменные в stack
word* t1 = (word*)stack;
stack = t1 + n;
// pre
ASSERT(ecIsOperable(ec) && ec->d == 3);
ASSERT(ec2SeemsOn3(a, ec));
ASSERT(a == b || wwIsDisjoint2(a, 3 * n, b, 2 * n));
// a == O => b <- O
if (qrIsZero(ecZ(a, n), ec->f))
return FALSE;
// t1 <- za^{-1}
qrInv(t1, ecZ(a, n), ec->f, stack);
// xb <- xa t1
qrMul(ecX(b), ecX(a), t1, ec->f, stack);
// t1 <- t1^2
qrSqr(t1, t1, ec->f, stack);
// yb <- ya t1
qrMul(ecY(b, n), ecY(a, n), t1, ec->f, stack);
// b != O
return TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq 0x18(%rdx), %rax
movq 0x30(%rax), %r13
leaq (%rsi,%r13,8), %r15
leaq (%r15,%r13,8), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0xffc0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x3c39d
leaq (%rbx,%r13,8), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq *0x78(%rdx)
movq 0x18(%r14), %rcx
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq 0x8(%rsp), %r12
movq %r12, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rcx
callq *0x70(%rdx)
movq 0x18(%r14), %rcx
leaq (,%r13,8), %rdi
addq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %r8
callq *0x68(%rcx)
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /agievich[P]bee2/src/math/ec2.c |
ec2NegLD | static void ec2NegLD(word b[], const word a[], const ec_o* ec, void* stack)
{
const size_t n = ec->f->n;
// переменные в stack
word* t1 = (word*)stack;
stack = t1 + n;
// pre
ASSERT(ecIsOperable(ec) && ec->d == 3);
ASSERT(ec2SeemsOn3(a, ec));
ASSERT(wwIsSameOrDisjoint(a, b, 3 * n));
// t1 <- xa * za
qrMul(t1, ecX(a), ecZ(a, n), ec->f, stack);
// b <- (xa, ya + t1, za)
wwCopy(b, a, 3 * n);
gf2Add2(ecY(b, n), t1, ec->f);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rdx), %rcx
movq 0x30(%rcx), %r13
leaq (%rbx,%r13,8), %r8
leaq (%rsi,%r13,8), %rax
leaq (%rax,%r13,8), %rdx
movq %rbx, %rdi
callq *0x68(%rcx)
leaq (,%r13,2), %rdx
addq %r13, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xe5c0
leaq (%r12,%r13,8), %rdi
movq 0x18(%r14), %rax
movq 0x30(%rax), %rdx
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xeed0
| /agievich[P]bee2/src/math/ec2.c |
ec2AddLD | static void ec2AddLD(word c[], const word a[], const word b[],
const ec_o* ec, void* stack)
{
const size_t n = ec->f->n;
// переменные в stack
word* t1 = (word*)stack;
word* t2 = t1 + n;
word* t3 = t2 + n;
word* t4 = t3 + n;
word* t5 = t4 + n;
word* t6 = t5 + n;
stack = t6 + n;
// pre
ASSERT(ecIsOperable(ec) && ec->d == 3);
ASSERT(ec2SeemsOn3(a, ec));
ASSERT(ec2SeemsOn3(b, ec));
ASSERT(wwIsSameOrDisjoint(a, c, 3 * n));
ASSERT(wwIsSameOrDisjoint(b, c, 3 * n));
// a == O => c <- b
if (qrIsZero(ecZ(a, n), ec->f))
{
wwCopy(c, b, 3 * n);
return;
}
// b == O => c <- a
if (qrIsZero(ecZ(b, n), ec->f))
{
wwCopy(c, a, 3 * n);
return;
}
// t1 <- xa zb [A]
qrMul(t1, ecX(a), ecZ(b, n), ec->f, stack);
// t2 <- xb za [B]
qrMul(t2, ecX(b), ecZ(a, n), ec->f, stack);
// t3 <- ya zb^2 [G]
qrSqr(t3, ecZ(b, n), ec->f, stack);
qrMul(t3, t3, ecY(a, n), ec->f, stack);
// t4 <- yb za^2 [H]
qrSqr(t4, ecZ(a, n), ec->f, stack);
qrMul(t4, t4, ecY(b, n), ec->f, stack);
// A == B => a == \pm b
if (qrCmp(t1, t2, ec->f) == 0)
{
// t3 == t4 => a == b => c <- 2a
if (qrCmp(t3, t4, ec->f) == 0)
ec2DblLD(c, a, ec, stack);
// t3 != t4 => a == -b => c <- O
else
qrSetZero(ecZ(c, n), ec->f);
return;
}
// t5 <- t1 + t2 [E]
gf2Add(t5, t1, t2, ec->f);
// t6 <- t3 + t4 [I]
gf2Add(t6, t3, t4, ec->f);
// t5 <- t5 t6 [J]
qrMul(t5, t5, t6, ec->f, stack);
// xc <- t1^2 [C]
qrSqr(ecX(c), t1, ec->f, stack);
// yc <- t2^2 [D]
qrSqr(ecY(c, n), t2, ec->f, stack);
// t6 <- xc + yc [ec->f]
gf2Add(t6, ecX(c), ecY(c, n), ec->f);
// zc <- t6 za zb [ec->f * Z1 * Z2]
qrMul(ecZ(c, n), ecZ(a, n), ecZ(b, n), ec->f, stack);
qrMul(ecZ(c, n), t6, ecZ(c, n), ec->f, stack);
// t4 <- t1 (t4 + yc) [A * (H + D)]
gf2Add2(t4, ecY(c, n), ec->f);
qrMul(t4, t1, t4, ec->f, stack);
// xc <- t2 (xc + t3) + t4 [B * (C + G) + A * (H + D)]
gf2Add2(ecX(c), t3, ec->f);
qrMul(ecX(c), t2, ecX(c), ec->f, stack);
gf2Add2(ecX(c), t4, ec->f);
// t1 <- t1 t5 [A * J]
qrMul(t1, t1, t5, ec->f, stack);
// t3 <- t3 t6 [ec->f * G]
qrMul(t3, t3, t6, ec->f, stack);
// t1 <- (t1 + t3) t6 [(A * J + ec->f * G) * ec->f]
gf2Add2(t1, t3, ec->f);
qrMul(t1, t1, t6, ec->f, stack);
// yc <- (t5 + zc) xc [(J + Z3) * X3]
gf2Add(ecY(c, n), t5, ecZ(c, n), ec->f);
qrMul(ecY(c, n), ecY(c, n), ecX(c), ec->f, stack);
// yc <- yc + t1 [(A * J + ec->f * G) * ec->f + (J + Z3) * X3]
gf2Add2(ecY(c, n), t1, ec->f);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x30(%rsp)
movq %rcx, %r14
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbp
movq 0x18(%rcx), %rax
movq 0x30(%rax), %r13
leaq (%rsi,%r13,8), %r12
leaq (%r12,%r13,8), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xffc0
testl %eax, %eax
je 0x3c463
leaq (,%r13,2), %rdx
addq %r13, %rdx
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
jmp 0x3c4b2
movq %r12, 0x20(%rsp)
movq %r15, 0x10(%rsp)
movq %rbx, 0x58(%rsp)
movq 0x30(%rsp), %r12
movq %rbp, 0x50(%rsp)
movq 0x8(%rsp), %rax
leaq (%rax,%r13,8), %r15
leaq (%r15,%r13,8), %rbx
movq 0x18(%r14), %rax
movq 0x30(%rax), %rsi
movq %rbx, %rdi
callq 0xffc0
testl %eax, %eax
je 0x3c4c5
leaq (,%r13,2), %rdx
addq %r13, %rdx
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe5c0
movq %r12, %rdi
leaq (%r12,%r13,8), %rax
movq %rax, 0x28(%rsp)
leaq (%rax,%r13,8), %r12
leaq (%r12,%r13,8), %rax
movq %rax, 0x18(%rsp)
leaq (%rax,%r13,8), %rax
movq %rax, 0x48(%rsp)
leaq (%rax,%r13,8), %rax
movq %rax, 0x40(%rsp)
leaq (%rax,%r13,8), %rbp
movq 0x18(%r14), %rcx
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
movq %rbp, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rcx
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r15, 0x38(%rsp)
movq %r12, %r15
movq 0x58(%rsp), %r12
movq %r12, %rdx
movq %rbp, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rdx
movq %r15, %rdi
movq %rbx, 0x60(%rsp)
movq %rbx, %rsi
movq %rbp, %rcx
callq *0x70(%rdx)
movq 0x18(%r14), %rcx
movq %r15, %rdi
movq %r15, 0x8(%rsp)
movq %r15, %rsi
movq 0x20(%rsp), %rdx
movq %rbp, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rdx
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rcx
callq *0x70(%rdx)
movq 0x18(%r14), %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq 0x38(%rsp), %rdx
movq %rbp, 0x20(%rsp)
movq %rbp, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rax
movq 0x30(%rax), %rdx
movq 0x30(%rsp), %rdi
movq %rdi, %rbp
movq 0x28(%rsp), %rsi
movq %rsi, %rbx
callq 0xf1b0
movq 0x18(%r14), %rcx
movq 0x30(%rcx), %rcx
testl %eax, %eax
je 0x3c798
movq 0x48(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0xee50
movq 0x18(%r14), %rax
movq 0x30(%rax), %rcx
movq 0x40(%rsp), %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xee50
movq 0x18(%r14), %rcx
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x20(%rsp), %rbp
movq %rbp, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rdx
movq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movq %rbp, %rcx
callq *0x70(%rdx)
movq 0x18(%r14), %rdx
leaq (%rbx,%r13,8), %r12
movq %r12, %rdi
movq 0x28(%rsp), %rsi
movq %rbp, %rcx
callq *0x70(%rdx)
movq 0x18(%r14), %rax
movq 0x30(%rax), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xee50
movq 0x18(%r14), %rcx
movq %rbp, %r15
leaq (%r12,%r13,8), %r13
movq %r12, 0x38(%rsp)
movq %r13, %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq %rbp, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rcx
movq %r13, 0x10(%rsp)
movq %r13, %rdi
movq 0x40(%rsp), %rsi
movq %r13, %rdx
movq %rbp, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rax
movq 0x30(%rax), %rdx
movq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xeed0
movq 0x18(%r14), %rcx
movq %rbp, %rdi
movq 0x30(%rsp), %r12
movq %r12, %rsi
movq %rbp, %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rax
movq 0x30(%rax), %rdx
movq %rbx, %rdi
movq 0x8(%rsp), %r13
movq %r13, %rsi
callq 0xeed0
movq 0x18(%r14), %rcx
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
movq %rbx, %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rax
movq 0x30(%rax), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xeed0
movq 0x18(%r14), %rcx
movq %r12, %rdi
movq %r12, %rsi
movq 0x48(%rsp), %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rcx
movq %r13, %rdi
movq %r13, %rsi
movq %r13, %rbp
movq 0x40(%rsp), %r13
movq %r13, %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rax
movq 0x30(%rax), %rdx
movq %r12, %rdi
movq %rbp, %rsi
callq 0xeed0
movq 0x18(%r14), %rcx
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rax
movq 0x30(%rax), %rcx
movq 0x38(%rsp), %r13
movq %r13, %rdi
movq 0x48(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xee50
movq 0x18(%r14), %rcx
movq %r13, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%r14), %rax
movq 0x30(%rax), %rdx
movq %r13, %rdi
movq %r12, %rsi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeed0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rcx, %rdx
callq 0xf1b0
testl %eax, %eax
movq 0x50(%rsp), %rdi
je 0x3c7d6
leaq (%rdi,%r13,8), %rax
leaq (%rax,%r13,8), %rdi
movq 0x18(%r14), %rax
movq 0x30(%rax), %rsi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfe90
movq 0x10(%rsp), %rsi
movq %r14, %rdx
movq 0x20(%rsp), %rcx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ccb4
| /agievich[P]bee2/src/math/ec2.c |
ec2AddALD | static void ec2AddALD(word c[], const word a[], const word b[],
const ec_o* ec, void* stack)
{
const size_t n = ec->f->n;
// переменные в stack
word* t1 = (word*)stack;
word* t2 = t1 + n;
word* t3 = t2 + n;
word* t4 = t3 + n;
stack = t4 + n;
// pre
ASSERT(ecIsOperable(ec) && ec->d == 3);
ASSERT(ec2SeemsOn3(a, ec));
ASSERT(ec2SeemsOnA(b, ec));
ASSERT(wwIsSameOrDisjoint(a, c, 3 * n));
ASSERT(b == c || wwIsDisjoint2(b, 2 * n, c, 3 * n));
// a == O => c <- (xb : yb : 1)
if (qrIsZero(ecZ(a, n), ec->f))
{
qrCopy(ecX(c), ecX(b), ec->f);
qrCopy(ecY(c, n), ecY(b, n), ec->f);
qrSetUnity(ecZ(c, n), ec->f);
return;
}
// t1 <- ya + yb za^2 [A]
qrSqr(t1, ecZ(a, n), ec->f, stack);
qrMul(t1, ecY(b, n), t1, ec->f, stack);
gf2Add2(t1, ecY(a, n), ec->f);
// t2 <- xa + xb za [B]
qrMul(t2, ecX(b), ecZ(a, n), ec->f, stack);
gf2Add2(t2, ecX(a), ec->f);
// t2 == 0 => a == \pm b
if (qrIsZero(t2, ec->f))
{
// t1 == 0 => a == b => c <- 2b
if (qrIsZero(t1, ec->f))
ec2DblALD(c, b, ec, stack);
// t1 != 0 => a == -b => c <- O
else
qrSetZero(ecZ(c, n), ec->f);
return;
}
// t3 <- t2 za [C]
qrMul(t3, t2, ecZ(a, n), ec->f, stack);
// zc <- t3^2 [C^2]
qrSqr(ecZ(c, n), t3, ec->f, stack);
// t4 <- xb zc [D]
qrMul(t4, ecX(b), ecZ(c, n), ec->f, stack);
// yc <- xb + yb [X2 + Y2]
gf2Add(ecY(c, n), ecX(b), ecY(b, n), ec->f);
// xc <- t2^2 + t1 + A t3 [B^2 + A + a2 * C]
qrSqr(ecX(c), t2, ec->f, stack);
gf2Add2(ecX(c), t1, ec->f);
if (qrIsUnity(ec->A, ec->f))
gf2Add2(ecX(c), t3, ec->f);
else if (!qrIsZero(ec->A, ec->f))
{
qrMul(t2, ec->A, t3, ec->f, stack);
gf2Add2(ecX(c), t2, ec->f);
}
// xc <- xc t3 + t1^2 [C * (A + B^2 + a2 * C) + A^2]
qrMul(ecX(c), ecX(c), t3, ec->f, stack);
qrSqr(t2, t1, ec->f, stack);
gf2Add2(ecX(c), t2, ec->f);
// yc <- yc zc^2 [(Y2 + X2) * Z3^2]
qrSqr(t2, ecZ(c, n), ec->f, stack);
qrMul(ecY(c, n), ecY(c, n), t2, ec->f, stack);
// t4 <- t4 + xc [D + X3]
gf2Add2(t4, ecX(c), ec->f);
// t1 <- t1 t3 + zc [A * C + Z3]
qrMul(t1, t1, t3, ec->f, stack);
gf2Add2(t1, ecZ(c, n), ec->f);
// t1 <- t1 t4 [(D + X3)(A * C + Z3)]
qrMul(t1, t1, t4, ec->f, stack);
// yc <- yc + t1 [(D + X3)(A * C + Z3) + (Y2 + X2) * Z3^2]
gf2Add2(ecY(c, n), t1, ec->f);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x28(%rsp)
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %rbp
movq 0x18(%rcx), %rax
movq 0x30(%rax), %r15
movq %rsi, 0x18(%rsp)
leaq (%rsi,%r15,8), %r14
leaq (%r14,%r15,8), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xffc0
movq 0x18(%rbx), %rdx
testl %eax, %eax
je 0x3c88b
movq 0x30(%rdx), %rdx
movq %rbp, %rdi
movq %r12, %rsi
callq 0xe5c0
leaq (,%r15,8), %r14
addq %rbp, %r14
leaq (%r12,%r15,8), %rsi
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rdx
movq %r14, %rdi
callq 0xe5c0
leaq (%r14,%r15,8), %rdi
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rsi
movq 0x30(%rax), %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe5c0
movq %rbp, 0x20(%rsp)
movq 0x28(%rsp), %rbp
leaq (,%r15,8), %rax
addq %rbp, %rax
movq %rax, 0x38(%rsp)
leaq (%rax,%r15,8), %rax
movq %rax, 0x10(%rsp)
leaq (%rax,%r15,8), %rax
movq %rax, 0x30(%rsp)
movq %r13, %rsi
movq %r13, 0x8(%rsp)
leaq (%rax,%r15,8), %r13
movq %rbp, %rdi
movq %r13, %rcx
callq *0x70(%rdx)
movq 0x18(%rbx), %rcx
leaq (%r12,%r15,8), %rsi
movq %rbp, %rdi
movq %rsi, 0x40(%rsp)
movq %rbp, %rdx
movq %r13, %r8
callq *0x68(%rcx)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rdx
movq %rbp, %rdi
movq %r14, %rsi
movq 0x38(%rsp), %r14
callq 0xeed0
movq 0x18(%rbx), %rcx
movq %r14, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rbp
movq %r13, %r8
callq *0x68(%rcx)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rdx
movq %r14, %rdi
movq 0x18(%rsp), %rsi
callq 0xeed0
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rsi
movq %r14, %rdi
callq 0xffc0
movq 0x18(%rbx), %rcx
testl %eax, %eax
je 0x3c979
movq 0x30(%rcx), %rsi
movq 0x28(%rsp), %rdi
callq 0xffc0
testl %eax, %eax
movq 0x20(%rsp), %rdi
je 0x3ca52
movq %r12, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3cec3
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
movq %rbp, %r8
callq *0x68(%rcx)
movq 0x18(%rbx), %rdx
movq 0x20(%rsp), %rax
leaq (%rax,%r15,8), %r13
leaq (,%r15,8), %r15
addq %r13, %r15
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rcx
callq *0x70(%rdx)
movq 0x18(%rbx), %rcx
movq 0x30(%rsp), %rdi
movq %r12, %rsi
movq %r15, 0x18(%rsp)
movq %r15, %rdx
movq %rbp, %r8
callq *0x68(%rcx)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rcx
movq %r13, 0x8(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq 0x40(%rsp), %rdx
callq 0xee50
movq 0x18(%rbx), %rdx
movq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %r13
movq %r14, %rsi
movq %rbp, %rcx
callq *0x70(%rdx)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rdx
movq %r12, %rdi
movq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0xeed0
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdi
movq 0x20(%rax), %rsi
movq 0x30(%rax), %rdx
callq 0xf520
movq 0x10(%rsp), %rcx
movq %rcx, %rsi
testl %eax, %eax
movq %rbp, %r15
movq %rcx, %rbp
je 0x3ca75
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rdx
movq %r12, %rdi
callq 0xeed0
jmp 0x3ca8e
leaq (%rdi,%r15,8), %rax
leaq (%rax,%r15,8), %rdi
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfe90
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdi
movq 0x30(%rax), %rsi
callq 0xffc0
testl %eax, %eax
je 0x3cb64
movq 0x18(%rbx), %rcx
movq %r12, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%rbx), %rdx
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq *0x70(%rdx)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0xeed0
movq 0x18(%rbx), %rdx
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq %r15, %rcx
callq *0x70(%rdx)
movq 0x18(%rbx), %rcx
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rdx
movq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xeed0
movq 0x18(%rbx), %rcx
movq %r14, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rdx
movq %r14, %rdi
movq 0x18(%rsp), %rsi
callq 0xeed0
movq 0x18(%rbx), %rcx
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rdx
movq %rbp, %rdi
movq %r14, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeed0
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %rsi
movq %r13, %rdi
movq %rbp, %rdx
movq %r15, %r8
callq *0x68(%rcx)
movq 0x38(%rsp), %rsi
jmp 0x3ca40
| /agievich[P]bee2/src/math/ec2.c |
gf2IsOperable | bool_t gf2IsOperable(const qr_o* f)
{
const size_t* p;
size_t n1;
if (!qrIsOperable(f) ||
!memIsValid(f->params, 4 * sizeof(size_t)))
return FALSE;
// проверить описание многочлена
p = (size_t*)f->params;
if (p[0] <= p[1] || p[1] < p[2] || p[2] < p[3] ||
(p[2] > 0 && (p[1] == p[2] || p[2] == p[3] || p[3] == 0)) ||
f->n != W_OF_B(p[0]) || f->no != O_OF_B(p[0]))
return FALSE;
// проверить модуль
n1 = f->n + (p[0] % B_PER_W == 0);
if (!wwIsValid(f->mod, n1) || f->mod[n1 - 1] == 0)
return FALSE;
// все нормально
return TRUE;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0xe7c0
xorl %ebx, %ebx
testl %eax, %eax
je 0x40f8c
movq 0x28(%r14), %rdi
pushq $0x20
popq %rsi
callq 0xeeb0
testl %eax, %eax
je 0x40f8c
movq 0x28(%r14), %rsi
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
jbe 0x40f8c
movq 0x10(%rsi), %rdx
cmpq %rdx, %rcx
jb 0x40f8c
movq 0x18(%rsi), %rsi
cmpq %rsi, %rdx
jb 0x40f8c
testq %rdx, %rdx
je 0x40f3e
testq %rsi, %rsi
je 0x40f8c
cmpq %rdx, %rcx
je 0x40f8c
cmpq %rsi, %rdx
je 0x40f8c
movq 0x30(%r14), %r15
leaq 0x3f(%rax), %rcx
shrq $0x6, %rcx
cmpq %rcx, %r15
jne 0x40f8c
leaq 0x7(%rax), %rcx
shrq $0x3, %rcx
cmpq %rcx, 0x38(%r14)
jne 0x40f8c
andl $0x3f, %eax
cmpq $0x1, %rax
adcq $0x0, %r15
movq 0x18(%r14), %rdi
leaq (,%r15,8), %rsi
callq 0xeeb0
testl %eax, %eax
je 0x40f8c
movq 0x18(%r14), %rax
xorl %ebx, %ebx
cmpq $0x0, -0x8(%rax,%r15,8)
setne %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
| /agievich[P]bee2/src/math/gf2.c |
gauden_alloc_param_full | vector_t ****
gauden_alloc_param_full(uint32 n_cb,
uint32 n_feat,
uint32 n_density,
const uint32 *veclen)
{
uint32 blksize, maxveclen;
vector_t ****param;
float32 *buf;
uint32 i, j, k, l, m;
for (blksize = 0, maxveclen = 0, j = 0; j < n_feat; j++) {
blksize += veclen[j];
if (veclen[j] > maxveclen) maxveclen = veclen[j];
}
param = (vector_t ****) ckd_calloc_4d(n_cb, n_feat, n_density,
maxveclen, sizeof(vector_t));
buf = ckd_calloc(n_cb * n_density * blksize * blksize,
sizeof(float32));
for (i = 0, m = 0; i < n_cb; i++) {
for (j = 0; j < n_feat; j++) {
for (k = 0; k < n_density; k++) {
for (l = 0; l < veclen[j]; l++) {
param[i][j][k][l] = &buf[m];
m += veclen[j];
}
}
}
}
return param;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movl %esi, 0xc(%rsp)
testl %esi, %esi
je 0x128b4
xorl %eax, %eax
xorl %r12d, %r12d
xorl %ecx, %ecx
movl (%rbx,%rax,4), %edx
addl %edx, %r12d
cmpl %ecx, %edx
cmoval %edx, %ecx
incq %rax
cmpq %rax, %r15
jne 0x1289d
movl %ecx, %ecx
jmp 0x128b9
xorl %ecx, %ecx
xorl %r12d, %r12d
movl %edi, 0x8(%rsp)
movl %edi, %edi
movl %ebp, %r13d
movl $0xf4, (%rsp)
leaq 0x13c50(%rip), %r9 # 0x26520
movl $0x8, %r8d
movq %rdi, 0x10(%rsp)
movq %r15, %rsi
movq %r13, %rdx
callq 0x9733
movq %rax, %r14
movl %ebp, %eax
imull 0x8(%rsp), %eax
imull %r12d, %r12d
imull %eax, %r12d
movl $0x4, %esi
movq %r12, %rdi
leaq 0x13c19(%rip), %rdx # 0x26520
movl $0xf7, %ecx
callq 0x94c8
cmpl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %r12d
je 0x12975
xorl %ecx, %ecx
xorl %edx, %edx
testl %r12d, %r12d
je 0x1296b
xorl %esi, %esi
testl %ebp, %ebp
je 0x12963
movl (%rbx,%rsi,4), %edi
xorl %r8d, %r8d
testq %rdi, %rdi
je 0x1295b
xorl %r9d, %r9d
movl %edx, %r10d
leaq (%rax,%r10,4), %r10
movq (%r14,%rcx,8), %r11
movq (%r11,%rsi,8), %r11
movq (%r11,%r8,8), %r11
movq %r10, (%r11,%r9,8)
incq %r9
addl %edi, %edx
cmpq %r9, %rdi
jne 0x1293a
incq %r8
cmpq %r13, %r8
jne 0x12932
incq %rsi
cmpq %r15, %rsi
jne 0x12928
incq %rcx
cmpq 0x10(%rsp), %rcx
jne 0x12921
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c |
gauden_mixture | float64
gauden_mixture(float64 **den,
uint32 **den_idx,
float32 **w,
gauden_t *g)
{
float64 out;
uint32 j;
out = 1.0;
for (j = 0; j < g->n_feat; j++) {
uint32 kk;
float64 oprob;
oprob = 0;
kk = 0;
while (kk < g->n_top) {
uint32 k;
k = den_idx[j][kk];
oprob += w[j][k] * den[j][kk];
++kk;
}
out *= oprob;
}
return out;
} | pushq %r14
pushq %rbx
movl (%rcx), %eax
testq %rax, %rax
je 0x14560
movl 0x18(%rcx), %ecx
movsd 0xeaf5(%rip), %xmm0 # 0x23008
xorl %r8d, %r8d
testq %rcx, %rcx
je 0x1454e
movq (%rsi,%r8,8), %r9
movq (%rdx,%r8,8), %r10
movq (%rdi,%r8,8), %r11
xorpd %xmm1, %xmm1
xorl %ebx, %ebx
movl (%r9,%rbx,4), %r14d
xorps %xmm2, %xmm2
cvtss2sd (%r10,%r14,4), %xmm2
mulsd (%r11,%rbx,8), %xmm2
addsd %xmm2, %xmm1
incq %rbx
cmpq %rbx, %rcx
jne 0x1452d
jmp 0x14552
xorpd %xmm1, %xmm1
mulsd %xmm1, %xmm0
incq %r8
cmpq %rax, %r8
jne 0x14516
jmp 0x14568
movsd 0xeaa0(%rip), %xmm0 # 0x23008
popq %rbx
popq %r14
retq
| /cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c |
gauden_norm_wt_var | void
gauden_norm_wt_var(vector_t ***in_var,
vector_t ***wt_var,
int32 pass2var,
float32 ***dnom,
vector_t ***mean,
uint32 n_mgau,
uint32 n_feat,
uint32 n_density,
const uint32 *veclen,
int32 tiedvar)
{
uint32 i, j, k, l;
if (tiedvar) {
gauden_tie_vars_dnoms(wt_var, pass2var, dnom, mean,
n_mgau, n_feat, n_density, veclen);
}
for (i = 0; i < n_mgau; i++) {
for (j = 0; j < n_feat; j++) {
for (k = 0; k < n_density; k++) {
if (dnom[i][j][k] != 0) {
for (l = 0; l < veclen[j]; l++) {
if (!pass2var) {
wt_var[i][j][k][l] =
(wt_var[i][j][k][l] / dnom[i][j][k]) -
(mean[i][j][k][l] * mean[i][j][k][l]);
}
else {
wt_var[i][j][k][l] /= dnom[i][j][k];
}
if (wt_var[i][j][k][l] < 0) {
E_ERROR("Variance (mgau= %u, feat= %u, "
"density=%u, component=%u) is less then 0. "
"Most probably the number of senones is "
"too high for such a small training "
"database. Use smaller $CFG_N_TIED_STATES.\n",
i, j, k, l);
}
}
}
else {
if (in_var) {
E_INFO("Copying unseen var (%u, %u, %u) from in_var\n",
i, j, k);
for (l = 0; l < veclen[j]; l++) {
wt_var[i][j][k][l] = in_var[i][j][k][l];
}
}
}
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x8(%rsp)
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
cmpl $0x0, 0x78(%rsp)
movl %r9d, %eax
movq %rax, 0x10(%rsp)
je 0x14b2a
cmpl $0x0, 0x60(%rsp)
je 0x14948
xorl %eax, %eax
testl %ebp, %ebp
jne 0x148a2
movq 0x70(%rsp), %rcx
movl (%rcx,%rax,4), %ecx
testq %rcx, %rcx
je 0x148a2
movq 0x8(%rsp), %rdx
movq (%rdx), %rdx
movq (%rdx,%rax,8), %rdx
movq (%r8), %rsi
movq (%rsi,%rax,8), %rsi
movq (%rsi), %rsi
xorl %edi, %edi
movss (%rdx), %xmm0
mulss (%rsi,%rdi,4), %xmm0
movss %xmm0, (%rsi,%rdi,4)
incq %rdi
cmpq %rdi, %rcx
jne 0x1488c
cmpl $0x2, 0x68(%rsp)
jb 0x14938
movq 0x70(%rsp), %rcx
movl (%rcx,%rax,4), %ecx
movq 0x8(%rsp), %rdx
movq (%rdx), %rdx
movq (%rdx,%rax,8), %rdx
movl $0x1, %esi
testq %rcx, %rcx
je 0x1491f
movq (%r15), %rdi
movq (%rdi,%rax,8), %r10
movq (%r10,%rsi,8), %rdi
movq (%r10), %r14
xorl %r10d, %r10d
movss (%rdi,%r10,4), %xmm0
addss (%r14,%r10,4), %xmm0
movss %xmm0, (%r14,%r10,4)
testl %ebp, %ebp
jne 0x14917
movq (%r8), %r11
movq (%r11,%rax,8), %r11
movq (%r11,%rsi,8), %rbx
movss (%rbx,%r10,4), %xmm0
mulss (%rdx,%rsi,4), %xmm0
movq (%r11), %r11
addss (%r11,%r10,4), %xmm0
movss %xmm0, (%r11,%r10,4)
incq %r10
cmpq %r10, %rcx
jne 0x148dc
movss (%rdx,%rsi,4), %xmm0
addss (%rdx), %xmm0
movss %xmm0, (%rdx)
incq %rsi
movl 0x68(%rsp), %edi
cmpq %rdi, %rsi
jne 0x148c6
incq %rax
movl 0x60(%rsp), %ecx
cmpq %rcx, %rax
jne 0x14863
cmpl $0x2, %r9d
jb 0x14a34
movl $0x1, %eax
cmpl $0x0, 0x60(%rsp)
je 0x14a26
xorl %ecx, %ecx
cmpl $0x0, 0x68(%rsp)
je 0x14a16
movq 0x70(%rsp), %rdx
movl (%rdx,%rcx,4), %edx
movq 0x8(%rsp), %rdi
movq (%rdi,%rax,8), %rsi
movq (%rsi,%rcx,8), %rsi
movq (%rdi), %rdi
movq (%rdi,%rcx,8), %rdi
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x149f7
movq (%r15,%rax,8), %r10
movq (%r10,%rcx,8), %r10
movq (%r10,%r12,8), %r10
movq (%r15), %r11
movq (%r11,%rcx,8), %r11
movq (%r11), %r11
xorl %ebx, %ebx
movss (%r10,%rbx,4), %xmm0
addss (%r11,%rbx,4), %xmm0
movss %xmm0, (%r11,%rbx,4)
testl %ebp, %ebp
jne 0x149ef
movq (%r8,%rax,8), %r14
movq (%r14,%rcx,8), %r14
movq (%r14,%r12,8), %r14
movss (%r14,%rbx,4), %xmm0
movq (%r8), %r14
movq (%r14,%rcx,8), %r14
mulss (%rsi,%r12,4), %xmm0
movq (%r14), %r14
addss (%r14,%rbx,4), %xmm0
movss %xmm0, (%r14,%rbx,4)
incq %rbx
cmpq %rbx, %rdx
jne 0x149ab
movss (%rsi,%r12,4), %xmm0
addss (%rdi), %xmm0
movss %xmm0, (%rdi)
incq %r12
movl 0x68(%rsp), %r10d
cmpq %r10, %r12
jne 0x1498e
incq %rcx
movl 0x60(%rsp), %edx
cmpq %rdx, %rcx
jne 0x14964
incq %rax
cmpq 0x10(%rsp), %rax
jne 0x14957
testl %r9d, %r9d
je 0x14d08
xorl %eax, %eax
cmpl $0x0, 0x60(%rsp)
je 0x14b1c
xorl %ecx, %ecx
cmpl $0x0, 0x68(%rsp)
je 0x14b0c
movq 0x70(%rsp), %rdx
movl (%rdx,%rcx,4), %edx
movq 0x8(%rsp), %rdi
movq (%rdi), %rsi
movq (%rsi,%rcx,8), %rsi
movq (%rdi,%rax,8), %rdi
movq (%rdi,%rcx,8), %rdi
xorl %r13d, %r13d
testq %rdx, %rdx
je 0x14af1
movq %r13, %r10
orq %rax, %r10
movq (%r15), %r11
movq (%r11,%rcx,8), %r11
movq (%r11), %r11
movq (%r15,%rax,8), %rbx
movq (%rbx,%rcx,8), %rbx
movq (%rbx,%r13,8), %rbx
xorl %r14d, %r14d
testl %ebp, %ebp
jne 0x14add
testl %r10d, %r10d
je 0x14ac2
movq (%r8), %r12
movq (%r12,%rcx,8), %r12
movq (%r12), %r12
movss (%r12,%r14,4), %xmm0
movq (%r8,%rax,8), %r12
movq (%r12,%rcx,8), %r12
movq (%r12,%r13,8), %r12
jmp 0x14ad7
movq (%r8), %r12
movq (%r12,%rcx,8), %r12
movq (%r12), %r12
movss (%r12,%r14,4), %xmm0
divss (%rsi), %xmm0
movss %xmm0, (%r12,%r14,4)
movss (%r11,%r14,4), %xmm0
movss %xmm0, (%rbx,%r14,4)
incq %r14
cmpq %r14, %rdx
jne 0x14a9a
movss (%rsi), %xmm0
movss %xmm0, (%rdi,%r13,4)
incq %r13
movl 0x68(%rsp), %r10d
cmpq %r10, %r13
jne 0x14a76
incq %rcx
movl 0x60(%rsp), %edx
cmpq %rdx, %rcx
jne 0x14a4c
incq %rax
cmpq 0x10(%rsp), %rax
jne 0x14a3f
movq %r8, 0x20(%rsp)
testl %r9d, %r9d
movq 0x8(%rsp), %rdi
movq 0x70(%rsp), %r8
je 0x14d08
xorps %xmm2, %xmm2
xorl %r12d, %r12d
cmpl $0x0, 0x60(%rsp)
je 0x14cfa
xorl %r13d, %r13d
cmpl $0x0, 0x68(%rsp)
je 0x14cea
xorl %r14d, %r14d
movq (%rdi,%r12,8), %rax
movq (%rax,%r13,8), %rax
movss (%rax,%r14,4), %xmm0
ucomiss %xmm2, %xmm0
jne 0x14b7d
jnp 0x14c59
cmpl $0x0, (%r8,%r13,4)
je 0x14cda
xorl %ebx, %ebx
testl %ebp, %ebp
je 0x14bb4
movq (%rdi,%r12,8), %rax
movq (%rax,%r13,8), %rax
movq (%r15,%r12,8), %rcx
movq (%rcx,%r13,8), %rcx
movq (%rcx,%r14,8), %rcx
movss (%rcx,%rbx,4), %xmm0
divss (%rax,%r14,4), %xmm0
movss %xmm0, (%rcx,%rbx,4)
jmp 0x14bf6
movq (%r15,%r12,8), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%r14,8), %rax
movss (%rax,%rbx,4), %xmm0
movq (%rdi,%r12,8), %rcx
movq (%rcx,%r13,8), %rcx
divss (%rcx,%r14,4), %xmm0
movq 0x20(%rsp), %rcx
movq (%rcx,%r12,8), %rcx
movq (%rcx,%r13,8), %rcx
movq (%rcx,%r14,8), %rcx
movss (%rcx,%rbx,4), %xmm1
mulss %xmm1, %xmm1
subss %xmm1, %xmm0
movss %xmm0, (%rax,%rbx,4)
movq (%r15,%r12,8), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%r14,8), %rax
ucomiss (%rax,%rbx,4), %xmm2
jbe 0x14c44
movl $0x694, %edx # imm = 0x694
movl $0x4, %edi
leaq 0x11907(%rip), %rsi # 0x26520
leaq 0x11e95(%rip), %rcx # 0x26ab5
movl %r12d, %r8d
movl %r13d, %r9d
xorl %eax, %eax
pushq %rbx
pushq %r14
callq 0xd380
xorps %xmm2, %xmm2
movq 0x80(%rsp), %r8
movq 0x18(%rsp), %rdi
addq $0x10, %rsp
incq %rbx
movl (%r8,%r13,4), %eax
cmpq %rax, %rbx
jb 0x14b8a
jmp 0x14cda
cmpq $0x0, 0x18(%rsp)
je 0x14cda
subq $0x8, %rsp
movl $0x69b, %edx # imm = 0x69B
movl $0x1, %edi
leaq 0x118aa(%rip), %rsi # 0x26520
leaq 0x11ef5(%rip), %rcx # 0x26b72
movl %r12d, %r8d
movl %r13d, %r9d
xorl %eax, %eax
pushq %r14
callq 0xd380
xorps %xmm2, %xmm2
movq 0x80(%rsp), %r8
movq 0x18(%rsp), %rdi
addq $0x10, %rsp
movl (%r8,%r13,4), %eax
testq %rax, %rax
je 0x14cda
movq 0x18(%rsp), %rcx
movq (%rcx,%r12,8), %rcx
movq (%rcx,%r13,8), %rcx
movq (%rcx,%r14,8), %rcx
movq (%r15,%r12,8), %rdx
movq (%rdx,%r13,8), %rdx
movq (%rdx,%r14,8), %rdx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x14cc8
incq %r14
movl 0x68(%rsp), %eax
cmpq %rax, %r14
jne 0x14b64
incq %r13
movl 0x60(%rsp), %eax
cmpq %rax, %r13
jne 0x14b56
incq %r12
cmpq 0x10(%rsp), %r12
jne 0x14b48
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c |
gauden_smooth_var | int
gauden_smooth_var(vector_t ***var,
float32 **var_floor,
uint32 n_mgau,
uint32 n_stream,
uint32 n_density,
const uint32 *veclen)
{
uint32 i, j, k, l;
float32 flr;
for (j = 0; j < n_stream; j++) {
for (l = 0; l < veclen[j]; l++) {
flr = var_floor[j][l];
for (i = 0; i < n_mgau; i++) {
for (k = 0; k < n_density; k++) {
if (var[i][j][k][l] < flr) var[i][j][k][l] = flr;
}
}
}
}
return S3_SUCCESS;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, -0x8(%rsp)
testl %ecx, %ecx
je 0x1586e
movl %ecx, %esi
movl %edx, %ecx
movl %r8d, %r10d
xorl %r11d, %r11d
movl (%r9,%r11,4), %ebx
testq %rbx, %rbx
je 0x15866
movq -0x8(%rsp), %rax
movq (%rax,%r11,8), %r14
xorl %r15d, %r15d
testl %edx, %edx
je 0x1585e
movss (%r14,%r15,4), %xmm0
xorl %r12d, %r12d
testl %r8d, %r8d
je 0x15856
movq (%rdi,%r12,8), %rax
movq (%rax,%r11,8), %r13
xorl %ebp, %ebp
movq (%r13,%rbp,8), %rax
ucomiss (%rax,%r15,4), %xmm0
jbe 0x1584e
movss %xmm0, (%rax,%r15,4)
incq %rbp
cmpq %rbp, %r10
jne 0x1583c
incq %r12
cmpq %rcx, %r12
jne 0x1582d
incq %r15
cmpq %rbx, %r15
jne 0x15820
incq %r11
cmpq %rsi, %r11
jne 0x1580b
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c |
solve_quadratic | uint32
solve_quadratic(float64 x, float64 y, float64 z, float64 *root1, float64 *root2)
{
float64 temp;
if (x == 0) {
if (y != 0) {
(*root1) = (*root2) = -z/y;
return TRUE;
}
else
return FALSE;
}
temp = y * y - (4 * x * z);
if (temp < 0) {
if (y != 0 && fabs(temp/(y*y)) < 0.0001) {
(*root1) = (*root2) = (-y / (2*x));
return TRUE;
}
else
return FALSE;
}
temp = sqrt(temp);
(*root1) = (temp - y) / (2*x);
(*root2) = (-temp - y) / (2*x);
return TRUE;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jne 0x15934
jp 0x15934
ucomisd %xmm3, %xmm1
jne 0x1591a
jnp 0x1599d
xorpd 0x1032e(%rip), %xmm2 # 0x25c50
divsd %xmm1, %xmm2
movsd %xmm2, (%rbx)
movsd %xmm2, (%r14)
jmp 0x159f7
movapd %xmm0, %xmm4
movsd 0x10bc0(%rip), %xmm0 # 0x26500
mulsd %xmm4, %xmm0
mulsd %xmm2, %xmm0
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
ucomisd %xmm0, %xmm3
jbe 0x159a1
xorl %eax, %eax
ucomisd %xmm3, %xmm1
jne 0x15968
jnp 0x159fc
divsd %xmm2, %xmm0
andpd 0x1030c(%rip), %xmm0 # 0x25c80
movsd 0x10b8c(%rip), %xmm2 # 0x26508
ucomisd %xmm0, %xmm2
jbe 0x159fc
xorpd 0x102c6(%rip), %xmm1 # 0x25c50
addsd %xmm4, %xmm4
divsd %xmm4, %xmm1
movsd %xmm1, (%rbx)
movsd %xmm1, (%r14)
jmp 0x159f7
xorl %eax, %eax
jmp 0x159fc
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x159b1
sqrtsd %xmm0, %xmm0
jmp 0x159ce
movapd %xmm1, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
callq 0x2410
movsd 0x8(%rsp), %xmm4
movapd 0x10(%rsp), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
addsd %xmm4, %xmm4
divsd %xmm4, %xmm2
movsd %xmm2, (%r14)
xorpd 0x10265(%rip), %xmm0 # 0x25c50
subsd %xmm1, %xmm0
divsd %xmm4, %xmm0
movsd %xmm0, (%rbx)
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c |
gauden_norm_wt_mmie_mean | void
gauden_norm_wt_mmie_mean(vector_t ***in_mean,
vector_t ***wt_mean,
vector_t ***wt_num_mean,
vector_t ***wt_den_mean,
vector_t ***in_var,
vector_t ***wt_num_var,
vector_t ***wt_den_var,
float32 ***num_dnom,
float32 ***den_dnom,
uint32 n_mgau,
uint32 n_feat,
uint32 n_density,
const uint32 *veclen,
float32 constE)
{
uint32 i, j, k, l;
float32 d_mmi = 0.0;
for (i = 0; i < n_mgau; i++) {
for (j = 0; j < n_feat; j++) {
for (k = 0; k < n_density; k++) {
if (num_dnom[i][j][k] != 0 || den_dnom[i][j][k] != 0) {
/* compute constant D, which controls the convergence speed and accuracy */
d_mmi = cal_constD(in_mean[i][j][k], wt_num_mean[i][j][k], wt_den_mean[i][j][k],
in_var[i][j][k], wt_num_var[i][j][k], wt_den_var[i][j][k], num_dnom[i][j][k], den_dnom[i][j][k], veclen[j], constE);
if (!finite(d_mmi)) {
E_ERROR("Constant D:%f (gau:%d feat:%d density:%d) is infinite, maybe unsufficient data\n", d_mmi, i, j, k);
for (l = 0; l < veclen[j]; l++) {
wt_mean[i][j][k][l] = in_mean[i][j][k][l];
}
continue;
}
/* update mean parameters */
for (l = 0; l < veclen[j]; l++) {
wt_mean[i][j][k][l] = (wt_num_mean[i][j][k][l] - wt_den_mean[i][j][k][l] + d_mmi * in_mean[i][j][k][l]) / (num_dnom[i][j][k] - den_dnom[i][j][k] + d_mmi);
if (!finite(wt_mean[i][j][k][l])) {
E_ERROR("The new mean:%f (gau:%d feat:%d density:%d vec:%d) is infinite, maybe unsufficient data\n", wt_mean[i][j][k][l], i, j, k, l);
wt_mean[i][j][k][l] = in_mean[i][j][k][l];
continue;
}
}
}
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movss %xmm0, 0x20(%rsp)
movq %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl 0xa8(%rsp), %eax
testl %eax, %eax
je 0x15e8b
movq %rsi, %r13
movq %rdi, %rbp
movq 0xc0(%rsp), %r10
movq 0xa0(%rsp), %rbx
movl %eax, %eax
movq %rax, 0x38(%rsp)
xorl %r11d, %r11d
movq %rdi, 0x50(%rsp)
cmpl $0x0, 0xb0(%rsp)
je 0x15e7d
xorl %r14d, %r14d
movq %r11, 0x18(%rsp)
cmpl $0x0, 0xb8(%rsp)
je 0x15e6a
xorl %r15d, %r15d
movq 0x98(%rsp), %rax
movq (%rax,%r11,8), %rax
movq (%rax,%r14,8), %rax
movss (%rax,%r15,4), %xmm0
ucomiss 0x107f8(%rip), %xmm0 # 0x263d8
jne 0x15c01
jp 0x15c01
movq (%rbx,%r11,8), %rax
movq (%rax,%r14,8), %rax
movss (%rax,%r15,4), %xmm1
ucomiss 0x107df(%rip), %xmm1 # 0x263d8
jne 0x15c01
jnp 0x15e57
movq (%rbp,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
movq 0x28(%rsp), %rax
movq (%rax,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rsi
movq 0x30(%rsp), %rax
movq (%rax,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdx
movq 0x40(%rsp), %rax
movq (%rax,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rcx
movq 0x48(%rsp), %rax
movq (%rax,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %r8
movq 0x90(%rsp), %rax
movq (%rax,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %r9
movq (%rbx,%r11,8), %rax
movq (%rax,%r14,8), %rax
movss (%rax,%r15,4), %xmm1
movl (%r10,%r14,4), %eax
movl %eax, (%rsp)
movss 0x20(%rsp), %xmm2
movq %r10, %r12
callq 0x15a04
movaps %xmm0, %xmm2
movd %xmm0, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpl $0x7f7fffff, %eax # imm = 0x7F7FFFFF
jle 0x15d16
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
movl %r15d, (%rsp)
movl $0x827, %edx # imm = 0x827
movl $0x4, %edi
leaq 0x10868(%rip), %rsi # 0x26520
leaq 0x10f10(%rip), %rcx # 0x26bcf
movq 0x18(%rsp), %r8
movl %r14d, %r9d
movb $0x1, %al
callq 0xd380
movl (%r12,%r14,4), %eax
testq %rax, %rax
movq %r12, %r10
movq 0x18(%rsp), %r11
je 0x15e57
movq (%rbp,%r11,8), %rcx
movq (%rcx,%r14,8), %rcx
movq (%rcx,%r15,8), %rcx
movq (%r13,%r11,8), %rdx
movq (%rdx,%r14,8), %rdx
movq (%rdx,%r15,8), %rdx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x15cff
jmp 0x15e57
cmpl $0x0, (%r12,%r14,4)
movq %r12, %r10
movq 0x18(%rsp), %r11
je 0x15e57
xorl %r12d, %r12d
movss %xmm2, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq (%rax,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rax
movss (%rax,%r12,4), %xmm1
movq 0x30(%rsp), %rax
movq (%rax,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rax
subss (%rax,%r12,4), %xmm1
movq (%rbp,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rax
movss (%rax,%r12,4), %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq 0x98(%rsp), %rax
movq (%rax,%r11,8), %rax
movq (%rax,%r14,8), %rax
movss (%rax,%r15,4), %xmm1
movq (%rbx,%r11,8), %rax
movq (%rax,%r14,8), %rax
subss (%rax,%r15,4), %xmm1
addss %xmm2, %xmm1
divss %xmm1, %xmm0
movd %xmm0, %eax
movq (%r13,%r11,8), %rcx
movq (%rcx,%r14,8), %rcx
movq (%rcx,%r15,8), %rcx
movss %xmm0, (%rcx,%r12,4)
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpl $0x7f800000, %eax # imm = 0x7F800000
jl 0x15e47
cvtss2sd %xmm0, %xmm0
movl %r12d, 0x8(%rsp)
movl %r15d, (%rsp)
movl $0x832, %edx # imm = 0x832
movl $0x4, %edi
leaq 0x10738(%rip), %rsi # 0x26520
leaq 0x10e30(%rip), %rcx # 0x26c1f
movl %r11d, %r8d
movl %r14d, %r9d
movb $0x1, %al
movq %r13, %rbp
movq %r10, %r13
movq %r11, %rbx
callq 0xd380
movss 0x24(%rsp), %xmm2
movq %rbx, %r11
movq %r13, %r10
movq %rbp, %r13
movq 0x50(%rsp), %rbp
movq 0xa0(%rsp), %rbx
movq (%rbp,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rax
movss (%rax,%r12,4), %xmm0
movq (%r13,%r11,8), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rax
movss %xmm0, (%rax,%r12,4)
incq %r12
movl (%r10,%r14,4), %eax
cmpq %rax, %r12
jb 0x15d32
incq %r15
movl 0xb8(%rsp), %eax
cmpq %rax, %r15
jne 0x15bc3
incq %r14
movl 0xb0(%rsp), %eax
cmpq %rax, %r14
jne 0x15bb2
incq %r11
cmpq 0x38(%rsp), %r11
jne 0x15b9c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libmodinv/gauden.c |
vector_normalize | int
vector_normalize(vector_t v,
uint32 dim)
{
uint32 i;
float64 s;
int ret_val = S3_SUCCESS;
for (i = 0, s = 0; i < dim; i++)
s += v[i];
if (s != 0) {
for (i = 0; i < dim; i++)
v[i] /= s;
}
else {
ret_val = S3_WARNING;
}
return ret_val;
} | xorpd %xmm1, %xmm1
movl %esi, %ecx
xorpd %xmm0, %xmm0
testl %esi, %esi
je 0x162c5
xorl %eax, %eax
xorps %xmm2, %xmm2
cvtss2sd (%rdi,%rax,4), %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %rcx
jne 0x162b1
ucomisd %xmm1, %xmm0
jne 0x162cd
jnp 0x162f3
xorl %eax, %eax
testl %esi, %esi
je 0x162f2
xorl %edx, %edx
xorps %xmm1, %xmm1
cvtss2sd (%rdi,%rdx,4), %xmm1
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x162d5
retq
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/vector.c |
acmod_set_set_n_tri_hint | int32
acmod_set_set_n_tri_hint(acmod_set_t *acmod_set,
uint32 n_tri)
{
assert(acmod_set->multi == NULL);
assert(acmod_set->max_n_multi == 0);
assert(acmod_set->n_multi == 0);
if (n_tri > 0) {
acmod_set->multi = ckd_calloc(n_tri,
sizeof(acmod_t));
acmod_set->max_n_multi = n_tri;
}
return S3_SUCCESS;
} | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
jne 0x16523
movq %rdi, %r14
cmpl $0x0, 0x1c(%rdi)
jne 0x16542
cmpl $0x0, 0x18(%r14)
jne 0x16561
movl %esi, %ebx
testl %esi, %esi
je 0x16519
movl %ebx, %edi
leaq 0x10914(%rip), %rdx # 0x26e16
movl $0x10, %esi
movl $0xc1, %ecx
callq 0x94c8
movq %rax, 0x10(%r14)
movl %ebx, 0x1c(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x109b8(%rip), %rdi # 0x26ee2
leaq 0x108e5(%rip), %rsi # 0x26e16
leaq 0x109c3(%rip), %rcx # 0x26efb
movl $0xbb, %edx
callq 0x2190
leaq 0x109e8(%rip), %rdi # 0x26f31
leaq 0x108c6(%rip), %rsi # 0x26e16
leaq 0x109a4(%rip), %rcx # 0x26efb
movl $0xbc, %edx
callq 0x2190
leaq 0x109e5(%rip), %rdi # 0x26f4d
leaq 0x108a7(%rip), %rsi # 0x26e16
leaq 0x10985(%rip), %rcx # 0x26efb
movl $0xbd, %edx
callq 0x2190
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c |
acmod_set_add_ci | acmod_id_t
acmod_set_add_ci(acmod_set_t *acmod_set,
const char *name,
const char **attrib)
{
uint32 id;
if (acmod_set->n_multi > 0) {
E_FATAL("Current acmod_set implementation requires all CI phones"
"to be defined before defining multi phones\n");
}
if (acmod_set->n_ci == acmod_set->max_n_ci) {
E_FATAL("Current acmod_set implementation requires the 'n_ci_hint' to be"
"exactly the number to be added.\n");
}
id = acmod_set->next_id;
acmod_set->next_id++;
acmod_set->n_ci++;
/* copy the name and attribute lists so that the caller
* does not have restrictions on overwriting the value
* of the passed arguments */
acmod_set->ci[id].name = strdup(name);
acmod_set->ci[id].attrib = new_attrib(attrib);
/* the following allows ci_acmod_t structures to be
passed w/o reference to the acmod_set structure itself */
acmod_set->ci[id].id = id;
return id;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x18(%rdi)
jne 0x1665f
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
je 0x16674
movq %rdx, %r14
movl 0x20(%rbx), %r15d
leal 0x1(%r15), %ecx
movl %ecx, 0x20(%rbx)
incl %eax
movl %eax, 0x8(%rbx)
movq %rsi, %rdi
callq 0x2420
movq (%rbx), %rcx
leaq (,%r15,8), %rdx
leaq (%rdx,%rdx,2), %r12
movq %rax, (%rcx,%r12)
movq %r14, %rdi
callq 0x16580
movq (%rbx), %rcx
movq %rax, 0x8(%rcx,%r12)
movb %r15b, 0x10(%rcx,%r12)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x107b0(%rip), %rsi # 0x26e16
leaq 0x108f8(%rip), %rcx # 0x26f65
movl $0xff, %edx
jmp 0x16687
leaq 0x1079b(%rip), %rsi # 0x26e16
leaq 0x10946(%rip), %rcx # 0x26fc8
movl $0x104, %edx # imm = 0x104
movl $0x5, %edi
xorl %eax, %eax
callq 0xd380
movl $0x1, %edi
callq 0x23f0
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c |
acmod_set_name2id | acmod_id_t
acmod_set_name2id(acmod_set_t *acmod_set,
const char *name)
{
uint32 i;
char tmp_store[1024];
char *tmp;
int n_scan;
int n_assign;
char base[1024];
acmod_id_t base_id;
char left[1024];
acmod_id_t left_id;
char right[1024];
acmod_id_t right_id;
char *word_posn_map = WORD_POSN_CHAR_MAP;
char posn[12];
uint32 posn_id;
strcpy(tmp_store, name);
tmp = tmp_store;
n_assign = sscanf(tmp, "%s%n", base, &n_scan);
tmp += n_scan;
if (n_assign != 1) {
E_ERROR("Error parsing acoustic model name %s\n", name);
return NO_ACMOD;
}
n_assign = sscanf(tmp, "%s%n", left, &n_scan);
tmp += n_scan;
if (n_assign != 1) {
for (i = 0; i < acmod_set->n_ci; i++) {
if (strcmp(acmod_set->ci[i].name, base) == 0)
return i;
}
return NO_ACMOD;
}
else {
n_assign = sscanf(tmp, "%s%n", right, &n_scan);
tmp += n_scan;
if (n_assign != 1) {
E_ERROR("Parse error while getting right context of %s\n", name);
return NO_ACMOD;
}
n_assign = sscanf(tmp, "%s%n", posn, &n_scan);
tmp += n_scan;
if (n_assign != 1) {
E_ERROR("Parse error while getting word position of %s\n", name);
return NO_ACMOD;
}
base_id = acmod_set_name2id(acmod_set, base);
left_id = acmod_set_name2id(acmod_set, left);
right_id = acmod_set_name2id(acmod_set, right);
for (posn_id = 0; posn_id < strlen(word_posn_map); posn_id++) {
if (posn[0] == word_posn_map[(uint32)posn_id])
break;
}
if (posn_id == strlen(word_posn_map)) {
E_ERROR("Unknown word position identifier %s\n", posn);
return NO_ACMOD;
}
return acmod_set_tri2id(acmod_set, base_id, left_id, right_id, (word_posn_t)posn_id);
}
return NO_ACMOD;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1010, %rsp # imm = 0x1010
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc10(%rsp), %r15
movq %r15, %rdi
callq 0x2090
leaq 0xf7a8(%rip), %rsi # 0x2602d
leaq 0x10(%rsp), %rdx
movq %rsp, %rcx
movq %r15, %rdi
xorl %eax, %eax
callq 0x22f0
cmpl $0x1, %eax
jne 0x169a0
movq %rsp, %rcx
movslq (%rcx), %rax
leaq (%rsp,%rax), %r15
addq $0xc10, %r15 # imm = 0xC10
leaq 0xf775(%rip), %rsi # 0x2602d
leaq 0x810(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x22f0
cmpl $0x1, %eax
jne 0x169d9
movq %rsp, %rcx
movslq (%rcx), %rax
addq %rax, %r15
leaq 0xf74a(%rip), %rsi # 0x2602d
leaq 0x410(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x22f0
cmpl $0x1, %eax
jne 0x16a10
movq %rsp, %rcx
movslq (%rcx), %rax
addq %rax, %r15
leaq 0xf71f(%rip), %rsi # 0x2602d
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x22f0
cmpl $0x1, %eax
jne 0x16a2a
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x16859
movl %eax, %ebp
leaq 0x810(%rsp), %rsi
movq %rbx, %rdi
callq 0x16859
movl %eax, %r14d
leaq 0x410(%rsp), %rsi
movq %rbx, %rdi
callq 0x16859
xorl %ecx, %ecx
movb 0x4(%rsp), %dl
leaq 0xd8be(%rip), %rsi # 0x24223
cmpb (%rcx,%rsi), %dl
je 0x16978
incq %rcx
cmpq $0x5, %rcx
jne 0x16965
movl $0x5, %ecx
cmpl $0x5, %ecx
jne 0x16a42
leaq 0x1048e(%rip), %rsi # 0x26e16
leaq 0x10823(%rip), %rcx # 0x271b2
leaq 0x4(%rsp), %r8
movl $0x1ea, %edx # imm = 0x1EA
movl $0x4, %edi
jmp 0x169bb
leaq 0x1046f(%rip), %rsi # 0x26e16
leaq 0x10780(%rip), %rcx # 0x2712e
movl $0x1be, %edx # imm = 0x1BE
movl $0x4, %edi
movq %r14, %r8
xorl %eax, %eax
callq 0xd380
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x1010, %rsp # imm = 0x1010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %r14d
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x169c7
movq (%rbx), %r12
xorl %r15d, %r15d
leaq 0x10(%rsp), %rbx
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x2270
testl %eax, %eax
je 0x16a25
incq %r15
addq $0x18, %r12
cmpq %r15, %r14
jne 0x169f2
jmp 0x169c7
leaq 0x103ff(%rip), %rsi # 0x26e16
leaq 0x10736(%rip), %rcx # 0x27154
movl $0x1d2, %edx # imm = 0x1D2
jmp 0x169b3
movl %r15d, %ebp
jmp 0x169c7
leaq 0x103e5(%rip), %rsi # 0x26e16
leaq 0x1074b(%rip), %rcx # 0x27183
movl $0x1db, %edx # imm = 0x1DB
jmp 0x169b3
cmpl $0x0, 0x18(%rbx)
je 0x169c2
movq 0x28(%rbx), %rdx
movl %ebp, %esi
movq (%rdx,%rsi,8), %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0x22377
movl %eax, %ebp
jmp 0x169c7
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c |
acmod_set_id2s2name | const char *
acmod_set_id2s2name(acmod_set_t *acmod_set,
acmod_id_t id)
{
static char str[1024];
char *pmap = WORD_POSN_CHAR_MAP;
acmod_id_t base;
acmod_id_t left;
acmod_id_t right;
word_posn_t posn;
if (id < acmod_set->n_ci)
return acmod_set->ci[id].name;
else if (id < acmod_set->next_id) {
acmod_set_id2tri(acmod_set, &base, &left, &right, &posn, id);
sprintf(str, "%s(%s,%s)%c",
acmod_set_id2name(acmod_set, base),
acmod_set_id2name(acmod_set, left),
acmod_set_id2name(acmod_set, right),
(posn != WORD_POSN_INTERNAL ? pmap[(int)posn] : '\0'));
return str;
}
else
return NULL;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r9d
movq %rdi, %r14
cmpl %esi, 0x8(%rdi)
jbe 0x16ab5
movq (%r14), %rax
movl %r9d, %ecx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %r14
jmp 0x16b4f
xorl %ebx, %ebx
cmpl %r9d, 0x20(%r14)
jbe 0x16b4c
leaq 0x14(%rsp), %r15
leaq 0x10(%rsp), %r13
leaq 0xc(%rsp), %rbp
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %r12, %r8
callq 0x16b61
movl (%r15), %esi
movq %r14, %rdi
callq 0x16c05
movq %rax, %r15
movl (%r13), %esi
movq %r14, %rdi
callq 0x16c05
movq %rax, %r13
movl (%rbp), %esi
movq %r14, %rdi
callq 0x16c05
movslq (%r12), %rcx
cmpq $0x3, %rcx
je 0x16b26
leaq 0xd701(%rip), %rdx # 0x24223
movsbl (%rcx,%rdx), %ebx
leaq 0x1b973(%rip), %r14 # 0x324a0
leaq 0x106a3(%rip), %rsi # 0x271d7
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq 0x23e0
jmp 0x16b4f
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c |
acmod_set_id2name | const char *
acmod_set_id2name(acmod_set_t *acmod_set,
acmod_id_t id)
{
static char str[1024];
char *pmap = WORD_POSN_CHAR_MAP;
acmod_id_t base;
acmod_id_t left;
acmod_id_t right;
word_posn_t posn;
if (id < acmod_set->n_ci)
return acmod_set->ci[id].name;
else if (id < acmod_set->next_id) {
acmod_set_id2tri(acmod_set, &base, &left, &right, &posn, id);
sprintf(str, "%s %s %s %c",
acmod_set_id2name(acmod_set, base),
acmod_set_id2name(acmod_set, left),
acmod_set_id2name(acmod_set, right),
pmap[(int)posn]);
return str;
}
else
return NULL;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r9d
movq %rdi, %rbx
cmpl %esi, 0x8(%rdi)
jbe 0x16c30
movq (%rbx), %rax
movl %r9d, %ecx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rbx
jmp 0x16cbd
cmpl %r9d, 0x20(%rbx)
jbe 0x16cbb
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
movq %rsp, %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x16b61
movl (%r14), %esi
movq %rbx, %rdi
callq 0x16c05
movq %rax, %r14
movl (%r15), %esi
movq %rbx, %rdi
callq 0x16c05
movq %rax, %r15
movl (%r12), %esi
movq %rbx, %rdi
callq 0x16c05
movslq (%r13), %rcx
leaq 0xd590(%rip), %rdx # 0x24223
movsbl (%rcx,%rdx), %r9d
leaq 0x1bc01(%rip), %rbx # 0x328a0
leaq 0x1053d(%rip), %rsi # 0x271e3
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x23e0
jmp 0x16cbd
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c |
acmod_set_base_phone | acmod_id_t
acmod_set_base_phone(acmod_set_t *acmod_set, acmod_id_t id)
{
uint32 addr;
if (id < acmod_set->n_ci)
return id;
else if (id < acmod_set->next_id) {
addr = id - acmod_set->n_ci;
return acmod_set->multi[addr].base;
}
else {
E_ERROR("acmod_set_base_phone() ID==%u is out-of-range\n", id);
return NO_ACMOD;
}
} | movl %esi, %eax
movl %esi, %ecx
subl 0x8(%rdi), %ecx
jb 0x16e25
cmpl %eax, 0x20(%rdi)
jbe 0x16df9
movq 0x10(%rdi), %rax
shlq $0x4, %rcx
movzbl (%rax,%rcx), %eax
retq
pushq %rax
leaq 0x10015(%rip), %rsi # 0x26e16
leaq 0x10510(%rip), %rcx # 0x27318
movl $0x31c, %edx # imm = 0x31C
movl $0x4, %edi
movl %eax, %r8d
xorl %eax, %eax
callq 0xd380
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c |
acmod_set_attrib | const char **
acmod_set_attrib(acmod_set_t *acmod_set,
acmod_id_t id)
{
char **attrib_list;
uint32 addr;
if (id < acmod_set->n_ci) {
attrib_list = acmod_set->ci[id].attrib;
}
else if (id < acmod_set->next_id) {
addr = id - acmod_set->n_ci;
attrib_list = acmod_set->multi[addr].attrib;
}
else {
E_ERROR("Phone id %u is out of range.\n", id);
return FALSE;
}
assert(attrib_list);
return (const char **)attrib_list;
} | pushq %rbx
movl %esi, %r8d
movl %esi, %eax
subl 0x8(%rdi), %eax
jae 0x16f1a
movq (%rdi), %rax
movl %r8d, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
addq $0x8, %rax
jmp 0x16f2f
cmpl %r8d, 0x20(%rdi)
jbe 0x16f56
movq 0x10(%rdi), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $0x8, %rax
movq (%rax), %rbx
testq %rbx, %rbx
jne 0x16f77
leaq 0x10427(%rip), %rdi # 0x27365
leaq 0xfed1(%rip), %rsi # 0x26e16
leaq 0x1046a(%rip), %rcx # 0x273b6
movl $0x362, %edx # imm = 0x362
callq 0x2190
leaq 0xfeb9(%rip), %rsi # 0x26e16
leaq 0x103e3(%rip), %rcx # 0x27347
xorl %ebx, %ebx
movl $0x35d, %edx # imm = 0x35D
movl $0x4, %edi
xorl %eax, %eax
callq 0xd380
movq %rbx, %rax
popq %rbx
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/acmod_set.c |
reindex | uint32
reindex(dtree_node_t *node,
uint32 *next_id)
{
node->node_id = (*next_id)++;
if (!IS_LEAF(node)) {
return reindex(node->y, next_id) +
reindex(node->n, next_id) + 1;
}
else {
return 1;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movl (%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movl %eax, (%r15)
movq 0x58(%r15), %rdi
testq %rdi, %rdi
jne 0x170e5
cmpq $0x0, 0x60(%r15)
je 0x170f7
movq %r14, %rsi
callq 0x170bc
movq 0x60(%r15), %r15
addl %eax, %ebx
incl %ebx
jmp 0x170c9
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
prune_subtrees | uint32
prune_subtrees(dtree_node_t *node)
{
uint32 n_pruned;
if (!IS_LEAF(node)) {
n_pruned = cnt_node(node->y) + cnt_node(node->n);
prune_subtrees(node->y); node->y = NULL;
prune_subtrees(node->n); node->n = NULL;
return n_pruned;
}
else {
/* it is a leaf node; nothing to do */
return 0;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %r14
testq %r14, %r14
jne 0x171bf
cmpq $0x0, 0x60(%rbx)
je 0x17201
movq %r14, %rdi
callq 0x17088
movl %eax, %r15d
movq 0x60(%rbx), %rdi
callq 0x17088
movl %eax, %ebp
addl %r15d, %ebp
movq %r14, %rdi
callq 0x171a5
xorl %r14d, %r14d
movq %r14, 0x58(%rbx)
movq 0x60(%rbx), %rdi
callq 0x171a5
movq %r14, 0x60(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x171f4
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
print_final_tree_recur | static void
print_final_tree_recur(FILE *fp,
dtree_node_t *node,
pset_t *pset)
{
if (!IS_LEAF(node)) {
fprintf(fp, "%u %u %u %e %e ",
node->node_id, node->y->node_id, node->n->node_id, node->wt_ent_dec, node->occ);
print_comp_quest(fp, pset, (comp_quest_t *)node->q);
fprintf(fp, "\n");
print_final_tree_recur(fp, node->y, pset);
print_final_tree_recur(fp, node->n, pset);
}
else {
fprintf(fp, "%u - - %e %e\n",
node->node_id, node->wt_ent, node->occ);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10350(%rip), %r12 # 0x27600
movq 0x58(%r14), %rax
testq %rax, %rax
jne 0x172c0
cmpq $0x0, 0x60(%r14)
je 0x17319
movl (%r14), %edx
movl (%rax), %ecx
movq 0x60(%r14), %rax
movl (%rax), %r8d
movsd 0x48(%r14), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x30(%r14), %xmm1
movq %rbx, %rdi
movq %r12, %rsi
movb $0x2, %al
callq 0x2280
movq 0x40(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1fcd0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2210
movq 0x58(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x17298
movq 0x60(%r14), %r14
jmp 0x172b0
movl (%r14), %edx
xorps %xmm1, %xmm1
cvtss2sd 0x30(%r14), %xmm1
movsd 0x38(%r14), %xmm0
leaq 0x102de(%rip), %rsi # 0x27610
movq %rbx, %rdi
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2280
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
read_final_tree | dtree_t *
read_final_tree(FILE *fp,
pset_t *pset,
uint32 n_pset)
{
dtree_t *out;
dtree_node_t *node;
uint32 n_node;
char *s, str[128];
lineiter_t *ln = NULL;
uint32 n_scan;
uint32 i, node_id, node_id_y, node_id_n;
comp_quest_t *q;
float64 ent;
float32 occ;
int err;
out = ckd_calloc(1, sizeof(dtree_t));
ln = lineiter_start_clean(fp);
s = ln->buf;
sscanf(s, "%s%n", str, &n_scan);
if (strcmp(str, "n_node") == 0) {
s += n_scan;
sscanf(s, "%u", &n_node);
}
else {
E_FATAL("Format error; expecting n_node\n");
}
out->n_node = n_node;
out->node = node = ckd_calloc(n_node, sizeof(dtree_node_t));
for (i = 0; i < n_node; i++)
node[i].node_id = i;
err = FALSE;
while ((ln = lineiter_next(ln))) {
s = ln->buf;
sscanf(s, "%u%n", &node_id, &n_scan);
s += n_scan;
sscanf(s, "%s%n", str, &n_scan);
s += n_scan;
if (strcmp(str, "-") == 0) {
node_id_y = NO_ID;
}
else {
node_id_y = atoi(str);
}
sscanf(s, "%s%n", str, &n_scan);
s += n_scan;
if (strcmp(str, "-") == 0) {
node_id_n = NO_ID;
}
else {
node_id_n = atoi(str);
}
sscanf(s, "%le%n", &ent, &n_scan);
s += n_scan;
sscanf(s, "%e%n", &occ, &n_scan);
s += n_scan;
if ((node_id_y != NO_ID) && (node_id_y != NO_ID)) {
q = (comp_quest_t *)ckd_calloc(1, sizeof(comp_quest_t));
if (s3parse_comp_quest(pset, n_pset, q, s) != S3_SUCCESS) {
err = TRUE;
}
node[node_id].q = q;
}
else
node[node_id].q = NULL;
/* ck if internal node */
if ((node_id_y != NO_ID) && (node_id_y != NO_ID))
node[node_id].wt_ent_dec = ent;
else
node[node_id].wt_ent = ent;
node[node_id].occ = occ;
if ((node_id_y != NO_ID) && (node_id_y != NO_ID)) {
node[node_id].y = &node[node_id_y];
node[node_id].n = &node[node_id_n];
node[node_id_y].p = node[node_id_n].p = &node[node_id];
}
else {
node[node_id].y = NULL;
node[node_id].n = NULL;
}
}
if (err == TRUE) {
free_tree(out);
out = NULL;
}
lineiter_free(ln);
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %edx, 0x1c(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, %rbx
leaq 0xfe6c(%rip), %rdx # 0x2741e
movl $0x1, %edi
movl $0x10, %esi
movl $0x111, %ecx # imm = 0x111
callq 0x94c8
movq %rax, %r13
movq %rbx, %rdi
callq 0xcd29
movq %rax, %rbx
movq (%rax), %r14
leaq 0xea4f(%rip), %rsi # 0x2602d
leaq 0x40(%rsp), %r15
leaq 0x4(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x22f0
movl $0x6f6e5f6e, %eax # imm = 0x6F6E5F6E
xorl (%r15), %eax
movl $0x65646f, %ecx # imm = 0x65646F
xorl 0x3(%r15), %ecx
orl %eax, %ecx
jne 0x1788d
movl 0x4(%rsp), %eax
addq %rax, %r14
leaq 0xfeb7(%rip), %rsi # 0x274d3
leaq 0x24(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x22f0
movl (%r12), %edi
movl %edi, 0x8(%r13)
leaq 0xfde1(%rip), %rdx # 0x2741e
movl $0x68, %esi
movl $0x120, %ecx # imm = 0x120
callq 0x94c8
movq %rax, %r15
movq %r13, 0x10(%rsp)
movq %rax, (%r13)
cmpl $0x0, (%r12)
je 0x17676
xorl %eax, %eax
movq %r15, %rcx
movl %eax, (%rcx)
incq %rax
movl 0x24(%rsp), %edx
addq $0x68, %rcx
cmpq %rdx, %rax
jb 0x17664
movq %rbx, %rdi
callq 0xccd0
testq %rax, %rax
je 0x1786c
leaq 0xe99f(%rip), %rbp # 0x2602d
movl $0x0, 0x8(%rsp)
movq %rax, 0x30(%rsp)
movq (%rax), %rbx
movq %rbx, %rdi
leaq 0xfe02(%rip), %rsi # 0x274aa
leaq 0xc(%rsp), %rdx
leaq 0x4(%rsp), %r13
movq %r13, %rcx
xorl %eax, %eax
callq 0x22f0
movl 0x4(%rsp), %r14d
addq %rbx, %r14
movq %r14, %rdi
movq %rbp, %rsi
leaq 0x40(%rsp), %r12
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x22f0
movl 0x4(%rsp), %r13d
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpw $0x2d, 0x40(%rsp)
je 0x176f8
movq %r12, %rdi
callq 0x23c0
movl %eax, %ebx
addq %r13, %r14
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
leaq 0x4(%rsp), %rcx
xorl %eax, %eax
callq 0x22f0
movl 0x4(%rsp), %r13d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpw $0x2d, 0x40(%rsp)
je 0x1772c
movq %r12, %rdi
callq 0x23c0
movl %eax, %eax
movq %rax, %r12
addq %r13, %r14
movq %r14, %rdi
leaq 0xfd73(%rip), %rsi # 0x274af
leaq 0x38(%rsp), %rdx
leaq 0x4(%rsp), %rbp
movq %rbp, %rcx
xorl %eax, %eax
callq 0x22f0
movl 0x4(%rsp), %r13d
addq %r14, %r13
movq %r13, %rdi
leaq 0xfd53(%rip), %rsi # 0x274b5
leaq 0x20(%rsp), %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x22f0
cmpl $-0x1, %ebx
je 0x177c3
movl 0x4(%rsp), %eax
addq %rax, %r13
movl $0x1, %edi
movl $0x18, %esi
leaq 0xfc90(%rip), %rdx # 0x2741e
movl $0x142, %ecx # imm = 0x142
callq 0x94c8
movq %rax, %r14
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq %rax, %rdx
movq %r13, %rcx
callq 0x1f757
testl %eax, %eax
movl $0x1, %eax
movl 0x8(%rsp), %ecx
cmovnel %eax, %ecx
movl %ecx, 0x8(%rsp)
jmp 0x177c6
xorl %r14d, %r14d
movl 0xc(%rsp), %eax
imulq $0x68, %rax, %rax
cmpl $-0x1, %ebx
movq %r14, 0x40(%r15,%rax)
movsd 0x38(%rsp), %xmm0
leaq 0x38(%r15,%rax), %rcx
leaq 0x48(%r15,%rax), %rax
cmoveq %rcx, %rax
movsd %xmm0, (%rax)
movl 0xc(%rsp), %eax
imulq $0x68, %rax, %rax
movss 0x20(%rsp), %xmm0
movss %xmm0, 0x30(%r15,%rax)
cmpl $-0x1, %ebx
leaq 0xe820(%rip), %rbp # 0x2602d
je 0x1783b
movl %ebx, %ecx
imulq $0x68, %rcx, %rcx
leaq (%r15,%rcx), %rdx
leaq (%r15,%rax), %rsi
movq %rdx, 0x58(%r15,%rax)
imulq $0x68, %r12, %rdx
leaq (%r15,%rdx), %rdi
movq %rdi, 0x60(%r15,%rax)
movq %rsi, 0x50(%r15,%rdx)
movq %rsi, 0x50(%r15,%rcx)
jmp 0x17844
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r15,%rax)
movq 0x30(%rsp), %rdi
callq 0xccd0
testq %rax, %rax
jne 0x17696
cmpl $0x1, 0x8(%rsp)
jne 0x1786c
movq 0x10(%rsp), %rdi
callq 0x178b6
xorl %ebx, %ebx
jmp 0x17871
movq 0x10(%rsp), %rbx
xorl %edi, %edi
callq 0xce49
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfb8a(%rip), %rsi # 0x2741e
leaq 0xfbef(%rip), %rcx # 0x2748a
movl $0x11c, %edx # imm = 0x11C
movl $0x5, %edi
xorl %eax, %eax
callq 0xd380
movl $0x1, %edi
callq 0x23f0
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
free_tree | void
free_tree(dtree_t *tr)
{
uint32 i;
dtree_node_t *node;
for (i = 0; i < tr->n_node; i++) {
node = &tr->node[i];
if (node->mixw_occ)
ckd_free_3d((void ***)node->mixw_occ);
if (node->means)
ckd_free_3d((void ***)node->means);
if (node->vars)
ckd_free_3d((void ***)node->vars);
if (node->id)
ckd_free(node->id);
/* node->q not freed because if tr is a
simple tree, it points to the question
in the master list of questions that needs
to stick around */
}
ckd_free(tr->node);
ckd_free(tr);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x1791d
movl $0x28, %r14d
xorl %r15d, %r15d
movq (%rbx), %r12
movq -0x10(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x178e2
callq 0x9709
movq -0x8(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x178f1
callq 0x9709
movq (%r12,%r14), %rdi
testq %rdi, %rdi
je 0x178ff
callq 0x9709
movq -0x20(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x1790e
callq 0x9614
incq %r15
movl 0x8(%rbx), %eax
addq $0x68, %r14
cmpq %rax, %r15
jb 0x178d0
movq (%rbx), %rdi
callq 0x9614
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9614
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
mk_disj | void
mk_disj(dtree_node_t *node,
uint32 clust,
comp_quest_t *q,
quest_t *conj,
uint32 c_idx,
uint32 *d_idx)
{
if (IS_LEAF(node)) {
if (node->clust == clust) {
uint32 i;
uint32 d;
d = *d_idx;
q->prod_len[d] = c_idx;
q->conj_q[d] = (quest_t *)ckd_calloc(c_idx, sizeof(quest_t));
for (i = 0; i < c_idx; i++) {
memcpy(&q->conj_q[d][i], &conj[i], sizeof(quest_t));
}
++(*d_idx);
}
else
return;
}
else {
quest_t *qu;
qu = (quest_t *)node->q;
conj[c_idx].ctxt = qu->ctxt;
conj[c_idx].neg = qu->neg;
conj[c_idx].pset = qu->pset;
conj[c_idx].member = qu->member;
conj[c_idx].posn = qu->posn;
mk_disj(node->y, clust, q, conj, c_idx+1, d_idx);
conj[c_idx].neg = !conj[c_idx].neg;
mk_disj(node->n, clust, q, conj, c_idx+1, d_idx);
return;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
movq 0x58(%r13), %rdi
testq %rdi, %rdi
jne 0x17966
cmpq $0x0, 0x60(%r13)
je 0x179c5
movq 0x40(%r13), %rax
movl (%rax), %ecx
movl %ebp, %ebx
shlq $0x5, %rbx
movl %ecx, (%r14,%rbx)
movl 0x4(%rax), %ecx
movl %ecx, 0x4(%r14,%rbx)
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14,%rbx)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r14,%rbx)
movq 0x18(%rax), %rax
movq %rax, 0x18(%r14,%rbx)
incl %ebp
movl %r12d, %esi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
movq (%rsp), %r9
callq 0x17938
xorl %eax, %eax
cmpl $0x0, 0x4(%r14,%rbx)
sete %al
movl %eax, 0x4(%r14,%rbx)
movq 0x60(%r13), %r13
jmp 0x17956
cmpl %r12d, 0x4(%r13)
jne 0x17a31
movq (%rsp), %rax
movl (%rax), %r13d
movq 0x8(%r15), %rax
movl %ebp, (%rax,%r13,4)
movl %ebp, %r12d
leaq 0xfa3a(%rip), %rdx # 0x2741e
movl $0x20, %esi
movq %r12, %rdi
movl $0x196, %ecx # imm = 0x196
callq 0x94c8
movq (%r15), %rcx
movq %rax, (%rcx,%r13,8)
testl %ebp, %ebp
je 0x17a2b
shlq $0x5, %r12
xorl %eax, %eax
movq (%r15), %rcx
movq (%rcx,%r13,8), %rcx
movups (%r14,%rax), %xmm0
movups 0x10(%r14,%rax), %xmm1
movups %xmm1, 0x10(%rcx,%rax)
movups %xmm0, (%rcx,%rax)
addq $0x20, %rax
cmpq %rax, %r12
jne 0x17a07
movq (%rsp), %rax
incl (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
cnt_class | uint32
cnt_class(dtree_node_t *node,
uint32 *n_a,
uint32 *n_b)
{
if (IS_LEAF(node)) {
if (node->clust)
++(*n_a);
else
++(*n_b);
}
else {
cnt_class(node->y, n_a, n_b);
cnt_class(node->n, n_a, n_b);
}
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x58(%r15), %rdi
testq %rdi, %rdi
jne 0x17a6a
cmpq $0x0, 0x60(%r15)
je 0x17a86
movq %r14, %rsi
movq %rbx, %rdx
callq 0x17a40
movq 0x60(%r15), %r15
testb $0x1, %r12b
cmovel %r13d, %ebp
movb $0x1, %r12b
jmp 0x17a5a
cmpl $0x0, 0x4(%r15)
je 0x17a92
incl (%r14)
jmp 0x17a94
incl (%rbx)
xorl %eax, %eax
testb $0x1, %r12b
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
prune_leaves | uint32
prune_leaves(dtree_node_t *node,
pset_t *pset)
{
dtree_node_t *y, *n;
uint32 y_clust, n_clust;
if (IS_LEAF(node))
return NO_CLUST;
y = node->y;
n = node->n;
if (!IS_LEAF(y)) {
y_clust = prune_leaves(y, pset);
}
else {
y_clust = y->clust;
}
if (!IS_LEAF(n)) {
n_clust = prune_leaves(n, pset);
}
else {
n_clust = n->clust;
}
if ((y_clust != NO_CLUST) && (y_clust == n_clust)) {
node->y = node->n = NULL;
node->clust = y_clust;
return y_clust;
}
return NO_CLUST;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
jne 0x17ac9
cmpq $0x0, 0x60(%rbx)
je 0x17b1f
movq 0x60(%rbx), %r15
cmpq $0x0, 0x58(%rdi)
jne 0x17adb
cmpq $0x0, 0x60(%rdi)
je 0x17b2f
movq %r14, %rsi
callq 0x17aac
movl %eax, %ebp
cmpq $0x0, 0x58(%r15)
jne 0x17af3
cmpq $0x0, 0x60(%r15)
je 0x17b34
movq %r15, %rdi
movq %r14, %rsi
callq 0x17aac
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $-0x1, %ebp
je 0x17b24
cmpl %ecx, %ebp
jne 0x17b24
leaq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ebp, 0x4(%rbx)
movl %ebp, %eax
jmp 0x17b24
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rdi), %ebp
jmp 0x17ae5
movl 0x4(%r15), %ecx
jmp 0x17b00
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
leaf_mixw_occ | uint32
leaf_mixw_occ(dtree_node_t *node,
pset_t *pset,
float32 ****mixw_occ,
uint32 *node_id,
uint32 n_state,
uint32 n_stream,
uint32 n_density,
uint32 off)
{
uint32 i, j, k;
if (IS_LEAF(node)) {
node_id[off] = node->node_id;
for (i = 0; i < n_state; i++) {
for (j = 0; j < n_stream; j++) {
for (k = 0; k < n_density; k++) {
mixw_occ[off][i][j][k] = node->mixw_occ[i][j][k];
}
}
}
return ++off;
}
else {
off = leaf_mixw_occ(node->y,
pset,
mixw_occ,
node_id,
n_state,
n_stream,
n_density,
off);
off = leaf_mixw_occ(node->n,
pset,
mixw_occ,
node_id,
n_state,
n_stream,
n_density,
off);
return off;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movl 0x48(%rsp), %eax
movl 0x40(%rsp), %ebx
movq 0x58(%r15), %rdi
testq %rdi, %rdi
jne 0x17b71
cmpq $0x0, 0x60(%r15)
je 0x17b93
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movl %ebp, %r8d
movl 0x4(%rsp), %r9d
pushq %rax
pushq %rbx
callq 0x17b3a
addq $0x10, %rsp
movq 0x60(%r15), %r15
jmp 0x17b61
movl (%r15), %edx
movl %eax, %ecx
movl %edx, (%r12,%rcx,4)
testl %ebp, %ebp
je 0x17bf8
movl %ebp, %edx
movl 0x4(%rsp), %esi
movl %ebx, %edi
xorl %r8d, %r8d
cmpl $0x0, 0x4(%rsp)
je 0x17bf0
xorl %r9d, %r9d
testl %ebx, %ebx
je 0x17be8
movq 0x18(%r15), %r10
movq (%r10,%r8,8), %r10
movq (%r10,%r9,8), %r10
movq (%r14,%rcx,8), %r11
movq (%r11,%r8,8), %r11
movq (%r11,%r9,8), %r11
xorl %r12d, %r12d
movss (%r10,%r12,4), %xmm0
movss %xmm0, (%r11,%r12,4)
incq %r12
cmpq %r12, %rdi
jne 0x17bd4
incq %r9
cmpq %rsi, %r9
jne 0x17bb5
incq %r8
cmpq %rdx, %r8
jne 0x17bab
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
leaf_mean_vars | uint32
leaf_mean_vars(dtree_node_t *node,
pset_t *pset,
float32 ****means,
float32 ****vars,
uint32 *node_id,
uint32 n_state,
uint32 n_stream,
uint32 *veclen,
uint32 off)
{
uint32 i, j, k;
if (IS_LEAF(node)) {
node_id[off] = node->node_id;
for (i = 0; i < n_state; i++) {
for (j = 0; j < n_stream; j++) {
for (k = 0; k < veclen[j]; k++) {
means[off][i][j][k] = node->means[i][j][k];
vars[off][i][j][k] = node->vars[i][j][k];
}
}
}
return ++off;
}
else {
off = leaf_mean_vars(node->y,
pset,
means,
vars,
node_id,
n_state,
n_stream,
veclen,
off);
off = leaf_mean_vars(node->n,
pset,
means,
vars,
node_id,
n_state,
n_stream,
veclen,
off);
return off;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, (%rsp)
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movl 0x50(%rsp), %eax
movq 0x48(%rsp), %rbp
movq 0x58(%r15), %rdi
testq %rdi, %rdi
jne 0x17c40
cmpq $0x0, 0x60(%r15)
je 0x17c6b
subq $0x8, %rsp
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r12, %r8
movl 0x8(%rsp), %r9d
pushq %rax
pushq %rbp
movl 0x58(%rsp), %eax
pushq %rax
callq 0x17c09
addq $0x20, %rsp
movq 0x60(%r15), %r15
jmp 0x17c30
movl (%r15), %edx
movl %eax, %ecx
movl %edx, (%r12,%rcx,4)
movl (%rsp), %edx
testl %edx, %edx
je 0x17d06
movl %edx, %edx
movq %rdx, (%rsp)
movl 0x40(%rsp), %edx
movl %edx, %esi
xorl %edi, %edi
movl 0x40(%rsp), %edx
testl %edx, %edx
je 0x17cfd
xorl %r8d, %r8d
movl (%rbp,%r8,4), %r9d
testq %r9, %r9
je 0x17cf5
movq 0x20(%r15), %rdx
movq 0x28(%r15), %r12
movq (%rdx,%rdi,8), %rdx
movq (%rdx,%r8,8), %r10
movq (%r14,%rcx,8), %rdx
movq (%rdx,%rdi,8), %rdx
movq (%rdx,%r8,8), %r11
movq (%r12,%rdi,8), %rdx
movq (%rdx,%r8,8), %r12
movq (%rbx,%rcx,8), %rdx
movq (%rdx,%rdi,8), %rdx
movq (%rdx,%r8,8), %r13
xorl %edx, %edx
movss (%r10,%rdx,4), %xmm0
movss %xmm0, (%r11,%rdx,4)
movss (%r12,%rdx,4), %xmm0
movss %xmm0, (%r13,%rdx,4)
incq %rdx
cmpq %rdx, %r9
jne 0x17cd4
incq %r8
cmpq %rsi, %r8
jne 0x17c98
incq %rdi
cmpq (%rsp), %rdi
jne 0x17c8d
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
tied_state | uint32
tied_state(dtree_node_t *node,
acmod_id_t b,
acmod_id_t l,
acmod_id_t r,
word_posn_t wp,
pset_t *pset)
{
uint32 dfeat[4];
dfeat[0] = (uint32)l;
dfeat[1] = (uint32)b;
dfeat[2] = (uint32)r;
dfeat[3] = (uint32)wp;
if (IS_LEAF(node)) {
/* Got to a state cluster. Return the id */
return node->clust;
}
else {
#ifdef HORRIBLY_VERBOSE
print_comp_quest(stderr, pset, (comp_quest_t *)node->q);
#endif
if (eval_comp_quest((comp_quest_t *)node->q, dfeat, 4)) {
#ifdef HORRIBLY_VERBOSE
fprintf(stderr, " -> y\n");
#endif
return tied_state(node->y, b, l, r, wp, pset);
}
else {
#ifdef HORRIBLY_VERBOSE
fprintf(stderr, " -> n\n");
#endif
return tied_state(node->n, b, l, r, wp, pset);
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
movl %edx, (%rsp)
movl %esi, 0x4(%rsp)
movl %ecx, 0x8(%rsp)
movl %r8d, 0xc(%rsp)
cmpq $0x0, 0x58(%rdi)
jne 0x17dcb
cmpq $0x0, 0x60(%r13)
je 0x17e0d
movq 0x40(%r13), %rdi
movq %rsp, %rsi
movl $0x4, %edx
callq 0x1fc41
testl %eax, %eax
je 0x17de6
movq 0x58(%r13), %rdi
jmp 0x17dea
movq 0x60(%r13), %rdi
movl %r12d, %esi
movl %r15d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movq %rbx, %r9
callq 0x17d8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%r13), %eax
jmp 0x17dfe
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
cnt_twig | uint32
cnt_twig(dtree_node_t *node)
{
if (IS_LEAF(node)) {
return 0;
} else if (IS_LEAF(node->y) && IS_LEAF(node->n)) {
return 1;
}
else {
if (IS_LEAF(node->y) && !IS_LEAF(node->n)) {
return cnt_twig(node->n);
}
else if (!IS_LEAF(node->y) && IS_LEAF(node->n)) {
return cnt_twig(node->y);
}
else
return cnt_twig(node->y) + cnt_twig(node->n);
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rcx
xorl %ebx, %ebx
movq %rcx, %r14
movq 0x58(%rcx), %rdi
testq %rdi, %rdi
jne 0x17e2f
cmpq $0x0, 0x60(%r14)
je 0x17ea3
movq 0x58(%rdi), %rax
testq %rax, %rax
jne 0x17e69
cmpq $0x0, 0x60(%rdi)
jne 0x17e51
movq 0x60(%r14), %rcx
cmpq $0x0, 0x58(%rcx)
jne 0x17e51
cmpq $0x0, 0x60(%rcx)
je 0x17eb1
testq %rax, %rax
jne 0x17e69
cmpq $0x0, 0x60(%rdi)
je 0x17e8b
testq %rax, %rax
jne 0x17e69
cmpq $0x0, 0x60(%rdi)
je 0x17e7e
movq 0x60(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x17e7e
cmpq $0x0, 0x60(%rax)
movq %rdi, %rcx
je 0x17e1c
callq 0x17e13
movq 0x60(%r14), %rcx
addl %eax, %ebx
jmp 0x17e1c
movq 0x60(%r14), %rcx
cmpq $0x0, 0x58(%rcx)
jne 0x17e1c
cmpq $0x0, 0x60(%rcx)
jne 0x17e1c
jmp 0x17e5d
xorl %eax, %eax
addl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %eax
jmp 0x17ea5
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
best_leaf_node | dtree_node_t *
best_leaf_node(dtree_node_t *node)
{
dtree_node_t *cmp_y, *cmp_n, *ret;
ret = NULL;
if (IS_LEAF(node)) {
ret = node;
}
else {
cmp_y = best_leaf_node(node->y);
cmp_n = best_leaf_node(node->n);
if ((cmp_y == NULL || cmp_y->q == NULL) &&
(cmp_n == NULL || cmp_n->q == NULL)) {
return NULL;
}
else if ((cmp_y == NULL) || (cmp_y->q == NULL)) {
ret = cmp_n;
}
else if ((cmp_n == NULL) || (cmp_n->q == NULL)) {
ret = cmp_y;
}
else if (cmp_y->wt_ent_dec > cmp_n->wt_ent_dec) {
ret = cmp_y;
}
else {
ret = cmp_n;
}
}
return ret;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
jne 0x1935d
cmpq $0x0, 0x60(%r14)
je 0x193c5
callq 0x19346
movq %rax, %rbx
movq 0x60(%r14), %rdi
callq 0x19346
testq %rbx, %rbx
je 0x1937a
cmpq $0x0, 0x40(%rbx)
jne 0x19397
testq %rax, %rax
je 0x193bd
movq 0x40(%rax), %rcx
testq %rcx, %rcx
movq %rax, %r14
cmoveq %rcx, %r14
testq %rbx, %rbx
je 0x193c5
testq %rcx, %rcx
je 0x193c5
cmpq $0x0, 0x40(%rbx)
je 0x193b8
testq %rax, %rax
je 0x193c2
cmpq $0x0, 0x40(%rax)
je 0x193c2
movsd 0x48(%rbx), %xmm0
ucomisd 0x48(%rax), %xmm0
cmovaq %rbx, %rax
movq %rax, %r14
jmp 0x193c5
xorl %r14d, %r14d
jmp 0x193c5
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/dtree.c |
s3parse_comp_quest | int
s3parse_comp_quest(pset_t *pset,
uint32 n_pset,
comp_quest_t *q,
char *in_str)
{
char *s;
uint32 i;
s = in_str;
for (; *s != '\0' && isspace((unsigned char)*s); s++);
if (*s == '\0') {
E_ERROR("Empty string seen for composite question\n");
return S3_ERROR;
}
if (*s != '(') {
E_ERROR("Composite question does not begin with '(' : %s\n",
in_str);
return S3_ERROR;
}
q->sum_len = s3cnt_q_term(in_str);
q->conj_q = (quest_t **)ckd_calloc(q->sum_len, sizeof(quest_t *));
q->prod_len = (uint32 *)ckd_calloc(q->sum_len, sizeof(uint32));
++s; /* skip the open paren */
i = 0;
do {
s = s3parse_conj(pset,
n_pset,
&q->conj_q[i],
&q->prod_len[i],
s);
++i;
} while (s && *s && *s == '(');
if (s == NULL) {
E_ERROR("Error while parsing %s\n", in_str);
return S3_ERROR;
}
return S3_SUCCESS;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb (%rcx), %bl
testb %bl, %bl
je 0x1f7a3
movq %rcx, %r13
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x2470
movq (%rax), %rax
leaq 0x1(%r13), %r12
movzbl %bl, %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x1f796
movb (%r12), %bl
incq %r12
testb %bl, %bl
jne 0x1f77f
jmp 0x1f7a3
cmpb $0x28, %bl
je 0x1f7d6
testl %ecx, %ecx
jne 0x1f8aa
leaq 0x81d2(%rip), %rsi # 0x2797c
leaq 0x8316(%rip), %rcx # 0x27ac7
movl $0x107, %edx # imm = 0x107
movl $0x4, %edi
xorl %eax, %eax
callq 0xd380
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb (%r13), %bl
movq %r13, %rdi
testb %bl, %bl
je 0x1f800
callq 0x2470
movq (%rax), %rax
movq %r13, %rdi
movzbl %bl, %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x1f800
movb 0x1(%rdi), %bl
incq %rdi
testb %bl, %bl
jne 0x1f7ec
movq %r13, (%rsp)
xorl %r13d, %r13d
cmpb $0x0, 0x1(%rdi)
movl $0x0, %ebx
je 0x1f834
incq %rdi
xorl %ebx, %ebx
movl $0x28, %esi
callq 0x2150
testq %rax, %rax
je 0x1f834
incl %ebx
movq %rax, %rdi
incq %rdi
cmpb $0x0, 0x1(%rax)
jne 0x1f817
movl %ebx, 0x10(%r14)
movl %ebx, %edi
leaq 0x813b(%rip), %rbx # 0x2797c
movl $0x8, %esi
movq %rbx, %rdx
movl $0x114, %ecx # imm = 0x114
callq 0x94c8
movq %rax, (%r14)
movl 0x10(%r14), %edi
movl $0x4, %esi
movq %rbx, %rdx
movl $0x115, %ecx # imm = 0x115
callq 0x94c8
movq %rax, 0x8(%r14)
movl %r13d, %ecx
leaq (,%rcx,8), %rdx
addq (%r14), %rdx
shlq $0x2, %rcx
addq 0x8(%r14), %rcx
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %r8
callq 0x1f4d3
testq %rax, %rax
je 0x1f8c7
movq %rax, %r12
incl %r13d
cmpb $0x28, (%rax)
je 0x1f870
xorl %eax, %eax
jmp 0x1f7c7
leaq 0x80cb(%rip), %rsi # 0x2797c
leaq 0x8239(%rip), %rcx # 0x27af1
movl $0x10e, %edx # imm = 0x10E
movl $0x4, %edi
movq %r13, %r8
jmp 0x1f8e3
leaq 0x80ae(%rip), %rsi # 0x2797c
leaq 0x824d(%rip), %rcx # 0x27b22
movl $0x124, %edx # imm = 0x124
movl $0x4, %edi
movq (%rsp), %r8
xorl %eax, %eax
callq 0xd380
jmp 0x1f7c2
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/quest.c |
best_q | float64
best_q(float32 ****mixw,
float32 ****means,
float32 ****vars,
uint32 *veclen,
uint32 n_model,
uint32 n_state,
uint32 n_stream,
uint32 n_density,
float32 *stwt,
uint32 **dfeat,
uint32 n_dfeat,
quest_t *all_q,
uint32 n_all_q,
pset_t *pset,
uint32 *id,
uint32 n_id,
float32 ***dist,
float64 node_wt_ent, /* Weighted entropy of node */
quest_t **out_best_q)
{
float32 ***yes_dist;
float32 ***yes_means=0;
float32 ***yes_vars=0;
float32 varfloor=0;
float64 y_ent;
float64 yes_dnom, yes_norm;
uint32 *yes_id;
float32 ***no_dist;
float32 ***no_means=0;
float32 ***no_vars=0;
float64 n_ent;
float64 no_dnom, no_norm;
uint32 *no_id;
uint32 n_yes, n_b_yes = 0;
uint32 n_no, n_b_no = 0;
uint32 i, j, k, q, b_q=0, s;
uint32 ii;
float64 einc, b_einc = -1.0e+50;
const char* type;
uint32 continuous, sumveclen=0;
type = cmd_ln_str("-ts2cbfn");
if (strcmp(type,".semi.")!=0 && strcmp(type,".cont.") != 0)
E_FATAL("Type %s unsupported; trees can only be built on types .semi. or .cont.\n",type);
if (strcmp(type,".cont.") == 0)
continuous = 1;
else
continuous = 0;
if (continuous == 1) {
varfloor = cmd_ln_float32("-varfloor");
/* Allocating for sumveclen is overallocation, but it eases coding */
for (ii=0,sumveclen=0;ii<n_stream;ii++) sumveclen += veclen[ii];
yes_means = (float32 ***)ckd_calloc_3d(n_state,n_stream,sumveclen,sizeof(float32));
yes_vars = (float32 ***)ckd_calloc_3d(n_state,n_stream,sumveclen,sizeof(float32));
no_means = (float32 ***)ckd_calloc_3d(n_state,n_stream,sumveclen,sizeof(float32));
no_vars = (float32 ***)ckd_calloc_3d(n_state,n_stream,sumveclen,sizeof(float32));
}
n_yes = n_no = 0;
yes_dist = (float32 ***)ckd_calloc_3d(n_state, n_stream, n_density, sizeof(float32));
no_dist = (float32 ***)ckd_calloc_3d(n_state, n_stream, n_density, sizeof(float32));
for (q = 0; q < n_all_q; q++) {
memset(&yes_dist[0][0][0], 0, sizeof(float32) * n_state * n_stream * n_density);
memset(&no_dist[0][0][0], 0, sizeof(float32) * n_state * n_stream * n_density);
if (continuous == 1) {
memset(&yes_means[0][0][0], 0, sizeof(float32) * n_state * n_stream * sumveclen);
memset(&yes_vars[0][0][0], 0, sizeof(float32) * n_state * n_stream * sumveclen);
memset(&no_means[0][0][0], 0, sizeof(float32) * n_state * n_stream * sumveclen);
memset(&no_vars[0][0][0], 0, sizeof(float32) * n_state * n_stream * sumveclen);
}
n_yes = n_no = 0;
for (ii = 0; ii < n_id; ii++) {
i = id[ii];
if (eval_quest(&all_q[q], dfeat[i], n_dfeat)) {
for (s = 0; s < n_state; s++) {
for (j = 0; j < n_stream; j++) {
for (k = 0; k < n_density; k++) {
yes_dist[s][j][k] += mixw[i][s][j][k];
}
}
}
if (continuous == 1) {
for (s = 0; s < n_state; s++) {
for (j = 0; j < n_stream; j++) {
for (k = 0; k < veclen[j]; k++) {
yes_means[s][j][k] += mixw[i][s][j][0] * means[i][s][j][k];
yes_vars[s][j][k] += mixw[i][s][j][0] * (vars[i][s][j][k] + means[i][s][j][k]*means[i][s][j][k]);
}
}
}
}
++n_yes;
}
else {
for (s = 0; s < n_state; s++) {
for (j = 0; j < n_stream; j++) {
for (k = 0; k < n_density; k++) {
no_dist[s][j][k] += mixw[i][s][j][k];
}
}
}
if (continuous == 1) {
for (s = 0; s < n_state; s++) {
for (j = 0; j < n_stream; j++) {
for (k = 0; k < veclen[j]; k++) {
no_means[s][j][k] += mixw[i][s][j][0] * means[i][s][j][k];
no_vars[s][j][k] += mixw[i][s][j][0] * (vars[i][s][j][k] + means[i][s][j][k]*means[i][s][j][k]);
}
}
}
}
++n_no;
}
}
if ((n_yes == 0) || (n_no == 0)) {
/* no split. All satisfy or all don't satisfy */
continue;
}
for (s = 0, einc = 0; s < n_state; s++) {
for (k = 0, yes_dnom = 0; k < n_density; k++) {
yes_dnom += yes_dist[s][0][k];
}
if (yes_dnom == 0)
break;
yes_norm = 1.0 / yes_dnom;
for (j = 0; j < n_stream; j++) {
for (k = 0; k < n_density; k++) {
yes_dist[s][j][k] *= yes_norm;
}
}
for (k = 0, no_dnom = 0; k < n_density; k++) {
no_dnom += no_dist[s][0][k];
}
if (no_dnom == 0)
break;
no_norm = 1.0 / no_dnom;
for (j = 0; j < n_stream; j++) {
for (k = 0; k < n_density; k++) {
no_dist[s][j][k] *= no_norm;
}
}
if (continuous == 1) {
y_ent = 0;
n_ent = 0;
for (j = 0; j < n_stream; j++) {
if (yes_dnom != 0) {
for (k = 0; k < veclen[j]; k++) {
yes_means[s][j][k] *= yes_norm;
yes_vars[s][j][k] = yes_vars[s][j][k]*yes_norm -
yes_means[s][j][k]*yes_means[s][j][k];
if (yes_vars[s][j][k] < varfloor) yes_vars[s][j][k] = varfloor;
}
}
if (no_dnom != 0) {
for (k = 0; k < veclen[j]; k++) {
no_means[s][j][k] *= no_norm;
no_vars[s][j][k] = no_vars[s][j][k]*no_norm -
no_means[s][j][k]*no_means[s][j][k];
if (no_vars[s][j][k] < varfloor) no_vars[s][j][k] = varfloor;
}
}
y_ent += yes_dnom * ent_cont(yes_means[s][j],yes_vars[s][j],veclen[j]);
n_ent += no_dnom * ent_cont(no_means[s][j],no_vars[s][j],veclen[j]);
}
einc += (float64)stwt[s] * (y_ent + n_ent);
}
else {
einc += (float64)stwt[s] * wt_ent_inc(yes_dist[s], yes_dnom,
no_dist[s], no_dnom,
dist[s], n_stream, n_density);
}
}
if (continuous == 1) {
einc -= node_wt_ent;
}
if (s < n_state) {
/* Ended iteration over states prematurely; assume 'bad' question */
continue;
}
if (einc > b_einc) {
b_einc = einc;
b_q = q;
n_b_yes = n_yes;
n_b_no = n_no;
}
}
if ((n_b_yes == 0) || (n_b_no == 0)) {
/* No best question */
*out_best_q = NULL;
return 0;
}
yes_id = (uint32 *)ckd_calloc(n_b_yes, sizeof(uint32));
no_id = (uint32 *)ckd_calloc(n_b_no, sizeof(uint32));
memset(&yes_dist[0][0][0], 0, sizeof(float32) * n_state * n_stream * n_density);
memset(&no_dist[0][0][0], 0, sizeof(float32) * n_state * n_stream * n_density);
n_yes = n_no = 0;
for (ii = 0; ii < n_id; ii++) {
i = id[ii];
if (eval_quest(&all_q[b_q], dfeat[i], n_dfeat)) {
for (s = 0; s < n_state; s++) {
for (j = 0; j < n_stream; j++) {
for (k = 0; k < n_density; k++) {
yes_dist[s][j][k] += mixw[i][s][j][k];
}
}
}
yes_id[n_yes] = i;
++n_yes;
}
else {
for (s = 0; s < n_state; s++) {
for (j = 0; j < n_stream; j++) {
for (k = 0; k < n_density; k++) {
no_dist[s][j][k] += mixw[i][s][j][k];
}
}
}
no_id[n_no] = i;
++n_no;
}
}
ckd_free_3d((void ***)yes_dist);
ckd_free((void *)yes_id);
ckd_free_3d((void ***)no_dist);
ckd_free((void *)no_id);
if (continuous == 1) {
ckd_free_3d((void ***)yes_means);
ckd_free_3d((void ***)yes_vars);
ckd_free_3d((void ***)no_means);
ckd_free_3d((void ***)no_vars);
}
*out_best_q = &all_q[b_q];
return b_einc;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movsd %xmm0, 0xb8(%rsp)
movl %r9d, 0x10(%rsp)
movq %rcx, %r12
movq %rdx, 0xa0(%rsp)
movq %rsi, %r15
movq %rdi, %r14
callq 0x9a8f
leaq 0x33df(%rip), %rsi # 0x233cf
movq %rax, %rdi
callq 0xb19f
movq %rax, %r13
leaq 0x33d6(%rip), %rsi # 0x233d8
movq %rax, %rdi
callq 0x2270
testl %eax, %eax
je 0x20025
leaq 0x33ca(%rip), %rsi # 0x233df
movq %r13, %rdi
callq 0x2270
testl %eax, %eax
jne 0x20d6d
movl 0x120(%rsp), %ebx
leaq 0x33ac(%rip), %rsi # 0x233df
movq %r13, %rdi
callq 0x2270
movq $0x0, 0xa8(%rsp)
movl 0x10(%rsp), %edi
movl %ebx, %ebp
movl %eax, 0x14(%rsp)
testl %eax, %eax
movq %rdi, 0x8(%rsp)
je 0x20095
xorps %xmm0, %xmm0
movss %xmm0, 0x74(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x58(%rsp)
movq $0x0, 0x60(%rsp)
movq $0x0, 0x78(%rsp)
jmp 0x2016f
callq 0x9a8f
leaq 0x3538(%rip), %rsi # 0x235d9
movq %rax, %rdi
callq 0xb1db
testl %ebx, %ebx
je 0x200c6
xorl %eax, %eax
xorl %ebx, %ebx
addl (%r12,%rax,4), %ebx
incq %rax
cmpq %rax, %rbp
jne 0x200b1
movl %ebx, %ebx
movq 0x8(%rsp), %rdi
jmp 0x200cd
movq 0x8(%rsp), %rdi
xorl %ebx, %ebx
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x74(%rsp)
leaq 0x7b42(%rip), %r13 # 0x27c20
movl $0x4, %ecx
movq %rbp, %rsi
movq %rbx, %rdx
movq %r13, %r8
movl $0x71, %r9d
callq 0x9633
movq %rax, 0x60(%rsp)
movl $0x4, %ecx
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r13, %r8
movl $0x72, %r9d
callq 0x9633
movq %rax, 0x58(%rsp)
movl $0x4, %ecx
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r13, %r8
movl $0x73, %r9d
callq 0x9633
movq %rax, 0x50(%rsp)
movl $0x4, %ecx
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, 0x78(%rsp)
movq %rbx, %rdx
movq %r13, %r8
movl $0x74, %r9d
callq 0x9633
movq 0x8(%rsp), %rdi
movq %rax, 0x48(%rsp)
movl 0x128(%rsp), %r13d
leaq 0x7aa2(%rip), %r8 # 0x27c20
movl $0x4, %ecx
movq %rbp, %rsi
movq %r13, %rdx
movl $0x79, %r9d
movq %rdi, %rbx
callq 0x9633
movq %rax, 0x20(%rsp)
movl $0x4, %ecx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
leaq 0x7a6f(%rip), %r8 # 0x27c20
movl $0x7a, %r9d
callq 0x9633
movl 0x150(%rsp), %esi
testl %esi, %esi
movq %rax, 0x38(%rsp)
je 0x20a8a
cmpl $0x0, 0x14(%rsp)
setne %dl
imulq %rbp, %rbx
shlq $0x2, %rbx
movq 0x78(%rsp), %rcx
imulq %rbx, %rcx
movq %rcx, 0x78(%rsp)
imulq %r13, %rbx
movq %rbx, 0xc8(%rsp)
cmpl $0x0, 0x10(%rsp)
sete %cl
movl %esi, %esi
movq %rsi, 0xc0(%rsp)
movb %cl, 0x6(%rsp)
orb %cl, %dl
movb %dl, 0x7(%rsp)
movq $0x0, 0x88(%rsp)
movsd 0x79ee(%rip), %xmm0 # 0x27c18
movsd %xmm0, 0x80(%rsp)
movl $0x0, 0x6c(%rsp)
movl $0x0, 0x70(%rsp)
movq $0x0, 0xa8(%rsp)
movq 0x20(%rsp), %r8
movq (%r8), %rax
movq (%rax), %rdi
xorl %esi, %esi
movq 0xc8(%rsp), %rbx
movq %rbx, %rdx
callq 0x21b0
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x21b0
cmpl $0x0, 0x14(%rsp)
jne 0x202e1
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %esi, %esi
movq 0x78(%rsp), %rbx
movq %rbx, %rdx
callq 0x21b0
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x21b0
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x21b0
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x21b0
cmpl $0x0, 0x168(%rsp)
movl 0x120(%rsp), %r9d
je 0x205f8
movq 0x88(%rsp), %rax
shlq $0x5, %rax
addq 0x148(%rsp), %rax
movq %rax, 0x28(%rsp)
xorl %ecx, %ecx
movl $0x0, 0x30(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x160(%rsp), %rax
movq %rcx, 0x18(%rsp)
movl (%rax,%rcx,4), %ebx
movq 0x138(%rsp), %rax
movq (%rax,%rbx,8), %rsi
movq 0x28(%rsp), %rdi
movl 0x140(%rsp), %edx
callq 0x1fbe6
testl %eax, %eax
je 0x2049d
cmpl $0x0, 0x10(%rsp)
movl 0x128(%rsp), %r8d
movl 0x120(%rsp), %r9d
movq 0x8(%rsp), %r10
movq 0x20(%rsp), %r11
je 0x203c3
xorl %eax, %eax
testl %r9d, %r9d
je 0x203bb
xorl %ecx, %ecx
testl %r8d, %r8d
je 0x203b3
movq (%r14,%rbx,8), %rdx
movq (%rdx,%rax,8), %rdx
movq (%rdx,%rcx,8), %rdx
movq (%r11,%rax,8), %rsi
movq (%rsi,%rcx,8), %rsi
xorl %edi, %edi
movss (%rdx,%rdi,4), %xmm0
addss (%rsi,%rdi,4), %xmm0
movss %xmm0, (%rsi,%rdi,4)
incq %rdi
cmpq %rdi, %r13
jne 0x2039c
incq %rcx
cmpq %rbp, %rcx
jne 0x20381
incq %rax
cmpq %r10, %rax
jne 0x2037a
cmpb $0x0, 0x7(%rsp)
jne 0x20494
xorl %eax, %eax
testl %r9d, %r9d
je 0x2047b
xorl %ecx, %ecx
movl (%r12,%rcx,4), %edx
testq %rdx, %rdx
je 0x2046f
movq (%r14,%rbx,8), %rsi
movq (%rsi,%rax,8), %rsi
movq (%rsi,%rcx,8), %rsi
movq (%r15,%rbx,8), %rdi
movq (%rdi,%rax,8), %rdi
movq (%rdi,%rcx,8), %rdi
movq 0x60(%rsp), %r8
movq (%r8,%rax,8), %r8
movq (%r8,%rcx,8), %r8
movq 0xa0(%rsp), %r9
movq (%r9,%rbx,8), %r9
movq (%r9,%rax,8), %r9
movq (%r9,%rcx,8), %r9
movq 0x58(%rsp), %r10
movq (%r10,%rax,8), %r10
movq (%r10,%rcx,8), %r10
xorl %r11d, %r11d
movss (%rsi), %xmm0
mulss (%rdi,%r11,4), %xmm0
addss (%r8,%r11,4), %xmm0
movss %xmm0, (%r8,%r11,4)
movss (%rdi,%r11,4), %xmm0
mulss %xmm0, %xmm0
addss (%r9,%r11,4), %xmm0
mulss (%rsi), %xmm0
addss (%r10,%r11,4), %xmm0
movss %xmm0, (%r10,%r11,4)
incq %r11
cmpq %r11, %rdx
jne 0x20431
incq %rcx
cmpq %rbp, %rcx
jne 0x203db
incq %rax
movq 0x8(%rsp), %r10
cmpq %r10, %rax
movl 0x120(%rsp), %r9d
jne 0x203d0
incl 0x34(%rsp)
jmp 0x205de
cmpl $0x0, 0x10(%rsp)
movl 0x128(%rsp), %r8d
movl 0x120(%rsp), %r9d
movq 0x8(%rsp), %r10
movq 0x38(%rsp), %r11
je 0x20509
xorl %eax, %eax
testl %r9d, %r9d
je 0x20501
xorl %ecx, %ecx
testl %r8d, %r8d
je 0x204f9
movq (%r14,%rbx,8), %rdx
movq (%rdx,%rax,8), %rdx
movq (%rdx,%rcx,8), %rdx
movq (%r11,%rax,8), %rsi
movq (%rsi,%rcx,8), %rsi
xorl %edi, %edi
movss (%rdx,%rdi,4), %xmm0
addss (%rsi,%rdi,4), %xmm0
movss %xmm0, (%rsi,%rdi,4)
incq %rdi
cmpq %rdi, %r13
jne 0x204e2
incq %rcx
cmpq %rbp, %rcx
jne 0x204c7
incq %rax
cmpq %r10, %rax
jne 0x204c0
cmpb $0x0, 0x7(%rsp)
jne 0x205da
xorl %eax, %eax
testl %r9d, %r9d
je 0x205c1
xorl %ecx, %ecx
movl (%r12,%rcx,4), %edx
testq %rdx, %rdx
je 0x205b5
movq (%r14,%rbx,8), %rsi
movq (%rsi,%rax,8), %rsi
movq (%rsi,%rcx,8), %rsi
movq (%r15,%rbx,8), %rdi
movq (%rdi,%rax,8), %rdi
movq (%rdi,%rcx,8), %rdi
movq 0x50(%rsp), %r8
movq (%r8,%rax,8), %r8
movq (%r8,%rcx,8), %r8
movq 0xa0(%rsp), %r9
movq (%r9,%rbx,8), %r9
movq (%r9,%rax,8), %r9
movq (%r9,%rcx,8), %r9
movq 0x48(%rsp), %r10
movq (%r10,%rax,8), %r10
movq (%r10,%rcx,8), %r10
xorl %r11d, %r11d
movss (%rsi), %xmm0
mulss (%rdi,%r11,4), %xmm0
addss (%r8,%r11,4), %xmm0
movss %xmm0, (%r8,%r11,4)
movss (%rdi,%r11,4), %xmm0
mulss %xmm0, %xmm0
addss (%r9,%r11,4), %xmm0
mulss (%rsi), %xmm0
addss (%r10,%r11,4), %xmm0
movss %xmm0, (%r10,%r11,4)
incq %r11
cmpq %r11, %rdx
jne 0x20577
incq %rcx
cmpq %rbp, %rcx
jne 0x20521
incq %rax
movq 0x8(%rsp), %r10
cmpq %r10, %rax
movl 0x120(%rsp), %r9d
jne 0x20516
incl 0x30(%rsp)
movq 0x18(%rsp), %rcx
incq %rcx
movl 0x168(%rsp), %eax
cmpq %rax, %rcx
jne 0x20322
jmp 0x2060d
movl $0x0, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x8(%rsp), %r10
cmpl $0x0, 0x34(%rsp)
sete %al
cmpl $0x0, 0x30(%rsp)
sete %cl
orb %al, %cl
je 0x2062b
movq 0x20(%rsp), %r8
jmp 0x20a5e
cmpl $0x0, 0x10(%rsp)
movl 0x128(%rsp), %edi
movq 0x20(%rsp), %r8
movq 0x38(%rsp), %r11
xorps %xmm1, %xmm1
je 0x20a12
xorl %ebx, %ebx
movb 0x6(%rsp), %al
xorpd %xmm2, %xmm2
testl %edi, %edi
je 0x20675
movq (%r8,%rbx,8), %rcx
movq (%rcx), %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rdx,4), %xmm0
addsd %xmm0, %xmm2
incq %rdx
cmpq %rdx, %r13
jne 0x20661
ucomisd 0x5e6b(%rip), %xmm2 # 0x264e8
jne 0x20685
jnp 0x20a16
movsd 0x297b(%rip), %xmm3 # 0x23008
divsd %xmm2, %xmm3
testl %r9d, %r9d
je 0x206cb
xorl %ecx, %ecx
testl %edi, %edi
je 0x206c3
movq (%r8,%rbx,8), %rdx
movq (%rdx,%rcx,8), %rdx
xorl %esi, %esi
xorps %xmm0, %xmm0
cvtss2sd (%rdx,%rsi,4), %xmm0
mulsd %xmm3, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %r13
jne 0x206a6
incq %rcx
cmpq %rbp, %rcx
jne 0x20698
testl %edi, %edi
je 0x206f2
movq (%r11,%rbx,8), %rcx
movq (%rcx), %rcx
xorpd %xmm4, %xmm4
xorl %edx, %edx
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rdx,4), %xmm0
addsd %xmm0, %xmm4
incq %rdx
cmpq %rdx, %r13
jne 0x206dc
jmp 0x206f6
xorpd %xmm4, %xmm4
ucomisd 0x5dea(%rip), %xmm4 # 0x264e8
jne 0x20706
jnp 0x20a16
movsd 0x28fa(%rip), %xmm5 # 0x23008
divsd %xmm4, %xmm5
testl %r9d, %r9d
je 0x2074c
xorl %eax, %eax
testl %edi, %edi
je 0x20744
movq (%r11,%rbx,8), %rcx
movq (%rcx,%rax,8), %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rdx,4), %xmm0
mulsd %xmm5, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r13
jne 0x20727
incq %rax
cmpq %rbp, %rax
jne 0x20719
movsd %xmm1, 0xb0(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x207cd
movq 0x130(%rsp), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rbx,4), %xmm0
movsd %xmm0, 0x18(%rsp)
movq (%r8,%rbx,8), %rdi
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movq (%r11,%rbx,8), %rsi
xorps %xmm1, %xmm1
cvtsd2ss %xmm4, %xmm1
movq 0x170(%rsp), %rax
movq (%rax,%rbx,8), %rdx
movl %r9d, %ecx
movl 0x128(%rsp), %r8d
callq 0x2268c
movq 0x38(%rsp), %r11
movq 0x20(%rsp), %r8
movq 0x8(%rsp), %r10
movl 0x120(%rsp), %r9d
movl 0x128(%rsp), %edi
mulsd 0x18(%rsp), %xmm0
jmp 0x209f4
testl %r9d, %r9d
je 0x209dd
movsd %xmm5, 0xd0(%rsp)
movsd %xmm2, 0x90(%rsp)
movq %rbx, 0x28(%rsp)
xorpd %xmm2, %xmm2
xorl %ebx, %ebx
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd %xmm3, 0xe0(%rsp)
movsd %xmm4, 0xd8(%rsp)
movsd %xmm2, 0x98(%rsp)
movl (%r12,%rbx,4), %edx
testq %rdx, %rdx
movss 0x74(%rsp), %xmm2
je 0x2088f
movq 0x60(%rsp), %rax
movq 0x28(%rsp), %rsi
movq (%rax,%rsi,8), %rax
movq (%rax,%rbx,8), %rax
movq 0x58(%rsp), %rcx
movq (%rcx,%rsi,8), %rcx
movq (%rcx,%rbx,8), %rcx
xorl %esi, %esi
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rsi,4), %xmm0
mulsd %xmm3, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rsi,4)
xorps %xmm1, %xmm1
cvtss2sd (%rcx,%rsi,4), %xmm1
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm3, %xmm1
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movaps %xmm2, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x20847
testq %rdx, %rdx
movsd 0xd0(%rsp), %xmm3
je 0x20906
movq 0x50(%rsp), %rax
movq 0x28(%rsp), %rsi
movq (%rax,%rsi,8), %rax
movq (%rax,%rbx,8), %rax
movq 0x48(%rsp), %rcx
movq (%rcx,%rsi,8), %rcx
movq (%rcx,%rbx,8), %rcx
xorl %esi, %esi
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rsi,4), %xmm0
mulsd %xmm3, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rsi,4)
xorps %xmm1, %xmm1
cvtss2sd (%rcx,%rsi,4), %xmm1
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm3, %xmm1
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movaps %xmm2, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x208be
movq 0x60(%rsp), %rax
movq %rbx, 0x18(%rsp)
movq 0x28(%rsp), %rbx
movq (%rax,%rbx,8), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x58(%rsp), %rax
movq (%rax,%rbx,8), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x12335
mulsd 0x90(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq (%rax,%rbx,8), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x48(%rsp), %rax
movq (%rax,%rbx,8), %rax
movq 0x18(%rsp), %rbx
movq (%rax,%rbx,8), %rsi
movl (%r12,%rbx,4), %edx
callq 0x12335
movsd 0xd8(%rsp), %xmm4
mulsd %xmm4, %xmm0
movsd 0x98(%rsp), %xmm2
addsd %xmm0, %xmm2
incq %rbx
cmpq %rbp, %rbx
movl 0x128(%rsp), %edi
movl 0x120(%rsp), %r9d
movq 0x8(%rsp), %r10
movq 0x20(%rsp), %r8
movq 0x38(%rsp), %r11
movsd 0xe0(%rsp), %xmm3
jne 0x2080e
movsd 0x40(%rsp), %xmm1
addsd %xmm2, %xmm1
movq 0x28(%rsp), %rbx
jmp 0x209e0
xorps %xmm1, %xmm1
movq 0x130(%rsp), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rbx,4), %xmm0
mulsd %xmm1, %xmm0
movsd 0xb0(%rsp), %xmm1
addsd %xmm0, %xmm1
incq %rbx
cmpq %r10, %rbx
setae %al
jne 0x20650
jmp 0x20a16
movb 0x6(%rsp), %al
cmpl $0x0, 0x14(%rsp)
jne 0x20a26
subsd 0xb8(%rsp), %xmm1
testb $0x1, %al
je 0x20a5e
ucomisd 0x80(%rsp), %xmm1
jbe 0x20a5e
movl 0x34(%rsp), %eax
movq %rax, 0xa8(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x70(%rsp)
movq 0x88(%rsp), %rax
movl %eax, 0x6c(%rsp)
movsd %xmm1, 0x80(%rsp)
movq 0x88(%rsp), %rcx
incq %rcx
movq %rcx, 0x88(%rsp)
cmpq 0xc0(%rsp), %rcx
jne 0x20254
movl 0x6c(%rsp), %esi
movl 0x70(%rsp), %r15d
jmp 0x20aa8
movsd 0x7186(%rip), %xmm0 # 0x27c18
movsd %xmm0, 0x80(%rsp)
xorl %r15d, %r15d
xorl %esi, %esi
movq %rbx, %r10
movq 0x20(%rsp), %r8
movq 0x178(%rsp), %rdi
xorl %ecx, %ecx
xorps %xmm0, %xmm0
movq 0xa8(%rsp), %rdx
testl %edx, %edx
je 0x20d58
testl %r15d, %r15d
je 0x20d58
movq %rsi, 0x90(%rsp)
movl %edx, %edi
leaq 0x7141(%rip), %rdx # 0x27c20
movl $0x4, %esi
movl $0x112, %ecx # imm = 0x112
movq %r10, %r12
movq %r8, %rbx
callq 0x94c8
movq %rax, 0x40(%rsp)
movl %r15d, %edi
movl $0x4, %esi
leaq 0x7118(%rip), %rdx # 0x27c20
movl $0x113, %ecx # imm = 0x113
callq 0x94c8
movq %rax, 0x98(%rsp)
movq (%rbx), %rax
movq (%rax), %rdi
imulq %rbp, %r12
imulq %r13, %r12
shlq $0x2, %r12
movq $0x0, 0x28(%rsp)
xorl %esi, %esi
movq %r12, %rdx
callq 0x21b0
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x21b0
movl 0x168(%rsp), %eax
testl %eax, %eax
je 0x20cd3
movq 0x90(%rsp), %rcx
shlq $0x5, %rcx
addq 0x148(%rsp), %rcx
movq %rcx, 0xa0(%rsp)
movl %eax, %eax
movq %rax, 0x18(%rsp)
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0x160(%rsp), %rax
movl (%rax,%rbx,4), %r12d
movq 0x138(%rsp), %rax
movq (%rax,%r12,8), %rsi
movq 0xa0(%rsp), %rdi
movl 0x140(%rsp), %edx
callq 0x1fbe6
testl %eax, %eax
je 0x20c3f
cmpl $0x0, 0x10(%rsp)
movl 0x128(%rsp), %r8d
movl 0x120(%rsp), %r9d
movq 0x8(%rsp), %r10
movq 0x20(%rsp), %r11
je 0x20c2b
xorl %eax, %eax
testl %r9d, %r9d
je 0x20c23
xorl %ecx, %ecx
testl %r8d, %r8d
je 0x20c1b
movq (%r14,%r12,8), %rdx
movq (%rdx,%rax,8), %rdx
movq (%rdx,%rcx,8), %rdx
movq (%r11,%rax,8), %rsi
movq (%rsi,%rcx,8), %rsi
xorl %edi, %edi
movss (%rdx,%rdi,4), %xmm0
addss (%rsi,%rdi,4), %xmm0
movss %xmm0, (%rsi,%rdi,4)
incq %rdi
cmpq %rdi, %r13
jne 0x20c04
incq %rcx
cmpq %rbp, %rcx
jne 0x20be9
incq %rax
cmpq %r10, %rax
jne 0x20be2
movl %r15d, %eax
movq 0x40(%rsp), %rcx
movl %r12d, (%rcx,%rax,4)
incl %r15d
jmp 0x20cc5
cmpl $0x0, 0x10(%rsp)
movl 0x128(%rsp), %r8d
movl 0x120(%rsp), %r9d
movq 0x8(%rsp), %r10
movq 0x38(%rsp), %r11
je 0x20cab
xorl %eax, %eax
testl %r9d, %r9d
je 0x20ca3
xorl %ecx, %ecx
testl %r8d, %r8d
je 0x20c9b
movq (%r14,%r12,8), %rdx
movq (%rdx,%rax,8), %rdx
movq (%rdx,%rcx,8), %rdx
movq (%r11,%rax,8), %rsi
movq (%rsi,%rcx,8), %rsi
xorl %edi, %edi
movss (%rdx,%rdi,4), %xmm0
addss (%rsi,%rdi,4), %xmm0
movss %xmm0, (%rsi,%rdi,4)
incq %rdi
cmpq %rdi, %r13
jne 0x20c84
incq %rcx
cmpq %rbp, %rcx
jne 0x20c69
incq %rax
cmpq %r10, %rax
jne 0x20c62
movq 0x28(%rsp), %rdx
movl %edx, %eax
movq 0x98(%rsp), %rcx
movl %r12d, (%rcx,%rax,4)
incl %edx
movq %rdx, 0x28(%rsp)
incq %rbx
cmpq 0x18(%rsp), %rbx
jne 0x20b8b
movq 0x20(%rsp), %rdi
callq 0x9709
movq 0x40(%rsp), %rdi
callq 0x9614
movq 0x38(%rsp), %rdi
callq 0x9709
movq 0x98(%rsp), %rdi
callq 0x9614
cmpl $0x0, 0x14(%rsp)
jne 0x20d2d
movq 0x60(%rsp), %rdi
callq 0x9709
movq 0x58(%rsp), %rdi
callq 0x9709
movq 0x50(%rsp), %rdi
callq 0x9709
movq 0x48(%rsp), %rdi
callq 0x9709
movq 0x90(%rsp), %rcx
shlq $0x5, %rcx
movq 0x148(%rsp), %rax
addq %rcx, %rax
movq %rax, %rcx
movsd 0x80(%rsp), %xmm0
movq 0x178(%rsp), %rdi
movq %rcx, (%rdi)
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6eac(%rip), %rsi # 0x27c20
leaq 0x266b(%rip), %rcx # 0x233e6
movl $0x67, %edx
movl $0x5, %edi
movq %r13, %r8
xorl %eax, %eax
callq 0xd380
movl $0x1, %edi
callq 0x23f0
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/best_q.c |
heapify32b | void
heapify32b(float32 *a, uint32 *k,
uint32 i,
uint32 sz,
hcmpfn32b_t cmp)
{
uint32 l, r, b, t_k;
float32 t_a;
l = LEFT(i);
r = RIGHT(i);
/* Determine the "best" node of i, l or r */
if ((l < sz) && cmp(a[l], a[i]))
b = l;
else
b = i;
if ((r < sz) && cmp(a[r], a[b]))
b = r;
/* If node i is not the first in the ordering,
* then switch i with the left or right child that is first and
* heapify the the tree rooted at the new node i position
*/
if (b != i) {
/* exchange the values... */
t_a = a[i];
a[i] = a[b];
a[b] = t_a;
/* ... and the keys */
t_k = k[i];
k[i] = k[b];
k[b] = t_k;
heapify32b(a, k, b, sz, cmp);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, 0xc(%rsp)
leal 0x1(,%r12,2), %r13d
movl %r12d, %ebx
cmpl %ecx, %r13d
jae 0x21d65
movl %r13d, %eax
movss (%r15,%rax,4), %xmm0
movss (%r15,%rbx,4), %xmm1
callq *0x10(%rsp)
movl 0xc(%rsp), %ecx
testl %eax, %eax
jne 0x21d68
movl %r12d, %r13d
leal 0x2(,%r12,2), %ebp
cmpl %ecx, %ebp
jae 0x21d94
movl %ebp, %eax
movss (%r15,%rax,4), %xmm0
movl %r13d, %eax
movss (%r15,%rax,4), %xmm1
callq *0x10(%rsp)
testl %eax, %eax
je 0x21d90
movl %ebp, %r13d
movl 0xc(%rsp), %ecx
cmpl %r12d, %r13d
je 0x21dcc
movss (%r15,%rbx,4), %xmm0
movl %r13d, %eax
movss (%r15,%rax,4), %xmm1
movss %xmm1, (%r15,%rbx,4)
movss %xmm0, (%r15,%rax,4)
movl (%r14,%rbx,4), %esi
movl (%r14,%rax,4), %edx
movl %edx, (%r14,%rbx,4)
movl %esi, (%r14,%rax,4)
movl %r13d, %r12d
jmp 0x21d3a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/heap.c |
heap32b_extr_top | uint32
heap32b_extr_top(float32 *out_a,
uint32 *out_k,
float32 *a, uint32 *k, uint32 sz,
hcmpfn32b_t cmp)
{
if (sz < 1) {
E_ERROR("Heap underflow\n");
return NO_KEY;
}
*out_a = a[0];
*out_k = k[0];
a[0] = a[sz-1];
k[0] = k[sz-1];
sz--;
heapify32b(a, k, 0, sz, cmp);
return sz;
} | pushq %rbx
testl %r8d, %r8d
je 0x21ef9
movl %r8d, %ebx
movss (%rdx), %xmm0
movss %xmm0, (%rdi)
movl (%rcx), %eax
movl %eax, (%rsi)
decl %ebx
movss (%rdx,%rbx,4), %xmm0
movss %xmm0, (%rdx)
movl (%rcx,%rbx,4), %eax
movl %eax, (%rcx)
movq %rdx, %rdi
movq %rcx, %rsi
xorl %edx, %edx
movl %ebx, %ecx
movq %r9, %r8
callq 0x21d1a
jmp 0x21f1d
leaq 0x5d86(%rip), %rsi # 0x27c86
leaq 0x5de3(%rip), %rcx # 0x27cea
movl $0x99, %edx
movl $0x4, %edi
xorl %eax, %eax
callq 0xd380
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/heap.c |
heap64b_ins | uint32
heap64b_ins(float64 *a, uint32 *k, uint32 sz,
float64 a_v, uint32 k_v,
hcmpfn64b_t cmp)
{
uint32 i, p;
++sz;
i = sz-1;
p = PARENT(i);
/* if the parent does not satisfy the ordering,
* then switch with i */
while ((i > 0) && !cmp(a[p], a_v)) {
a[i] = a[p];
k[i] = k[p];
i = p;
p = PARENT(p);
}
a[i] = a_v;
k[i] = k_v;
return sz;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r13d
movl %edx, 0x8(%rsp)
testl %edx, %edx
je 0x220af
movq %r8, %r12
movl 0x8(%rsp), %eax
movl %eax, %ebx
leal -0x1(%rbx), %ebp
movl %ebp, %r13d
shrl %r13d
movsd (%r15,%r13,8), %xmm0
movsd 0x10(%rsp), %xmm1
callq *%r12
testl %eax, %eax
jne 0x220ac
movsd (%r15,%r13,8), %xmm0
movl %ebx, %eax
movsd %xmm0, (%r15,%rax,8)
movl (%r14,%r13,4), %ecx
movl %ecx, (%r14,%rax,4)
movl %r13d, %ebx
cmpl $0x1, %ebp
ja 0x22070
jmp 0x220af
movl %ebx, %r13d
movl 0x8(%rsp), %eax
incl %eax
movl %r13d, %edx
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%r15,%rdx,8)
movl 0xc(%rsp), %ecx
movl %ecx, (%r14,%rdx,4)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/heap.c |
itree_new | itree_t *
itree_new(uint32 n_cell_hint)
{
itree_t *new;
uint32 i;
new = ckd_calloc(1, sizeof(itree_t));
new->cell = ckd_calloc(n_cell_hint, sizeof(cell_t));
for (i = 0; i < n_cell_hint; i++) {
new->cell[i].id = NO_ID;
new->cell[i].sib = NULL_INDEX;
new->cell[i].child = NULL_INDEX;
}
new->max_n_cell = n_cell_hint;
return new;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x5bad(%rip), %r12 # 0x27cfa
movl $0x1, %edi
movl $0x10, %esi
movq %r12, %rdx
movl $0x3f, %ecx
callq 0x94c8
movq %rax, %r14
movl %ebx, %r15d
movl $0xc, %esi
movq %r15, %rdi
movq %r12, %rdx
movl $0x40, %ecx
callq 0x94c8
movq %rax, (%r14)
testl %ebx, %ebx
je 0x2219b
shlq $0x2, %r15
leaq (%r15,%r15,2), %rdx
movq %rax, %rdi
movl $0xff, %esi
callq 0x21b0
movl %ebx, 0xc(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/itree.c |
itree_add_sib | cell_index_t itree_add_sib(itree_t *t,
cell_index_t end,
cell_id_t id)
{
cell_index_t new;
cell_t *cell;
if (t->n_cell == t->max_n_cell) {
E_FATAL("index cells exhausted (exceeded the allocated size %d)\n",t->max_n_cell);
}
new = itree_new_cell(t);
cell = t->cell;
if (new != 0)
/* this is not the first cell, so link it w/ prior */
cell[end].sib = new;
cell[new].id = id;
cell[new].child = NULL_INDEX;
cell[new].sib = NULL_INDEX;
return new;
} | pushq %rax
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %r8d
cmpl %r8d, %eax
je 0x2226b
jae 0x22294
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
movq (%rdi), %rcx
testl %eax, %eax
je 0x22259
movl %esi, %esi
leaq (%rsi,%rsi,2), %rsi
movl %eax, 0x8(%rcx,%rsi,4)
leaq (%rax,%rax,2), %rsi
movl %edx, (%rcx,%rsi,4)
movq $-0x1, 0x4(%rcx,%rsi,4)
popq %rcx
retq
leaq 0x5a88(%rip), %rsi # 0x27cfa
leaq 0x5b27(%rip), %rcx # 0x27da0
movl $0x77, %edx
movl $0x5, %edi
xorl %eax, %eax
callq 0xd380
movl $0x1, %edi
callq 0x23f0
leaq 0x5ac4(%rip), %rdi # 0x27d5f
leaq 0x5a58(%rip), %rsi # 0x27cfa
leaq 0x5ad0(%rip), %rcx # 0x27d79
movl $0x4d, %edx
callq 0x2190
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/itree.c |
itree_find_tri | cell_index_t itree_find(itree_t *t,
cell_index_t *end,
cell_index_t start,
cell_id_t id)
{
cell_t *cell;
cell_index_t i, l = NO_ID, o;
cell = t->cell;
if (cell[start].id != NO_ID) {
for (i = start; (i != NO_ID) && (cell[i].id != id); i = cell[i].sib)
l = i;
if (i != NO_ID)
o = i;
else
o = NULL_INDEX;
}
else {
o = NULL_INDEX;
l = start;
}
*end = l;
return o;
} | movq (%rdi), %rdi
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $-0x1, (%rdi)
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
je 0x223a8
xorl %r8d, %r8d
movl %r8d, %r9d
leaq (%r9,%r9,2), %r9
cmpl %esi, (%rdi,%r9,4)
je 0x223a8
leaq (%rdi,%r9,4), %r8
movl 0x8(%r8), %r8d
cmpl $-0x1, %r8d
jne 0x2238d
cmpl $-0x1, %r8d
je 0x22444
movl %r8d, %eax
leaq (%rax,%rax,2), %rax
movl 0x4(%rdi,%rax,4), %r8d
leaq (%r8,%r8,2), %rsi
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $-0x1, (%rdi,%rsi,4)
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
je 0x223f4
movl %r8d, %esi
cmpl $-0x1, %r8d
je 0x223f4
movl %esi, %r8d
leaq (%r8,%r8,2), %r8
cmpl %edx, (%rdi,%r8,4)
je 0x223f4
leaq (%rdi,%r8,4), %rsi
movl 0x8(%rsi), %esi
cmpl $-0x1, %esi
jne 0x223db
cmpl $-0x1, %esi
je 0x22444
movl %esi, %eax
leaq (%rax,%rax,2), %rax
movl 0x4(%rdi,%rax,4), %esi
leaq (%rsi,%rsi,2), %rdx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $-0x1, (%rdi,%rdx,4)
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
je 0x22435
movl %esi, %edx
cmpl $-0x1, %esi
je 0x22435
movl %edx, %esi
leaq (%rsi,%rsi,2), %rsi
cmpl %ecx, (%rdi,%rsi,4)
je 0x22435
leaq (%rdi,%rsi,4), %rdx
movl 0x8(%rdx), %edx
cmpl $-0x1, %edx
jne 0x2241e
cmpl $-0x1, %edx
je 0x22444
movl %edx, %eax
leaq (%rax,%rax,2), %rax
movl 0x4(%rdi,%rax,4), %eax
retq
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/itree.c |
itree_enum | cell_id_t
itree_enum()
{
cell_index_t nxt;
nxt = base->cell[posn].sib; /* get next posn (given left and right) */
if (nxt != NULL_INDEX) {
/* exists, so set the posn leaf node to the next one */
posn = nxt;
}
else {
/* no next posn (given left and right) */
/* therefore get the next right context if any */
nxt = base->cell[right].sib;
if (nxt != NULL_INDEX) {
/* found a next right context, so save it */
right = nxt;
/* set the posn to the first position given the new right */
posn = base->cell[right].child;
}
else {
/* no next right context exists */
/* therefore get a new left context if any */
nxt = base->cell[left].sib;
if (nxt != NULL_INDEX) {
/* a next left context exists so save it */
left = nxt;
/* get the first right context given the left */
right = base->cell[left].child;
/* get the first posn given the left and right */
posn = base->cell[right].child;
}
else {
return NULL_INDEX; /* no more left contexts, so the
whole tree for this base phone
has been enumerated */
}
}
}
/* if we arrive here, posn will reference the cell with the
next triphone id */
return base->cell[posn].child;
} | movq 0x10b15(%rip), %rax # 0x33128
movq (%rax), %rax
movl 0xdfd0(%rip), %ecx # 0x305ec
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0x22672
movl 0xdfb9(%rip), %ecx # 0x305e8
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
jne 0x22662
movl 0xdfa2(%rip), %ecx # 0x305e4
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rax,%rcx,4), %ecx
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
je 0x22683
movl %ecx, 0xdf8a(%rip) # 0x305e4
leaq (%rcx,%rcx,2), %rcx
movl 0x4(%rax,%rcx,4), %ecx
movl %ecx, 0xdf80(%rip) # 0x305e8
movl %ecx, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x4(%rax,%rcx,4), %ecx
movl %ecx, 0xdf74(%rip) # 0x305ec
movl %ecx, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x4(%rax,%rcx,4), %eax
retq
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
nopl (%rax)
| /cmusphinx[P]sphinxtrain/src/libs/libcommon/itree.c |
HttpTestListener::HttpTestListener(int) | HttpTestListener::HttpTestListener(int port) {
response_status_code_ = 200;
is_request_complete_ = false;
is_last_value_ = false;
this->local_port_ = port;
this->parser_ = (http_parser*)calloc(1, sizeof(http_parser));
} | pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %rcx
movq %rcx, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0x90(%rdi), %rcx
movq %rcx, 0x80(%rdi)
movq %rax, 0x88(%rdi)
movb %al, 0x90(%rdi)
leaq 0xa8(%rdi), %rcx
movl %eax, 0xa8(%rdi)
movq %rax, 0xb0(%rdi)
movq %rcx, 0xb8(%rdi)
movq %rcx, 0xc0(%rdi)
movq %rax, 0xc8(%rdi)
leaq 0xd8(%rdi), %rcx
movl %eax, 0xd8(%rdi)
movq %rax, 0xe0(%rdi)
movq %rcx, 0xe8(%rdi)
movq %rcx, 0xf0(%rdi)
movq %rax, 0xf8(%rdi)
leaq 0x108(%rdi), %rcx
movl %eax, 0x108(%rdi)
movq %rax, 0x110(%rdi)
movq %rcx, 0x118(%rdi)
movq %rcx, 0x120(%rdi)
movq %rax, 0x128(%rdi)
leaq 0x140(%rdi), %rcx
movq %rcx, 0x130(%rdi)
movq %rax, 0x138(%rdi)
movb %al, 0x140(%rdi)
leaq 0x160(%rdi), %rcx
movq %rcx, 0x150(%rdi)
movq %rax, 0x158(%rdi)
movb %al, 0x160(%rdi)
movl $0xc8, 0x18(%rdi)
movb %al, (%rdi)
movb %al, 0x170(%rdi)
movl %esi, 0x14(%rdi)
movl $0x1, %edi
movl $0x20, %esi
callq 0x4130
movq %rax, 0x178(%rbx)
popq %rbx
retq
nop
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/http_test_listener.cc |
arangodb::velocypack::Builder::reportAdd() | void Builder::reportAdd() {
VELOCYPACK_ASSERT(!_stack.empty());
if (_indexes.capacity() == 0) {
// make an initial reservation for several items at
// a time, in order to save frequent reallocations for
// the first few attributes
_indexes.reserve(8);
}
_indexes.push_back(_pos - _stack.back().startPos);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x90, %rdi
callq 0x10be0
cmpq $0x0, %rax
jne 0xb0eb
movq 0x10(%rsp), %rdi
addq $0x90, %rdi
movl $0x8, %esi
callq 0x10c00
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x90, %rax
movq %rax, (%rsp)
movq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x70, %rdi
callq 0x44d0
movq (%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq (%rcx), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x10d10
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/src/Builder.cpp |
arangodb::velocypack::Builder::add(arangodb::velocypack::ArrayIterator&&) | uint8_t* Builder::add(ArrayIterator&& sub) {
if (VELOCYPACK_UNLIKELY(_stack.empty())) {
throw Exception(Exception::BuilderNeedOpenArray);
}
ValueLength const pos = _stack.back().startPos;
if (VELOCYPACK_UNLIKELY(_start[pos] != 0x06 && _start[pos] != 0x13)) {
throw Exception(Exception::BuilderNeedOpenArray);
}
auto const oldPos = _pos;
while (sub.valid()) {
add(*sub);
sub.next();
}
return _start + oldPos;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x70, %rdi
callq 0x4000
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb6db
jmp 0xb70f
movl $0x18, %edi
callq 0x30b0
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
movl $0x20, %esi
callq 0x4510
movq 0x10(%rsp), %rdi
leaq 0x3042d(%rip), %rsi # 0x3bb30
leaq -0x71ba(%rip), %rdx # 0x4550
callq 0x3260
movq 0x18(%rsp), %rdi
addq $0x70, %rdi
callq 0x44d0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x30(%rsp)
movq 0x18(%rax), %rax
movq 0x30(%rsp), %rcx
movzbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x6, %ecx
movb %al, 0xf(%rsp)
je 0xb761
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x13, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb76f
jmp 0xb7a1
movl $0x18, %edi
callq 0x30b0
movq %rax, %rdi
movq %rdi, (%rsp)
movl $0x20, %esi
callq 0x4510
movq (%rsp), %rdi
leaq 0x3039b(%rip), %rsi # 0x3bb30
leaq -0x724c(%rip), %rdx # 0x4550
callq 0x3260
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x111e0
testb $0x1, %al
jne 0xb7bf
jmp 0xb7e9
movq 0x38(%rsp), %rdi
callq 0x11200
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xf6b0
movq 0x38(%rsp), %rdi
callq 0x11230
jmp 0xb7af
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
addq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
| /arangodb[P]velocypack/src/Builder.cpp |
arangodb::velocypack::ObjectIterator::key(bool) const | [[nodiscard]] Slice key(bool translate = true) const {
if (VELOCYPACK_UNLIKELY(!valid())) {
throw Exception{Exception::IndexOutOfBounds};
}
if (_current != nullptr) {
Slice s{_current};
return translate ? s.makeKey() : s;
}
return _slice.getNthKey(_position, translate);
} | subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x110c0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x10f4d
jmp 0x10f81
movl $0x18, %edi
callq 0x30b0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
movl $0xd, %esi
callq 0x4510
movq 0x8(%rsp), %rdi
leaq 0x2abbb(%rip), %rsi # 0x3bb30
leaq -0xca2c(%rip), %rdx # 0x4550
callq 0x3260
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x10fc4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x18(%rsp), %rdi
callq 0x4620
testb $0x1, 0x27(%rsp)
je 0x10fb8
leaq 0x18(%rsp), %rdi
callq 0x211e0
movq %rax, 0x30(%rsp)
jmp 0x10fc2
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x10fe0
movq 0x10(%rsp), %rdi
movq 0x18(%rdi), %rsi
movb 0x27(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x1dee0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::ObjectIterator::operator*() const | [[nodiscard]] ObjectPair operator*() const {
if (_current != nullptr) {
Slice key{_current};
return {key.makeKey(), Slice(_current + key.byteSize())};
}
// intentionally no out-of-bounds checking here,
// as it will be performed by Slice::getNthOffset()
Slice key{_slice.getNthKeyUntranslated(_position)};
return {key.makeKey(), Slice(key.begin() + key.byteSize())};
} | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x11169
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x38(%rsp), %rdi
callq 0x4620
leaq 0x38(%rsp), %rdi
callq 0x211e0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x48(%rsp)
leaq 0x48(%rsp), %rcx
addq $0x8, %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1cb30
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
addq %rax, %rsi
callq 0x4620
jmp 0x111c4
movq 0x28(%rsp), %rdi
movq 0x18(%rdi), %rsi
callq 0x1e040
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x211e0
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1cad0
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1cb30
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq %rax, %rsi
callq 0x4620
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::Dumper::appendDouble(double) | void Dumper::appendDouble(double v) {
char temp[24];
double a = fabs(v);
if (a >= ldexpl(1.0, 53) && a < ldexpl(1.0, 64)) {
// This is a special case which we want to handle separately, because
// of two reasons:
// (1) The function fpconv_dtoa below only guarantees to write a
// decimal representation which gives the same double value when
// parsed back into a double. It can write a wrong integer.
// Therefore we want to use the integer code in this case.
// (2) The function fpconv_dtoa will write a normal integer
// representation in this case without a decimal point. If we
// parse this back to vpack later, we end up in a different
// representation (uint64_t or int64_t), so we want to append
// ".0" to the string in this case.
// Note that this automatically excludes all infinities and NaNs,
// which will be handled in the function fpconv_dtoa below.
uint64_t u;
if (v < 0) {
u = static_cast<uint64_t>(-v);
_sink->append("-", 1);
} else {
u = static_cast<uint64_t>(v);
}
appendUInt(u);
_sink->append(".0", 2);
return;
}
int len = fpconv_dtoa(v, &temp[0]);
_sink->append(&temp[0], static_cast<ValueLength>(len));
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movaps 0x122d0(%rip), %xmm1 # 0x2c780
movsd 0x68(%rsp), %xmm0
pand %xmm1, %xmm0
movlpd %xmm0, 0x48(%rsp)
fldl 0x48(%rsp)
fstpt 0x30(%rsp)
movq %rsp, %rax
fld1
fstpt (%rax)
movl $0x35, %edi
callq 0x31b0
fldt 0x30(%rsp)
fucompi %st(1), %st
fstp %st(0)
jb 0x1a5d9
jmp 0x1a4e9
fldl 0x48(%rsp)
fstpt 0x1c(%rsp)
movq %rsp, %rax
fld1
fstpt (%rax)
movl $0x40, %edi
callq 0x31b0
fldt 0x1c(%rsp)
fld %st(1)
fstp %st(0)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0x1a5d9
jmp 0x1a518
xorps %xmm0, %xmm0
ucomisd 0x68(%rsp), %xmm0
jbe 0x1a57c
movq 0x28(%rsp), %rax
movaps 0x12261(%rip), %xmm0 # 0x2c790
movsd 0x68(%rsp), %xmm1
pxor %xmm0, %xmm1
movaps %xmm1, %xmm0
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0x11ac0(%rip), %xmm1 # 0x2c010
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, 0x40(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
leaq 0x1225c(%rip), %rsi # 0x2c7ce
movl $0x1, %edx
callq *0x18(%rax)
jmp 0x1a5ad
movsd 0x68(%rsp), %xmm0
movsd 0x11a86(%rip), %xmm2 # 0x2c010
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x19f70
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
leaq 0x12201(%rip), %rsi # 0x2c7d0
movl $0x2, %edx
callq *0x18(%rax)
jmp 0x1a608
movsd 0x68(%rsp), %xmm0
leaq 0x50(%rsp), %rdi
callq 0x249e0
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x3c(%rsp)
movq 0x8(%rax), %rdi
leaq 0x50(%rsp), %rsi
movslq 0x3c(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x78, %rsp
retq
nopl (%rax)
| /arangodb[P]velocypack/src/Dumper.cpp |
arangodb::velocypack::Dumper::dumpInteger(arangodb::velocypack::Slice) | void Dumper::dumpInteger(Slice slice) {
VELOCYPACK_ASSERT(slice.isInteger());
if (slice.isType(ValueType::UInt)) {
uint64_t v = slice.getUIntUnchecked();
appendUInt(v);
} else if (slice.isType(ValueType::Int)) {
int64_t v = slice.getIntUnchecked();
appendInt(v);
} else if (slice.isType(ValueType::SmallInt)) {
int64_t v = slice.getSmallIntUnchecked();
if (v < 0) {
_sink->push_back('-');
v = -v;
}
_sink->push_back('0' + static_cast<char>(v));
}
} | subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movl $0xc, %esi
callq 0x1d420
testb $0x1, %al
jne 0x1a7dd
jmp 0x1a800
leaq 0x30(%rsp), %rdi
callq 0x1fcc0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x19f70
jmp 0x1a8a4
leaq 0x30(%rsp), %rdi
movl $0xb, %esi
callq 0x1d420
testb $0x1, %al
jne 0x1a815
jmp 0x1a835
leaq 0x30(%rsp), %rdi
callq 0x21b30
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x19a40
jmp 0x1a8a2
leaq 0x30(%rsp), %rdi
movl $0xd, %esi
callq 0x1d420
testb $0x1, %al
jne 0x1a84a
jmp 0x1a8a0
leaq 0x30(%rsp), %rdi
callq 0x1fd50
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jge 0x1a881
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movl $0x2d, %esi
callq *0x10(%rax)
xorl %eax, %eax
subq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq (%rdi), %rax
movsbl %cl, %esi
callq *0x10(%rax)
jmp 0x1a8a2
jmp 0x1a8a4
addq $0x38, %rsp
retq
nopl (%rax)
| /arangodb[P]velocypack/src/Dumper.cpp |
arangodb::velocypack::ArrayIterator::first() const | [[nodiscard]] uint8_t const* first() const noexcept {
if (VELOCYPACK_UNLIKELY(_size == 0)) {
return nullptr;
}
auto const head = _slice.head();
VELOCYPACK_ASSERT(head != 0x01); // no empty array allowed here
if (head == 0x13) {
return _slice.start() + _slice.getStartOffsetFromCompact();
}
return _slice.begin() + _slice.findDataOffset(head);
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x10(%rax)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1acd5
jmp 0x1ace0
movq $0x0, 0x30(%rsp)
jmp 0x1ad58
movq 0x18(%rsp), %rdi
callq 0x1cab0
movb %al, 0x27(%rsp)
movzbl 0x27(%rsp), %eax
cmpl $0x13, %eax
jne 0x1ad2c
movq 0x18(%rsp), %rdi
callq 0x1caa0
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x22150
movq %rax, 0x10(%rsp)
jmp 0x1ad18
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x1ad58
movq 0x18(%rsp), %rdi
callq 0x1cae0
movq 0x18(%rsp), %rdi
movq %rax, (%rsp)
movzbl 0x27(%rsp), %esi
callq 0x1dd70
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x3ee0
nopw (%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::HexDump::appendHex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned char) | void HexDump::appendHex(std::string& result, uint8_t value) {
uint8_t x = value / 16;
result.push_back((x < 10 ? ('0' + x) : ('a' + x - 10)));
x = value % 16;
result.push_back((x < 10 ? ('0' + x) : ('a' + x - 10)));
} | subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movzbl 0x2f(%rsp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movb %al, 0x2e(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movzbl 0x2e(%rsp), %eax
cmpl $0xa, %eax
jge 0x1b543
movzbl 0x2e(%rsp), %eax
addl $0x30, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1b552
movzbl 0x2e(%rsp), %eax
addl $0x61, %eax
subl $0xa, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movsbl %al, %esi
callq 0x17800
movzbl 0x2f(%rsp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, 0x2e(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movzbl 0x2e(%rsp), %eax
cmpl $0xa, %eax
jge 0x1b598
movzbl 0x2e(%rsp), %eax
addl $0x30, %eax
movl %eax, 0xc(%rsp)
jmp 0x1b5a7
movzbl 0x2e(%rsp), %eax
addl $0x61, %eax
subl $0xa, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movsbl %al, %esi
callq 0x17800
addq $0x38, %rsp
retq
nopl (%rax)
| /arangodb[P]velocypack/src/HexDump.cpp |
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 1ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length) {
return *start;
}
if constexpr (length > 1 &&
length < 5) { // starting with 5 bytes memcpy shows better
// results than shifts. But
return readIntFixedHelper<T, length>(
start); // for big-endian we leave shifts as this saves some cpu cyles
// on byteswapping
}
if constexpr (length >= 5 && length < 8) {
if constexpr (std::endian::native != std::endian::little) {
return readIntFixedHelper<T, length>(start);
} else {
T v{};
memcpy(&v, start, length);
return v;
}
}
if constexpr (length == 8) {
T v;
memcpy(&v, start, 8);
if constexpr (std::endian::native != std::endian::little) {
v = littleToHost(v);
}
return v;
}
return 0;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
retq
nop
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
wyhash(void const*, unsigned long, unsigned long, unsigned long const*) | static inline uint64_t wyhash(const void* key, size_t len, uint64_t seed,
const uint64_t* secret) {
const uint8_t* p = (const uint8_t*)key;
seed ^= *secret;
uint64_t a, b;
if (_likely_(len <= 16)) {
if (_likely_(len >= 4)) {
a = (_wyr4(p) << 32) | _wyr4(p + ((len >> 3) << 2));
b = (_wyr4(p + len - 4) << 32) | _wyr4(p + len - 4 - ((len >> 3) << 2));
} else if (_likely_(len > 0)) {
a = _wyr3(p, len);
b = 0;
} else
a = b = 0;
} else {
size_t i = len;
if (_unlikely_(i > 48)) {
uint64_t see1 = seed, see2 = seed;
do {
seed = _wymix(_wyr8(p) ^ secret[1], _wyr8(p + 8) ^ seed);
see1 = _wymix(_wyr8(p + 16) ^ secret[2], _wyr8(p + 24) ^ see1);
see2 = _wymix(_wyr8(p + 32) ^ secret[3], _wyr8(p + 40) ^ see2);
p += 48;
i -= 48;
} while (_likely_(i > 48));
seed ^= see1 ^ see2;
}
while (_unlikely_(i > 16)) {
seed = _wymix(_wyr8(p) ^ secret[1], _wyr8(p + 8) ^ seed);
i -= 16;
p += 16;
}
a = _wyr8(p + i - 16);
b = _wyr8(p + i - 8);
}
return _wymix(secret[1] ^ len, _wymix(a ^ secret[1], b ^ seed));
} | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rax
xorq 0x70(%rsp), %rax
movq %rax, 0x70(%rsp)
cmpq $0x10, 0x78(%rsp)
ja 0x1bc68
cmpq $0x4, 0x78(%rsp)
jb 0x1bc28
movq 0x60(%rsp), %rdi
callq 0x1c240
shlq $0x20, %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rdi
movq 0x78(%rsp), %rax
shrq $0x3, %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x1c240
movq %rax, %rcx
movq 0x28(%rsp), %rax
orq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
addq 0x78(%rsp), %rdi
addq $-0x4, %rdi
callq 0x1c240
shlq $0x20, %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rdi
addq 0x78(%rsp), %rdi
addq $-0x4, %rdi
movq 0x78(%rsp), %rcx
shrq $0x3, %rcx
shlq $0x2, %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
callq 0x1c240
movq %rax, %rcx
movq 0x30(%rsp), %rax
orq %rcx, %rax
movq %rax, 0x50(%rsp)
jmp 0x1bc63
cmpq $0x0, 0x78(%rsp)
jbe 0x1bc4f
movq 0x60(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x1c260
movq %rax, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
jmp 0x1bc61
movq $0x0, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
jmp 0x1bc63
jmp 0x1be22
movq 0x78(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpq $0x30, 0x48(%rsp)
jbe 0x1bd8d
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rdi
callq 0x1c2e0
movq 0x68(%rsp), %rcx
xorq 0x8(%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x1c2e0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
xorq 0x70(%rsp), %rsi
callq 0x1c2b0
movq %rax, 0x70(%rsp)
movq 0x60(%rsp), %rdi
addq $0x10, %rdi
callq 0x1c2e0
movq 0x68(%rsp), %rcx
xorq 0x10(%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rdi
addq $0x18, %rdi
callq 0x1c2e0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
xorq 0x40(%rsp), %rsi
callq 0x1c2b0
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x1c2e0
movq 0x68(%rsp), %rcx
xorq 0x18(%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
addq $0x28, %rdi
callq 0x1c2e0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
xorq 0x38(%rsp), %rsi
callq 0x1c2b0
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x60(%rsp)
movq 0x48(%rsp), %rax
subq $0x30, %rax
movq %rax, 0x48(%rsp)
cmpq $0x30, 0x48(%rsp)
ja 0x1bc92
movq 0x40(%rsp), %rax
xorq 0x38(%rsp), %rax
xorq 0x70(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x1bd8f
cmpq $0x10, 0x48(%rsp)
jbe 0x1bdf2
movq 0x60(%rsp), %rdi
callq 0x1c2e0
movq 0x68(%rsp), %rcx
xorq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x1c2e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
xorq 0x70(%rsp), %rsi
callq 0x1c2b0
movq %rax, 0x70(%rsp)
movq 0x48(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x60(%rsp)
jmp 0x1bd8f
movq 0x60(%rsp), %rdi
addq 0x48(%rsp), %rdi
addq $-0x10, %rdi
callq 0x1c2e0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
addq 0x48(%rsp), %rdi
addq $-0x8, %rdi
callq 0x1c2e0
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rax
xorq 0x78(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
movq 0x68(%rsp), %rax
xorq 0x8(%rax), %rdi
movq 0x50(%rsp), %rsi
xorq 0x70(%rsp), %rsi
callq 0x1c2b0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x1c2b0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-wyhash.h |
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 4ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length) {
return *start;
}
if constexpr (length > 1 &&
length < 5) { // starting with 5 bytes memcpy shows better
// results than shifts. But
return readIntFixedHelper<T, length>(
start); // for big-endian we leave shifts as this saves some cpu cyles
// on byteswapping
}
if constexpr (length >= 5 && length < 8) {
if constexpr (std::endian::native != std::endian::little) {
return readIntFixedHelper<T, length>(start);
} else {
T v{};
memcpy(&v, start, length);
return v;
}
}
if constexpr (length == 8) {
T v;
memcpy(&v, start, 8);
if constexpr (std::endian::native != std::endian::little) {
v = littleToHost(v);
}
return v;
}
return 0;
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x1c5b0
popq %rcx
retq
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 5ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length) {
return *start;
}
if constexpr (length > 1 &&
length < 5) { // starting with 5 bytes memcpy shows better
// results than shifts. But
return readIntFixedHelper<T, length>(
start); // for big-endian we leave shifts as this saves some cpu cyles
// on byteswapping
}
if constexpr (length >= 5 && length < 8) {
if constexpr (std::endian::native != std::endian::little) {
return readIntFixedHelper<T, length>(start);
} else {
T v{};
memcpy(&v, start, length);
return v;
}
}
if constexpr (length == 8) {
T v;
memcpy(&v, start, 8);
if constexpr (std::endian::native != std::endian::little) {
v = littleToHost(v);
}
return v;
}
return 0;
} | movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %ecx
movl %ecx, -0x10(%rsp)
movb 0x4(%rax), %al
movb %al, -0xc(%rsp)
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 7ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length) {
return *start;
}
if constexpr (length > 1 &&
length < 5) { // starting with 5 bytes memcpy shows better
// results than shifts. But
return readIntFixedHelper<T, length>(
start); // for big-endian we leave shifts as this saves some cpu cyles
// on byteswapping
}
if constexpr (length >= 5 && length < 8) {
if constexpr (std::endian::native != std::endian::little) {
return readIntFixedHelper<T, length>(start);
} else {
T v{};
memcpy(&v, start, length);
return v;
}
}
if constexpr (length == 8) {
T v;
memcpy(&v, start, 8);
if constexpr (std::endian::native != std::endian::little) {
v = littleToHost(v);
}
return v;
}
return 0;
} | movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %ecx
movl %ecx, -0x10(%rsp)
movw 0x4(%rax), %cx
movw %cx, -0xc(%rsp)
movb 0x6(%rax), %al
movb %al, -0xa(%rsp)
movq -0x10(%rsp), %rax
retq
nop
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 2u, 8u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
(static_cast<T>(*p) << Shift);
// for some reason MSVC detects possible operator precedence error here ~~^
// ^
}
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0x1c470
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 2u, 0u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
(static_cast<T>(*p) << Shift);
// for some reason MSVC detects possible operator precedence error here ~~^
// ^
}
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0x1c570
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shlq $0x0, %rcx
orq %rcx, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 0u, 16u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
(static_cast<T>(*p) << Shift);
// for some reason MSVC detects possible operator precedence error here ~~^
// ^
}
} | movq %rdi, -0x8(%rsp)
xorl %eax, %eax
retq
nopl (%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 3u, 8u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
(static_cast<T>(*p) << Shift);
// for some reason MSVC detects possible operator precedence error here ~~^
// ^
}
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0x1c610
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::getDouble() const | double getDouble() const {
if (!isDouble()) {
throw Exception(Exception::InvalidValueType, "Expecting type Double");
}
auto v = readIntegerFixed<uint64_t, 8>(start() + 1);
double r;
std::memcpy(&r, &v, sizeof(double));
return r;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1d540
testb $0x1, %al
jne 0x1d9c5
movl $0x18, %edi
callq 0x30b0
movq %rax, %rdi
movq %rdi, (%rsp)
movl $0x11, %esi
leaq 0xf51f(%rip), %rdx # 0x2cec8
callq 0x1af20
movq (%rsp), %rdi
leaq 0x1e177(%rip), %rsi # 0x3bb30
leaq -0x19470(%rip), %rdx # 0x4550
callq 0x3260
movq 0x8(%rsp), %rdi
callq 0x1caa0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1bb20
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::extractPointer() const | char const* extractPointer() const {
union Converter {
char const* value;
char binary[sizeof(char const*)];
} converter;
std::memcpy(&converter.binary[0], start() + 1, sizeof(char const*));
return converter.value;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1caa0
movq 0x1(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::copyBinary() const | std::vector<uint8_t> copyBinary() const {
if (!isBinary()) {
throw Exception(Exception::InvalidValueType, "Expecting type Binary");
}
uint8_t const h = head();
VELOCYPACK_ASSERT(h >= 0xc0 && h <= 0xc7);
std::vector<uint8_t> out;
ValueLength length =
readIntegerNonEmpty<ValueLength>(start() + 1, h - 0xbf);
checkOverflow(length);
out.reserve(static_cast<std::size_t>(length));
out.insert(out.end(), start() + 1 + h - 0xbf,
start() + 1 + h - 0xbf + length);
return out;
} | subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x1d660
testb $0x1, %al
jne 0x208bc
movl $0x18, %edi
callq 0x30b0
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
movl $0x11, %esi
leaq 0xc757(%rip), %rdx # 0x2cff6
callq 0x1af20
movq 0x18(%rsp), %rdi
leaq 0x1b280(%rip), %rsi # 0x3bb30
leaq -0x1c367(%rip), %rdx # 0x4550
callq 0x3260
movq 0x30(%rsp), %rdi
callq 0x1cab0
movq 0x20(%rsp), %rdi
movb %al, 0x6f(%rsp)
movb $0x0, 0x6e(%rsp)
callq 0x209f0
movq 0x30(%rsp), %rdi
callq 0x1caa0
movq %rax, %rdi
incq %rdi
movzbl 0x6f(%rsp), %eax
addl $0xffffff41, %eax # imm = 0xFFFFFF41
movslq %eax, %rsi
callq 0x1bf50
movq 0x20(%rsp), %rdi
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x60(%rsp), %rsi
callq 0x20a00
jmp 0x2091e
movq 0x20(%rsp), %rdi
callq 0x20bb0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x20be0
movq 0x30(%rsp), %rdi
callq 0x1caa0
movq 0x30(%rsp), %rdi
movzbl 0x6f(%rsp), %ecx
leaq -0xbe(%rax,%rcx), %rax
movq %rax, 0x8(%rsp)
callq 0x1caa0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
movzbl 0x6f(%rsp), %eax
addq %rax, %rcx
movq 0x60(%rsp), %rax
leaq -0xbe(%rax,%rcx), %rcx
movq 0x48(%rsp), %rsi
callq 0x20b00
movq %rax, 0x10(%rsp)
jmp 0x20995
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x1, 0x6e(%rsp)
testb $0x1, 0x6e(%rsp)
jne 0x209d1
jmp 0x209c7
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x20c20
jmp 0x209de
movq 0x20(%rsp), %rdi
callq 0x20c20
movq 0x28(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x3280
nopl (%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/SliceBase.h |
bool arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::binaryEquals<arangodb::velocypack::Slice, arangodb::velocypack::Slice>(arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice> const&) const | bool binaryEquals(SliceBase<S, T> const& other) const {
if (start() == other.start()) {
// same underlying data, so the slices must be identical
return true;
}
if (head() != other.head()) {
return false;
}
ValueLength const size = byteSize();
if (size != other.byteSize()) {
return false;
}
return (std::memcmp(start(), other.start(), checkOverflow(size)) == 0);
} | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1caa0
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1caa0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jne 0x215a3
movb $0x1, 0x4f(%rsp)
jmp 0x2164a
movq 0x20(%rsp), %rdi
callq 0x1cab0
movzbl %al, %eax
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1cab0
movb %al, %cl
movl 0x1c(%rsp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x215d2
movb $0x0, 0x4f(%rsp)
jmp 0x2164a
movq 0x20(%rsp), %rdi
callq 0x1cb30
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1cb30
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x21609
movb $0x0, 0x4f(%rsp)
jmp 0x2164a
movq 0x20(%rsp), %rdi
callq 0x1caa0
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1caa0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdx
callq 0x30a0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x4f(%rsp)
movb 0x4f(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /arangodb[P]velocypack/include/velocypack/SliceBase.h |
build_fp(double) | static Fp build_fp(double d) {
uint64_t bits = get_dbits(d);
Fp fp;
fp.frac = bits & fracmask;
fp.exp = (bits & expmask) >> 52;
if (fp.exp) {
fp.frac += hiddenbit;
fp.exp -= expbias;
} else {
fp.exp = -expbias + 1;
}
return fp;
} | subq $0x28, %rsp
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x24ad0
movq %rax, 0x8(%rsp)
movabsq $0xfffffffffffff, %rax # imm = 0xFFFFFFFFFFFFF
andq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
andq 0x8(%rsp), %rax
shrq $0x34, %rax
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x2516f
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x20(%rsp), %eax
subl $0x433, %eax # imm = 0x433
movl %eax, 0x20(%rsp)
jmp 0x25177
movl $0xfffffbce, 0x20(%rsp) # imm = 0xFFFFFBCE
movq 0x18(%rsp), %rax
movl 0x20(%rsp), %edx
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/src/fpconv.cpp |
normalize(Fp*) | static void normalize(Fp* fp) {
while ((fp->frac & hiddenbit) == 0) {
fp->frac <<= 1;
fp->exp--;
}
int shift = 64 - 52 - 1;
fp->frac <<= shift;
fp->exp -= shift;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
andq (%rcx), %rax
cmpq $0x0, %rax
jne 0x252fb
movq -0x8(%rsp), %rax
movq (%rax), %rcx
shlq %rcx
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x252c5
movl $0xb, -0xc(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movq (%rax), %rdx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, (%rax)
movl -0xc(%rsp), %edx
movq -0x8(%rsp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
retq
nopl (%rax)
| /arangodb[P]velocypack/src/fpconv.cpp |
XXH32_endian_align | XXH_FORCE_INLINE xxh_u32 XXH32_endian_align(const xxh_u8* input, size_t len,
xxh_u32 seed, XXH_alignment align) {
const xxh_u8* bEnd = input + len;
xxh_u32 h32;
#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && \
(XXH_ACCEPT_NULL_INPUT_POINTER >= 1)
if (input == NULL) {
len = 0;
bEnd = input = (const xxh_u8*)(size_t)16;
}
#endif
if (len >= 16) {
const xxh_u8* const limit = bEnd - 15;
xxh_u32 v1 = seed + XXH_PRIME32_1 + XXH_PRIME32_2;
xxh_u32 v2 = seed + XXH_PRIME32_2;
xxh_u32 v3 = seed + 0;
xxh_u32 v4 = seed - XXH_PRIME32_1;
do {
v1 = XXH32_round(v1, XXH_get32bits(input));
input += 4;
v2 = XXH32_round(v2, XXH_get32bits(input));
input += 4;
v3 = XXH32_round(v3, XXH_get32bits(input));
input += 4;
v4 = XXH32_round(v4, XXH_get32bits(input));
input += 4;
} while (input < limit);
h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) +
XXH_rotl32(v4, 18);
} else {
h32 = seed + XXH_PRIME32_5;
}
h32 += (xxh_u32)len;
return XXH32_finalize(h32, input, len & 15, align);
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movq 0x50(%rsp), %rax
addq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x10, 0x48(%rsp)
jb 0x25a59
movq 0x38(%rsp), %rax
addq $-0xf, %rax
movq %rax, 0x28(%rsp)
movl 0x44(%rsp), %eax
addl $0x9e3779b1, %eax # imm = 0x9E3779B1
addl $0x85ebca77, %eax # imm = 0x85EBCA77
movl %eax, 0x24(%rsp)
movl 0x44(%rsp), %eax
addl $0x85ebca77, %eax # imm = 0x85EBCA77
movl %eax, 0x20(%rsp)
movl 0x44(%rsp), %eax
addl $0x0, %eax
movl %eax, 0x1c(%rsp)
movl 0x44(%rsp), %eax
subl $0x9e3779b1, %eax # imm = 0x9E3779B1
movl %eax, 0x18(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movl 0x40(%rsp), %esi
callq 0x2a140
movl 0x8(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x50(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rdi
movl 0x40(%rsp), %esi
callq 0x2a140
movl 0xc(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, 0x20(%rsp)
movq 0x50(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x50(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movl 0x40(%rsp), %esi
callq 0x2a140
movl 0x10(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, 0x1c(%rsp)
movq 0x50(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x50(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x50(%rsp), %rdi
movl 0x40(%rsp), %esi
callq 0x2a140
movl 0x14(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, 0x18(%rsp)
movq 0x50(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x28(%rsp), %rax
jb 0x25956
movl 0x24(%rsp), %eax
roll %eax
movl 0x20(%rsp), %ecx
roll $0x7, %ecx
addl %ecx, %eax
movl 0x1c(%rsp), %ecx
roll $0xc, %ecx
addl %ecx, %eax
movl 0x18(%rsp), %ecx
roll $0x12, %ecx
addl %ecx, %eax
movl %eax, 0x34(%rsp)
jmp 0x25a66
movl 0x44(%rsp), %eax
addl $0x165667b1, %eax # imm = 0x165667B1
movl %eax, 0x34(%rsp)
movq 0x48(%rsp), %rax
addl 0x34(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %edi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
andq $0xf, %rdx
movl 0x40(%rsp), %ecx
callq 0x26070
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/src/xxhash.h |
VELOCYPACK_XXH32_update | XXH_PUBLIC_API XXH_errorcode XXH32_update(XXH32_state_t* state,
const void* input, size_t len) {
if (input == NULL)
#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && \
(XXH_ACCEPT_NULL_INPUT_POINTER >= 1)
return XXH_OK;
#else
return XXH_ERROR;
#endif
{
const xxh_u8* p = (const xxh_u8*)input;
const xxh_u8* const bEnd = p + len;
state->total_len_32 += (XXH32_hash_t)len;
state->large_len |=
(XXH32_hash_t)((len >= 16) | (state->total_len_32 >= 16));
if (state->memsize + len < 16) { /* fill in tmp buffer */
XXH_memcpy((xxh_u8*)(state->mem32) + state->memsize, input, len);
state->memsize += (XXH32_hash_t)len;
return XXH_OK;
}
if (state->memsize) { /* some data left from previous update */
XXH_memcpy((xxh_u8*)(state->mem32) + state->memsize, input,
16 - state->memsize);
{
const xxh_u32* p32 = state->mem32;
state->v1 = XXH32_round(state->v1, XXH_readLE32(p32));
p32++;
state->v2 = XXH32_round(state->v2, XXH_readLE32(p32));
p32++;
state->v3 = XXH32_round(state->v3, XXH_readLE32(p32));
p32++;
state->v4 = XXH32_round(state->v4, XXH_readLE32(p32));
}
p += 16 - state->memsize;
state->memsize = 0;
}
if (p <= bEnd - 16) {
const xxh_u8* const limit = bEnd - 16;
xxh_u32 v1 = state->v1;
xxh_u32 v2 = state->v2;
xxh_u32 v3 = state->v3;
xxh_u32 v4 = state->v4;
do {
v1 = XXH32_round(v1, XXH_readLE32(p));
p += 4;
v2 = XXH32_round(v2, XXH_readLE32(p));
p += 4;
v3 = XXH32_round(v3, XXH_readLE32(p));
p += 4;
v4 = XXH32_round(v4, XXH_readLE32(p));
p += 4;
} while (p <= limit);
state->v1 = v1;
state->v2 = v2;
state->v3 = v3;
state->v4 = v4;
}
if (p < bEnd) {
XXH_memcpy(state->mem32, p, (size_t)(bEnd - p));
state->memsize = (unsigned)(bEnd - p);
}
}
return XXH_OK;
} | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x25bb8
movl $0x1, 0x74(%rsp)
jmp 0x25f47
movq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movl %eax, %ecx
movq 0x68(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
cmpq $0x10, 0x58(%rsp)
setae %al
andb $0x1, %al
movzbl %al, %ecx
movq 0x68(%rsp), %rax
cmpl $0x10, (%rax)
setae %al
andb $0x1, %al
movzbl %al, %eax
orl %eax, %ecx
movq 0x68(%rsp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq 0x68(%rsp), %rax
movl 0x28(%rax), %eax
addq 0x58(%rsp), %rax
cmpq $0x10, %rax
jae 0x25c61
movq 0x68(%rsp), %rdi
addq $0x18, %rdi
movq 0x68(%rsp), %rax
movl 0x28(%rax), %eax
addq %rax, %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x25f50
movq 0x58(%rsp), %rax
movl %eax, %ecx
movq 0x68(%rsp), %rax
addl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movl $0x0, 0x74(%rsp)
jmp 0x25f47
movq 0x68(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0x25dab
movq 0x68(%rsp), %rdi
addq $0x18, %rdi
movq 0x68(%rsp), %rax
movl 0x28(%rax), %eax
addq %rax, %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rcx
movl $0x10, %eax
subl 0x28(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x25f50
movq 0x68(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x25fd0
movl 0x18(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x40(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x25fd0
movl 0x1c(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x40(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x25fd0
movl 0x20(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x40(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
callq 0x25fd0
movl 0x24(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x68(%rsp), %rax
movl $0x10, %ecx
subl 0x28(%rax), %ecx
movq 0x50(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movl $0x0, 0x28(%rax)
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
ja 0x25efc
movq 0x48(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x68(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x30(%rsp)
movq 0x68(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x68(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x28(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x25fd0
movl 0x8(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, 0x34(%rsp)
movq 0x50(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x50(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rdi
callq 0x25fd0
movl 0xc(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, 0x30(%rsp)
movq 0x50(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x50(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x25fd0
movl 0x10(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, 0x2c(%rsp)
movq 0x50(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x50(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x50(%rsp), %rdi
callq 0x25fd0
movl 0x14(%rsp), %edi
movl %eax, %esi
callq 0x25f90
movl %eax, 0x28(%rsp)
movq 0x50(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0x25e00
movl 0x34(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x30(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x2c(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x28(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x50(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x25f3f
movq 0x68(%rsp), %rdi
addq $0x18, %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x50(%rsp), %rax
subq %rax, %rdx
callq 0x25f50
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x28(%rax)
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
| /arangodb[P]velocypack/src/xxhash.h |
VELOCYPACK_XXH64_digest | XXH_PUBLIC_API XXH64_hash_t XXH64_digest(const XXH64_state_t* state) {
xxh_u64 h64;
if (state->total_len >= 32) {
xxh_u64 const v1 = state->v1;
xxh_u64 const v2 = state->v2;
xxh_u64 const v3 = state->v3;
xxh_u64 const v4 = state->v4;
h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) +
XXH_rotl64(v4, 18);
h64 = XXH64_mergeRound(h64, v1);
h64 = XXH64_mergeRound(h64, v2);
h64 = XXH64_mergeRound(h64, v3);
h64 = XXH64_mergeRound(h64, v4);
} else {
h64 = state->v3 /*seed*/ + XXH_PRIME64_5;
}
h64 += (xxh_u64)state->total_len;
return XXH64_finalize(h64, (const xxh_u8*)state->mem64,
(size_t)state->total_len, XXH_aligned);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x20, (%rax)
jb 0x26ec3
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
rolq %rax
movq 0x18(%rsp), %rcx
rolq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
rolq $0xc, %rcx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
rolq $0x12, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x26f10
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x26f10
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x26f10
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x26f10
movq %rax, 0x28(%rsp)
jmp 0x26edb
movq 0x30(%rsp), %rcx
movabsq $0x27d4eb2f165667c5, %rax # imm = 0x27D4EB2F165667C5
addq 0x18(%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x28, %rsi
movq 0x30(%rsp), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
callq 0x26f70
addq $0x38, %rsp
retq
nop
| /arangodb[P]velocypack/src/xxhash.h |
XXH64_finalize | static xxh_u64 XXH64_finalize(xxh_u64 h64, const xxh_u8* ptr, size_t len,
XXH_alignment align) {
#define XXH_PROCESS1_64 \
do { \
h64 ^= (*ptr++) * XXH_PRIME64_5; \
h64 = XXH_rotl64(h64, 11) * XXH_PRIME64_1; \
} while (0)
#define XXH_PROCESS4_64 \
do { \
h64 ^= (xxh_u64)(XXH_get32bits(ptr)) * XXH_PRIME64_1; \
ptr += 4; \
h64 = XXH_rotl64(h64, 23) * XXH_PRIME64_2 + XXH_PRIME64_3; \
} while (0)
#define XXH_PROCESS8_64 \
do { \
xxh_u64 const k1 = XXH64_round(0, XXH_get64bits(ptr)); \
ptr += 8; \
h64 ^= k1; \
h64 = XXH_rotl64(h64, 27) * XXH_PRIME64_1 + XXH_PRIME64_4; \
} while (0)
/* Rerolled version for 32-bit targets is faster and much smaller. */
if (XXH_REROLL || XXH_REROLL_XXH64) {
len &= 31;
while (len >= 8) {
XXH_PROCESS8_64;
len -= 8;
}
if (len >= 4) {
XXH_PROCESS4_64;
len -= 4;
}
while (len > 0) {
XXH_PROCESS1_64;
--len;
}
return XXH64_avalanche(h64);
} else {
switch (len & 31) {
case 24:
XXH_PROCESS8_64;
/* fallthrough */
case 16:
XXH_PROCESS8_64;
/* fallthrough */
case 8:
XXH_PROCESS8_64;
return XXH64_avalanche(h64);
case 28:
XXH_PROCESS8_64;
/* fallthrough */
case 20:
XXH_PROCESS8_64;
/* fallthrough */
case 12:
XXH_PROCESS8_64;
/* fallthrough */
case 4:
XXH_PROCESS4_64;
return XXH64_avalanche(h64);
case 25:
XXH_PROCESS8_64;
/* fallthrough */
case 17:
XXH_PROCESS8_64;
/* fallthrough */
case 9:
XXH_PROCESS8_64;
XXH_PROCESS1_64;
return XXH64_avalanche(h64);
case 29:
XXH_PROCESS8_64;
/* fallthrough */
case 21:
XXH_PROCESS8_64;
/* fallthrough */
case 13:
XXH_PROCESS8_64;
/* fallthrough */
case 5:
XXH_PROCESS4_64;
XXH_PROCESS1_64;
return XXH64_avalanche(h64);
case 26:
XXH_PROCESS8_64;
/* fallthrough */
case 18:
XXH_PROCESS8_64;
/* fallthrough */
case 10:
XXH_PROCESS8_64;
XXH_PROCESS1_64;
XXH_PROCESS1_64;
return XXH64_avalanche(h64);
case 30:
XXH_PROCESS8_64;
/* fallthrough */
case 22:
XXH_PROCESS8_64;
/* fallthrough */
case 14:
XXH_PROCESS8_64;
/* fallthrough */
case 6:
XXH_PROCESS4_64;
XXH_PROCESS1_64;
XXH_PROCESS1_64;
return XXH64_avalanche(h64);
case 27:
XXH_PROCESS8_64;
/* fallthrough */
case 19:
XXH_PROCESS8_64;
/* fallthrough */
case 11:
XXH_PROCESS8_64;
XXH_PROCESS1_64;
XXH_PROCESS1_64;
XXH_PROCESS1_64;
return XXH64_avalanche(h64);
case 31:
XXH_PROCESS8_64;
/* fallthrough */
case 23:
XXH_PROCESS8_64;
/* fallthrough */
case 15:
XXH_PROCESS8_64;
/* fallthrough */
case 7:
XXH_PROCESS4_64;
/* fallthrough */
case 3:
XXH_PROCESS1_64;
/* fallthrough */
case 2:
XXH_PROCESS1_64;
/* fallthrough */
case 1:
XXH_PROCESS1_64;
/* fallthrough */
case 0:
return XXH64_avalanche(h64);
}
}
/* impossible to reach */
XXH_ASSERT(0);
return 0; /* unreachable, but some compilers complain without it */
} | subq $0xf8, %rsp
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rdx, 0xd8(%rsp)
movl %ecx, 0xd4(%rsp)
movq 0xd8(%rsp), %rax
andl $0x1f, %eax
movq %rax, 0x8(%rsp)
subq $0x1f, %rax
ja 0x2831a
movq 0x8(%rsp), %rax
leaq 0x7444(%rip), %rcx # 0x2e400
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x26fc7
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0xc8(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0xc8(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x2704c
jmp 0x2704e
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0xc0(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0xc0(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x270d3
jmp 0x270d5
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0xb8(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0xb8(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x2a250
movq %rax, 0xf0(%rsp)
jmp 0x28326
jmp 0x27174
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0xb0(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0xb0(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x271f9
jmp 0x271fb
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0xa8(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0xa8(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27280
jmp 0x27282
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0xa0(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0xa0(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27307
jmp 0x27309
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a140
movl %eax, %eax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe0(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xe0(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x17, %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
imulq %rcx, %rax
movabsq $0x165667b19e3779f9, %rcx # imm = 0x165667B19E3779F9
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x2a250
movq %rax, 0xf0(%rsp)
jmp 0x28326
jmp 0x2739c
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x98(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x98(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27421
jmp 0x27423
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x90(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x90(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x274a8
jmp 0x274aa
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x88(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x88(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x2752f
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x2a250
movq %rax, 0xf0(%rsp)
jmp 0x28326
jmp 0x275a5
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x80(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x80(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x2762a
jmp 0x2762c
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x78(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x78(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x276ab
jmp 0x276ad
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x70(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x70(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x2772c
jmp 0x2772e
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a140
movl %eax, %eax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe0(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xe0(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x17, %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
imulq %rcx, %rax
movabsq $0x165667b19e3779f9, %rcx # imm = 0x165667B19E3779F9
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x277a7
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x2a250
movq %rax, 0xf0(%rsp)
jmp 0x28326
jmp 0x2781d
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x68(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x68(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x2789c
jmp 0x2789e
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x60(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x60(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x2791d
jmp 0x2791f
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x58(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x58(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x2799e
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x279fa
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x2a250
movq %rax, 0xf0(%rsp)
jmp 0x28326
jmp 0x27a70
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x50(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x50(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27aef
jmp 0x27af1
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x48(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x48(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27b70
jmp 0x27b72
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x40(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x40(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27bf1
jmp 0x27bf3
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a140
movl %eax, %eax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe0(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xe0(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x17, %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
imulq %rcx, %rax
movabsq $0x165667b19e3779f9, %rcx # imm = 0x165667B19E3779F9
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27c6c
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27cc8
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x2a250
movq %rax, 0xf0(%rsp)
jmp 0x28326
jmp 0x27d3e
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x38(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x38(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27dbd
jmp 0x27dbf
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x30(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x30(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27e3e
jmp 0x27e40
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x28(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x28(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27ebf
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27f1b
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x27f77
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x2a250
movq %rax, 0xf0(%rsp)
jmp 0x28326
jmp 0x27fed
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x20(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x20(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x2806c
jmp 0x2806e
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x18(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x18(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x280ed
jmp 0x280ef
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a1f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x26d90
movq %rax, 0x10(%rsp)
movq 0xe0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
movq 0x10(%rsp), %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x1b, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x2816e
jmp 0x28170
movq 0xe0(%rsp), %rdi
movl 0xd4(%rsp), %esi
callq 0x2a140
movl %eax, %eax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe0(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xe0(%rsp)
movq 0xe8(%rsp), %rax
rolq $0x17, %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
imulq %rcx, %rax
movabsq $0x165667b19e3779f9, %rcx # imm = 0x165667B19E3779F9
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x281e9
jmp 0x281eb
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x28247
jmp 0x28249
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x282a5
jmp 0x282a7
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rsp)
movzbl (%rax), %eax
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
imulq %rcx, %rax
xorq 0xe8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
rolq $0xb, %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
imulq %rcx, %rax
movq %rax, 0xe8(%rsp)
jmp 0x28303
movq 0xe8(%rsp), %rdi
callq 0x2a250
movq %rax, 0xf0(%rsp)
jmp 0x28326
movq $0x0, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/src/xxhash.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.