name string | code string | asm string | file string |
|---|---|---|---|
mbedtls_cipher_auth_encrypt | int mbedtls_cipher_auth_encrypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *ad, size_t ad_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rax
movq %r8, %r10
movq %rcx, %r9
movq %rdx, %r8
movq %rsi, %rcx
movq 0x50(%rsp), %rbx
movq 0x48(%rsp), %r14
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %r11
movq 0x30(%rsp), %rdx
movq (%rdi), %r15
movl 0x4(%r15), %ebp
cmpl $0x8, %ebp
je 0x7a4e
cmpl $0x6, %eb... | /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_auth_decrypt | int mbedtls_cipher_auth_decrypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *ad, size_t ad_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r10
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x50(%rsp), %rbx
movq 0x48(%rsp), %r11
movq 0x40(%rsp), %r15
movq 0x38(%rsp), %r14
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
movl 0x4(%rax), %ebp
cmpl $0x8, %ebp
je 0x7ae7
movl $0xffff9f... | /project-everest[P]mbedtls/library/cipher.c |
arc4_ctx_alloc | static void * arc4_ctx_alloc( void )
{
mbedtls_arc4_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_arc4_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_arc4_init( ctx );
return( ctx );
} | pushq %rbx
pushq $0x1
popq %rdi
movl $0x108, %esi # imm = 0x108
callq 0x40f0
movq %rax, %rbx
testq %rax, %rax
je 0x7c2b
movq %rbx, %rdi
callq 0xaafc
movq %rbx, %rax
popq %rbx
retq
| /project-everest[P]mbedtls/library/cipher_wrap.c |
des3_ctx_alloc | static void * des3_ctx_alloc( void )
{
mbedtls_des3_context *des3;
des3 = mbedtls_calloc( 1, sizeof( mbedtls_des3_context ) );
if( des3 == NULL )
return( NULL );
mbedtls_des3_init( des3 );
return( des3 );
} | pushq %rbx
pushq $0x1
popq %rdi
movl $0x180, %esi # imm = 0x180
callq 0x40f0
movq %rax, %rbx
testq %rax, %rax
je 0x7d84
movq %rbx, %rdi
callq 0x7de9
movq %rbx, %rax
popq %rbx
retq
| /project-everest[P]mbedtls/library/cipher_wrap.c |
mbedtls_des_setkey | void mbedtls_des_setkey( uint32_t SK[32], const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
uint32_t X, Y, T;
GET_UINT32_BE( X, key, 0 );
GET_UINT32_BE( Y, key, 4 );
/*
* Permuted Choice 1
*/
T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4);
T = ((Y ) ^ X) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, -0x8(%rsp)
movzbl (%rsi), %ecx
movl %ecx, %eax
shll $0x18, %eax
movzbl 0x1(%rsi), %edx
shll $0x10, %edx
orl %eax, %edx
movzbl 0x2(%rsi), %eax
shll $0x8, %eax
movzbl 0x3(%rsi), %r8d
orl %edx, %r8d
orl %eax, %r8d
movl 0x4(%rsi), %edx
bswapl %edx... | /project-everest[P]mbedtls/library/des.c |
mbedtls_des_setkey_dec | int mbedtls_des_setkey_dec( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
mbedtls_des_setkey( ctx->sk, key );
for( i = 0; i < 16; i += 2 )
{
SWAP( ctx->sk[i ], ctx->sk[30 - i] );
SWAP( ctx->sk[i + 1], ctx->sk[31 - i] );
}
return( 0 );
} | pushq %rbx
movq %rdi, %rbx
callq 0x7e78
leaq 0x7c(%rbx), %rax
xorl %ecx, %ecx
cmpq $0xf, %rcx
ja 0x8323
movl (%rbx,%rcx,4), %edx
movl -0x4(%rax), %esi
movl %esi, (%rbx,%rcx,4)
movl %edx, -0x4(%rax)
movl 0x4(%rbx,%rcx,4), %edx
movl (%rax), %esi
movl %esi, 0x4(%rbx,%rcx,4)
movl %edx, (%rax)
addq $0x2, %rcx
addq $-0x8, %r... | /project-everest[P]mbedtls/library/des.c |
des3_set2key | static void des3_set2key( uint32_t esk[96],
uint32_t dsk[96],
const unsigned char key[MBEDTLS_DES_KEY_SIZE*2] )
{
int i;
mbedtls_des_setkey( esk, key );
mbedtls_des_setkey( dsk + 32, key + 8 );
for( i = 0; i < 32; i += 2 )
{
dsk[i ] =... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7e78
leaq 0x80(%rbx), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x7e78
pushq $0x40
popq %rax
pushq $0x1f
popq %rcx
leaq -0x40(%rax), %rdx
cmpq $0x1f, %rdx
ja 0x83dc
movl -0x4(%r14,%rcx,4), %edx
movl %edx, -0x100(%r... | /project-everest[P]mbedtls/library/des.c |
des3_set3key | static void des3_set3key( uint32_t esk[96],
uint32_t dsk[96],
const unsigned char key[24] )
{
int i;
mbedtls_des_setkey( esk, key );
mbedtls_des_setkey( dsk + 32, key + 8 );
mbedtls_des_setkey( esk + 64, key + 16 );
for( i = 0; i < 32; i += 2 )
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7e78
leaq 0x80(%rbx), %rdi
leaq 0x8(%r15), %rsi
callq 0x7e78
leaq 0x100(%r14), %rdi
addq $0x10, %r15
movq %r15, %rsi
callq 0x7e78
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x1f, %rcx
ja 0x84db
movl 0x178(%r14,%rax), %ed... | /project-everest[P]mbedtls/library/des.c |
mbedtls_aes_setkey_dec | int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int i, j, ret;
mbedtls_aes_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_aes_init( &cty );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movl $0x120, %edx # imm = 0x120
movq %r12, %rdi
xorl %esi, %esi
callq 0x40c0
leaq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
movq %r12, ... | /project-everest[P]mbedtls/library/aes.c |
mbedtls_internal_aes_encrypt | int mbedtls_internal_aes_encrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
RK = ctx->rk;
GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
movl (%rax), %r8d
movl 0x4(%rax), %r9d
xorl (%rsi), %r8d
xorl 0x4(%rsi), %r9d
movq %rdx, -0x8(%rsp)
movl 0x8(%rax), %r11d
xorl 0x8(%rsi), %r11d
movl 0xc(%rax), %edx
xorl 0xc(%rsi), %edx
movl (%rdi), %ecx
sarl %ecx
addq $0x2c, %rax
mo... | /project-everest[P]mbedtls/library/aes.c |
mbedtls_internal_aes_decrypt | int mbedtls_internal_aes_decrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
RK = ctx->rk;
GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
movl (%rax), %ecx
movl 0x4(%rax), %r8d
xorl (%rsi), %ecx
xorl 0x4(%rsi), %r8d
movq %rdx, -0x8(%rsp)
movl 0x8(%rax), %r11d
xorl 0x8(%rsi), %r11d
movl 0xc(%rax), %r15d
xorl 0xc(%rsi), %r15d
movl (%rdi), %edx
sarl %edx
addq $0x2c, %rax
... | /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_crypt_ecb | int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
return( mbe... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x2000000, %edi # imm = 0x2000000
callq 0x6b2c
movq %r15, %rdi
testl %eax, %eax
je 0xa214
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq... | /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_crypt_cfb8 | int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
unsigned char c;
unsigned char ov[17];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
xorl %r14d, %r14d
cmpq %r14, %r12
je 0xa44b
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r13, %rdi
pushq $0x1
popq %rsi
movq %r15... | /project-everest[P]mbedtls/library/aes.c |
mbedtls_arc4_self_test | int mbedtls_arc4_self_test( int verbose )
{
int i, ret = 0;
unsigned char ibuf[8];
unsigned char obuf[8];
mbedtls_arc4_context ctx;
mbedtls_arc4_init( &ctx );
for( i = 0; i < 3; i++ )
{
if( verbose != 0 )
mbedtls_printf( " ARC4 test #%d: ", i + 1 );
memcpy( ib... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edi, %ebx
leaq 0x10(%rsp), %r14
movl $0x108, %edx # imm = 0x108
movq %r14, %rdi
xorl %esi, %esi
callq 0x40c0
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r15
leaq 0x4a89(%rip), %r12 # 0xf690
xorl ... | /project-everest[P]mbedtls/library/arc4.c |
blowfish_enc | static void blowfish_enc( mbedtls_blowfish_context *ctx, uint32_t *xl, uint32_t *xr )
{
uint32_t Xl, Xr, temp;
short i;
Xl = *xl;
Xr = *xr;
for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS; ++i )
{
Xl = Xl ^ ctx->P[i];
Xr = F( ctx, Xl ) ^ Xr;
temp = Xl;
Xl = Xr;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
movl (%rdx), %r12d
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0xae7a
movl %eax, %ebp
xorl (%r15,%r13,4), %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0xb150
xorl %r12d, %eax
incq %r13
... | /project-everest[P]mbedtls/library/blowfish.c |
mbedtls_camellia_setkey_dec | int mbedtls_camellia_setkey_dec( mbedtls_camellia_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int idx, ret;
size_t i;
mbedtls_camellia_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_camellia_init( &cty );
/* Also checks keybits */
if( ( r... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movl $0x114, %edx # imm = 0x114
movq %r15, %rdi
xorl %esi, %esi
callq 0x40c0
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xb1b7
movl %eax, %ebp... | /project-everest[P]mbedtls/library/camellia.c |
mbedtls_camellia_crypt_ecb | int mbedtls_camellia_crypt_ecb( mbedtls_camellia_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
int NR;
uint32_t *RK, X[4];
( (void) mode );
NR = ctx->nr;
RK = ctx->rk;
GET_UINT32_BE( X[0], input,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movl (%rdi), %r13d
movl (%rdx), %eax
movl 0x4(%rdx), %ecx
bswapl %eax
bswapl %ecx
movl 0x8(%rdx), %esi
leaq 0x8(%rsp), %r15
xorl 0x4(%rdi), %eax
movl 0xc(%rdx), %edx
movl %eax, -0x8(%r15)
xorl 0x8(%rdi), %... | /project-everest[P]mbedtls/library/camellia.c |
mbedtls_camellia_self_test | int mbedtls_camellia_self_test( int verbose )
{
int i, j, u, v;
unsigned char key[32];
unsigned char buf[64];
unsigned char src[16];
unsigned char dst[16];
#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char iv[16];
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
size_t offset, len;
unsigned ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movl %edi, %ebp
pxor %xmm0, %xmm0
leaq 0x80(%rsp), %rax
movdqa %xmm0, (%rax)
movdqa %xmm0, 0x10(%rax)
leaq 0x504f(%rip), %r14 # 0x10d90
leaq 0x4ab8(%rip), %r15 # 0x10800
xorl %r12d, %r12d
movl %edi, 0x... | /project-everest[P]mbedtls/library/camellia.c |
mbedtls_ccm_setkey | int mbedtls_ccm_setkey( mbedtls_ccm_context *ctx,
mbedtls_cipher_id_t cipher,
const unsigned char *key,
unsigned int keybits )
{
int ret;
const mbedtls_cipher_info_t *cipher_info;
cipher_info = mbedtls_cipher_info_from_values( cipher, ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
pushq $0x1
popq %rdx
movl %esi, %edi
movl %ecx, %esi
callq 0x7052
movq %rax, %r12
pushq $-0xd
popq %rax
testq %r12, %r12
je 0xc2c2
cmpl $0x10, 0x20(%r12)
jne 0xc2c2
movq %r15, %rdi
callq 0x709b
movq %r15, %rdi
movq %r... | /project-everest[P]mbedtls/library/ccm.c |
List<NameSingletonPair>::Get(long) const | Item& List<Item>::Get(long index) const {
if (_count <= _size) {
return _items[index];
} else {
throw std::out_of_range("Index out of range in List::Get");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
cmpq 0x8(%rdi), %rax
jg 0x1589
shlq $0x4, %rsi
addq (%rdi), %rsi
movq %rsi, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1040
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
lea... | /BartVandewoestyne[P]Design-Patterns-GoF/Creational_Patterns/Singleton/registry_of_singletons/../../../Foundation_Classes/List.cpp |
main | int main()
{
// TODO: commenting this line in shows that it is still possible to
// create instances of MySingleton using its default constructor. If
// we try to avoid that by making the MySingleton() constructor protected
// instead of public, then the line
// static MySingleton theSingleton;... | pushq %rax
callq 0x1340
leaq 0x96e(%rip), %rdi # 0x201f
movq %rax, %rsi
callq 0x148e
callq 0x1340
xorl %eax, %eax
popq %rcx
retq
| /BartVandewoestyne[P]Design-Patterns-GoF/Creational_Patterns/Singleton/registry_of_singletons/main.cpp |
ObjectList::hit(Ray const&, double, double, Hit&) const | bool ObjectList::hit(const Ray& r, double t_min, double t_max, Hit& rec) const {
Hit temp_hit;
bool hit_something = false;
double t_curr = t_max;
for (const auto& object : objects_) {
if (object->hit(r, t_min, t_curr, temp_hit) && temp_hit.t_ < t_curr) {
hit_something = true;
t_curr = temp_hit.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x18(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x58(%rsp)
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, 0x30(%rsp)
movapd %xmm0, 0x40(%rsp)
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %r15
cmpq %r15, %r12
je 0x7352
mo... | /pshriwise[P]openmc_render/src/geom.cpp |
gen_color(Vec3, int) | std::array<uint8_t, 3> gen_color( Color pixel_color, int n_samples) {
double r = pixel_color.x();
double g = pixel_color.y();
double b = pixel_color.z();
// Divide by the total number of samples per pixel
auto rcp_samples = 1.0 / n_samples;
r *= rcp_samples;
g *= rcp_samples;
b *= rcp_samples;
// Ga... | subq $0x18, %rsp
cvtsi2sd %edi, %xmm0
movsd 0x5bc8(%rip), %xmm1 # 0xd020
divsd %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x28(%rsp), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
mulsd 0x30(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x5bbf(%rip), %xmm1 # 0xd048
callq 0x6320
movsd %xmm0, 0x10(%... | /pshriwise[P]openmc_render/src/color.cpp |
void spdlog::logger::log_<int>(spdlog::source_loc, spdlog::level::level_enum, fmt::v9::basic_string_view<char>, int&&) | void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&... args)
{
bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled)
{
return;
}
SPDLOG_TRY
{
memo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %r8, %r13
movq %rcx, 0x28(%rsp)
movq %rdx, %r12
movl %esi, %ebp
movl 0x40(%rdi), %ebx
cmpl %esi, %ebx
setg %r15b
movq %rdi, 0x20(%rsp)
addq $0x68, %rdi
callq 0x3575c
movl %eax, %r14d
xorb $0x1, %al
testb %a... | /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/logger.h |
fast_float::adjusted_mantissa fast_float::digit_comp<double, char>(fast_float::parsed_number_string_t<char>&, fast_float::adjusted_mantissa) | inline FASTFLOAT_CONSTEXPR20
adjusted_mantissa digit_comp(parsed_number_string_t<UC>& num, adjusted_mantissa am) noexcept {
// remove the invalid exponent bias
am.power2 -= invalid_am_bias;
int32_t sci_exp = scientific_exponent(num);
size_t max_digits = binary_format<T>::max_digits();
size_t digits = 0;
bi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movl (%rdi), %ebx
incl %ebx
movl $0x2710, %ecx # imm = 0x2710
cmpq $0x270f, %rax # imm = 0x270F
jbe 0x3128c
xorl %edx, %ed... | /njoy[P]ENDFtk/build_O2/_deps/fast_float-src/include/fast_float/digit_comparison.h |
std::shared_ptr<spdlog::async_logger> spdlog::async_factory_impl<(spdlog::async_overflow_policy)0>::create<spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_nullmutex>, spdlog::color_mode&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, spdlog::color_mode&) | static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)
{
auto ®istry_inst = details::registry::instance();
// create global thread pool if not already exists..
auto &mutex = registry_inst.tp_mutex();
std::lock_guard<std::recursive_mutex> tp_loc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
callq 0x34970
movq %rax, %r15
movq %rax, %rdi
callq 0x35e02
movq %rax, %rbp
movq %rax, %rdi
callq 0x3c82a
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x35d6e
cmpq $0x0, 0x28(%rsp)
jne 0x426... | /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/async.h |
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 0x7ba8
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 0x7bb9
movl %eb... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
blowfish_ctx_alloc | static void * blowfish_ctx_alloc( void )
{
mbedtls_blowfish_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_blowfish_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_blowfish_init( ctx );
return( ctx );
} | pushq %rbx
movl $0x1, %edi
movl $0x1048, %esi # imm = 0x1048
callq 0x40f0
testq %rax, %rax
je 0x8607
movq %rax, %rbx
movq %rax, %rdi
callq 0xcc4c
jmp 0x8609
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/cipher_wrap.c |
mbedtls_des_crypt_ecb | int mbedtls_des_crypt_ecb( mbedtls_des_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
int i;
uint32_t X, Y, T, *SK;
SK = ctx->sk;
GET_UINT32_BE( X, input, 0 );
GET_UINT32_BE( Y, input, 4 );
DES_IP( X, Y );
for( i = 0; i < 8... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x10(%rsp)
movq %rdi, -0x8(%rsp)
movl (%rsi), %ecx
movl 0x4(%rsi), %eax
bswapl %ecx
bswapl %eax
movl %ecx, %edx
shrl $0x4, %edx
xorl %eax, %edx
andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F
xorl %edx, %eax
shll $0x4, %edx
xorl %ecx, %edx
mov... | /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_blowfish_crypt_ecb | int mbedtls_blowfish_crypt_ecb( mbedtls_blowfish_context *ctx,
int mode,
const unsigned char input[MBEDTLS_BLOWFISH_BLOCKSIZE],
unsigned char output[MBEDTLS_BLOWFISH_BLOCKSIZE] )
{
uint32_t X0, X1;
GET_UINT32_BE( X0, input, 0 );
GET_UINT32_BE( X1... | pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %ecx
bswapl %ecx
movl %ecx, 0xc(%rsp)
movl 0x4(%rdx), %eax
bswapl %eax
movl %eax, 0x8(%rsp)
testl %esi, %esi
je 0xce5b
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xcdbe
jmp 0xcec5
movl $0x12, %edx
movl $0xff, %esi
movl %eax, %r8d
movl %ecx, %eax
xorl -0x4(%r... | /Dragonchang[P]https_client/mbedtls/library/blowfish.c |
mbedtls_camellia_crypt_cbc | int mbedtls_camellia_crypt_cbc( mbedtls_camellia_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[16];
if( length %... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movl $0xffffffda, %eax # imm = 0xFFFFFFDA
testb $0xf, %r12b
jne 0xdbc1
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r13
testl %esi, %esi
je 0xdb7c
testq %r12, %r12
je 0xdbbf
xorl %eax, %eax
movb (%r15,%rax), %cl
x... | /Dragonchang[P]https_client/mbedtls/library/camellia.c |
mbedtls_ccm_setkey | int mbedtls_ccm_setkey( mbedtls_ccm_context *ctx,
mbedtls_cipher_id_t cipher,
const unsigned char *key,
unsigned int keybits )
{
int ret;
const mbedtls_cipher_info_t *cipher_info;
cipher_info = mbedtls_cipher_info_from_values( cipher, ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %edi
movl %ecx, %esi
movl $0x1, %edx
callq 0x7923
movq %rax, %r12
movl $0xfffffff3, %eax # imm = 0xFFFFFFF3
testq %r12, %r12
je 0xe2b9
cmpl $0x10, 0x20(%r12)
jne 0xe2b9
movq %r15, %rdi
callq 0x7978
mo... | /Dragonchang[P]https_client/mbedtls/library/ccm.c |
mbedtls_ccm_auth_decrypt | int mbedtls_ccm_auth_decrypt( mbedtls_ccm_context *ctx, size_t length,
const unsigned char *iv, size_t iv_len,
const unsigned char *add, size_t add_len,
const unsigned char *input, unsigned char *output,
const unsigned char *tag, si... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rax
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rbx
movq 0x48(%rsp), %r15
movq 0x38(%rsp), %r14
subq $0x8, %rsp
leaq 0x8(%rsp), %r10
movl $0x1, %esi
movq %rbx, %rdx
pushq %r15
pushq %r10
pushq %r14
pushq 0x50(%rsp)
pushq %rax
callq 0xe333
addq $0... | /Dragonchang[P]https_client/mbedtls/library/ccm.c |
mbedtls_ccm_self_test | int mbedtls_ccm_self_test( int verbose )
{
mbedtls_ccm_context ctx;
unsigned char out[32];
size_t i;
int ret;
mbedtls_ccm_init( &ctx );
if( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES, key, 8 * sizeof key ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( " CCM: setup f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edi, %ebx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
leaq 0x602e(%rip), %rdx # 0x148f... | /Dragonchang[P]https_client/mbedtls/library/ccm.c |
swapBytes(unsigned char*, int) | void swapBytes(unsigned char* var, int size)
{
int i = 0;
int j = size - 1;
char c;
while (i < j) {
c = var[i]; var[i] = var[j]; var[j] = c;
i++, j--;
}
} | cmpl $0x2, %esi
jl 0x12946
movl %esi, %eax
addq $-0x2, %rax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
movb 0x1(%rdi,%rax), %sil
movb %sil, (%rdi,%rcx)
movb %dl, 0x1(%rdi,%rax)
incq %rcx
leaq -0x1(%rax), %rdx
cmpq %rax, %rcx
movq %rdx, %rax
jl 0x12927
retq
| /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenio::save_edges(char*) | void tetgenio::save_edges(char* filebasename)
{
FILE *fout;
char outedgefilename[FILENAMESIZE];
int i;
sprintf(outedgefilename, "%s.edge", filebasename);
printf("Saving edges to %s\n", outedgefilename);
fout = fopen(outedgefilename, "w");
fprintf(fout, "%d %d\n", numberofedges, edgemarkerlist != NULL ? ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400, %rsp # imm = 0x400
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x5fa8a(%rip), %rsi # 0x736e1
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x8060
leaq 0x5fa7e(%rip), %rdi # 0x736e9
movq %r14, %rsi
xorl %eax, %eax
callq 0x8050
leaq 0... | /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenbehavior::usage() | void tetgenbehavior::usage()
{
printf("TetGen\n");
printf("A Quality Tetrahedral Mesh Generator and 3D Delaunay ");
printf("Triangulator\n");
printf("Version 1.5\n");
printf("May 31, 2014\n");
printf("\n");
printf("Copyright (C) 2002 - 2014\n");
printf("\n");
printf("What Can TetGen Do?\n");
printf(... | pushq %rax
leaq 0x632f8(%rip), %rdi # 0x778cc
callq 0x8320
leaq 0x5f21e(%rip), %rdi # 0x737fe
xorl %eax, %eax
callq 0x8050
leaq 0x632e5(%rip), %rdi # 0x778d3
callq 0x8320
leaq 0x632e6(%rip), %rdi # 0x778e0
callq 0x8320
leaq 0x632e6(%rip), %rdi # 0x778ec
callq 0x8320
movl $0xa, %edi
callq 0x82a0
leaq... | /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenmesh::memorypool::traverse() | void* tetgenmesh::memorypool::traverse()
{
void *newitem;
uintptr_t alignptr;
// Stop upon exhausting the list of items.
if (pathitem == nextitem) {
return (void *) NULL;
}
// Check whether any untraversed items remain in the current block.
if (pathitemsleft == 0) {
// Find the next block.
pa... | movq 0x28(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
je 0x163c9
movl 0x54(%rdi), %eax
testl %eax, %eax
jne 0x163b7
movq 0x20(%rdi), %rax
movq (%rax), %rax
movq %rax, 0x20(%rdi)
movslq 0x30(%rdi), %rsi
leaq (%rsi,%rax), %rcx
addq $0x8, %rcx
addq $0x8, %rax
xorl %edx, %edx
divq %rsi
subq %rdx, %rcx
movl 0x3c(%rdi), %eax
movslq 0x... | /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenmesh::incircle3d(double*, double*, double*, double*) | REAL tetgenmesh::incircle3d(point pa, point pb, point pc, point pd)
{
REAL area2[2], n1[3], n2[3], c[3];
REAL sign, r, d;
// Calculate the areas of the two triangles [a, b, c] and [b, a, d].
facenormal(pa, pb, pc, n1, 1, NULL);
area2[0] = dot(n1, n1);
facenormal(pb, pa, pd, n2, 1, NULL);
area2[1] = dot(n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x18(%rsp)
xorl %ebx, %ebx
movq %rbx, (%rsp)
leaq 0x90(%rsp), %rbp
movq %rbp, %r8
movl $0x1, %r9d
callq 0x183c8
movaps (%rbp), %xmm0
movaps %xmm0, 0x30(%rsp)
movup... | /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenmesh::orthosphere(double*, double*, double*, double*, double, double, double, double, double*, double*) | bool tetgenmesh::orthosphere(REAL* pa, REAL* pb, REAL* pc, REAL* pd,
REAL aheight, REAL bheight, REAL cheight,
REAL dheight, REAL* orthocent, REAL* radius)
{
REAL A[4][4], rhs[4], D;
int indx[4];
// Set the coefficient matrix A (4 x 4).
A[0][0] = 1.0... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %r9, %rbx
movq %rsi, %rax
movq 0xe0(%rsp), %r14
movabsq $0x3ff0000000000000, %rdi # imm = 0x3FF0000000000000
leaq 0x40(%rsp), %rsi
movq %rdi, (%rsi)
movups (%rax), %xmm4
movups %xmm4, 0x8(%rsi)
movsd 0x10(%rax), %xmm4
movsd %xmm4, 0x18(%rsi)
movq %rdi, 0x20(%rsi)
m... | /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenmesh::finddirection(tetgenmesh::triface*, double*) | enum tetgenmesh::interresult
tetgenmesh::finddirection(triface* searchtet, point endpt)
{
triface neightet;
point pa, pb, pc, pd;
enum {HMOVE, RMOVE, LMOVE} nextmove;
REAL hori, rori, lori;
int t1ver;
int s;
// The origin is fixed.
pa = org(*searchtet);
if ((point) searchtet->tet[7] == dummypoint)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq (%rsi), %rsi
movslq 0x8(%rbx), %rcx
leaq 0x56354(%rip), %rdx # 0x80270
movslq (%rdx,%rcx,4), %rdx
movq (%rsi,%rdx,8), %r13
movq 0x38(%rsi), %rdx
movq %rdi, (%rsp)
cmpq 0x118(%rdi), %rdx
jne 0x29f6... | /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenmesh::hilbert_split(double**, int, int, int, double, double, double, double, double, double) | int tetgenmesh::hilbert_split(point* vertexarray,int arraysize,int gc0,int gc1,
REAL bxmin, REAL bxmax, REAL bymin, REAL bymax,
REAL bzmin, REAL bzmax)
{
point swapvert;
int axis, d;
REAL split;
int i, j;
// Find the current splitting axis. 'axis'... | pushq %rbx
xorl %ecx, %r8d
movl %r8d, %eax
sarl %eax
cmpl $0x1, %r8d
ja 0x2a879
addsd %xmm1, %xmm0
jmp 0x2a890
cmpl $0x1, %eax
jne 0x2a888
addsd %xmm3, %xmm2
movapd %xmm2, %xmm0
jmp 0x2a890
addsd %xmm5, %xmm4
movapd %xmm4, %xmm0
mulsd 0x47798(%rip), %xmm0 # 0x72030
leal -0x1(%rdx), %r8d
btl %eax, %ecx
movslq %eax, %... | /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
doctest::detail::MessageBuilder::log() | bool MessageBuilder::log() {
m_string = getTlsOssResult();
DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
const bool isWarn = m_severity & assertType::is_warn;
// warn is just a message in this context so we don't treat it as an assert
if(!isWarn) {
addAsser... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x88c0
cmpb $0x0, 0x17(%rbx)
jns 0xb664
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb664
callq 0x65e0
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x2fe7d(%rip), %rax # 0x3b4f... | /taskflow[P]taskflow/3rd-party/doctest/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_case_skipped(doctest::TestCaseData const&) | void test_case_skipped(const TestCaseData& in) override {
if(opt.no_skipped_summary == false) {
test_case_start_impl(in);
xml.writeAttribute("skipped", "true");
xml.endElement();
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x78(%rdi), %rax
cmpb $0x0, 0x7f(%rax)
jne 0x157e3
movq %rdi, %rbx
callq 0x163b6
addq $0x8, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x17239(%rip), %rsi # 0x2c9da
leaq 0x17239(%rip), %rdx # 0x2c9e1
movq %rsp, %r14
movq %r14, %rdi
callq 0x26b5e... | /taskflow[P]taskflow/3rd-party/doctest/doctest.h |
doctest::(anonymous namespace)::operator<<(std::ostream&, doctest::(anonymous namespace)::XmlEncode const&) | std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
xmlEncode.encodeTo( os );
return os;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x15ec8
movq %rsi, %r14
xorl %r15d, %r15d
leaq 0x159f8(%rip), %r13 # 0x2b68e
movq %rsp, %r12
leaq 0x159de(%rip), %rbp # 0x2b67e
movq (%r14), %rax
movb (%rax,%r15), %dl
addq... | /taskflow[P]taskflow/3rd-party/doctest/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::file_line_to_stream(char const*, int, char const*) | virtual void file_line_to_stream(const char* file, int line,
const char* tail = "") {
s << Color::LightGrey << skipPathFromFilename(file) << (opt.gnu_file_line ? ":" : "(")
<< (opt.no_line_numbers ? 0 : line) // 0 or the real num depending on the option
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq %r15, %rdi
movl $0x17, %esi
callq 0x8f2b
movq %r12, %rdi
callq 0x93b9
testq %rax, %rax
je 0x1ab16
movq %rax, %r12
movq %rax, %rdi
callq 0x61b0
movq %r15, %rdi
movq %r12, %rsi
... | /taskflow[P]taskflow/3rd-party/doctest/doctest.h |
tf::NonblockingNotifierV2::commit_wait(tf::NonblockingNotifierV2::Waiter*) | void commit_wait(Waiter* w) {
#if __cplusplus >= TF_CPP20
w->state.store(Waiter::kNotSignaled, std::memory_order_relaxed);
#else
w->state = Waiter::kNotSignaled;
#endif
const uint64_t me = (w - &_waiters[0]) | w->epoch;
uint64_t state = _state.load(std::memory_order_seq_cst);
for (;;) {
//_che... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x3fff0000000, %rdi # imm = 0x3FFF0000000
movl $0x0, 0x68(%rsi)
movq %rsi, %r12
subq 0x8(%r14), %r12
sarq $0x7, %r12
orq 0x8(%rsi), %r12
movq (%r14), %r15
movabsq $-0x3ffffffc001, %r13 # imm = 0xFF... | /taskflow[P]taskflow/taskflow/core/nonblocking_notifier.hpp |
tf::TFProfManager::TFProfManager() | inline TFProfManager::TFProfManager() :
_fpath {get_env(TF_ENABLE_PROFILER)} {
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa140(%rip), %rsi # 0x2b356
leaq 0xa14b(%rip), %rdx # 0x2b368
movq %rsp, %r14
movq %r14, %rdi
callq 0x26b5e
movq (%r14), %rdi
callq 0x65b0
testq %rax, %rax
leaq 0x942f(%rip), %r14 # 0x2a66... | /taskflow[P]taskflow/taskflow/core/observer.hpp |
tf::TFProfObserver::dump(std::ostream&) const | inline void TFProfObserver::dump(std::ostream& os) const {
using namespace std::chrono;
size_t first;
for(first = 0; first<_timeline.segments.size(); ++first) {
if(_timeline.segments[first].size() > 0) {
break;
}
}
// not timeline data to dump
if(first == _timeline.segments.size()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rax
cmpq %rcx, %rdx
je 0x2168d
cmpq $0... | /taskflow[P]taskflow/taskflow/core/observer.hpp |
tf::TFProfObserver::summary(std::ostream&) const | inline void TFProfObserver::summary(std::ostream& os) const {
using namespace std::chrono;
Summary summary;
std::optional<observer_stamp_t> view_beg, view_end;
// find the first non-empty worker
size_t first;
for(first = 0; first<_timeline.segments.size(); ++first) {
if(_timeline.segments[first].si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
xorps %xmm0, %xmm0
movups %xmm0, 0x160(%rsp,%rax)
addq $0x20, %rax
cmpq $0xe0, %rax
jne 0x21a92
xorps %xmm0, %xmm0
movups %xmm0, 0x240(%rsp)
movq $0x0, 0x250(%rsp)... | /taskflow[P]taskflow/taskflow/core/observer.hpp |
long tf::Serializer<std::basic_ofstream<char, std::char_traits<char>>, long>::_save<std::vector<tf::Timeline, std::allocator<tf::Timeline>> const&, (void*)0>(std::vector<tf::Timeline, std::allocator<tf::Timeline>> const&) | SizeType Serializer<Stream, SizeType>::_save(T&& t) {
using U = std::decay_t<T>;
auto sz = _save(make_size_tag(t.size()));
if constexpr (std::is_arithmetic_v<typename U::value_type>) {
_stream.write(
reinterpret_cast<const char*>(t.data()),
t.size() * sizeof(typename U::value_type)
);
s... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movq %rsp, %rsi
movq %rcx, (%rsi)
movq (%rdi), %rdi
movl $0x8, %r14d
movl $0x8, %edx
callq 0x6600
m... | /taskflow[P]taskflow/taskflow/core/../utility/serializer.hpp |
long tf::Serializer<std::basic_ofstream<char, std::char_traits<char>>, long>::_save<std::vector<std::vector<std::vector<tf::Segment, std::allocator<tf::Segment>>, std::allocator<std::vector<tf::Segment, std::allocator<tf::Segment>>>>, std::allocator<std::vector<std::vector<tf::Segment, std::allocator<tf::Segment>>, std... | SizeType Serializer<Stream, SizeType>::_save(T&& t) {
using U = std::decay_t<T>;
auto sz = _save(make_size_tag(t.size()));
if constexpr (std::is_arithmetic_v<typename U::value_type>) {
_stream.write(
reinterpret_cast<const char*>(t.data()),
t.size() * sizeof(typename U::value_type)
);
s... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rsp, %rsi
movq %rcx, (%rsi)
movq (%rdi), %rdi
movl $0x8, %r14d
movl $0x8, %edx
callq 0x6600
m... | /taskflow[P]taskflow/taskflow/core/../utility/serializer.hpp |
long tf::Serializer<std::basic_ofstream<char, std::char_traits<char>>, long>::_save<std::vector<std::vector<tf::Segment, std::allocator<tf::Segment>>, std::allocator<std::vector<tf::Segment, std::allocator<tf::Segment>>>> const&, (void*)0>(std::vector<std::vector<tf::Segment, std::allocator<tf::Segment>>, std::allocato... | SizeType Serializer<Stream, SizeType>::_save(T&& t) {
using U = std::decay_t<T>;
auto sz = _save(make_size_tag(t.size()));
if constexpr (std::is_arithmetic_v<typename U::value_type>) {
_stream.write(
reinterpret_cast<const char*>(t.data()),
t.size() * sizeof(typename U::value_type)
);
s... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rsp, %rsi
movq %rcx, (%rsi)
movq (%rdi), %rdi
movl $0x8, %r14d
movl $0x8, %edx
callq 0x6600
m... | /taskflow[P]taskflow/taskflow/core/../utility/serializer.hpp |
long tf::Serializer<std::basic_ofstream<char, std::char_traits<char>>, long>::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, tf::TaskType const&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&, s... | SizeType Serializer<Stream, SizeType>::operator() (T&&... items) {
return (_save(std::forward<T>(items)) + ...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
callq 0x226f6
movq %rax, %rbx
movl (%r13), %eax
leaq 0x8(%rsp), %r13
movl %eax, (%r13)
movq (%r15), %rdi
movl $0x4, %edx
movq %r13, %rsi
callq 0x6600
movq (%r12), %rax
movq %rax, (%r13)... | /taskflow[P]taskflow/taskflow/core/../utility/serializer.hpp |
long tf::Serializer<std::basic_ofstream<char, std::char_traits<char>>, long>::_save<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, (void*)0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SizeType Serializer<Stream, SizeType>::_save(T&& t) {
using U = std::decay_t<T>;
auto sz = _save(make_size_tag(t.size()));
_stream.write(
reinterpret_cast<const char*>(t.data()),
t.size()*sizeof(typename U::value_type)
);
return sz + t.size()*sizeof(typename U::value_type);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq (%rdi), %rdi
movl $0x8, %edx
callq 0x6600
movq (%r14), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x6600
movq 0x8(%rbx), %rax
addq $0x8, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /taskflow[P]taskflow/taskflow/core/../utility/serializer.hpp |
tf::TFProfObserver::Summary::dump_tsum(std::ostream&) const | inline void TFProfObserver::Summary::dump_tsum(std::ostream& os) const {
// task summary
size_t type_w{10}, count_w{5}, time_w{9}, avg_w{8}, min_w{8}, max_w{8};
std::for_each(tsum.begin(), tsum.end(), [&](const auto& i){
if(i.count == 0) return;
count_w = (std::max)(count_w, std::to_string(i.count).size())... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x200000000, %r13 # imm = 0x200000000
leaq 0x20(%rsp), %rax
movq $0x5, (%rax)
movq %rax, %rdx
leaq 0x50(%rsp), %r15
movq $0x9, (%r15)
movl $0x8, %eax
leaq 0x48(%rsp), %rbp
movq %rax, (%rbp)
l... | /taskflow[P]taskflow/taskflow/core/observer.hpp |
tf::TFProfObserver::Summary::dump_wsum(std::ostream&) const | inline void TFProfObserver::Summary::dump_wsum(std::ostream& os) const {
// task summary
size_t w_w{10}, t_w{10}, l_w{5}, c_w{5}, d_w{9}, avg_w{8}, min_w{8}, max_w{8};
std::for_each(wsum.begin(), wsum.end(), [&](const auto& i){
if(i.count == 0) return;
l_w = (std::max)(l_w, std::to_string(i.level).siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movl $0x5, %eax
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, %rdx
leaq 0x40(%rsp), %r14
movq %rax, (%r14)
leaq 0x58(%rsp), %r12
movq $0x9, (%r12)
movl $0x8, %eax
leaq 0x50(%rsp), %r15
movq %rax, (%r1... | /taskflow[P]taskflow/taskflow/core/observer.hpp |
tf::TFProfObserver::on_exit(tf::WorkerView, tf::TaskView) | inline void TFProfObserver::on_exit(WorkerView wv, TaskView tv) {
size_t w = wv.id();
assert(!_stacks[w].empty());
if(_stacks[w].size() > _timeline.segments[w].size()) {
_timeline.segments[w].resize(_stacks[w].size());
}
auto beg = _stacks[w].top();
_stacks[w].pop();
_timeline.segments[w][_stac... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq 0x30(%rdi), %rdx
leaq (%rax,%rax,4), %r15
shlq $0x4, %r15
movq 0x48(%rdx,%r15), %rcx
movq %rcx, %rdi
subq 0x28(%rdx,%r15), %rdi
shrq $0x3, %rdi
cmpq $0x1, %rcx
adcq $-0x1, %rdi
movq 0x18(%r14), %rcx
sh... | /taskflow[P]taskflow/taskflow/core/observer.hpp |
dg::DGLLVMPointerAnalysis::getLLVMPointsTo(llvm::Value const*) | LLVMPointsToSet getLLVMPointsTo(const llvm::Value *val) override {
DGLLVMPointsToSet *pts;
if (auto *node = getPointsToNode(val)) {
if (node->pointsTo.empty()) {
pts = new DGLLVMPointsToSet(getUnknownPTSet());
} else {
pts = new DGLLVMPointsToSet(n... | subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x70420
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x6e74f
movq 0x30(%rsp), %rdi
addq $0xb0, %rdi
callq 0x70460
testb $0x1,... | /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::DGLLVMPointerAnalysis::getLLVMPointsToChecked(llvm::Value const*) | std::pair<bool, LLVMPointsToSet>
getLLVMPointsToChecked(const llvm::Value *val) override {
DGLLVMPointsToSet *pts;
if (auto *node = getPointsToNode(val)) {
if (node->pointsTo.empty()) {
pts = new DGLLVMPointsToSet(getUnknownPTSet());
return {false, pts->to... | subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x70420
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x6e8c0
movq 0x60(%rsp), %rdi
addq $0xb0, %rdi
callq 0x70460
testb $0x1,... | /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::pta::PointerGraph::PointerGraph() | PointerGraph() {
// nodes[0] represents invalid node (the node with id 0)
nodes.emplace_back(nullptr);
// the first several nodes are special nodes. For now, we just replace
// them with nullptr, as those are created statically <-- FIXME!
nodes.emplace_back(nullptr);
node... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
callq 0x6edd0
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
callq 0x6ede0
movq 0x8(%rsp), %rdi
movl $0x3, 0x40(%rdi)
addq $0x48, %rdi
callq 0x6edf0
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
call... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerGraph.h |
dg::pta::LLVMPointerGraphBuilder::getPointsToNodeOrNull(llvm::Value const*) | PSNode *getPointsToNodeOrNull(const llvm::Value *val) {
// if we have a mapping for this node (e.g. the original
// node was optimized away and replaced by mapping),
// return it
if (auto *mp = mapping.get(val))
return mp;
if (auto *nds = getNodes(val)) {
... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x98, %rdi
movq 0x20(%rsp), %rsi
callq 0x705e0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x70592
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x705c8
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7... | /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerGraph.h |
dg::pta::LLVMPointerGraphBuilder::getNodes(llvm::Value const*) | PSNodesSeq *getNodes(const llvm::Value *val) {
auto it = nodes_map.find(val);
if (it == nodes_map.end())
return nullptr;
// the node corresponding to the real llvm value
// is always the last
return &it->second;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x188, %rdi # imm = 0x188
leaq 0x20(%rsp), %rsi
callq 0x70d60
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x188, %rdi # imm = 0x188
callq 0x70db0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp)... | /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerGraph.h |
dg::DGLLVMPointerAnalysis::buildSubgraph() | void buildSubgraph() {
// run the analysis itself
assert(_builder && "Incorrectly constructed PTA, missing builder");
PS = _builder->buildLLVMPointerGraph();
if (!PS) {
llvm::errs() << "Pointer Subgraph was not built, aborting\n";
abort();
}
/*
... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x88, %rdi
callq 0x70480
movq %rax, %rdi
callq 0x6c040
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x78(%rax)
cmpq $0x0, 0x78(%rax)
jne 0x784a3
callq 0x6c390
movq %rax, %rdi
leaq 0x1fd0b(%rip), %rsi # 0x981a4
callq 0x6d320
c... | /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::pta::PointerAnalysisFS::getMemoryObjects(dg::pta::PSNode*, dg::pta::Pointer const&, std::vector<dg::pta::MemoryObject*, std::allocator<dg::pta::MemoryObject*>>&) | void getMemoryObjects(PSNode *where, const Pointer &pointer,
std::vector<MemoryObject *> &objects) override {
MemoryMapT *mm = where->getData<MemoryMapT>();
assert(mm && "Node does not have memory map");
auto I = mm->find(pointer.target);
if (I != mm->end()) {
... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x7a800
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x7a850
movq %rax, 0x50(%rsp)
lea... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::pta::PointerAnalysisFS::beforeProcessed(dg::pta::PSNode*) | bool beforeProcessed(PSNode *n) override {
MemoryMapT *mm = n->getData<MemoryMapT>();
if (mm)
return false;
// on these nodes the memory map can change
if (needsMerge(n)) {
mm = createMM();
// if this is the root of the entry procedure,
/... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x78abd
movb $0x0, 0x47(%rsp)
jmp 0x78b71
movq 0x30(%rsp), %rdi
callq 0x7c1b0
testb $0x1, %al
jne 0x78acd
jmp 0x78b3... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::pta::PointerAnalysisFS::afterProcessed(dg::pta::PSNode*) | bool afterProcessed(PSNode *n) override {
bool changed = false;
PointsToSetT *overwritten = nullptr;
MemoryMapT *mm = n->getData<MemoryMapT>();
// we must have the memory map, we created it
// in the beforeProcessed method
assert(mm && "Do not have memory map");
... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
movq $0x0, 0x98(%rsp)
movq 0xa8(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x90(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x7b680
cmpl $0x3, %eax
jne 0x78c1e
movq 0xa8(%rsp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x7e9b0
movq %rax... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::DGLLVMPointerAnalysisImpl<dg::pta::PointerAnalysisFS>::functionPointerCall(dg::pta::PSNode*, dg::pta::PSNode*) | bool functionPointerCall(PSNode *callsite, PSNode *called) override {
using namespace pta;
const llvm::Function *F = llvm::dyn_cast<llvm::Function>(
called->getUserData<llvm::Value>());
// with vararg it may happen that we get pointer that
// is not to function, so just b... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
addq $0x8, %rdi
callq 0x77900
movq %rax, %rdi
callq 0x7f8f0
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x78faa
movb $0x0, 0x77(%rsp)
jmp 0x790ee
movq 0x50(%rsp), %rdi
... | /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::pta::PointerAnalysisFS::canChangeMM(dg::pta::PSNode*) | static bool canChangeMM(PSNode *n) {
switch (n->getType()) {
case PSNodeType::STORE:
case PSNodeType::MEMCPY:
case PSNodeType::CALL_FUNCPTR:
// a call via function pointer needs to
// have its own memory map as we dont know
// how the graph will look l... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x7b680
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x11, %eax
ja 0x7a98c
movq (%rsp), %rax
leaq 0x1d6dc(%rip), %rcx # 0x98038
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, 0x17(%rsp)
jmp 0x7a991
movq 0x8(%rsp), %rdi
ca... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::pta::PointerAnalysisFS::mergeMaps(std::map<dg::pta::PSNode*, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>, std::less<dg::pta::PSNode*>, std::allocator<std::pair<dg::pta::PSNode* const, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>>>>*, std::... | static bool mergeMaps(MemoryMapT *mm, MemoryMapT *from,
PointsToSetT *overwritten) {
bool changed = false;
for (auto &it : *from) {
PSNode *fromTarget = it.first;
std::unique_ptr<MemoryObject> &toMo = (*mm)[fromTarget];
if (toMo == nullptr)
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movb $0x0, 0x5f(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x7cc40
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x7a850
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7a8... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::pta::PointerAnalysisFS::mergeObjects(dg::pta::PSNode*, dg::pta::MemoryObject*, dg::pta::MemoryObject*, dg::pta::PointerIdPointsToSet*) | static bool mergeObjects(PSNode *node, MemoryObject *to, MemoryObject *from,
PointsToSetT *overwritten) {
bool changed = false;
for (auto &fromIt : from->pointsTo) {
if (overwritten && overwritten->count(Pointer(node, fromIt.first)))
continue;
... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
movq 0xb0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x7d8c0
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rdi
callq 0x7d8f0
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), ... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::pta::PointerAnalysisFI::getMemoryObjects(dg::pta::PSNode*, dg::pta::Pointer const&, std::vector<dg::pta::MemoryObject*, std::allocator<dg::pta::MemoryObject*>>&) | void getMemoryObjects(PSNode *where, const Pointer &pointer,
std::vector<MemoryObject *> &objects) override {
// irrelevant in flow-insensitive
(void) where;
PSNode *n = pointer.target;
// we want to have memory in allocation sites
if (n->getType() == P... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x7b680
cmpl $0x6, %eax
je 0x7fd2d
movq 0x40(%rsp), %rdi
callq 0x7b680
cmpl $0x4, ... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFI.h |
dg::DGLLVMPointerAnalysisImpl<dg::pta::PointerAnalysisFI>::handleFork(dg::pta::PSNode*, dg::pta::PSNode*) | bool handleFork(PSNode *forkNode, PSNode *called) override {
using namespace llvm;
using namespace dg::pta;
assert(called->getType() == PSNodeType::FUNCTION &&
"The called value is not a function");
PSNodeFork *fork = PSNodeFork::get(forkNode);
builder->addFuncti... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x7fb70
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0xa0(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x6c1d0
movb $0x1, %al
andb $0x1, %... | /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::pta::PointerAnalysisFI::~PointerAnalysisFI() | void preprocessGEPs() {
// if a node is in a loop (a scc that has more than one node),
// then every GEP that is also stored to the same memory afterwards
// in the loop will end up with Offset::UNKNOWN after some
// number of iterations (in FI analysis), so we can do that right now
... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x3080e(%rip), %rax # 0xb09c8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x88, %rdi
callq 0x80770
movq 0x8(%rsp), %rdi
callq 0x794a0
addq $0x18, %rsp
retq
nopl (%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFI.h |
dg::pta::PointerAnalysisFI::preprocessGEPs() | void preprocessGEPs() {
// if a node is in a loop (a scc that has more than one node),
// then every GEP that is also stored to the same memory afterwards
// in the loop will end up with Offset::UNKNOWN after some
// number of iterations (in FI analysis), so we can do that right now
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x6d670
movq %rax, %rdi
callq 0x80ee0
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x80ef0
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x80f20
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x80f50
testb $0x1, %al
jne... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFI.h |
dg::pta::PointerAnalysisFSInv::beforeProcessed(dg::pta::PSNode*) | bool beforeProcessed(PSNode *n) override {
MemoryMapT *mm = n->getData<MemoryMapT>();
if (mm)
return false;
// on these nodes the memory map can change
if (needsMerge(n)) { // root node
mm = createMM();
// if this is the root of the entry procedure,
... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x8138d
movb $0x0, 0x47(%rsp)
jmp 0x81441
movq 0x30(%rsp), %rdi
callq 0x81870
testb $0x1, %al
jne 0x8139d
jmp 0x8140... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::DGLLVMPointerAnalysisImpl<dg::pta::PointerAnalysisFSInv>::handleFork(dg::pta::PSNode*, dg::pta::PSNode*) | bool handleFork(PSNode *forkNode, PSNode *called) override {
using namespace llvm;
using namespace dg::pta;
assert(called->getType() == PSNodeType::FUNCTION &&
"The called value is not a function");
PSNodeFork *fork = PSNodeFork::get(forkNode);
builder->addFuncti... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x7fb70
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0xa0(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x6c1d0
movb $0x1, %al
andb $0x1, %... | /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::pta::PointerAnalysisFSInv::handleUninitialized(std::map<dg::pta::PSNode*, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>, std::less<dg::pta::PSNode*>, std::allocator<std::pair<dg::pta::PSNode* const, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject... | bool handleUninitialized(MemoryMapT *mm, MemoryMapT *pm) {
bool changed = false;
for (auto &it : *mm) {
auto pmit = pm->find(it.first);
if (pmit == pm->end()) {
for (auto &mit : *it.second) {
if (mit.first.isUnknown())
c... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movb $0x0, 0x8f(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x7cc40
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x7a850
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x7a8... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::containsRemovableLocals(dg::pta::PSNode*, dg::pta::PointerIdPointsToSet&) | static bool containsRemovableLocals(PSNode *where, PointsToSetT &S) {
for (const auto &ptr : S) {
if (ptr.isNull() || ptr.isUnknown() || ptr.isInvalidated())
continue;
if (PSNodeAlloc *alloc = PSNodeAlloc::get(ptr.target)) {
if (isLocal(alloc, where) && k... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x77620
movq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x77970
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x77a10
testb $0x1, %al
jne 0x8230e
jmp 0x823b3
l... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::replaceLocalsWithInv(dg::pta::PSNode*, dg::pta::PointerIdPointsToSet&) | static void replaceLocalsWithInv(PSNode *where, PointsToSetT &S1) {
PointsToSetT S;
for (const auto &ptr : S1) {
if (ptr.isNull() || ptr.isUnknown() || ptr.isInvalidated())
continue;
if (PSNodeAlloc *alloc = PSNodeAlloc::get(ptr.target)) {
// if ... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x7e5c0
movq 0xa8(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x77620
movq 0x68(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x77970
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x77a10
testb... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::invalidateMemory(dg::pta::PSNode*, dg::pta::PSNode*, bool) | static bool invalidateMemory(PSNode *node, PSNode *pred,
bool is_free = false) {
MemoryMapT *pmm = pred->getData<MemoryMapT>();
if (!pmm) {
// predecessor was not processed yet
return false;
}
MemoryMapT *mm = node->getData<Memory... | subq $0x1e8, %rsp # imm = 0x1E8
movb %dl, %al
movq %rdi, 0x1d8(%rsp)
movq %rsi, 0x1d0(%rsp)
andb $0x1, %al
movb %al, 0x1cf(%rsp)
movq 0x1d0(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x1c0(%rsp)
cmpq $0x0, 0x1c0(%rsp)
jne 0x82783
movb $0x0, 0x1e7(%rsp)
jmp 0x82ec9
movq 0x1d8(%rsp), %rdi
addq $0x8, ... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::moFromFreeToOverwrite(dg::pta::PSNode*) | static PSNode *moFromFreeToOverwrite(PSNode *operand) {
// Bail out if the operand has no pointers yet,
// otherwise we can add invalidated imprecisely
// (the rest of invalidateMemory would not perform strong update)
if (operand->pointsTo.empty())
return nullptr;
//... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
addq $0xb0, %rdi
callq 0x70460
testb $0x1, %al
jne 0x82f00
jmp 0x82f0e
movq $0x0, 0x40(%rsp)
jmp 0x82f90
movq 0x38(%rsp), %rdi
callq 0x832e0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7b680
cmpl $0x2, %eax
jne 0x82f87
movq 0x30(%rsp), %rdi
addq $0x8,... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::overwriteMOFromFree(std::map<dg::pta::PSNode*, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>, std::less<dg::pta::PSNode*>, std::allocator<std::pair<dg::pta::PSNode* const, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject... | static bool overwriteMOFromFree(MemoryMapT *mm, PSNode *target) {
// if we know exactly which memory object
// is being used for freeing the memory,
// we can set it to invalidated
auto *mo = getOrCreateMO(mm, target);
if (mo->pointsTo.size() == 1) {
auto &S = mo->poi... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x821e0
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
callq 0x83330
cmpq $0x1, %rax
jne 0x83081
movq 0x78(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
leaq 0x68(%rsp), %rdi
xorl %eax, %eax
m... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::invStrongUpdate(dg::pta::PSNode const*) | static bool invStrongUpdate(const PSNode *operand) {
// If we are freeing memory through node that
// points to precisely known valid memory that is not allocated
// on a loop, we can do strong update.
//
// TODO: we can do strong update also on must-aliases
// of the inv... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
addq $0xb0, %rdi
callq 0x778b0
cmpq $0x1, %rax
je 0x8313a
movb $0x0, 0x47(%rsp)
jmp 0x831be
movq 0x38(%rsp), %rsi
addq $0xb0, %rsi
leaq 0x8(%rsp), %rdi
callq 0x77620
leaq 0x8(%rsp), %rdi
callq 0x778c0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp... | /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::llvmdg::LazyLLVMCallGraph::_initializeAddressTaken() | void _initializeAddressTaken() {
assert(!_address_taken_initialized);
_address_taken_initialized = true;
for (auto &F : *_module) {
if (F.isDeclaration())
continue;
if (funHasAddressTaken(&F)) {
_address_taken.push_back(&F);
}
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movb $0x1, 0xa0(%rax)
movq 0x40(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x86db0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x86de0
t... | /mchalupa[P]dg/include/dg/llvm/CallGraph/CallGraph.h |
dg::GenericCallGraph<llvm::Function const*>::FuncNode::addCall(dg::GenericCallGraph<llvm::Function const*>::FuncNode*) | bool addCall(FuncNode *x) {
if (calls(x))
return false;
_calls.push_back(x);
if (!x->isCalledBy(this))
x->_callers.push_back(this);
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rsi
callq 0x8ca80
testb $0x1, %al
jne 0x8be57
jmp 0x8be5e
movb $0x0, 0x27(%rsp)
jmp 0x8bea3
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x10(%rsp), %rsi
callq 0x8cab0
movq (%rsp), %rsi
movq 0x10(%rsp), %rdi... | /mchalupa[P]dg/include/dg/CallGraph/CallGraph.h |
trie_insert | void trie_insert(struct trie_node *root, struct trie_node *new, const unsigned int lvl)
{
if (new->len < root->len)
swap_nodes(root, new);
if (is_left_child(&new->prefix, lvl)) {
if (!root->lchild)
return add_child_node(root, new, LEFT);
return trie_insert(root->lchild, new, lvl + 1);
}
if (!root->rchil... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movb 0x38(%rdi), %al
cmpb %al, 0x38(%rsi)
jae 0x225c
movl 0x10(%r14), %ecx
movl %ecx, 0x30(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x30(%r14), %rcx
movu... | /rtrlib[P]rtrlib/./rtrlib/pfx/trie/trie.c |
trie_lookup | struct trie_node *trie_lookup(const struct trie_node *root, const struct lrtr_ip_addr *prefix, const uint8_t mask_len,
unsigned int *lvl)
{
while (root) {
if (root->len <= mask_len && lrtr_ip_addr_equal(lrtr_ip_addr_get_bits(&root->prefix, 0, root->len),
lrtr_ip_addr_get_bits(prefix, 0, root->len)))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %fs:0x28, %rax
movq %rax, 0x80(%rsp)
testq %rdi, %rdi
je 0x23b1
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x68(%rsp), %r12
leaq 0x38(%rsp), %r13
movb 0x38(%rbx), %al
cmpb %bpl, %al
ja 0x2373
movzbl %al, %e... | /rtrlib[P]rtrlib/./rtrlib/pfx/trie/trie.c |
trie_lookup_exact | struct trie_node *trie_lookup_exact(struct trie_node *root_node, const struct lrtr_ip_addr *prefix,
const uint8_t mask_len, unsigned int *lvl, bool *found)
{
*found = false;
while (root_node) {
if (*lvl > 0 && root_node->len > mask_len) {
(*lvl)--;
return root_node->parent;
}
if (root_node->len ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movb $0x0, (%r8)
testq %rdi, %rdi
je 0x242e
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movl (%rcx), %eax
testl %eax, %eax
setne %cl
movb 0x38(%rdi), %dl
cmpb %bpl, %dl
seta %... | /rtrlib[P]rtrlib/./rtrlib/pfx/trie/trie.c |
trie_remove | struct trie_node *trie_remove(struct trie_node *root, const struct lrtr_ip_addr *prefix, const uint8_t mask_len,
const unsigned int lvl)
{
/* If the node has no children we can simply remove it
* If the node has children, we swap the node with the child that
* has the smaller prefix length and drop the ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
cmpb %bpl, 0x38(%rdi)
jne 0x2634
movl 0x10(%r15), %eax
movl %eax, 0x40(%rsp)
movups (%r15), %xmm0
movaps %xmm0, 0x30(%rsp)
movl 0x40(%rsp), %e... | /rtrlib[P]rtrlib/./rtrlib/pfx/trie/trie.c |
main | int main(void)
{
trie_test();
printf("Test successful\n");
return EXIT_SUCCESS;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %fs:0x28, %rax
movq %rax, 0x130(%rsp)
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0xd0(%rsp), %r14
movb $0x10, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x28(%r14)
leaq 0x27d5(%rip), %rdi # 0x5004... | /rtrlib[P]rtrlib/tests/test_trie.c |
testing::internal::TypedExpectation<void ()>::GetCurrentAction(testing::internal::FunctionMockerBase<void ()> const*, std::tuple<> const&) const | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
g_gmock_mutex.AssertHeld();
const int count = call_count();
Assert(count >= 1, __FILE__, __LINE__,
"call_count() is <= 0 when GetCurrentAction() is "
"called - this should never happen.");
const int action_count = static_cast<int>(un... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x218(%rbp)
leaq 0x8ef2f(%rip), %rdi # 0x109a18
callq 0x77aa0
movq -0x218(%rbp), %rdi
callq 0x7ae80
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ea... | /DanRuta[P]webassembly-workflow/test/googletest/googlemock/include/gmock/gmock-spec-builders.h |
testing::internal::FunctionMockerBase<int (int, int)>::DescribeDefaultActionTo(std::tuple<int, int> const&, std::ostream*) const | void DescribeDefaultActionTo(const ArgumentTuple& args,
::std::ostream* os) const {
const OnCallSpec<F>* const spec = FindOnCallSpec(args);
if (spec == NULL) {
*os << (internal::type_equals<Result, void>::value ?
"returning directly.\n" :
"return... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7bc00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7c731
movq -0x18(%rbp), %rdi
leaq 0x5750e(%rip), %rsi # 0xd3c35
callq 0x725c0
jmp 0x7c7b5
mov... | /DanRuta[P]webassembly-workflow/test/googletest/googlemock/include/gmock/gmock-spec-builders.h |
testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop[abi:cxx11](int) | std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
return os_stack_trace_getter()->CurrentStackTrace(
static_cast<int>(GTEST_FLAG(stack_trace_depth)),
skip_count + 1
// Skips the user-specified number of frames plus this function
// itself.
); // NOLINT
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8cf40
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl 0x7ec74(%rip), %edx # 0x109808
movl -0x14(%rbp), %ecx
addl $0... | /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::AssertionResult::AssertionResult(testing::AssertionResult const&) | AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_),
message_(other.message_.get() != NULL ?
new ::std::string(*other.message_) :
static_cast< ::std::string*>(NULL)) {
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x808f0
movb $0x0, -0x19(%rbp)
cmpq $0x0, %rax
je 0x8... | /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::CalculateOptimalEdits(std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
const std::vector<size_t>& right) {
std::vector<std::vector<double> > costs(
left.size() + 1, std::vector<double>(right.size() + 1));
std::vector<std::vector<EditType> > best_move(
le... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa76c0
incq %rax
movq %rax, -0x118(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa76c0
incq %rax
... | /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::internal::ShouldUseColor(bool) | bool ShouldUseColor(bool stdout_is_tty) {
const char* const gtest_color = GTEST_FLAG(color).c_str();
if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if GTEST_OS_WINDOWS
// On Windows the TERM variable is usually not set, but the
// console there does support colors.
return stdout_is_t... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
leaq 0x74cb9(%rip), %rdi # 0x109790
callq 0x72240
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x417af(%rip), %rsi # 0xd629a
callq 0x904c0
testb $0x1, %al
jne 0x94af9
jmp 0x94c6f
leaq 0x41f4d(%rip), %rdi # 0... | /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::internal::ShouldShard(char const*, char const*, bool) | bool ShouldShard(const char* total_shards_env,
const char* shard_index_env,
bool in_subprocess_for_death_test) {
if (in_subprocess_for_death_test) {
return false;
}
const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1);
const Int32 shard_index = Int32FromEnvOr... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x95159
movb $0x0, -0x1(%rbp)
jmp 0x95746
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x95760... | /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestCase const&) | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(COLOR_GREEN, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_param() == ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8cf10
movl %eax, %esi
leaq 0x41b62(%rip), %rdx # 0xd7504
leaq 0x408c9(%rip), %rcx # 0xd6272
leaq -0x30(%rbp), %rdi
callq 0x95aa0
leaq 0x411f9(%rip), %rsi # 0xd6bb2
xorl %eax, %eax
movl $0x... | /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(testing::UnitTest const&) | void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
const int failed_test_count = unit_test.failed_test_count();
if (failed_test_count == 0) {
return;
}
for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
const TestCase& test_case = *unit_test.GetTestCase(i);
i... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x960a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x95f73
jmp 0x96096
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x960d0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %... | /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
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.