name string | code string | asm string | file string |
|---|---|---|---|
av1_iadst16 | void av1_iadst16(const int32_t *input, int32_t *output, int8_t cos_bit,
const int8_t *stage_range) {
assert(output != input);
const int32_t size = 16;
const int32_t *cospi = cospi_arr(cos_bit);
int32_t stage = 0;
int32_t *bf0, *bf1;
int32_t step[16];
// stage 0;
// stage 1;
stage++... | subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movb %al, 0x77(%rsp)
movq %rcx, 0x68(%rsp)
movl $0x10, 0x64(%rsp)
movsbl 0x77(%rsp), %edi
callq 0x9f4a90
movq %rax, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x4... | /m-ab-s[P]aom/av1/common/av1_inv_txfm1d.c |
av1_fdct4 | void av1_fdct4(const int32_t *input, int32_t *output, int8_t cos_bit,
const int8_t *stage_range) {
const int32_t size = 4;
const int32_t *cospi;
int32_t stage = 0;
int32_t *bf0, *bf1;
int32_t step[4];
// stage 0;
av1_range_check_buf(stage, input, input, size, stage_range[stage]);
// st... | subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb %al, 0x47(%rsp)
movq %rcx, 0x38(%rsp)
movl $0x4, 0x34(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %edi
movq 0x50(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x38(%rsp), %rax
movslq 0x24(%rsp), %r8
movl $0x4, %ecx
movsbl (%rax,%r8), %r8d
callq 0... | /m-ab-s[P]aom/av1/encoder/av1_fwd_txfm1d.c |
av1_fdct8 | void av1_fdct8(const int32_t *input, int32_t *output, int8_t cos_bit,
const int8_t *stage_range) {
const int32_t size = 8;
const int32_t *cospi;
int32_t stage = 0;
int32_t *bf0, *bf1;
int32_t step[8];
// stage 0;
av1_range_check_buf(stage, input, input, size, stage_range[stage]);
// st... | subq $0x68, %rsp
movb %dl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb %al, 0x57(%rsp)
movq %rcx, 0x48(%rsp)
movl $0x8, 0x44(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %edi
movq 0x60(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x48(%rsp), %rax
movslq 0x34(%rsp), %r8
movl $0x8, %ecx
movsbl (%rax,%r8), %r8d
callq 0... | /m-ab-s[P]aom/av1/encoder/av1_fwd_txfm1d.c |
av1_fdct16 | void av1_fdct16(const int32_t *input, int32_t *output, int8_t cos_bit,
const int8_t *stage_range) {
const int32_t size = 16;
const int32_t *cospi;
int32_t stage = 0;
int32_t *bf0, *bf1;
int32_t step[16];
// stage 0;
av1_range_check_buf(stage, input, input, size, stage_range[stage]);
/... | subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movb %al, 0x77(%rsp)
movq %rcx, 0x68(%rsp)
movl $0x10, 0x64(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %edi
movq 0x80(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0x68(%rsp), %rax
movslq 0x54(%rsp), %r8
movl $0x10, %ecx
movsbl (%rax,%r8), %r8d
callq... | /m-ab-s[P]aom/av1/encoder/av1_fwd_txfm1d.c |
av1_fadst4 | void av1_fadst4(const int32_t *input, int32_t *output, int8_t cos_bit,
const int8_t *stage_range) {
int bit = cos_bit;
const int32_t *sinpi = sinpi_arr(bit);
int32_t x0, x1, x2, x3;
int32_t s0, s1, s2, s3, s4, s5, s6, s7;
// stage 0
av1_range_check_buf(0, input, input, 4, stage_range[0]);
... | subq $0x68, %rsp
movb %dl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb %al, 0x57(%rsp)
movq %rcx, 0x48(%rsp)
movsbl 0x57(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %edi
callq 0xa0b7a0
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x48(%rsp), %rax
xorl %edi, %edi
movl $0x4, %ecx... | /m-ab-s[P]aom/av1/encoder/av1_fwd_txfm1d.c |
av1_fadst16 | void av1_fadst16(const int32_t *input, int32_t *output, int8_t cos_bit,
const int8_t *stage_range) {
const int32_t size = 16;
const int32_t *cospi;
int32_t stage = 0;
int32_t *bf0, *bf1;
int32_t step[16];
// stage 0;
av1_range_check_buf(stage, input, input, size, stage_range[stage]);
... | subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movb %al, 0x77(%rsp)
movq %rcx, 0x68(%rsp)
movl $0x10, 0x64(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %edi
movq 0x80(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0x68(%rsp), %rax
movslq 0x54(%rsp), %r8
movl $0x10, %ecx
movsbl (%rax,%r8), %r8d
callq... | /m-ab-s[P]aom/av1/encoder/av1_fwd_txfm1d.c |
round_shift_16bit | static inline void round_shift_16bit(__m128i *in, int size, int bit) {
if (bit < 0) {
bit = -bit;
__m128i rounding = _mm_set1_epi16(1 << (bit - 1));
for (int i = 0; i < size; ++i) {
in[i] = _mm_adds_epi16(in[i], rounding);
in[i] = _mm_srai_epi16(in[i], bit);
}
} else if (bit > 0) {
f... | subq $0x48, %rsp
movq %rdi, -0x58(%rsp)
movl %esi, -0x5c(%rsp)
movl %edx, -0x60(%rsp)
cmpl $0x0, -0x60(%rsp)
jge 0xa400bc
movl -0x60(%rsp), %eax
negl %eax
movl %eax, -0x60(%rsp)
movb -0x60(%rsp), %cl
decb %cl
movl $0x1, %eax
shll %cl, %eax
movw %ax, -0x22(%rsp)
movw -0x22(%rsp), %ax
movw %ax, -0x7a(%rsp)
movw %ax, 0xa(... | /m-ab-s[P]aom/av1/common/x86/av1_txfm_sse2.h |
transpose_16bit_4x4 | static inline void transpose_16bit_4x4(const __m128i *const in,
__m128i *const out) {
// Unpack 16 bit elements. Goes from:
// in[0]: 00 01 02 03 XX XX XX XX
// in[1]: 10 11 12 13 XX XX XX XX
// in[2]: 20 21 22 23 XX XX XX XX
// in[3]: 30 31 32 33 XX XX XX XX
// to... | subq $0x38, %rsp
movq %rdi, -0x58(%rsp)
movq %rsi, -0x60(%rsp)
movq -0x58(%rsp), %rax
movaps (%rax), %xmm1
movaps 0x10(%rax), %xmm0
movaps %xmm1, -0x20(%rsp)
movaps %xmm0, -0x30(%rsp)
movaps -0x20(%rsp), %xmm0
movaps -0x30(%rsp), %xmm1
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],x... | /m-ab-s[P]aom/aom_dsp/x86/transpose_sse2.h |
av1_lowbd_fwd_txfm2d_4x8_sse2 | void av1_lowbd_fwd_txfm2d_4x8_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)stride;
(void)bd;
__m128i buf0[8], buf1[8], *buf;
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_4X8];
const int txw_idx = get_txw_idx(TX_4X8);
const int ... | subq $0x168, %rsp # imm = 0x168
movb %cl, %al
movq %rdi, 0x160(%rsp)
movq %rsi, 0x158(%rsp)
movl %edx, 0x154(%rsp)
movb %al, 0x153(%rsp)
movl %r8d, 0x14c(%rsp)
leaq 0x1657ca(%rip), %rax # 0xba5b10
movq 0x28(%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x5, %edi
callq 0xa3fd00
movl %eax, 0x2c(%rsp)
movl $0x5, %... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
av1_lowbd_fwd_txfm2d_4x16_sse2 | void av1_lowbd_fwd_txfm2d_4x16_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
__m128i buf0[16], buf1[16];
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_4X16];
const int txw_idx = get_txw_idx(TX_4X16);
const int txh_idx = get_tx... | subq $0x278, %rsp # imm = 0x278
movb %cl, %al
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movl %edx, 0x264(%rsp)
movb %al, 0x263(%rsp)
movl %r8d, 0x25c(%rsp)
leaq 0x1652ba(%rip), %rax # 0xba5b10
movq 0x68(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0xd, %edi
callq 0xa3fd00
movl %eax, 0x44(%rsp)
movl $0xd, %... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
av1_lowbd_fwd_txfm2d_8x4_sse2 | void av1_lowbd_fwd_txfm2d_8x4_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
__m128i buf0[8], buf1[8], *buf;
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_8X4];
const int txw_idx = get_txw_idx(TX_8X4);
const int txh_idx = get_tx... | subq $0x168, %rsp # imm = 0x168
movb %cl, %al
movq %rdi, 0x160(%rsp)
movq %rsi, 0x158(%rsp)
movl %edx, 0x154(%rsp)
movb %al, 0x153(%rsp)
movl %r8d, 0x14c(%rsp)
leaq 0x164f9a(%rip), %rax # 0xba5b10
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x6, %edi
callq 0xa3fd00
movl %eax, 0x2c(%rsp)
movl $0x6, %... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
transpose_16bit_8x8 | static inline void transpose_16bit_8x8(const __m128i *const in,
__m128i *const out) {
// Unpack 16 bit elements. Goes from:
// in[0]: 00 01 02 03 04 05 06 07
// in[1]: 10 11 12 13 14 15 16 17
// in[2]: 20 21 22 23 24 25 26 27
// in[3]: 30 31 32 33 34 35 36 37
// in... | subq $0x398, %rsp # imm = 0x398
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rax
movaps (%rax), %xmm1
movaps 0x10(%rax), %xmm0
movaps %xmm1, 0x100(%rsp)
movaps %xmm0, 0xf0(%rsp)
movaps 0x100(%rsp), %xmm0
movaps 0xf0(%rsp), %xmm1
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1... | /m-ab-s[P]aom/aom_dsp/x86/transpose_sse2.h |
av1_lowbd_fwd_txfm2d_8x16_sse2 | void av1_lowbd_fwd_txfm2d_8x16_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
__m128i buf0[16], buf1[16];
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_8X16];
const int txw_idx = get_txw_idx(TX_8X16);
const int txh_idx = get_tx... | subq $0x278, %rsp # imm = 0x278
movb %cl, %al
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movl %edx, 0x264(%rsp)
movb %al, 0x263(%rsp)
movl %r8d, 0x25c(%rsp)
leaq 0x16448a(%rip), %rax # 0xba5b10
movq 0x38(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x7, %edi
callq 0xa3fd00
movl %eax, 0x44(%rsp)
movl $0x7, %... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
av1_lowbd_fwd_txfm2d_8x32_sse2 | void av1_lowbd_fwd_txfm2d_8x32_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
__m128i buf0[32], buf1[32];
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_8X32];
const int txw_idx = get_txw_idx(TX_8X32);
const int txh_idx = get_tx... | subq $0x478, %rsp # imm = 0x478
movb %cl, %al
movq %rdi, 0x470(%rsp)
movq %rsi, 0x468(%rsp)
movl %edx, 0x464(%rsp)
movb %al, 0x463(%rsp)
movl %r8d, 0x45c(%rsp)
leaq 0x1641da(%rip), %rax # 0xba5b10
movq 0x78(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0xf, %edi
callq 0xa3fd00
movl %eax, 0x44(%rsp)
movl $0xf, %... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
av1_lowbd_fwd_txfm2d_16x4_sse2 | void av1_lowbd_fwd_txfm2d_16x4_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
__m128i buf0[16], buf1[16];
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_16X4];
const int txw_idx = get_txw_idx(TX_16X4);
const int txh_idx = get_tx... | subq $0x278, %rsp # imm = 0x278
movb %cl, %al
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movl %edx, 0x264(%rsp)
movb %al, 0x263(%rsp)
movl %r8d, 0x25c(%rsp)
leaq 0x163eea(%rip), %rax # 0xba5b10
movq 0x70(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0xe, %edi
callq 0xa3fd00
movl %eax, 0x44(%rsp)
movl $0xe, %... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
transpose_16bit_8x4 | static inline void transpose_16bit_8x4(const __m128i *const in,
__m128i *const out) {
// Unpack 16 bit elements. Goes from:
// in[0]: 00 01 02 03 04 05 06 07
// in[1]: 10 11 12 13 14 15 16 17
// in[2]: 20 21 22 23 24 25 26 27
// in[3]: 30 31 32 33 34 35 36 37
// t... | subq $0x238, %rsp # imm = 0x238
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movaps (%rax), %xmm1
movaps 0x10(%rax), %xmm0
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps 0x50(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1... | /m-ab-s[P]aom/aom_dsp/x86/transpose_sse2.h |
av1_lowbd_fwd_txfm2d_16x8_sse2 | void av1_lowbd_fwd_txfm2d_16x8_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
__m128i buf0[16], buf1[16];
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_16X8];
const int txw_idx = get_txw_idx(TX_16X8);
const int txh_idx = get_tx... | subq $0x278, %rsp # imm = 0x278
movb %cl, %al
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movl %edx, 0x264(%rsp)
movb %al, 0x263(%rsp)
movl %r8d, 0x25c(%rsp)
leaq 0x1638fa(%rip), %rax # 0xba5b10
movq 0x40(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x8, %edi
callq 0xa3fd00
movl %eax, 0x44(%rsp)
movl $0x8, %... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
av1_lowbd_fwd_txfm2d_16x16_sse2 | void av1_lowbd_fwd_txfm2d_16x16_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
__m128i buf0[16], buf1[32];
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_16X16];
const int txw_idx = get_txw_idx(TX_16X16);
const int txh_idx = ge... | subq $0x378, %rsp # imm = 0x378
movb %cl, %al
movq %rdi, 0x370(%rsp)
movq %rsi, 0x368(%rsp)
movl %edx, 0x364(%rsp)
movb %al, 0x363(%rsp)
movl %r8d, 0x35c(%rsp)
leaq 0x16367a(%rip), %rax # 0xba5b10
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x2, %edi
callq 0xa3fd00
movl %eax, 0x44(%rsp)
movl $0x2, %... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
av1_lowbd_fwd_txfm2d_16x32_sse2 | void av1_lowbd_fwd_txfm2d_16x32_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
__m128i buf0[32], buf1[64];
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_16X32];
const int txw_idx = get_txw_idx(TX_16X32);
const int txh_idx = ge... | subq $0x678, %rsp # imm = 0x678
movb %cl, %al
movq %rdi, 0x670(%rsp)
movq %rsi, 0x668(%rsp)
movl %edx, 0x664(%rsp)
movb %al, 0x663(%rsp)
movl %r8d, 0x65c(%rsp)
leaq 0x16337a(%rip), %rax # 0xba5b10
movq 0x48(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x9, %edi
callq 0xa3fd00
movl %eax, 0x44(%rsp)
movl $0x9, %... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
av1_lowbd_fwd_txfm2d_32x8_sse2 | void av1_lowbd_fwd_txfm2d_32x8_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
__m128i buf0[32], buf1[32];
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_32X8];
const int txw_idx = get_txw_idx(TX_32X8);
const int txh_idx = get_tx... | subq $0x478, %rsp # imm = 0x478
movb %cl, %al
movq %rdi, 0x470(%rsp)
movq %rsi, 0x468(%rsp)
movl %edx, 0x464(%rsp)
movb %al, 0x463(%rsp)
movl %r8d, 0x45c(%rsp)
leaq 0x162fca(%rip), %rax # 0xba5b10
movq 0x80(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x10, %edi
callq 0xa3fd00
movl %eax, 0x44(%rsp)
movl $0x10,... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
av1_lowbd_fwd_txfm2d_32x32_sse2 | void av1_lowbd_fwd_txfm2d_32x32_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
__m128i buf0[32], buf1[128];
const int8_t *shift = av1_fwd_txfm_shift_ls[TX_32X32];
const int txw_idx = get_txw_idx(TX_32X32);
const int txh_idx = g... | subq $0xa78, %rsp # imm = 0xA78
movb %cl, %al
movq %rdi, 0xa70(%rsp)
movq %rsi, 0xa68(%rsp)
movl %edx, 0xa64(%rsp)
movb %al, 0xa63(%rsp)
movl %r8d, 0xa5c(%rsp)
leaq 0x16295a(%rip), %rax # 0xba5b10
movq 0x18(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x3, %edi
callq 0xa3fd00
movl %eax, 0x44(%rsp)
movl $0x3, %... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
av1_lowbd_fwd_txfm2d_64x16_sse2 | void av1_lowbd_fwd_txfm2d_64x16_sse2(const int16_t *input, int32_t *output,
int stride, TX_TYPE tx_type, int bd) {
(void)bd;
(void)tx_type;
assert(tx_type == DCT_DCT);
const TX_SIZE tx_size = TX_64X16;
__m128i buf0[64], buf1[128];
const int8_t *shift = av1_fwd_txfm_shift... | subq $0xc78, %rsp # imm = 0xC78
movb %cl, %al
movq %rdi, 0xc70(%rsp)
movq %rsi, 0xc68(%rsp)
movl %edx, 0xc64(%rsp)
movb %al, 0xc63(%rsp)
movl %r8d, 0xc5c(%rsp)
movb $0x12, 0xc5b(%rsp)
leaq 0x1625a2(%rip), %rax # 0xba5b10
movq 0x90(%rax), %rax
movq %rax, 0x48(%rsp)
movl $0x12, %edi
callq 0xa3fd00
movl %eax... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
fdct4x4_new_sse2 | static void fdct4x4_new_sse2(const __m128i *input, __m128i *output,
int8_t cos_bit) {
const int32_t *cospi = cospi_arr(cos_bit);
const __m128i cospi_p32_p32 = pair_set_epi16(cospi[32], cospi[32]);
const __m128i cospi_p32_m32 = pair_set_epi16(cospi[32], -cospi[32]);
const __m128i cos... | subq $0x3f8, %rsp # imm = 0x3F8
movb %dl, %al
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movb %al, 0xe7(%rsp)
movsbl 0xe7(%rsp), %edi
callq 0xa21c60
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movzwl 0x80(%rax), %eax
movl %eax, %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, 0x10c(%rsp)
movl 0x10c(%rsp), %e... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
fadst4x4_new_sse2 | static void fadst4x4_new_sse2(const __m128i *input, __m128i *output,
int8_t cos_bit) {
const int32_t *sinpi = sinpi_arr(cos_bit);
const __m128i sinpi_p01_p02 = pair_set_epi16(sinpi[1], sinpi[2]);
const __m128i sinpi_p04_m01 = pair_set_epi16(sinpi[4], -sinpi[1]);
const __m128i sinpi... | subq $0x668, %rsp # imm = 0x668
movb %dl, %al
movq %rdi, 0x1a0(%rsp)
movq %rsi, 0x198(%rsp)
movb %al, 0x197(%rsp)
movsbl 0x197(%rsp), %edi
callq 0xa49e40
movq %rax, 0x188(%rsp)
movq 0x188(%rsp), %rcx
movzwl 0x4(%rcx), %eax
movl 0x8(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, 0x1bc(%rsp)
movl 0x1bc... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
fidentity4x4_new_sse2 | static inline void fidentity4x4_new_sse2(const __m128i *const input,
__m128i *const output,
const int8_t cos_bit) {
(void)cos_bit;
const __m128i one = _mm_set1_epi16(1);
for (int i = 0; i < 4; ++i) {
const __m128i a = _mm_unpac... | subq $0xe8, %rsp
movb %dl, %al
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movb %al, 0x5f(%rsp)
movw $0x1, 0xbe(%rsp)
movw 0xbe(%rsp), %ax
movw %ax, 0xe(%rsp)
movw %ax, 0xe6(%rsp)
movw %ax, 0xe4(%rsp)
movw %ax, 0xe2(%rsp)
movw %ax, 0xe0(%rsp)
movw %ax, 0xde(%rsp)
movw %ax, 0xdc(%rsp)
movw %ax, 0xda(%rsp)
movw %ax, 0xd8... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.h |
fdct4x8_new_sse2 | static void fdct4x8_new_sse2(const __m128i *input, __m128i *output,
int8_t cos_bit) {
const int32_t *cospi = cospi_arr(cos_bit);
const __m128i __rounding = _mm_set1_epi32(1 << (cos_bit - 1));
__m128i cospi_m32_p32 = pair_set_epi16(-cospi[32], cospi[32]);
__m128i cospi_p32_p32 = pai... | subq $0x648, %rsp # imm = 0x648
movb %dl, %al
movq %rdi, 0x2d0(%rsp)
movq %rsi, 0x2c8(%rsp)
movb %al, 0x2c7(%rsp)
movsbl 0x2c7(%rsp), %edi
callq 0xa21c60
movq %rax, 0x2b8(%rsp)
movb 0x2c7(%rsp), %cl
decb %cl
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x2fc(%rsp)
movl 0x2fc(%rsp), %eax
movl %eax, 0x51c(%rsp)
m... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
fadst4x8_new_sse2 | static void fadst4x8_new_sse2(const __m128i *input, __m128i *output,
int8_t cos_bit) {
const int32_t *cospi = cospi_arr(cos_bit);
const __m128i __zero = _mm_setzero_si128();
const __m128i __rounding = _mm_set1_epi32(1 << (cos_bit - 1));
__m128i cospi_p32_p32 = pair_set_epi16(cospi... | subq $0x8b8, %rsp # imm = 0x8B8
movb %dl, %al
movq %rdi, 0x420(%rsp)
movq %rsi, 0x418(%rsp)
movb %al, 0x417(%rsp)
movsbl 0x417(%rsp), %edi
callq 0xa21c60
movq %rax, 0x408(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x8a0(%rsp)
movaps 0x8a0(%rsp), %xmm0
movaps %xmm0, 0x3f0(%rsp)
movb 0x417(%rsp), %cl
decb %cl
movl... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
fidentity8x8_new_sse2 | static inline void fidentity8x8_new_sse2(const __m128i *input, __m128i *output,
int8_t cos_bit) {
(void)cos_bit;
output[0] = _mm_adds_epi16(input[0], input[0]);
output[1] = _mm_adds_epi16(input[1], input[1]);
output[2] = _mm_adds_epi16(input[2], input[2]);
output[3] =... | subq $0xa8, %rsp
movb %dl, %al
movq %rdi, -0x68(%rsp)
movq %rsi, -0x70(%rsp)
movb %al, -0x71(%rsp)
movq -0x68(%rsp), %rax
movdqa (%rax), %xmm1
movq -0x68(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm1, 0x90(%rsp)
movdqa %xmm0, 0x80(%rsp)
movdqa 0x90(%rsp), %xmm0
movdqa 0x80(%rsp), %xmm1
paddsw %xmm1, %xmm0
movq -0x70(%r... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.h |
fdct8x4_new_sse2 | static void fdct8x4_new_sse2(const __m128i *input, __m128i *output,
int8_t cos_bit) {
const int32_t *cospi = cospi_arr(cos_bit);
const __m128i __rounding = _mm_set1_epi32(1 << (cos_bit - 1));
__m128i cospi_p32_p32 = pair_set_epi16(cospi[32], cospi[32]);
__m128i cospi_p32_m32 = pair... | subq $0x7f8, %rsp # imm = 0x7F8
movb %dl, %al
movq %rdi, 0x2b0(%rsp)
movq %rsi, 0x2a8(%rsp)
movb %al, 0x2a7(%rsp)
movsbl 0x2a7(%rsp), %edi
callq 0xa21c60
movq %rax, 0x298(%rsp)
movb 0x2a7(%rsp), %cl
decb %cl
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x2cc(%rsp)
movl 0x2cc(%rsp), %eax
movl %eax, 0x76c(%rsp)
m... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.c |
fidentity8x4_new_sse2 | static inline void fidentity8x4_new_sse2(const __m128i *const input,
__m128i *const output,
const int8_t cos_bit) {
(void)cos_bit;
const __m128i one = _mm_set1_epi16(1);
for (int i = 0; i < 4; ++i) {
const __m128i a_lo = _mm_un... | subq $0x128, %rsp # imm = 0x128
movb %dl, %al
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movb %al, 0x7f(%rsp)
movw $0x1, 0xfe(%rsp)
movw 0xfe(%rsp), %ax
movw %ax, 0xe(%rsp)
movw %ax, 0x126(%rsp)
movw %ax, 0x124(%rsp)
movw %ax, 0x122(%rsp)
movw %ax, 0x120(%rsp)
movw %ax, 0x11e(%rsp)
movw %ax, 0x11c(%rsp)
mov... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.h |
store_rect_16bit_to_32bit | static inline void store_rect_16bit_to_32bit(const __m128i a,
int32_t *const b) {
const __m128i one = _mm_set1_epi16(1);
const __m128i a_lo = _mm_unpacklo_epi16(a, one);
const __m128i a_hi = _mm_unpackhi_epi16(a, one);
const __m128i b_lo = scale_round_sse2(a_lo, NewS... | subq $0x118, %rsp # imm = 0x118
movaps %xmm0, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movw $0x1, 0xbe(%rsp)
movw 0xbe(%rsp), %ax
movw %ax, 0xde(%rsp)
movw %ax, 0xdc(%rsp)
movw %ax, 0xda(%rsp)
movw %ax, 0xd8(%rsp)
movw %ax, 0xd6(%rsp)
movw %ax, 0xd4(%rsp)
movw %ax, 0xd2(%rsp)
movw %ax, 0xd0(%rsp)
movzwl 0xde(%rsp), ... | /m-ab-s[P]aom/av1/common/x86/av1_txfm_sse2.h |
fidentity8x16_new_sse2 | static inline void fidentity8x16_new_sse2(const __m128i *input, __m128i *output,
int8_t cos_bit) {
(void)cos_bit;
const __m128i one = _mm_set1_epi16(1);
for (int i = 0; i < 16; ++i) {
const __m128i a_lo = _mm_unpacklo_epi16(input[i], one);
const __m128i a_hi = _m... | subq $0x128, %rsp # imm = 0x128
movb %dl, %al
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movb %al, 0x7f(%rsp)
movw $0x1, 0xfe(%rsp)
movw 0xfe(%rsp), %ax
movw %ax, 0xe(%rsp)
movw %ax, 0x126(%rsp)
movw %ax, 0x124(%rsp)
movw %ax, 0x122(%rsp)
movw %ax, 0x120(%rsp)
movw %ax, 0x11e(%rsp)
movw %ax, 0x11c(%rsp)
mov... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.h |
store_16bit_to_32bit | static inline void store_16bit_to_32bit(__m128i a, int32_t *b) {
const __m128i a_lo = _mm_unpacklo_epi16(a, a);
const __m128i a_hi = _mm_unpackhi_epi16(a, a);
const __m128i a_1 = _mm_srai_epi32(a_lo, 16);
const __m128i a_2 = _mm_srai_epi32(a_hi, 16);
_mm_store_si128((__m128i *)b, a_1);
_mm_store_si128((__m1... | subq $0x98, %rsp
movaps %xmm0, -0x30(%rsp)
movq %rdi, -0x38(%rsp)
movaps -0x30(%rsp), %xmm0
movaps %xmm0, -0x10(%rsp)
movaps %xmm0, -0x20(%rsp)
movaps -0x10(%rsp), %xmm0
movaps -0x20(%rsp), %xmm1
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
movaps %xmm0, -0x50(%rsp)... | /m-ab-s[P]aom/av1/common/x86/av1_txfm_sse2.h |
fadst8x8_new_sse2 | static inline void fadst8x8_new_sse2(const __m128i *input, __m128i *output,
int8_t cos_bit) {
const int32_t *cospi = cospi_arr(cos_bit);
const __m128i __zero = _mm_setzero_si128();
const __m128i __rounding = _mm_set1_epi32(1 << (cos_bit - 1));
const __m128i cospi_p32_p32 = ... | subq $0x1ea8, %rsp # imm = 0x1EA8
movb %dl, %al
movq %rdi, 0xa10(%rsp)
movq %rsi, 0xa08(%rsp)
movb %al, 0xa07(%rsp)
movsbl 0xa07(%rsp), %edi
callq 0xa21c60
movq %rax, 0x9f8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x1e90(%rsp)
movaps 0x1e90(%rsp), %xmm0
movaps %xmm0, 0x9e0(%rsp)
movb 0xa07(%rsp), %cl
decb %cl
m... | /m-ab-s[P]aom/av1/encoder/x86/av1_fwd_txfm_sse2.h |
algorithm_suite::copy_if_sequence() | void copy_if_sequence()
{
std::vector<double> input = { 1.0, 2.0, 3.0, 4.0, 5.0 };
cumulative::moment<double> filter;
std::copy_if(input.begin(), input.end(), push_inserter(filter), less_than<double>(3.0));
TRIAL_TEST_EQ(filter.size(), 2);
TRIAL_TEST_EQ(filter.mean(), 1.5);
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movups 0x2475(%rip), %xmm0 # 0xdb88
leaq 0x30(%rsp), %rbx
movaps %xmm0, 0x10(%rbx)
movups 0x2455(%rip), %xmm0 # 0xdb78
movaps %xmm0, (%rbx)
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
movq %rax, 0x20(%rbx)
leaq 0x18(%rsp), %r14
pushq $0x5
popq %rdx
leaq 0x... | /breese[P]trial/test/cumulative/moment_suite.cpp |
green_loop_release | int green_loop_release(green_loop_t loop)
{
green_assert(loop != NULL);
green_assert(loop->refs > 0);
if (--(loop->refs) > 0) {
return GREEN_SUCCESS;
}
green_assert(loop != NULL);
green_assert(loop->coroutines == 0);
green_free(loop);
return GREEN_SUCCESS;
} | pushq %rbx
testq %rdi, %rdi
je 0x1347
movl (%rdi), %eax
testl %eax, %eax
jle 0x136e
leal -0x1(%rax), %ecx
movl %ecx, (%rdi)
cmpl $0x1, %eax
jne 0x1343
cmpl $0x0, 0x4(%rdi)
jne 0x1395
callq 0x1030
xorl %eax, %eax
popq %rbx
retq
movq 0x3caa(%rip), %rbx # 0x4ff8
movq (%rbx), %rdi
leaq 0x1d88(%rip), %rsi # 0x30e0... | /AndreLouisCaron[P]libgreen/src/green.c |
green_future_result | int green_future_result(green_future_t future, void ** p, int * i)
{
if (future == NULL) {
return GREEN_EINVAL;
}
green_assert(future->refs > 0);
if (future->state == green_future_pending) {
return GREEN_EBUSY;
}
if (future->state == green_future_aborted) {
return GREEN_... | testq %rdi, %rdi
je 0x25d3
cmpl $0x0, 0x8(%rdi)
jle 0x25f4
movl 0x20(%rdi), %eax
testl %eax, %eax
je 0x25d7
cmpl $0x1, %eax
jne 0x25db
pushq $0x8
jmp 0x25d9
pushq $0x1
jmp 0x25d9
pushq $0x3
popq %rax
retq
testq %rsi, %rsi
je 0x25e7
movq 0x10(%rdi), %rax
movq %rax, (%rsi)
xorl %eax, %eax
testq %rdx, %rdx
je 0x25f3
movl ... | /AndreLouisCaron[P]libgreen/src/green.c |
void Catch::Capturer::captureValues<char [4], int, char [6]>(unsigned long, char const (&) [4], int const&, char const (&) [6]) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl $0x4, %ebp
movl $0x4, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r13, %rdx
testq %rax, %rax
cmoveq %rbp, %rdx
leaq 0x8(%rsp... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [4], int, int>(unsigned long, char const (&) [4], int const&, int const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl $0x4, %ebp
movl $0x4, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r13, %rdx
testq %rax, %rax
cmoveq %rbp, %rdx
leaq 0x8(%rsp... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [7], int, unsigned short>(unsigned long, char const (&) [7], int const&, unsigned short const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl $0x7, %ebp
movl $0x7, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r13, %rdx
testq %rax, %rax
cmoveq %rbp, %rdx
leaq 0x8(%rsp... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [7], int, unsigned int>(unsigned long, char const (&) [7], int const&, unsigned int const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl $0x7, %ebp
movl $0x7, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r13, %rdx
testq %rax, %rax
cmoveq %rbp, %rdx
leaq 0x8(%rsp... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [7], int, unsigned long>(unsigned long, char const (&) [7], int const&, unsigned long const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl $0x7, %ebp
movl $0x7, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r13, %rdx
testq %rax, %rax
cmoveq %rbp, %rdx
leaq 0x8(%rsp... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [4], int, unsigned int>(unsigned long, char const (&) [4], int const&, unsigned int const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl $0x4, %ebp
movl $0x4, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r13, %rdx
testq %rax, %rax
cmoveq %rbp, %rdx
leaq 0x8(%rsp... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [4], int, char>(unsigned long, char const (&) [4], int const&, char const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl $0x4, %ebp
movl $0x4, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r13, %rdx
testq %rax, %rax
cmoveq %rbp, %rdx
leaq 0x8(%rsp... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<int, char [6]>(unsigned long, int const&, char const (&) [6]) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xa4cac
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9d94c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x99630
movq 0x1... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<int, int>(unsigned long, int const&, int const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xa4cac
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9d94c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x996c0
movq 0x1... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<int, unsigned short>(unsigned long, int const&, unsigned short const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xa4cac
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9d94c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x99750
movq 0x1... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<int, unsigned long>(unsigned long, int const&, unsigned long const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xa4cac
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9d94c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x99870
movq 0x1... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<int, char>(unsigned long, int const&, char const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xa4cac
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9d94c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x99900
movq 0x1... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [6], char [6]>(unsigned long, char const (&) [6], char const (&) [6]) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [6], unsigned int>(unsigned long, char const (&) [6], unsigned int const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [6], char>(unsigned long, char const (&) [6], char const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [20], int, int, int>(unsigned long, char const (&) [20], int const&, int const&, int const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r13
movl $0x14, %ebx
movl $0x14, %edx
movq %rbp, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %rbp, %rdx
testq %rax, %rax
cmoveq %rbx,... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [7], double>(unsigned long, char const (&) [7], double const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x7, %r13d
movl $0x7, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [5], char [14]>(unsigned long, char const (&) [5], char const (&) [14]) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x5, %r13d
movl $0x5, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [7], char [14]>(unsigned long, char const (&) [7], char const (&) [14]) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x7, %r13d
movl $0x7, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [6], char [14]>(unsigned long, char const (&) [6], char const (&) [14]) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [4], double>(unsigned long, char const (&) [4], double const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x4, %r13d
movl $0x4, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [5], double>(unsigned long, char const (&) [5], double const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x5, %r13d
movl $0x5, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [6], double>(unsigned long, char const (&) [6], double const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [11], double>(unsigned long, char const (&) [11], double const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0xb, %r13d
movl $0xb, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [6], long double>(unsigned long, char const (&) [6], long double const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [5], long long>(unsigned long, char const (&) [5], long long const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x5, %r13d
movl $0x5, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [3], char>(unsigned long, char const (&) [3], char const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x3, %r13d
movl $0x3, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [4], unsigned short>(unsigned long, char const (&) [4], unsigned short const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x4, %r13d
movl $0x4, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [7]>(unsigned long, char const (&) [7]) | void captureValues( size_t index, T const& value ) {
captureValue( index, Catch::Detail::stringify( value ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x7, %r12d
movl $0x7, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %rbx, %rdx
testq %rax, %rax
cmoveq %r12, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa47a... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<unsigned char>(unsigned long, unsigned char const&) | void captureValues( size_t index, T const& value ) {
captureValue( index, Catch::Detail::stringify( value ) );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdx), %esi
movq %rsp, %r15
movq %r15, %rdi
callq 0xa4f3e
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9d94c
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9b0b6
movq 0x10(%rsp), %rsi
incq %rsi
callq ... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [3], void const*>(unsigned long, char const (&) [3], void const* const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x3, %r13d
movl $0x3, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r12, %rdx
testq %rax, %rax
cmoveq %r13, %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<void*>(unsigned long, void* const&) | void captureValues( size_t index, T const& value ) {
captureValue( index, Catch::Detail::stringify( value ) );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x9b5a4
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9d94c
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9b574
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<char [6], void*, void*>(unsigned long, char const (&) [6], void* const&, void* const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl $0x6, %ebp
movl $0x6, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x10560
movq %rax, %rdx
subq %r13, %rdx
testq %rax, %rax
cmoveq %rbp, %rdx
leaq 0x8(%rsp... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
void Catch::Capturer::captureValues<void*, void*>(unsigned long, void* const&, void* const&) | void captureValues( size_t index, T const& value, Ts const&... values ) {
captureValue( index, Catch::Detail::stringify(value) );
captureValues( index+1, values... );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x9b5a4
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9d94c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9b6fd
movq 0x1... | /embeddedartistry[P]printf/build_O3/_deps/catch2-src/src/catch2/../catch2/catch_message.hpp |
dropt_misuse | void
dropt_misuse(const char* message, const char* filename, int line)
{
#ifdef NDEBUG
fprintf(stderr, "dropt: %s\n", message);
#else
fprintf(stderr, "dropt: %s (%s: %d)\n", message, filename, line);
abort();
#endif
} | pushq %rax
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %rdx
movq 0x5a2c(%rip), %rax # 0x7ff8
movq (%rax), %rdi
leaq 0x2c7e(%rip), %rsi # 0x5254
xorl %eax, %eax
callq 0x2140
callq 0x2060
| /jamesderlin[P]dropt/src/dropt.c |
dropt_get_error_message | const dropt_char*
dropt_get_error_message(dropt_context* context)
{
if (context == NULL)
{
DROPT_MISUSE("No dropt context specified.");
return DROPT_TEXT_LITERAL("");
}
if (context->errorDetails.err == dropt_error_none)
{
return DROPT_TEXT_LITERAL("");
}
if (context... | pushq %rbx
testq %rdi, %rdi
je 0x2651
movq %rdi, %rbx
movl 0x38(%rdi), %edi
testl %edi, %edi
je 0x262b
cmpq $0x0, 0x50(%rbx)
jne 0x263d
movq 0x28(%rbx), %rax
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
testq %rax, %rax
je 0x2634
movq 0x30(%rbx), %rcx
callq *%rax
jmp 0x2639
leaq 0x2c35(%rip), %rax # 0x5267
jmp 0x26... | /jamesderlin[P]dropt/src/dropt.c |
dropt_get_help | dropt_char*
dropt_get_help(const dropt_context* context,
const dropt_help_params* helpParams)
{
dropt_char* helpText = NULL;
dropt_stringstream* ss = dropt_ssopen();
if (context == NULL)
{
DROPT_MISUSE("No dropt context specified.");
}
else if (ss != NULL)
{
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x2240
testq %r14, %r14
je 0x2956
movq %rax, %rbx
testq %rax, %rax
je 0x276d
testq %r15, %r15
je 0x277e
movl (%r15), %eax
movl %eax, (%rsp)
movl 0x4(%r15), %r12d
cmpb $0x0, 0x8(%r15)
sete %al
movl %eax, 0x... | /jamesderlin[P]dropt/src/dropt.c |
dropt_init_help_params | void
dropt_init_help_params(dropt_help_params* helpParams)
{
if (helpParams == NULL)
{
DROPT_MISUSE("No dropt help parameters specified.");
return;
}
helpParams->indent = default_help_indent;
helpParams->description_start_column = default_description_start_column;
helpParams->bl... | testq %rdi, %rdi
je 0x2972
movabsq $0x600000002, %rax # imm = 0x600000002
movq %rax, (%rdi)
movb $0x1, 0x8(%rdi)
retq
pushq %rax
callq 0x2326
| /jamesderlin[P]dropt/src/dropt.c |
is_valid_option | static bool
is_valid_option(const dropt_option* option)
{
return option != NULL
&& !( option->long_name == NULL
&& option->short_name == DROPT_TEXT_LITERAL('\0')
&& option->description == NULL
&& option->arg_description == NULL
&& optio... | testq %rdi, %rdi
je 0x2987
movb $0x1, %al
cmpq $0x0, 0x8(%rdi)
je 0x298a
retq
xorl %eax, %eax
retq
cmpb $0x0, (%rdi)
jne 0x2986
cmpq $0x0, 0x10(%rdi)
jne 0x2986
cmpq $0x0, 0x18(%rdi)
jne 0x2986
cmpq $0x0, 0x20(%rdi)
jne 0x2986
cmpq $0x0, 0x28(%rdi)
jne 0x2986
cmpl $0x0, 0x30(%rdi)
jne 0x2986
cmpq $0x0, 0x38(%rdi)
setne... | /jamesderlin[P]dropt/src/dropt.c |
dropt_parse | dropt_char**
dropt_parse(dropt_context* context,
int argc, dropt_char** argv)
{
dropt_char* arg;
parse_state ps;
ps.option = NULL;
ps.optionArgument = NULL;
ps.argNext = argv;
if (argv == NULL)
{
/* Nothing to do. */
goto exit;
}
if (context == NULL)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
je 0x2e3f
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2ed9
movl %esi, %r14d
cmpl $-0x1, %esi
jne 0x2a40
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
incl %r14d
c... | /jamesderlin[P]dropt/src/dropt.c |
dropt_new_context | dropt_context*
dropt_new_context(const dropt_option* options)
{
dropt_context* context = NULL;
size_t n;
if (options == NULL)
{
DROPT_MISUSE("No option list specified.");
goto exit;
}
/* Sanity-check the options. */
for (n = 0; is_valid_option(&options[n]); n++)
{
... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x309b
movq %rdi, %rbx
callq 0x2978
testb %al, %al
je 0x302b
leaq 0x40(%rbx), %r14
xorl %r15d, %r15d
cmpb $0x3d, -0x40(%r14)
je 0x3096
movq -0x38(%r14), %rdi
testq %rdi, %rdi
je 0x3016
movl $0x3d, %esi
callq 0x20f0
testq %rax, %rax
jne 0x3096
incq %r15
movq %r14, %rd... | /jamesderlin[P]dropt/src/dropt.c |
dropt_set_strncmp | void
dropt_set_strncmp(dropt_context* context, dropt_strncmp_func cmp)
{
if (context == NULL)
{
DROPT_MISUSE("No dropt context specified.");
return;
}
if (cmp == NULL) { cmp = dropt_strncmp; }
context->ncmpstr = cmp;
/* Changing the sort method invalidates our existing lookup t... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x30e1
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x30b8
movq 0x4f18(%rip), %rsi # 0x7fd0
movq %rsi, 0x58(%rbx)
movq 0x10(%rbx), %rdi
callq 0x2050
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq 0x2050
movq %r14, 0x18(%rbx)
addq $0x8, %rsp
popq %rb... | /jamesderlin[P]dropt/src/dropt.c |
dropt_free_context | void
dropt_free_context(dropt_context* context)
{
dropt_clear_error(context);
free_lookup_tables(context);
free(context);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20c0
testq %rbx, %rbx
je 0x3114
movq 0x10(%rbx), %rdi
callq 0x2050
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq 0x2050
movq %r14, 0x18(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2050
| /jamesderlin[P]dropt/src/dropt.c |
cmp_key_option_proxy_long | static int
cmp_key_option_proxy_long(const void* key, const void* item)
{
const char_array* longName = key;
const option_proxy* op = item;
size_t optionLen;
int ret;
assert(longName != NULL);
assert(op != NULL);
assert(op->option != NULL);
assert(op->context != NULL);
assert(op->co... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x33b1
testq %rsi, %rsi
je 0x33d0
movq (%rsi), %rax
testq %rax, %rax
je 0x33ef
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x340e
movq 0x58(%rcx), %r13
testq %r13, %r13
je 0x342d
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r1... | /jamesderlin[P]dropt/src/dropt.c |
parse_option_arg | static dropt_error
parse_option_arg(dropt_context* context, parse_state* ps)
{
dropt_error err;
bool consumeNextArg = false;
if (OPTION_TAKES_ARG(ps->option) && ps->optionArgument == NULL)
{
/* The option expects an argument, but none was specified with '='.
* Try using the next item ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
xorl %r15d, %r15d
cmpq $0x0, 0x18(%rsi)
je 0x353d
cmpq $0x0, 0x8(%rbx)
je 0x3592
xorl %r15d, %r15d
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x35bd
testl %eax, %eax
je 0x3579
movq (%rbx), %rsi
testb $0x4, 0x30(%rsi)
je 0x357b
testb %r15... | /jamesderlin[P]dropt/src/dropt.c |
set_option_value | static dropt_error
set_option_value(dropt_context* context,
const dropt_option* option, const dropt_char* optionArgument)
{
assert(option != NULL);
if (option->handler == NULL)
{
DROPT_MISUSE("No option handler specified.");
return dropt_error_bad_configuration;
}
... | pushq %rax
testq %rsi, %rsi
je 0x35d4
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x35f3
movq 0x28(%rsi), %rcx
popq %r8
jmpq *%rax
leaq 0x1d9d(%rip), %rdi # 0x5378
leaq 0x1a7a(%rip), %rsi # 0x505c
leaq 0x1f40(%rip), %rcx # 0x5529
movl $0x3d4, %edx # imm = 0x3D4
callq 0x2120
callq 0x24b6
| /jamesderlin[P]dropt/src/dropt.c |
set_short_option_error_details | static void
set_short_option_error_details(dropt_context* context, dropt_error err,
dropt_char shortName,
const dropt_char* optionArgument)
{
/* "-?" is just a placeholder. */
dropt_char shortNameBuf[] = DROPT_TEXT_LITERAL("-?");
assert(context ... | pushq %rax
movb $0x0, 0x6(%rsp)
movw $0x3f2d, 0x4(%rsp) # imm = 0x3F2D
testb %dl, %dl
je 0x3623
movq %rcx, %r8
leaq 0x4(%rsp), %rax
movb %dl, 0x1(%rax)
movl $0x2, %ecx
movq %rax, %rdx
callq 0x2f1c
popq %rax
retq
leaq 0x200a(%rip), %rdi # 0x5634
leaq 0x1a2b(%rip), %rsi # 0x505c
leaq 0x2025(%rip), %rcx ... | /jamesderlin[P]dropt/src/dropt.c |
dropt_handle_uint | dropt_error
dropt_handle_uint(dropt_context* context,
const dropt_option* option,
const dropt_char* optionArgument,
void* dest)
{
dropt_error err = dropt_error_none;
int val = 0;
unsigned int* out = dest;
if (out == NULL)
{
DROPT_MISUSE(... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testq %rcx, %rcx
je 0x36f6
movq %rdx, %r14
movl $0x5, %eax
xorl %edx, %edx
testq %r14, %r14
je 0x3719
movzbl (%r14), %ecx
testl %ecx, %ecx
je 0x3717
cmpl $0x2d, %ecx
jne 0x372b
movl $0x6, %eax
jmp 0x3719
leaq 0x1fdb(%rip), %rdi # 0x56d8
leaq 0x... | /jamesderlin[P]dropt/src/dropt_handlers.c |
dropt_handle_double | dropt_error
dropt_handle_double(dropt_context* context,
const dropt_option* option,
const dropt_char* optionArgument,
void* dest)
{
dropt_error err = dropt_error_none;
double val = 0.0;
double* out = dest;
if (out == NULL)
{
DROPT_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testq %rcx, %rcx
je 0x3989
movq %rdx, %r14
movl $0x5, %eax
xorpd %xmm0, %xmm0
testq %rdx, %rdx
je 0x39aa
cmpb $0x0, (%r14)
je 0x39aa
callq 0x2070
movq %rax, %r15
movl $0x0, (%rax)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x20a0
movq (%r... | /jamesderlin[P]dropt/src/dropt_handlers.c |
dropt_handle_string | dropt_error
dropt_handle_string(dropt_context* context,
const dropt_option* option,
const dropt_char* optionArgument,
void* dest)
{
dropt_error err = dropt_error_none;
const dropt_char** out = dest;
if (out == NULL)
{
DROPT_MISUSE("No ... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
testq %rcx, %rcx
je 0x39e4
xorl %eax, %eax
testq %r14, %r14
setne %cl
sete %al
leal (%rax,%rax,4), %eax
jmp 0x3a03
leaq 0x1ced(%rip), %rdi # 0x56d8
leaq 0x1d08(%rip), %rsi # 0x56fa
movl $0x1c9, %edx # imm = 0x1C9
callq 0x21f0
movl $0x... | /jamesderlin[P]dropt/src/dropt_handlers.c |
dropt_safe_realloc | void*
dropt_safe_realloc(void* p, size_t numElements, size_t elementSize)
{
size_t numBytes;
/* `elementSize` shouldn't legally be 0, but we check for it in case a
* caller got the argument order wrong.
*/
if (numElements == 0 || elementSize == 0)
{
/* The behavior of `realloc(p, 0)` ... | pushq %rbx
movq %rdx, %rbx
testq %rsi, %rsi
setne %al
testq %rdx, %rdx
setne %cl
testb %cl, %al
jne 0x3aca
callq 0x2050
testq %rbx, %rbx
jne 0x3ad2
leaq 0x1d3a(%rip), %rdi # 0x57ec
leaq 0x1d44(%rip), %rsi # 0x57fd
leaq 0x1d96(%rip), %rcx # 0x5856
movl $0x95, %edx
callq 0x2120
movq %rbx, %rax
mulq %rsi
jn... | /jamesderlin[P]dropt/src/dropt_string.c |
dropt_strndup | dropt_char*
dropt_strndup(const dropt_char* s, size_t n)
{
dropt_char* copy;
size_t len = 0;
assert(s != NULL);
while (len < n && s[len] != DROPT_TEXT_LITERAL('\0'))
{
len++;
}
if (len + 1 < len)
{
/* This overflow check shouldn't be strictly necessary. `len` can be at... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3b51
movq %rdi, %rbx
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x3b12
cmpb $0x0, (%rbx,%r14)
je 0x3b12
incq %r14
cmpq %r14, %rsi
jne 0x3b00
movq %rsi, %r14
cmpq $-0x1, %r14
je 0x3b45
leaq 0x1(%r14), %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0x2220
movq %rax, %r15
test... | /jamesderlin[P]dropt/src/dropt_string.c |
dropt_strnicmp | int
dropt_strnicmp(const dropt_char* s, const dropt_char* t, size_t n)
{
assert(s != NULL);
assert(t != NULL);
if (s == t) { return 0; }
while (n--)
{
if (*s == DROPT_TEXT_LITERAL('\0') && *t == DROPT_TEXT_LITERAL('\0'))
{
break;
}
else if (*s == *t || d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3c4f
movq %rsi, %r14
testq %rsi, %rsi
je 0x3c6e
movq %rdx, %rbx
movq %rdi, %r15
cmpq %r14, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x3c2f
xorl %r12d, %r12d
movsbq (%r15,%r12), %r13
testq %r13, %r13
jne 0x... | /jamesderlin[P]dropt/src/dropt_string.c |
dropt_vsnprintf | int
dropt_vsnprintf(dropt_char* s, size_t n, const dropt_char* format, va_list args)
{
#if __STDC_VERSION__ >= 199901L || __GNUC__
/* ISO C99-compliant.
*
* As far as I can tell, gcc's implementation of `vsnprintf` has always
* matched the behavior required by the C99 standard (which is to return
... | testq %rdx, %rdx
jne 0x20b0
pushq %rax
leaq 0x1c9c(%rip), %rdi # 0x593a
leaq 0x1b58(%rip), %rsi # 0x57fd
leaq 0x1c9d(%rip), %rcx # 0x5949
movl $0x14e, %edx # imm = 0x14E
callq 0x2120
| /jamesderlin[P]dropt/src/dropt_string.c |
dropt_asprintf | dropt_char*
dropt_asprintf(const dropt_char* format, ...)
{
dropt_char* s;
va_list args;
va_start(args, format);
s = dropt_vasprintf(format, args);
va_end(args);
return s;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x3e27
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)... | /jamesderlin[P]dropt/src/dropt_string.c |
dropt_ssopen | dropt_stringstream*
dropt_ssopen(void)
{
dropt_stringstream* ss = malloc(sizeof *ss);
if (ss != NULL)
{
ss->used = 0;
ss->maxSize = default_stringstream_buffer_size;
ss->string = dropt_safe_malloc(ss->maxSize, sizeof *ss->string);
if (ss->string == NULL)
{
... | pushq %rbx
movl $0x18, %edi
callq 0x21a0
testq %rax, %rax
je 0x3e96
movq %rax, %rbx
movq $0x0, 0x10(%rax)
movq $0x100, 0x8(%rax) # imm = 0x100
movl $0x100, %edi # imm = 0x100
callq 0x21a0
movq %rax, (%rbx)
testq %rax, %rax
je 0x3e8e
movb $0x0, (%rax)
jmp 0x3e98
movq %rbx, %rdi
callq 0x2050
xorl %ebx, %... | /jamesderlin[P]dropt/src/dropt_string.c |
dropt_ssresize | static size_t
dropt_ssresize(dropt_stringstream* ss, size_t n)
{
assert(ss != NULL);
/* Don't allow shrinking if it will truncate the string. */
if (n < ss->maxSize) { n = MAX(n, ss->used + 1 /* NUL */); }
/* There should always be a buffer to point to. */
assert(n > 0);
if (n != ss->maxSize)... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
jbe 0x3f13
movq 0x10(%r14), %rcx
incq %rcx
cmpq %rbx, %rcx
cmovaq %rcx, %rbx
testq %rbx, %rbx
je 0x3f41
cmpq %rax, %rbx
je 0x3f39
movq (%r14), %rdi
movl $0x1, %edx
movq %rbx, %rsi
callq 0x2220
testq %rax, %rax
je 0x3f3... | /jamesderlin[P]dropt/src/dropt_string.c |
dropt_ssfinalize | dropt_char*
dropt_ssfinalize(dropt_stringstream* ss)
{
dropt_char* s;
assert(ss != NULL);
/* Shrink to fit. */
dropt_ssresize(ss, 0);
s = ss->string;
ss->string = NULL;
dropt_ssclose(ss);
return s;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3f90
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3ef2
movq (%rbx), %r14
movq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x2050
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1a50(%rip), %rdi # 0x59e7
leaq 0x185f(%rip), %rsi # 0x57fd
leaq 0x1a76(%rip)... | /jamesderlin[P]dropt/src/dropt_string.c |
dropt_vssprintf | int
dropt_vssprintf(dropt_stringstream* ss, const dropt_char* format, va_list args)
{
int n;
va_list argsCopy;
assert(ss != NULL);
assert(format != NULL);
va_copy(argsCopy, args);
n = dropt_vsnprintf(NULL, 0, format, argsCopy);
va_end(argsCopy);
if (n > 0)
{
size_t availabl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x4099
movq %rsi, %r15
testq %rsi, %rsi
je 0x40b8
movq %rdx, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %... | /jamesderlin[P]dropt/src/dropt_string.c |
dropt_ssprintf | int
dropt_ssprintf(dropt_stringstream* ss, const dropt_char* format, ...)
{
int n;
va_list args;
va_start(args, format);
n = dropt_vssprintf(ss, format, args);
va_end(args);
return n;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x419d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%... | /jamesderlin[P]dropt/src/dropt_string.c |
void mvm::interpreter<(anonymous namespace)::mini_set, mvm::list::mplist<mvm::meta_bytecode<mvm::bytecode_serializer>, mvm::meta_value_stack<mvm::value_stack<mvm::list::mplist<unsigned int>>>>>::interpret_instr<mvm::instr_set<(anonymous namespace)::mini_set>::consumer_instr<mvm::meta_tie<mvm::meta_bytecode, unsigned in... | void interpreter<Set, InstancesList>::interpret_instr() {
if constexpr (concept ::is_producer_v<I>) {
this->produce<
instance_of_tie_t<instance_list_type,
typename traits::producers_traits<I>::producer_type>,
typename traits::producers_traits<I>::data_type>(this->con... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21c50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /kenavolic[P]mvm/include/mvm/interpreter.h |
void mvm::interpreter<(anonymous namespace)::mini_set, mvm::list::mplist<mvm::meta_bytecode<mvm::bytecode_serializer>, mvm::meta_value_stack<mvm::value_stack<mvm::list::mplist<unsigned int>>>>>::interpret_instr<mvm::instr_set<(anonymous namespace)::mini_set>::consumer_producer_instr<mvm::meta_tie<mvm::meta_value_stack,... | void interpreter<Set, InstancesList>::interpret_instr() {
if constexpr (concept ::is_producer_v<I>) {
this->produce<
instance_of_tie_t<instance_list_type,
typename traits::producers_traits<I>::producer_type>,
typename traits::producers_traits<I>::data_type>(this->con... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x21dc0
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x20f90
addq $0x20, %rsp
popq %rbp
retq
nop
| /kenavolic[P]mvm/include/mvm/interpreter.h |
void mvm::interpreter<(anonymous namespace)::mini_set, mvm::list::mplist<mvm::meta_bytecode<mvm::bytecode_serializer>, mvm::meta_value_stack<mvm::value_stack<mvm::list::mplist<unsigned int>>>>>::interpret_instr<mvm::instr_set<(anonymous namespace)::mini_set>::consumer_producer_instr<mvm::meta_tie<mvm::meta_value_stack,... | void interpreter<Set, InstancesList>::interpret_instr() {
if constexpr (concept ::is_producer_v<I>) {
this->produce<
instance_of_tie_t<instance_list_type,
typename traits::producers_traits<I>::producer_type>,
typename traits::producers_traits<I>::data_type>(this->con... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x22360
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x21580
addq $0x20, %rsp
popq %rbp
retq
| /kenavolic[P]mvm/include/mvm/interpreter.h |
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.