name string | code string | asm string | file string |
|---|---|---|---|
mbedtls_asn1_write_int | int mbedtls_asn1_write_int( unsigned char **p, unsigned char *start, int val )
{
int ret;
size_t len = 0;
// TODO negative values and values larger than 128
// DER format assumes 2s complement for numbers, so the leftmost bit
// should be 0 for positive numbers and 1 for negative numbers.
//
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq %rax, %rcx
subq %rsi, %rcx
pushq $-0x6c
popq %rbx
testq %rcx, %rcx
jle 0x2aace
movq %rsi, %r15
movq %rdi, %r14
leaq -0x1(%rax), %rcx
movq %rcx, (%rdi)
movb %dl, -0x1(%rax)
pushq $0x1
popq %r12
testl %edx, %edx
jle 0x2aa99
movq (%r14), %rax
cm... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_printable_string | int mbedtls_asn1_write_printable_string( unsigned char **p, unsigned char *start,
const char *text, size_t text_len )
{
int ret;
size_t len = 0;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) text, text_len ) );... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
setb %cl
cmpq %rbx, %rax
setb %al
orb %cl, %al
pushq $-0x6c
popq %rbp
jne 0x2ab57
movq %rsi, %r15
subq %rbx, %rdi
movq %rdi, (%r14)
movq %rdx, %rsi
movq %rbx, %rdx
callq 0xc150
testl ... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_ia5_string | int mbedtls_asn1_write_ia5_string( unsigned char **p, unsigned char *start,
const char *text, size_t text_len )
{
int ret;
size_t len = 0;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) text, text_len ) );
MBEDTL... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
setb %cl
cmpq %rbx, %rax
setb %al
orb %cl, %al
pushq $-0x6c
popq %rbp
jne 0x2abdf
movq %rsi, %r15
subq %rbx, %rdi
movq %rdi, (%r14)
movq %rdx, %rsi
movq %rbx, %rdx
callq 0xc150
testl ... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_bitstring | int mbedtls_asn1_write_bitstring( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t bits )
{
int ret;
size_t len = 0, size;
size = ( bits / 8 ) + ( ( bits % 8 ) ? 1 : 0 );
// Calculate byte length
//
if( *p < start || (size_t)( *p - start ) < s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdi, %rbx
movq %rcx, %r12
shrq $0x3, %r12
movl %r13d, %eax
andl $0x7, %eax
cmpq $0x1, %rax
sbbq $-0x1, %r12
movq (%rdi), %rdi
pushq $-0x6c
popq %rbp
movq %rdi, %rax
subq %rsi, %rax
jb 0x2ac88
cmpq %r12, %rax
jbe 0x2ac88
m... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_write_octet_string | int mbedtls_asn1_write_octet_string( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t size )
{
int ret;
size_t len = 0;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start, buf, size ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
setb %cl
cmpq %rbx, %rax
setb %al
orb %cl, %al
pushq $-0x6c
popq %rbp
jne 0x2ad14
movq %rsi, %r15
subq %rbx, %rdi
movq %rdi, (%r14)
movq %rdx, %rsi
movq %rbx, %rdx
callq 0xc150
testl ... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_asn1_store_named_data | mbedtls_asn1_named_data *mbedtls_asn1_store_named_data( mbedtls_asn1_named_data **head,
const char *oid, size_t oid_len,
const unsigned char *val,
size_t val_len )
{
mbedtls_asn1_named_data *cur;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x107ff
testq %rax, %rax
je 0x2ad85
movq %rax, %rbx
cmpq %r14, 0x20(%rax)
jae 0x2aded
movq %r15, %r12
pushq $0x1
popq %rdi
movq %r14, %rsi
c... | /project-everest[P]mbedtls/library/asn1write.c |
mbedtls_cipher_list | const int *mbedtls_cipher_list( void )
{
const mbedtls_cipher_definition_t *def;
int *type;
if( ! supported_init )
{
def = mbedtls_cipher_definitions;
type = mbedtls_cipher_supported;
while( def->type != 0 )
*type++ = (*def++).type;
*type = 0;
supp... | cmpb $0x0, 0x20629(%rip) # 0x4b458
jne 0x2ae5c
xorl %eax, %eax
leaq 0x1d946(%rip), %rdx # 0x48780
leaq 0x2061f(%rip), %rcx # 0x4b460
movl (%rdx,%rax,4), %esi
testl %esi, %esi
je 0x2ae51
movl %esi, (%rcx,%rax)
addq $0x4, %rax
jmp 0x2ae41
andl $0x0, (%rcx,%rax)
movb $0x1, 0x205fc(%rip) # 0x4b458
leaq 0x20... | /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_info_from_values | const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
int key_bitlen,
const mbedtls_cipher_mode_t mode )
{
const mbedtls_cipher_definition_t *def;
for( def = mbedtls_cipher_d... | leaq 0x1d8b3(%rip), %rcx # 0x48780
addq $0x8, %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x2aef2
movq 0x28(%rax), %r8
cmpl %edi, (%r8)
jne 0x2aeec
cmpl %esi, 0x8(%rax)
jne 0x2aeec
cmpl %edx, 0x4(%rax)
je 0x2aef2
addq $0x10, %rcx
jmp 0x2aed1
retq
| /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_free | void mbedtls_cipher_free( mbedtls_cipher_context_t *ctx )
{
if( ctx == NULL )
return;
#if defined(MBEDTLS_CMAC_C)
if( ctx->cmac_ctx )
{
mbedtls_zeroize( ctx->cmac_ctx, sizeof( mbedtls_cmac_context_t ) );
mbedtls_free( ctx->cmac_ctx );
}
#endif
if( ctx->cipher_ctx )
ct... | testq %rdi, %rdi
je 0x2af3e
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x2af2b
movq (%rbx), %rax
movq 0x28(%rax), %rax
callq *0x48(%rax)
pushq $-0x58
popq %rax
testq %rax, %rax
je 0x2af3d
movb $0x0, 0x58(%rbx,%rax)
incq %rax
jmp 0x2af2e
popq %rbx
retq
| /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_setup | int mbedtls_cipher_setup( mbedtls_cipher_context_t *ctx, const mbedtls_cipher_info_t *cipher_info )
{
if( NULL == cipher_info || NULL == ctx )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_a... | testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
jne 0x2afb9
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm... | /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_set_padding_mode | int mbedtls_cipher_set_padding_mode( mbedtls_cipher_context_t *ctx, mbedtls_cipher_padding_t mode )
{
if( NULL == ctx ||
MBEDTLS_MODE_CBC != ctx->cipher_info->mode )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
switch( mode )
{
#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
case ... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x2aff9
movq (%rdi), %rcx
cmpl $0x2, 0x4(%rcx)
jne 0x2aff9
movl $0xffff9f80, %eax # imm = 0xFFFF9F80
cmpl $0x4, %esi
ja 0x2aff9
movl %esi, %eax
leaq 0x1ce80(%rip), %rcx # 0x47e60
movq (%rcx,%rax,8), %rcx
leaq 0x1ce9d(%rip), %rdx # 0x47e88... | /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_setkey | int mbedtls_cipher_setkey( mbedtls_cipher_context_t *ctx, const unsigned char *key,
int key_bitlen, const mbedtls_operation_t operation )
{
if( NULL == ctx || NULL == ctx->cipher_info )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( ( ctx->cipher_info->flags & MBEDTLS_CIPHER_VARIABLE_KEY_LEN ... | testq %rdi, %rdi
je 0x2b035
movq (%rdi), %rax
testq %rax, %rax
je 0x2b035
testb $0x2, 0x1c(%rax)
jne 0x2b012
cmpl %edx, 0x8(%rax)
jne 0x2b035
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
pushq $0x30
popq %r8
cmpl $0x1, %ecx
je 0x2b03f
movl 0x4(%rax), %r9d
cmpl $0x3, %r9d
je 0x2b03f
cmpl $0x5, %r9d
je 0x2b03f
testl %ecx, %... | /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_set_iv | int mbedtls_cipher_set_iv( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len )
{
size_t actual_iv_size;
if( NULL == ctx || NULL == ctx->cipher_info || NULL == iv )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
/* avoid buffer overflow in ctx->iv */
if( iv_... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x2b0b0
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %dil
orb %dl, %dil
jne 0x2b0a9
movl $0xffff9f80, %eax # imm = 0xFFFF9F80
cmpq $0x10, %rbx
ja 0x2b0a9
testb ... | /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_update_ad | int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx,
const unsigned char *ad, size_t ad_len )
{
if( NULL == ctx || NULL == ctx->cipher_info )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
{
return mbedtls_gcm_star... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x2b100
movq %rdx, %r9
movq %rdi, %rdx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x2b100
xorl %eax, %eax
cmpl $0x6, 0x4(%rcx)
jne 0x2b100
movq %rsi, %r8
movq 0x50(%rdx), %rdi
movl 0xc(%rdx), %esi
movq 0x48(%rdx), %rcx
addq $0x38, %rdx
jmp 0x2bd81
retq
| /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_update | int mbedtls_cipher_update( mbedtls_cipher_context_t *ctx, const unsigned char *input,
size_t ilen, unsigned char *output, size_t *olen )
{
int ret;
size_t block_size = 0;
if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0xffff9f00, %ebp # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x2b138
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r12
movq (%rdi), %rcx
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x2b149
movl %... | /project-everest[P]mbedtls/library/cipher.c |
chacha20poly1305_init | static void chacha20poly1305_init(ptls_aead_context_t *_ctx, const void *iv, const void *aad, size_t aadlen)
{
struct chacha20poly1305_context_t *ctx = (struct chacha20poly1305_context_t *)_ctx;
uint8_t tmpbuf[64];
/* init chacha */
memset(tmpbuf, 0, 16 - PTLS_CHACHA20POLY1305_IV_SIZE);
memcpy(tmpb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
leaq 0x20(%rsp), %r12
andl $0x0, -0x10(%r12)
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, -0xc(%r12)
movl 0x8(%rsi), %eax
movl %eax, -0x4(%r12)
leaq 0x60(%rdi), %r13
leaq 0x40(%rdi), %rsi
pushq $0x20
... | /rperper[P]picotls/lib/cifra.c |
select_u8 | static inline uint8_t select_u8(uint32_t i, volatile const uint8_t *tab, uint32_t n)
{
uint8_t r = 0;
uint32_t ii;
for (ii = 0; ii < n; ii++)
{
uint8_t mask = mask_u8(i, ii);
r = (r & ~mask) | (tab[ii] & mask);
}
return r;
} | xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x2, %rcx
je 0x9fa1
movl %ecx, %edx
xorl %edi, %edx
negl %edx
movl %edi, %r8d
orb %dl, %r8b
movzbl (%rsi,%rcx), %edx
movzbl %al, %eax
cmovnsl %edx, %eax
incq %rcx
jmp 0x9f80
retq
| /rperper[P]picotls/deps/cifra/src/bitops.h |
cf_poly1305_init | void cf_poly1305_init(cf_poly1305 *ctx,
const uint8_t r[16],
const uint8_t s[16])
{
memset(ctx, 0, sizeof *ctx);
ctx->r[0] = r[0];
ctx->r[1] = r[1];
ctx->r[2] = r[2];
ctx->r[3] = r[3] & 0x0f;
ctx->r[4] = r[4] & 0xfc;
ctx->r[5] = r[5];
ctx->r[6] = r[6];... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0xb0, %edx
xorl %esi, %esi
callq 0x61b0
movzbl (%r15), %eax
movl %eax, 0x44(%r14)
movzbl 0x1(%r15), %eax
movl %eax, 0x48(%r14)
movzbl 0x2(%r15), %eax
movl %eax, 0x4c(%r14)
movzbl 0x3(%r15), %eax
andl $0xf, %eax
movl %eax, 0x50(%r14)
... | /rperper[P]picotls/deps/cifra/src/poly1305.c |
cf_poly1305_finish | void cf_poly1305_finish(cf_poly1305 *ctx,
uint8_t out[16])
{
if (ctx->npartial)
poly1305_last_block(ctx);
uint32_t s[17];
size_t i;
for (i = 0; i < 16; i++)
s[i] = ctx->s[i];
s[16] = 0;
poly1305_full_reduce(ctx->h);
poly1305_add(ctx->h, s);
for (i = 0; i < 16; i++)
... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa8(%rdi), %rax
testq %rax, %rax
je 0xa465
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
andl $0x0, 0x40(%rsp)
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0xa453
movzbl 0x9... | /rperper[P]picotls/deps/cifra/src/poly1305.c |
poly1305_block | static void poly1305_block(cf_poly1305 *ctx,
const uint32_t c[17])
{
poly1305_add(ctx->h, c);
poly1305_mul(ctx->h, ctx->r);
} | pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0xa50d
leaq 0x44(%rbx), %rax
leaq 0x84(%rbx), %rcx
pushq $0x1
popq %rdx
xorl %esi, %esi
cmpq $0x11, %rsi
je 0xa5a7
xorl %r8d, %r8d
movq %rax, %r9
xorl %edi, %edi
cmpq %r8, %rdx
je 0xa570
movl (%r9), %r10d
imull (%rbx,%r8,4), %r10d
addl %r10d, %edi
incq %r8
addq $-0x4, %... | /rperper[P]picotls/deps/cifra/src/poly1305.c |
cf_sha224_init | void cf_sha224_init(cf_sha256_context *ctx)
{
memset(ctx, 0, sizeof *ctx);
ctx->H[0] = 0xc1059ed8;
ctx->H[1] = 0x367cd507;
ctx->H[2] = 0x3070dd17;
ctx->H[3] = 0xf70e5939;
ctx->H[4] = 0xffc00b31;
ctx->H[5] = 0x68581511;
ctx->H[6] = 0x64f98fa7;
ctx->H[7] = 0xbefa4fa4;
} | xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movaps 0xf1a9(%rip), %xmm0 # 0x19800
movups %xmm0, (%rdi)
movaps 0xf1af(%rip), %xmm0 # 0x19810
movups %xmm0, 0x10(%rdi)
retq
| /rperper[P]picotls/deps/cifra/src/sha256.c |
cf_sha256_digest | void cf_sha256_digest(const cf_sha256_context *ctx, uint8_t hash[CF_SHA256_HASHSZ])
{
/* We copy the context, so the finalisation doesn't effect the caller's
* context. This means the caller can do:
*
* x = init()
* x.update('hello')
* h1 = x.digest()
* x.update(' world')
* h2 = x.digest()
*
... | subq $0x78, %rsp
movq %rsi, %rax
movq %rdi, %rsi
pushq $0xe
popq %rcx
leaq 0x8(%rsp), %rdx
movq %rdx, %rdi
rep movsq (%rsi), %es:(%rdi)
movq %rdx, %rdi
movq %rax, %rsi
callq 0xa872
addq $0x78, %rsp
retq
| /rperper[P]picotls/deps/cifra/src/sha256.c |
cf_sha512_init | void cf_sha512_init(cf_sha512_context *ctx)
{
memset(ctx, 0, sizeof *ctx);
ctx->H[0] = UINT64_C(0x6a09e667f3bcc908);
ctx->H[1] = UINT64_C(0xbb67ae8584caa73b);
ctx->H[2] = UINT64_C(0x3c6ef372fe94f82b);
ctx->H[3] = UINT64_C(0xa54ff53a5f1d36f1);
ctx->H[4] = UINT64_C(0x510e527fade682d1);
ctx->H[5] = UINT64_C(... | pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
movl $0x90, %edx
xorl %esi, %esi
callq 0x61b0
movabsq $0x6a09e667f3bcc908, %rax # imm = 0x6A09E667F3BCC908
movq %rax, (%rbx)
movabsq $-0x4498517a7b3558c5, %rax # imm = 0xBB67AE8584CAA73B
movq %rax, 0x8(%rbx)
movabsq $0x3c6ef372fe94f82b, %rax # imm = 0x3C6EF372FE94F82B
movq %r... | /rperper[P]picotls/deps/cifra/src/sha512.c |
sha512_update_block | static void sha512_update_block(void *vctx, const uint8_t *inp)
{
cf_sha512_context *ctx = vctx;
uint64_t W[16];
uint64_t a = ctx->H[0],
b = ctx->H[1],
c = ctx->H[2],
d = ctx->H[3],
e = ctx->H[4],
f = ctx->H[5],
g = ctx->H[6],
h = ctx-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r9
movq (%rdi), %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
movq 0x28(%rdi), %rbp
movq 0x30(%rdi), %rax
movq %rdi, 0x40(%rsp)
movq 0x38(%rdi), %r12
xorl %r13d, %r13d
movq %rcx, 0... | /rperper[P]picotls/deps/cifra/src/sha512.c |
cf_sha512_digest_final | void cf_sha512_digest_final(cf_sha512_context *ctx, uint8_t hash[CF_SHA512_HASHSZ])
{
uint64_t digested_bytes = ctx->blocks;
digested_bytes = digested_bytes * CF_SHA512_BLOCKSZ + ctx->npartial;
uint64_t digested_bits = digested_bytes * 8;
size_t padbytes = CF_SHA512_BLOCKSZ - ((digested_bytes + 16) % CF_SHA512... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc0(%rdi), %eax
leaq 0xc8(%rdi), %rsi
movq 0xc8(%rdi), %rcx
shlq $0xa, %rax
leaq (,%rcx,8), %r13
leaq (%rax,%rcx,8), %rbp
addl $0x10, %ecx
andl $0x7f, %ecx
movl $0x80, %eax
subq %rcx, %rax
addq $0x40, %rdi... | /rperper[P]picotls/deps/cifra/src/sha512.c |
cf_blockwise_accumulate_final | void cf_blockwise_accumulate_final(uint8_t *partial, size_t *npartial, size_t nblock,
const void *inp, size_t nbytes,
cf_blockwise_in_fn process,
cf_blockwise_in_fn process_final,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb0d1
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%rsi), %rdi
subq %rdi, %rdx
jbe 0xb0d1
movq %r8, %rbx
movq %rcx, %r14
testq %rcx, %rcx
setne %al
testq %r8, %r8
sete %cl
orb %al, %cl
je 0xb0d1
movq %r9, %rbp
tes... | /rperper[P]picotls/deps/cifra/src/blockwise.c |
cf_hash | void cf_hash(const cf_chash *h, const void *m, size_t nm, uint8_t *out)
{
cf_chash_ctx ctx;
assert(h);
h->init(&ctx);
h->update(&ctx, m, nm);
h->digest(&ctx, out);
mem_clean(&ctx, sizeof ctx);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x170, %rsp # imm = 0x170
testq %rdi, %rdi
je 0xb3f0
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq *0x10(%r14)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x18(%r14)
movq %r13,... | /rperper[P]picotls/deps/cifra/src/chash.c |
ptls_openssl_init_sign_certificate | int ptls_openssl_init_sign_certificate(ptls_openssl_sign_certificate_t *self, EVP_PKEY *key)
{
*self = (ptls_openssl_sign_certificate_t){{sign_certificate}};
size_t scheme_index = 0;
#define PUSH_SCHEME(id, md) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x108(%rip), %rax # 0xb6a3
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
andq $0x0, 0x48(%rdi)
movq %rsi, %rdi
callq 0x6360
movl $0x... | /rperper[P]picotls/lib/openssl.c |
secp_key_exchange | static int secp_key_exchange(ptls_key_exchange_algorithm_t *algo, ptls_iovec_t *pubkey, ptls_iovec_t *secret, ptls_iovec_t peerkey)
{
EC_GROUP *group = NULL;
BN_CTX *bn_ctx = NULL;
int ret;
if ((group = EC_GROUP_new_by_curve_name((int)algo->data)) == NULL) {
ret = PTLS_ERROR_LIBRARY;
go... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r15
movl 0x18(%rdi), %edi
callq 0x6710
testq %rax, %rax
je 0xc207
movq %rax, %rbx
callq 0x6240
testq %rax, %rax
je 0xc20e
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
... | /rperper[P]picotls/lib/openssl.c |
sha384_create | static int sign_certificate(ptls_sign_certificate_t *_self, ptls_t *tls, uint16_t *selected_algorithm, ptls_buffer_t *outbuf,
ptls_iovec_t input, const uint16_t *algorithms, size_t num_algorithms)
{
ptls_openssl_sign_certificate_t *self = (ptls_openssl_sign_certificate_t *)_self;
con... | pushq %rbx
movl $0xf0, %edi
callq 0x6550
movq %rax, %rbx
testq %rax, %rax
je 0xc5af
leaq 0xca1(%rip), %rax # 0xd22b
movq %rax, (%rbx)
leaq 0xca0(%rip), %rax # 0xd234
movq %rax, 0x8(%rbx)
leaq 0xd6f(%rip), %rax # 0xd30e
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
addq $0x18, %rdi
callq 0x6480
movq %rbx, %rax... | /rperper[P]picotls/lib/openssl.c |
x9_62_decode_point | static EC_POINT *x9_62_decode_point(const EC_GROUP *group, ptls_iovec_t vec, BN_CTX *bn_ctx)
{
EC_POINT *point = NULL;
if ((point = EC_POINT_new(group)) == NULL)
return NULL;
if (!EC_POINT_oct2point(group, point, vec.base, vec.len, bn_ctx)) {
EC_POINT_free(point);
return NULL;
}... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x6780
testq %rax, %rax
je 0xc858
movq %rax, %rbx
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x6700
testl %eax, %eax
jne 0xc85a
movq %rbx, %rdi
callq 0x6... | /rperper[P]picotls/lib/openssl.c |
aead_do_encrypt_final | static size_t aead_do_encrypt_final(ptls_aead_context_t *_ctx, void *_output)
{
struct aead_crypto_context_t *ctx = (struct aead_crypto_context_t *)_ctx;
uint8_t *output = _output;
size_t off = 0, tag_size = ctx->super.algo->tag_size;
int blocklen, ret;
ret = EVP_EncryptFinal_ex(ctx->evp_ctx, outpu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x28(%rax), %rbx
movq 0x40(%rdi), %rdi
leaq 0x4(%rsp), %rdx
callq 0x6670
testl %eax, %eax
je 0xcfc5
movslq 0x4(%rsp), %r12
movq 0x40(%r15), %rdi
addq %r12, %r14
pushq $0x10
popq %rsi
movl %ebx, %edx
movq %r14, ... | /rperper[P]picotls/lib/openssl.c |
aead_do_decrypt | static size_t aead_do_decrypt(ptls_aead_context_t *_ctx, void *_output, const void *input, size_t inlen, const void *iv,
const void *aad, size_t aadlen)
{
struct aead_crypto_context_t *ctx = (struct aead_crypto_context_t *)_ctx;
uint8_t *output = _output;
size_t off = 0, tag_si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x28(%rax), %r13
pushq $-0x1
popq %rax
cmpq %r13, %rcx
jb 0xd0d3
movq %r9, %rbx
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq 0x40(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq ... | /rperper[P]picotls/lib/openssl.c |
sha384_clone | static int sign_certificate(ptls_sign_certificate_t *_self, ptls_t *tls, uint16_t *selected_algorithm, ptls_buffer_t *outbuf,
ptls_iovec_t input, const uint16_t *algorithms, size_t num_algorithms)
{
ptls_openssl_sign_certificate_t *self = (ptls_openssl_sign_certificate_t *)_self;
con... | pushq %rbx
movq %rdi, %rbx
movl $0xf0, %edi
callq 0x6550
testq %rax, %rax
je 0xd332
movl $0xf0, %edx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x6320
popq %rbx
retq
| /rperper[P]picotls/lib/openssl.c |
ptls_buffer__do_pushv | int ptls_buffer__do_pushv(ptls_buffer_t *buf, const void *src, size_t len)
{
int ret;
if (len == 0)
return 0;
if ((ret = ptls_buffer_reserve(buf, len)) != 0)
return ret;
memcpy(buf->base + buf->off, src, len);
buf->off += len;
return 0;
} | xorl %eax, %eax
testq %rdx, %rdx
je 0xd423
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rsi
callq 0xd359
testl %eax, %eax
jne 0xd41e
movq (%r14), %rdi
addq 0x10(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6320
addq %rbx, 0x10(%r14)
xorl %eax, %eax
popq %rbx
popq %... | /rperper[P]picotls/lib/picotls.c |
ptls_new | ptls_t *ptls_new(ptls_context_t *ctx, int is_server)
{
ptls_t *tls;
assert(ctx->get_time != NULL && "please set ctx->get_time to `&ptls_get_time`; see #92");
if ((tls = malloc(sizeof(*tls))) == NULL)
return NULL;
update_open_count(ctx, 1);
*tls = (ptls_t){ctx};
tls->is_server = is_ser... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0xdac3
movl %esi, %ebp
movq %rdi, %r14
movl $0x218, %edi # imm = 0x218
callq 0x6550
movq %rax, %rbx
testq %rax, %rax
je 0xdab5
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0xda4d
pushq $0x1
popq %rsi
callq *(%rdi)
leaq 0x8(%rbx), %rd... | /rperper[P]picotls/lib/picotls.c |
send_client_hello | static int send_client_hello(ptls_t *tls, ptls_message_emitter_t *emitter, ptls_handshake_properties_t *properties,
ptls_iovec_t *cookie)
{
ptls_iovec_t resumption_secret = {NULL}, resumption_ticket;
uint32_t obfuscated_ticket_age = 0;
size_t msghash_off;
uint8_t binder_key[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, %r15
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x50(%rdi), %r12
movq 0x108(%rdi), %rdi
testq %rdi, %rdi
movq %rdx, 0x20(%rsp)
je 0xe18e
callq 0x12b68
movq 0x20(%rsp), %rdx
testl %eax, %eax
sete %cl
jmp 0xe... | /rperper[P]picotls/lib/picotls.c |
ptls_calc_hash | int ptls_calc_hash(ptls_hash_algorithm_t *algo, void *output, const void *src, size_t len)
{
ptls_hash_context_t *ctx;
if ((ctx = algo->create()) == NULL)
return PTLS_ERROR_NO_MEMORY;
ctx->update(ctx, src, len);
ctx->final(ctx, output, PTLS_HASH_FINAL_MODE_FREE);
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
callq *0x10(%rdi)
testq %rax, %rax
je 0x105c1
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *(%rax)
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *0x8(%r14)
jmp 0x105c6
... | /rperper[P]picotls/lib/picotls.c |
setup_traffic_protection | static int setup_traffic_protection(ptls_t *tls, int is_enc, const char *secret_label, size_t epoch, int skip_notify)
{
static const char *log_labels[2][4] = {
{NULL, "CLIENT_EARLY_TRAFFIC_SECRET", "CLIENT_HANDSHAKE_TRAFFIC_SECRET", "CLIENT_TRAFFIC_SECRET_0"},
{NULL, NULL, "SERVER_HANDSHAKE_TRAFFIC_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r12d
movq %rcx, %r15
movl %esi, %ebp
movq %rdi, %r14
leaq 0xb0(%rdi), %rbx
leaq 0x58(%rdi), %rax
testl %esi, %esi
cmoveq %rax, %rbx
testq %rdx, %rdx
je 0x1321e
movq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0x139d6
testl %eax, %eax
jne 0x132d3
movq %r15, 0... | /rperper[P]picotls/lib/picotls.c |
push_change_cipher_spec | static int push_change_cipher_spec(ptls_t *tls, ptls_buffer_t *sendbuf)
{
int ret = 0;
if (!tls->send_change_cipher_spec)
goto Exit;
buffer_push_record(sendbuf, PTLS_CONTENT_TYPE_CHANGE_CIPHER_SPEC, { ptls_buffer_push(sendbuf, 1); });
tls->send_change_cipher_spec = 0;
Exit:
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testb $0x4, 0x160(%rdi)
je 0x13344
movq %rsi, %r15
movq %rdi, %r14
leaq 0x5(%rsp), %rsi
movw $0x314, (%rsi) # imm = 0x314
movb $0x3, 0x2(%rsi)
pushq $0x3
popq %rdx
movq %r15, %rdi
callq 0xd3e5
testl %eax, %eax
jne 0x13342
leaq 0x8156(%rip),... | /rperper[P]picotls/lib/picotls.c |
aead_encrypt | static size_t aead_encrypt(struct st_ptls_traffic_protection_t *ctx, void *output, const void *input, size_t inlen,
uint8_t content_type)
{
uint8_t aad[5];
size_t off = 0;
build_aad(aad, inlen + 1 + ctx->aead->algo->tag_size);
ptls_aead_encrypt_init(ctx->aead, ctx->seq++, aad... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa(%rsp), %r15
movb %r8b, (%r15)
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq 0x1(%rcx,%rax), %rax
leaq 0xb(%rsp), %rdx
movw $0x317, (%rdx) # imm =... | /rperper[P]picotls/lib/picotls.c |
handle_key_update | static int handle_key_update(ptls_t *tls, ptls_message_emitter_t *emitter, ptls_iovec_t message)
{
const uint8_t *src = message.base + PTLS_HANDSHAKE_HEADER_SIZE, *const end = message.base + message.len;
int ret;
/* validate */
if (end - src != 1 || *src > 1)
return PTLS_ALERT_DECODE_ERROR;
... | pushq $0x32
popq %rax
cmpq $0x5, %rdx
jne 0x17aca
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpb $0x1, 0x4(%rsi)
ja 0x17ac3
movq %rdi, %rbx
xorl %esi, %esi
callq 0x13b17
testl %eax, %eax
jne 0x17ac3
cmpb $0x0, 0x4(%r14)
je 0x17ac1
movq (%rbx), %rax
cmpq $0x0, 0x90(%rax)
je 0x17aba
pushq $0xa
popq %rax
jmp 0x17ac... | /rperper[P]picotls/lib/picotls.c |
send_certificate_and_certificate_verify | static int send_certificate_and_certificate_verify(ptls_t *tls, ptls_message_emitter_t *emitter,
struct st_ptls_signature_algorithms_t *signature_algorithms,
ptls_iovec_t context, const char *context_string, int push_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %r9, %rbp
movq %r8, %r9
movq %rcx, %r8
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
movq 0x40(%rcx), %rax
testq %rax, %rax
leaq 0xb758(%rip), %rdi # 0x234b8
cmovneq %rax, %rdi
testb $0x20, 0x160(%... | /rperper[P]picotls/lib/picotls.c |
decode_signature_algorithms | static int decode_signature_algorithms(struct st_ptls_signature_algorithms_t *sa, const uint8_t **src, const uint8_t *end)
{
int ret;
ptls_decode_block(*src, end, 2, {
do {
uint16_t id;
if ((ret = ptls_decode16(&id, src, end)) != 0)
goto Exit;
if (sa-... | movq (%rsi), %r8
movq %rdx, %rcx
subq %r8, %rcx
movl $0x32, %eax
cmpq $0x2, %rcx
jb 0x184e3
pushq %rbx
leaq 0x1(%r8), %rcx
movq %rcx, (%rsi)
movzbl (%r8), %r9d
shll $0x8, %r9d
leaq 0x2(%r8), %rcx
movq %rcx, (%rsi)
movzbl 0x1(%r8), %r8d
orq %r9, %r8
movq %rdx, %r9
subq %rcx, %r9
cmpq %r9, %r8
ja 0x184e2
leaq (%rcx,%r8),... | /rperper[P]picotls/lib/picotls.c |
derive_resumption_secret | static int derive_resumption_secret(ptls_key_schedule_t *sched, uint8_t *secret, ptls_iovec_t nonce)
{
int ret;
if ((ret = derive_secret(sched, secret, "res master")) != 0)
goto Exit;
if ((ret = hkdf_expand_label(sched->hashes[0].algo, secret, sched->hashes[0].algo->digest_size,
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
leaq 0x2af6(%rip), %rdx # 0x1b289
callq 0x139d6
testl %eax, %eax
jne 0x187cf
movq 0x8(%r14), %rax
movq 0x58(%r14), %rdi
movq 0x8(%rdi), %rdx
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
mo... | /rperper[P]picotls/lib/picotls.c |
client_do_handle_certificate | static int client_do_handle_certificate(ptls_t *tls, const uint8_t *src, const uint8_t *end)
{
int got_certs, ret;
if ((ret = handle_certificate(tls, src, end, &got_certs)) != 0)
return ret;
if (!got_certs)
return PTLS_ALERT_ILLEGAL_PARAMETER;
return 0;
} | pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movq %rbx, %rcx
callq 0x18916
xorl %ecx, %ecx
cmpl $0x0, (%rbx)
pushq $0x2f
popq %rdx
cmovnel %ecx, %edx
testl %eax, %eax
cmovel %edx, %eax
addq $0x10, %rsp
popq %rbx
retq
| /rperper[P]picotls/lib/picotls.c |
handle_certificate_verify | static int handle_certificate_verify(ptls_t *tls, ptls_iovec_t message, const char *context_string)
{
const uint8_t *src = message.base + PTLS_HANDSHAKE_HEADER_SIZE, *const end = message.base + message.len;
uint16_t algo;
ptls_iovec_t signature;
uint8_t signdata[PTLS_MAX_CERTIFICATE_VERIFY_SIGNDATA_SIZE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
pushq $0x32
popq %rbp
cmpq $0x6, %rdx
jl 0x18ca0
movq %rdx, %rbx
movabsq $0x7ffffffffffffffe, %rax # imm = 0x7FFFFFFFFFFFFFFE
andq %rdx, %rax
cmpq $0x6, %rax
je 0x18ca0
movq %rsi, %r14
leaq (%rsi,%rbx), %rax
movzwl 0x6(%rsi), %edx
rolw $... | /rperper[P]picotls/lib/picotls.c |
Fossilize::FeatureFilter::Impl::validate_module_capability(spv::Capability) const | bool FeatureFilter::Impl::validate_module_capability(spv::Capability cap) const
{
// From table 75 in Vulkan spec.
switch (cap)
{
case spv::CapabilityMatrix:
case spv::CapabilityShader:
case spv::CapabilityInputAttachment:
case spv::CapabilitySampled1D:
case spv::CapabilityImage1D:
case spv::CapabilitySampled... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %edx
movq %rdi, %r14
movb $0x1, %bl
cmpl $0x46, %esi
jbe 0xb0f5
leal -0x1146(%rdx), %eax
cmpl $0x4c, %eax
jbe 0xb114
leal -0x1491(%rdx), %eax
cmpl $0x2f, %eax
jbe 0xb131
leal -0x1780(%rdx), %eax
cmpl $0x12, %eax
jbe 0xb14d
leal -0x14d8(%rdx), %eax
cmpl $0xe, ... | /ValveSoftware[P]Fossilize/cli/fossilize_feature_filter.cpp |
panic | static int panic (lua_State *L) {
const char *msg = (lua_type(L, -1) == LUA_TSTRING)
? lua_tostring(L, -1)
: "error object is not a string";
lua_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n",
msg);
return 0; /* return to Lua to a... | pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %rsi
callq 0x68d4
cmpl $0x4, %eax
jne 0x5627
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6bb8
movq %rax, %rdx
jmp 0x562e
leaq 0x2410b(%rip), %rdx # 0x29739
movq 0x349a3(%rip), %rbx # 0x39fd8
movq (%rbx), %rdi
leaq 0x24117(%rip), %rsi # 0x29756
xo... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
warnfcont | static void warnfcont (void *ud, const char *message, int tocont) {
lua_State *L = (lua_State *)ud;
lua_writestringerror("%s", message); /* write message */
if (tocont) /* not the last part? */
lua_setwarnf(L, warnfcont, L); /* to be continued */
else { /* last part */
lua_writestringerror("%s", "\n... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %rbx
movq 0x34973(%rip), %r14 # 0x39fd8
movq (%r14), %rsi
movq %rax, %rdi
callq 0x53a0
movq (%r14), %rdi
callq 0x53b0
testl %ebp, %ebp
je 0x5692
leaq -0x31(%rip), %rsi # 0x5652
movq %rbx, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq ... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
db_debug | static int db_debug (lua_State *L) {
for (;;) {
char buffer[250];
lua_writestringerror("%s", "lua_debug> ");
if (fgets(buffer, sizeof(buffer), stdin) == NULL ||
strcmp(buffer, "cont\n") == 0)
return 0;
if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
lua_pcal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbx
movq 0x34376(%rip), %rbp # 0x39fd8
movq (%rbp), %rsi
leaq 0x2613a(%rip), %rdi # 0x2bda7
callq 0x53a0
movq (%rbp), %rdi
callq 0x53b0
movq 0x3434e(%rip), %r14 # 0x39fd0
movq (%r14), %rd... | /mmanyen[P]CLua/build_O1/_deps/lua/ldblib.c |
StringTest | LuaGlue(StringTest)
{
if (pLua->GetArgumentType(1) != LuaArgType::ARG_TYPE_STRING)
{
printf("Fail: StringTest argument is not a String\n");
sLuaBasedTestResult += -4;
}
const char* r = pLua->GetStringArgument(1, "fail");
pLua->PushString(r);
return 1;
} | pushq %rax
movq 0x3448f(%rip), %rdi # 0x3a348
movl $0x1, %esi
callq 0x650c
cmpl $0x2, %eax
je 0x5edb
leaq 0x231ea(%rip), %rdi # 0x290b9
callq 0x5480
addl $-0x4, 0x34475(%rip) # 0x3a350
movq 0x34466(%rip), %rdi # 0x3a348
leaq 0x23137(%rip), %rdx # 0x29020
movl $0x1, %esi
callq 0x64ba
movq 0x3444e(%rip... | /mmanyen[P]CLua/test/test.cpp |
NumberTest | LuaGlue(NumberTest)
{
if (pLua->GetArgumentType(1) != LuaArgType::ARG_TYPE_NUMBER)
{
printf("Fail: NumberTest argument is not a Number\n");
sLuaBasedTestResult += -5;
}
double r = pLua->GetNumberArgument(1, INFINITY);
pLua->PushNumber(r);
return 1;
} | pushq %rax
movq 0x34437(%rip), %rdi # 0x3a348
movl $0x1, %esi
callq 0x650c
cmpl $0x1, %eax
je 0x5f33
leaq 0x231bc(%rip), %rdi # 0x290e3
callq 0x5480
addl $-0x5, 0x3441d(%rip) # 0x3a350
movq 0x3440e(%rip), %rdi # 0x3a348
movsd 0x230c6(%rip), %xmm0 # 0x29008
movl $0x1, %esi
callq 0x64c6
movq 0x343f5(%ri... | /mmanyen[P]CLua/test/test.cpp |
BoolTest | LuaGlue(BoolTest)
{
if (pLua->GetArgumentType(1) != LuaArgType::ARG_TYPE_BOOL)
{
printf("Fail: BoolTest argument is not a Boolean\n");
sLuaBasedTestResult += -7;
}
bool r = pLua->GetBoolArgument(1);
pLua->PushBool(r);
return 1;
} | pushq %rax
movq 0x34383(%rip), %rdi # 0x3a348
movl $0x1, %esi
callq 0x650c
cmpl $0x3, %eax
je 0x5fe7
leaq 0x2315d(%rip), %rdi # 0x29138
callq 0x5480
addl $-0x7, 0x34369(%rip) # 0x3a350
movq 0x3435a(%rip), %rdi # 0x3a348
movl $0x1, %esi
xorl %edx, %edx
callq 0x64dc
movq 0x34347(%rip), %rdi # 0x3a348
m... | /mmanyen[P]CLua/test/test.cpp |
main | int main()
{
int retval = 0;
printf("Hello World!\n");
pLua = new CLua();
pLua->AddFunction("FAIL", FAIL);
pLua->AddFunction(myFunctions);
if (!pLua->RunString("print('Test String has run')"))
{
printf("Failed to run c string\n");
retval += -1;
}
if (!pLua->RunScrip... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x23132(%rip), %rdi # 0x29161
callq 0x5480
movl $0x20, %edi
callq 0x5330
movq %rax, %rbx
movq %rax, %rdi
callq 0x615e
movq %rbx, 0x342f8(%rip) # 0x3a348
leaq 0x22fd8(%rip), %rsi # 0x2902f
leaq -0x1e2(%rip), %rdx # 0x5e7c
movq %rbx, %rdi
callq 0x647e
movq 0x342db(%r... | /mmanyen[P]CLua/test/test.cpp |
lua_rawlen | LUA_API lua_Unsigned lua_rawlen (lua_State *L, int idx) {
const TValue *o = index2value(L, idx);
switch (ttypetag(o)) {
case LUA_VSHRSTR: return cast(lua_Unsigned, tsvalue(o)->shrlen);
case LUA_VLNGSTR: return cast(lua_Unsigned, tsvalue(o)->u.lnglen);
case LUA_VUSERDATA: return cast(lua_Unsigned, uvalue... | pushq %rax
callq 0x6836
movq %rax, %rcx
movzbl 0x8(%rax), %edx
andl $0x3f, %edx
xorl %eax, %eax
cmpl $0x6, %edx
jg 0x6c7b
cmpl $0x4, %edx
je 0x6c8e
cmpl $0x5, %edx
jne 0x6c96
movq (%rcx), %rdi
popq %rax
jmp 0x1ba26
cmpl $0x7, %edx
je 0x6c85
cmpl $0x14, %edx
jne 0x6c96
movq (%rcx), %rax
movq 0x10(%rax), %rax
jmp 0x6c96
... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_topointer | LUA_API const void *lua_topointer (lua_State *L, int idx) {
const TValue *o = index2value(L, idx);
switch (ttypetag(o)) {
case LUA_VLCF: return cast_voidp(cast_sizet(fvalue(o)));
case LUA_VUSERDATA: case LUA_VLIGHTUSERDATA:
return touserdata(o);
default: {
if (iscollectable(o))
retur... | pushq %rax
callq 0x6836
movzbl 0x8(%rax), %ecx
movl %ecx, %edx
andl $0x3f, %edx
cmpl $0x2, %edx
je 0x6d36
cmpl $0x7, %edx
je 0x6d36
cmpl $0x16, %edx
je 0x6d68
testb $0x40, %cl
jne 0x6d68
jmp 0x6d6d
movl %ecx, %edx
andb $0xf, %dl
cmpb $0x2, %dl
je 0x6d68
andl $0xf, %ecx
cmpl $0x7, %ecx
jne 0x6d6d
movq (%rax), %rcx
movzw... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_pushlstring | LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) {
TString *ts;
lua_lock(L);
ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len);
setsvalue2s(L, L->top.p, ts);
api_incr_top(L);
luaC_checkGC(L);
lua_unlock(L);
return getstr(ts);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
je 0x6db8
movq %rbx, %rdi
callq 0x170cb
jmp 0x6dc7
leaq 0x23438(%rip), %rsi # 0x2a1f7
movq %rbx, %rdi
callq 0x1734a
movq %rax, %r14
movq 0x10(%rbx), %rax
movq %r14, (%rax)
movb 0x8(%r14), %cl
orb $0x40, %cl
movb %cl, 0x8(%rax)
addq $0x10, 0x10(%rbx)
... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_pushexternalstring | LUA_API const char *lua_pushexternalstring (lua_State *L,
const char *s, size_t len, lua_Alloc falloc, void *ud) {
TString *ts;
lua_lock(L);
api_check(L, len <= MAX_SIZE, "string too large");
api_check(L, s[len] == '\0', "string not ending with zero");
ts = luaS_newextlstr (L, s, len, falloc, ud);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x17456
movq %rax, %rbx
movq 0x10(%r14), %rax
movq %rbx, (%rax)
movb 0x8(%rbx), %cl
orb $0x40, %cl
movb %cl, 0x8(%rax)
addq $0x10, 0x10(%r14)
movq %rbx, %r15
movq 0x18(%r14), %rax
cmpq $0x0, 0x18(%rax)
jg 0x6e44
movq %r14, %rdi
callq 0xdd3f
addq $0x18, %rbx
cmpb $0... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_pushstring | LUA_API const char *lua_pushstring (lua_State *L, const char *s) {
lua_lock(L);
if (s == NULL)
setnilvalue(s2v(L->top.p));
else {
TString *ts;
ts = luaS_new(L, s);
setsvalue2s(L, L->top.p, ts);
s = getstr(ts); /* internal copy's address */
}
api_incr_top(L);
luaC_checkGC(L);
lua_unloc... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x6e8e
movq %rbx, %rdi
callq 0x1734a
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movb 0x8(%rax), %dl
orb $0x40, %dl
movb %dl, 0x8(%rcx)
leaq 0x18(%rax), %r14
cmpb $0x0, 0xb(%rax)
jns 0x6e99
movq (%r14), %r14
jmp 0x6e99
movq 0x10(%rbx), %rax
movb $0x0, 0x8... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_pushvfstring | LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
va_list argp) {
const char *ret;
lua_lock(L);
ret = luaO_pushvfstring(L, fmt, argp);
luaC_checkGC(L);
lua_unlock(L);
return ret;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x12822
movq %rax, %r14
movq 0x18(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jg 0x6ede
movq %rbx, %rdi
callq 0xdd3f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_pushfstring | LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
const char *ret;
va_list argp;
lua_lock(L);
va_start(argp, fmt);
ret = luaO_pushvfstring(L, fmt, argp);
va_end(argp);
luaC_checkGC(L);
if (ret == NULL) /* error? */
luaD_throw(L, LUA_ERRMEM);
lua_unlock(L);
return ret;
} | pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x6f46
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps ... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_pushcclosure | LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
lua_lock(L);
if (n == 0) {
setfvalue(s2v(L->top.p), fn);
api_incr_top(L);
}
else {
int i;
CClosure *cl;
api_checkpop(L, n);
api_check(L, n <= MAXUPVAL, "upvalue index too large");
cl = luaF_newCclosure(L, n);
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x7037
movl %edx, %ebp
movq %rbx, %rdi
movl %edx, %esi
callq 0xcfb0
movq %r14, 0x18(%rax)
testl %ebp, %ebp
jle 0x6ffb
movl %ebp, %ecx
shlq $0x4, %rcx
movq %rcx, %rdx
negq %rdx
xorl %esi, %esi
movq 0x10(%rbx), %rdi
addq %rdx, %rdi
movq ... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_pushboolean | LUA_API void lua_pushboolean (lua_State *L, int b) {
lua_lock(L);
if (b)
setbtvalue(s2v(L->top.p));
else
setbfvalue(s2v(L->top.p));
api_incr_top(L);
lua_unlock(L);
} | testl %esi, %esi
setne %al
movq 0x10(%rdi), %rcx
shlb $0x4, %al
incb %al
movb %al, 0x8(%rcx)
addq $0x10, 0x10(%rdi)
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
auxgetstr | static int auxgetstr (lua_State *L, const TValue *t, const char *k) {
lu_byte tag;
TString *str = luaS_new(L, k);
luaV_fastget(t, str, s2v(L->top.p), luaH_getstr, tag);
if (!tagisempty(tag))
api_incr_top(L);
else {
setsvalue2s(L, L->top.p, str);
api_incr_top(L);
tag = luaV_finishget(L, t, s2v(... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x1734a
movq %rax, %r15
movb $0x30, %al
cmpb $0x45, 0x8(%r14)
jne 0x7103
movq (%r14), %rdi
movq 0x10(%rbx), %rdx
movq %r15, %rsi
callq 0x1af59
movq 0x10(%rbx), %rcx
testb $0xf, %al
je 0x7115
addq $0x10, %rcx
movq %rcx, 0x10(%rbx)
jmp... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_gettable | LUA_API int lua_gettable (lua_State *L, int idx) {
lu_byte tag;
TValue *t;
lua_lock(L);
api_checkpop(L, 1);
t = index2value(L, idx);
luaV_fastget(t, s2v(L->top.p - 1), s2v(L->top.p - 1), luaH_get, tag);
if (tagisempty(tag))
tag = luaV_finishget(L, t, s2v(L->top.p - 1), L->top.p - 1, tag);
lua_unlock... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6836
movq %rax, %r14
movb $0x30, %al
cmpb $0x45, 0x8(%r14)
jne 0x7176
movq (%r14), %rdi
movq 0x10(%rbx), %rdx
addq $-0x10, %rdx
movq %rdx, %rsi
callq 0x1afe1
testb $0xf, %al
jne 0x7194
movq 0x10(%rbx), %rcx
addq $-0x10, %rcx
movzbl %al, %r8d
movq %rbx, %rdi
movq ... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_geti | LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {
TValue *t;
lu_byte tag;
lua_lock(L);
t = index2value(L, idx);
luaV_fastgeti(t, n, s2v(L->top.p), tag);
if (tagisempty(tag)) {
TValue key;
setivalue(&key, n);
tag = luaV_finishget(L, t, &key, L->top.p, tag);
}
api_incr_top(L);
lu... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x6836
movq %rax, %r15
movb $0x30, %al
cmpb $0x45, 0x8(%r15)
jne 0x722d
movq (%r15), %rdi
leaq -0x1(%r14), %rax
movl 0xc(%rdi), %ecx
cmpq %rcx, %rax
jae 0x7221
movq 0x10(%rdi), %rcx
movb 0x4(%rcx,%rax), %al
testb $0xf, %al
je 0x722d... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_rawget | LUA_API int lua_rawget (lua_State *L, int idx) {
Table *t;
lu_byte tag;
lua_lock(L);
api_checkpop(L, 1);
t = gettable(L, idx);
tag = luaH_get(t, s2v(L->top.p - 1), s2v(L->top.p - 1));
L->top.p--; /* pop key */
return finishrawget(L, tag);
} | pushq %rbx
movq %rdi, %rbx
callq 0x6836
movq (%rax), %rdi
movq 0x10(%rbx), %rdx
addq $-0x10, %rdx
movq %rdx, %rsi
callq 0x1afe1
movq 0x10(%rbx), %rcx
leaq -0x10(%rcx), %rdx
movq %rdx, 0x10(%rbx)
andb $0xf, %al
jne 0x7292
movb $0x0, -0x8(%rcx)
movzbl %al, %eax
addq $0x10, 0x10(%rbx)
popq %rbx
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_rawgeti | LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
Table *t;
lu_byte tag;
lua_lock(L);
t = gettable(L, idx);
luaH_fastgeti(t, n, s2v(L->top.p), tag);
return finishrawget(L, tag);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x6836
movq (%rax), %rdi
leaq -0x1(%r14), %rax
movl 0xc(%rdi), %ecx
cmpq %rcx, %rax
jae 0x72e7
movq 0x10(%rdi), %rcx
movb 0x4(%rcx,%rax), %al
testb $0xf, %al
je 0x72f3
movq 0x10(%rbx), %rcx
movb %al, 0x8(%rcx)
movq 0x10(%rbx), %rcx
movq 0x10(%rdi), ... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_rawgetp | LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {
Table *t;
TValue k;
lua_lock(L);
t = gettable(L, idx);
setpvalue(&k, cast_voidp(p));
return finishrawget(L, luaH_get(t, &k, s2v(L->top.p)));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x6836
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movb $0x2, 0x8(%rsi)
movq 0x10(%rbx), %rdx
callq 0x1afe1
andb $0xf, %al
jne 0x7345
movq 0x10(%rbx), %rcx
movb $0x0, 0x8(%rcx)
movzbl %al, %eax
addq $0x10, 0x10(%rbx)
addq $0x18, %... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_createtable | LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
Table *t;
lua_lock(L);
t = luaH_new(L);
sethvalue2s(L, L->top.p, t);
api_incr_top(L);
if (narray > 0 || nrec > 0)
luaH_resize(L, t, cast_uint(narray), cast_uint(nrec));
luaC_checkGC(L);
lua_unlock(L);
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x1ad47
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movb $0x45, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
testl %r14d, %r14d
setle %cl
testl %ebp, %ebp
setle %dl
testb %dl, %cl
jne 0x7395
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
movl %eb... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_getmetatable | LUA_API int lua_getmetatable (lua_State *L, int objindex) {
const TValue *obj;
Table *mt;
int res = 0;
lua_lock(L);
obj = index2value(L, objindex);
switch (ttype(obj)) {
case LUA_TTABLE:
mt = hvalue(obj)->metatable;
break;
case LUA_TUSERDATA:
mt = uvalue(obj)->metatable;
brea... | pushq %rbx
movq %rdi, %rbx
callq 0x6836
movzbl 0x8(%rax), %ecx
andl $0xf, %ecx
cmpq $0x7, %rcx
je 0x73d5
cmpl $0x5, %ecx
jne 0x73de
movq (%rax), %rax
addq $0x20, %rax
jmp 0x73ec
movq (%rax), %rax
addq $0x18, %rax
jmp 0x73ec
movq 0x18(%rbx), %rax
leaq (%rax,%rcx,8), %rax
addq $0x1d8, %rax # imm = 0x1D8
movq (... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_getiuservalue | LUA_API int lua_getiuservalue (lua_State *L, int idx, int n) {
TValue *o;
int t;
lua_lock(L);
o = index2value(L, idx);
api_check(L, ttisfulluserdata(o), "full userdata expected");
if (n <= 0 || n > uvalue(o)->nuvalue) {
setnilvalue(s2v(L->top.p));
t = LUA_TNONE;
}
else {
setobj2s(L, L->top.p... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %edx, %edx
jle 0x7431
movl %edx, %r14d
movq %rbx, %rdi
callq 0x6836
movq (%rax), %rax
movzwl 0xa(%rax), %ecx
cmpl %r14d, %ecx
jge 0x7440
movq 0x10(%rbx), %rax
movb $0x0, 0x8(%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x7466
movq 0x10(%rbx), %rcx
decl... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
auxsetstr | static void auxsetstr (lua_State *L, const TValue *t, const char *k) {
int hres;
TString *str = luaS_new(L, k);
api_checkpop(L, 1);
luaV_fastset(t, str, s2v(L->top.p - 1), hres, luaH_psetstr);
if (hres == HOK) {
luaV_finishfastset(L, t, s2v(L->top.p - 1));
L->top.p--; /* pop value */
}
else {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x1734a
movq %rax, %r15
movl $0x2, %r8d
cmpb $0x45, 0x8(%r14)
jne 0x74eb
movq (%r14), %rdi
movq 0x10(%rbx), %rdx
addq $-0x10, %rdx
movq %r15, %rsi
callq 0x1b457
movl %eax, %r8d
movq 0x10(%rbx), %rax
testl %r8d, %r8d
je 0x7525
movq %r... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_settable | LUA_API void lua_settable (lua_State *L, int idx) {
TValue *t;
int hres;
lua_lock(L);
api_checkpop(L, 2);
t = index2value(L, idx);
luaV_fastset(t, s2v(L->top.p - 2), s2v(L->top.p - 1), hres, luaH_pset);
if (hres == HOK)
luaV_finishfastset(L, t, s2v(L->top.p - 1));
else
luaV_finishset(L, t, s2v(L... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6836
movq %rax, %r14
movl $0x2, %r8d
cmpb $0x45, 0x8(%rax)
jne 0x7589
movq (%r14), %rdi
movq 0x10(%rbx), %rdx
leaq -0x20(%rdx), %rsi
addq $-0x10, %rdx
callq 0x1b4dc
movl %eax, %r8d
movq 0x10(%rbx), %rcx
testl %r8d, %r8d
je 0x75a7
leaq -0x20(%rcx), %rdx
addq $-0x1... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_pcallk | LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
lua_KContext ctx, lua_KFunction k) {
struct CallS c;
TStatus status;
ptrdiff_t func;
lua_lock(L);
api_check(L, k == NULL || !isLua(L->ci),
"cannot use continuations inside hooks");
api_checkpop(L, nargs +... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rax
movl %edx, %ebp
movq %rdi, %rbx
testl %ecx, %ecx
je 0x7970
jle 0x7975
movq 0x20(%rbx), %rdx
movl %ecx, %r8d
shlq $0x4, %r8
addq (%rdx), %r8
jmp 0x7980
xorl %r8d, %r8d
jmp 0x7984
movslq %ecx, %r8
shlq $0x4, %r8
addq 0x10(%rbx), %r8
subq 0x30(%rbx), %r8
not... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
lua_setupvalue | LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
const char *name;
TValue *val = NULL; /* to avoid warnings */
GCObject *owner = NULL; /* to avoid warnings */
TValue *fi;
lua_lock(L);
fi = index2value(L, funcindex);
api_checknelems(L, 1);
name = aux_upvalue(fi, n, &val, &owner... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
callq 0x6836
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x7fb5
movq %rax, %r14
testq %rax, %rax
je 0x80c5... | /mmanyen[P]CLua/build_O1/_deps/lua/lapi.c |
luaL_argerror | LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) {
lua_Debug ar;
const char *argword;
if (!lua_getstack(L, 0, &ar)) /* no stack frame? */
return luaL_error(L, "bad argument #%d (%s)", arg, extramsg);
lua_getinfo(L, "nt", &ar);
if (arg <= ar.extraargs) /* error in an extra argum... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %rdx
xorl %esi, %esi
callq 0x9f91
testl %eax, %eax
je 0x8722
leaq 0x21360(%rip), %rsi # 0x29a46
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0xa19e
movzbl 0x3f(%r15), %eax
movl... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_error | LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
va_list argp;
va_start(argp, fmt);
luaL_where(L, 1);
lua_pushvfstring(L, fmt, argp);
va_end(argp);
lua_concat(L, 2);
return lua_error(L);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x8828
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movap... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
pushglobalfuncname | static int pushglobalfuncname (lua_State *L, lua_Debug *ar) {
int top = lua_gettop(L);
lua_getinfo(L, "f", ar); /* push function */
lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
luaL_checkstack(L, 6, "not enough stack"); /* slots for 'findfield' */
if (findfield(L, top + 1, 2)) {
const char *nam... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x663a
movl %eax, %r14d
leaq 0x20dce(%rip), %rsi # 0x2966c
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa19e
leaq 0x20d4f(%rip), %rdx # 0x295ff
movq %rbx, %rdi
movl $0xfff0b9d8, %esi # imm = 0xFFF0B9D8
callq 0x71a1
lea... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_typeerror | LUALIB_API int luaL_typeerror (lua_State *L, int arg, const char *tname) {
const char *msg;
const char *typearg; /* name for the type of the actual argument */
if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING)
typearg = lua_tostring(L, -1); /* use the given type name */
else if (lua_type(L, arg) == ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x20b6f(%rip), %rdx # 0x294f8
callq 0x89f6
movq %r14, %rdi
cmpl $0x4, %eax
jne 0x89a4
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6bb8
jmp 0x89cd
movl %ebx, %esi
callq 0x68d4
cmpl $0x2, %eax
jne 0x89b9
... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
resizebox | static void *resizebox (lua_State *L, int idx, size_t newsize) {
UBox *box = (UBox *)lua_touserdata(L, idx);
if (box->bsize == newsize) /* not changing size? */
return box->box; /* keep the buffer */
else {
void *ud;
lua_Alloc allocf = lua_getallocf(L, &ud);
void *temp = allocf(ud, box->box, box... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
callq 0x6cbc
movq %rax, %r14
cmpq %rbx, 0x8(%rax)
jne 0x9193
movq (%r14), %r12
jmp 0x91c5
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x7ec9
movq (%r12), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rcx
callq *%r... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_ref | LUALIB_API int luaL_ref (lua_State *L, int t) {
int ref;
if (lua_isnil(L, -1)) {
lua_pop(L, 1); /* remove from stack */
return LUA_REFNIL; /* 'nil' has a unique fixed reference */
}
t = lua_absindex(L, t);
if (lua_rawgeti(L, t, 1) == LUA_TNUMBER) /* already initialized? */
ref = (int)lua_tointe... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x68d4
testl %eax, %eax
je 0x9279
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6619
movl %eax, %ebp
movl $0x1, %edx
movq %rbx, %rdi
movl %eax, %esi
callq 0x72... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_unref | LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
if (ref >= 0) {
t = lua_absindex(L, t);
lua_rawgeti(L, t, 1);
lua_assert(lua_isinteger(L, -1));
lua_rawseti(L, t, ref); /* t[ref] = t[1] */
lua_pushinteger(L, ref);
lua_rawseti(L, t, 1); /* t[1] = ref */
}
} | testl %edx, %edx
js 0x9356
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0x6619
movl %eax, %r14d
movl $0x1, %edx
movq %rbx, %rdi
movl %eax, %esi
callq 0x729c
movl %ebp, %r15d
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x7782
movq %rbx, %rdi
movq %r15, %rsi
call... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_loadfilex | LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename,
const char *mode) {
LoadF lf;
int status, readstatus;
int c;
int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */
if (filename == NULL) {
lua_pushliteral(L, "=stdin");
l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2018, %rsp # imm = 0x2018
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x663a
movl %eax, %ebp
incl %ebp
testq %r14, %r14
je 0x93c3
leaq 0x201fa(%rip), %rsi # 0x29580
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
skipcomment | static int skipcomment (FILE *f, int *cp) {
int c = *cp = skipBOM(f);
if (c == '#') { /* first line is a comment (Unix exec. file)? */
do { /* skip first line */
c = getc(f);
} while (c != EOF && c != '\n');
*cp = getc(f); /* next character after comment, if present */
return 1; /* there w... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5120
movl %eax, %ebp
cmpl $0xef, %eax
jne 0x95f6
movq %r14, %rdi
callq 0x5120
cmpl $0xbb, %eax
jne 0x95f6
movq %r14, %rdi
callq 0x5120
cmpl $0xbf, %eax
jne 0x95f6
movq %r14, %rdi
callq 0x5120
movl %eax, %ebp
movl %ebp, (%rbx)
xorl %eax, %eax
cmpl ... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
getF | static const char *getF (lua_State *L, void *ud, size_t *size) {
LoadF *lf = (LoadF *)ud;
(void)L; /* not used */
if (lf->n > 0) { /* are there pre-read characters to be read? */
*size = lf->n; /* return them (chars already in buffer) */
lf->n = 0; /* no more pre-read characters */
}
else { /* re... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl (%rsi), %eax
testq %rax, %rax
je 0x9645
movq %rax, (%r14)
movl $0x0, (%rbx)
addq $0x10, %rbx
jmp 0x9654
movq 0x8(%rbx), %rdi
callq 0x5490
testl %eax, %eax
je 0x965f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10(%r... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
getS | static const char *getS (lua_State *L, void *ud, size_t *size) {
LoadS *ls = (LoadS *)ud;
(void)L; /* not used */
if (ls->size == 0) return NULL;
*size = ls->size;
ls->size = 0;
return ls->s;
} | movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x96b7
movq %rax, (%rdx)
movq $0x0, 0x8(%rsi)
movq (%rsi), %rax
retq
xorl %eax, %eax
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_len | LUALIB_API lua_Integer luaL_len (lua_State *L, int idx) {
lua_Integer l;
int isnum;
lua_len(L, idx);
l = lua_tointegerx(L, -1, &isnum);
if (l_unlikely(!isnum))
luaL_error(L, "object length is not an integer");
lua_pop(L, 1); /* remove object */
return l;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7eaa
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x6b52
movq %rax, %r14
cmpl $0x0, (%r15)
je 0x9794
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movq %... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_tolstring | LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
idx = lua_absindex(L,idx);
if (luaL_callmeta(L, idx, "__tostring")) { /* metafield? */
if (!lua_isstring(L, -1))
luaL_error(L, "'__tostring' must return a string");
}
else {
switch (lua_type(L, idx)) {
case LUA_TNU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rdi, %r14
callq 0x6619
movl %eax, %ebp
leaq 0x1fde7(%rip), %rdx # 0x295ae
movq %r14, %rdi
movl %eax, %esi
callq 0x96f8
movq %r14, %rdi
testl %eax, %eax
je 0x9800
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x6960... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_setfuncs | LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
luaL_checkstack(L, nup, "too many upvalues");
for (; l->name != NULL; l++) { /* fill the table with given functions */
if (l->func == NULL) /* placeholder? */
lua_pushboolean(L, 0);
else {
int i;
for (i = 0; i < n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x1fcba(%rip), %rdx # 0x295ed
movl %ebx, %esi
callq 0x8e28
cmpq $0x0, (%r15)
je 0x999d
movl %ebx, %ebp
negl %ebp
movl $0xfffffffe, %r12d # imm = 0xFFFFFFFE
subl %ebx, %r12d
cmpq $0x... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_getsubtable | LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
if (lua_getfield(L, idx, fname) == LUA_TTABLE)
return 1; /* table already there */
else {
lua_pop(L, 1); /* remove previous result */
idx = lua_absindex(L, idx);
lua_newtable(L);
lua_pushvalue(L, -1); /* copy to be l... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
callq 0x71a1
movl $0x1, %ebp
cmpl $0x5, %eax
je 0x9a1a
movq %r14, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movq %r14, %rdi
movl %r15d, %esi
callq 0x6619
movl %eax, %r15d
xorl %ebp, %ebp
movq ... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_requiref | LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
lua_CFunction openf, int glb) {
luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
lua_getfield(L, -1, modname); /* LOADED[modname] */
if (!lua_toboolean(L, -1)) { /* package not already loaded? */
lua_po... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1fbbf(%rip), %rdx # 0x295ff
movl $0xfff0b9d8, %esi # imm = 0xFFF0B9D8
callq 0x99b7
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %rbx, %rdx
callq 0x71a1
movq %r1... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_addgsub | LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s,
const char *p, const char *r) {
const char *wild;
size_t l = strlen(p);
while ((wild = strstr(s, p)) != NULL) {
luaL_addlstring(b, s, ct_diff2sz(wild - s)); /* push prefix */
luaL_addstring(b, r); /* push r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x5180
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x50f0
testq %rax, %rax
je 0x9b99
movq %rax, %r14
movq %r14, %rbp
subq %r12, %rbp
je 0x9b74
mo... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_gsub | LUALIB_API const char *luaL_gsub (lua_State *L, const char *s,
const char *p, const char *r) {
luaL_Buffer b;
luaL_buffinit(L, &b);
luaL_addgsub(&b, s, p, r);
luaL_pushresult(&b);
return lua_tostring(L, -1);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x420, %rsp # imm = 0x420
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x20(%rsp), %rax
movq %rdi, -0x8(%rax)
movq %rax, -0x20(%rax)
movq $0x0, -0x10(%rax)
movq $0x400, -0x18(%rax) # imm = 0x400
movq %rsp, %r13
movq %r13... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luai_makeseed | static unsigned int luai_makeseed (void) {
unsigned int buff[BUFSEED];
unsigned int res;
unsigned int i;
time_t t = time(NULL);
char *b = (char*)buff;
addbuff(b, b); /* local variable's address */
addbuff(b, t); /* time */
/* fill (rare but possible) remain of the buffer with zeros */
memset(b, 0, s... | subq $0x18, %rsp
xorl %edi, %edi
callq 0x52e0
movq %rax, %rcx
movq %rsp, %rax
movq %rax, (%rax)
movq %rcx, 0x8(%rax)
movl $0x1, %ecx
movl %eax, %edx
movl %eax, %esi
shrl $0x3, %esi
shll $0x7, %eax
addl %esi, %eax
addl (%rsp,%rcx,4), %eax
xorl %edx, %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x9c4e
addq $0x18, %rsp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
l_alloc | static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
(void)ud; (void)osize; /* not used */
if (nsize == 0) {
free(ptr);
return NULL;
}
else
return realloc(ptr, nsize);
} | movq %rsi, %rdi
testq %rcx, %rcx
je 0x9c7d
movq %rcx, %rsi
jmp 0x54c0
pushq %rax
callq 0x53c0
xorl %eax, %eax
popq %rcx
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
luaL_checkversion_ | LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
lua_Number v = lua_version(L);
if (sz != LUAL_NUMSIZES) /* check numeric types */
luaL_error(L, "core and library have incompatible numeric types");
else if (v != ver)
luaL_error(L, "version mismatch: app. needs %f, Lua core p... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0x6610
cmpq $0x88, %r14
jne 0x9cd2
movapd %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm0, %xmm1
jne 0x9cba
jnp 0x9cea
leaq 0x1f977(%rip), %rsi # 0x29638
movq %rbx, %rdi
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
findfield | static int findfield (lua_State *L, int objidx, int level) {
if (level == 0 || !lua_istable(L, -1))
return 0; /* not found */
lua_pushnil(L); /* start 'next' loop */
while (lua_next(L, -2)) { /* for each pair in table */
if (lua_type(L, -2) == LUA_TSTRING) { /* ignore non-string keys */
if (lua_... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testl %edx, %edx
je 0x9de6
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x68d4
cmpl $0x5, %eax
jne 0x9de6
movq %rbx, %rdi
callq 0x6d71
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0x... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
checkcontrol | static int checkcontrol (lua_State *L, const char *message, int tocont) {
if (tocont || *(message++) != '@') /* not a control message? */
return 0;
else {
if (strcmp(message, "off") == 0)
lua_setwarnf(L, warnfoff, L); /* turn warnings off */
else if (strcmp(message, "on") == 0)
lua_setwarn... | xorl %eax, %eax
testl %edx, %edx
je 0x9e0b
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpb $0x40, (%rsi)
jne 0x9e6a
movq %rdi, %rbx
incq %r14
leaq 0x1f964(%rip), %rsi # 0x29788
movq %r14, %rdi
callq 0x5420
testl %eax, %eax
je 0x9e53
leaq 0x2152b(%rip), %rsi # 0x2b362
movq %r14, %rdi
callq 0x5420
movl... | /mmanyen[P]CLua/build_O1/_deps/lua/lauxlib.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.