name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
unsigned int ans_fold_mapping_and_exceptions<2u>(unsigned int, unsigned char*&) | uint32_t ans_fold_mapping_and_exceptions(uint32_t x, uint8_t*& except_out)
{
const uint32_t radix = 8;
uint32_t radix_mask = ((1 << radix) - 1);
size_t offset = 0;
size_t thres = 1 << (fidelity + radix - 1);
while (x >= thres) {
*except_out++ = x & radix_mask;
x = x >> radix;
offset = offset + (1 << (fidelity - 1)) * radix_mask;
}
return x + offset;
} | movl %edi, %eax
xorl %ecx, %ecx
cmpl $0x200, %eax # imm = 0x200
jb 0x4a5b7
movq (%rsi), %rdx
addl $0x1fe, %ecx # imm = 0x1FE
leaq 0x1(%rdx), %rdi
movq %rdi, (%rsi)
movb %al, (%rdx)
shrl $0x8, %eax
jmp 0x4a599
addl %ecx, %eax
retq
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
ans_fold_encode<3u>::create(unsigned int const*, unsigned long) | static ans_fold_encode create(const uint32_t* in_u32, size_t n)
{
const uint32_t MAX_SIGMA = 1 << (fidelity + 8 + 1);
ans_fold_encode model;
std::vector<uint64_t> freqs(MAX_SIGMA, 0);
uint32_t max_sym = 0;
for (size_t i = 0; i < n; i++) {
auto mapped_u32 = ans_fold_mapping<fidelity>(in_u32[i]);
freqs[mapped_u32]++;
max_sym = std::max(mapped_u32, max_sym);
}
model.nfreqs = adjust_freqs(freqs, max_sym, true);
model.frame_size = std::accumulate(
std::begin(model.nfreqs), std::end(model.nfreqs), 0);
uint64_t cur_base = 0;
uint64_t tmp = constants::K * constants::RADIX;
model.table.resize(max_sym + 1);
for (size_t sym = 0; sym < model.nfreqs.size(); sym++) {
model.table[sym].freq = model.nfreqs[sym];
model.table[sym].base = cur_base;
model.table[sym].sym_upper_bound = tmp * model.nfreqs[sym];
cur_base += model.nfreqs[sym];
}
model.lower_bound = constants::K * model.frame_size;
return model;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
leaq 0x28(%rsp), %rdx
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, %r12
movq %rdi, %rbx
andq $0x0, (%rdx)
vmovups %ymm0, 0x10(%rdi)
vmovups %ymm0, (%rdi)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x1000, %esi # imm = 0x1000
vzeroupper
callq 0x35cc8
xorl %r14d, %r14d
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x4a822
movl (%r12,%r13,4), %edi
callq 0x4a990
movq 0x10(%rsp), %rdx
movl %eax, %ecx
incq (%rdx,%rcx,8)
cmpl %r14d, %eax
cmoval %eax, %r14d
incq %r13
jmp 0x4a7fd
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rcx
movl %r14d, %edx
movl %ecx, %r8d
callq 0x30eed
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x384e0
movq %r15, %rdi
callq 0x36d6c
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x4a868
addl (%rax), %ecx
addq $0x4, %rax
jmp 0x4a85b
movslq %ecx, %rax
leaq 0x18(%rbx), %rdi
incl %r14d
movq %rax, 0x30(%rbx)
movq %r14, %rsi
callq 0x49e18
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
subq %rax, %rcx
addq $0x8, %rdx
sarq $0x2, %rcx
cmpq %rdi, %rcx
je 0x4a8c1
movzwl (%rax,%rdi,4), %r8d
movw %r8w, -0x8(%rdx)
movl %esi, -0x4(%rdx)
movl (%rax,%rdi,4), %r8d
incq %rdi
addl %r8d, %esi
shlq $0x24, %r8
movq %r8, (%rdx)
addq $0x10, %rdx
jmp 0x4a898
movq 0x30(%rbx), %rax
leaq 0x10(%rsp), %rdi
shlq $0x4, %rax
movq %rax, 0x38(%rbx)
callq 0x35d80
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4a8ea
leaq 0x10(%rsp), %rdi
movq %rax, %r14
callq 0x35d80
jmp 0x4a8fc
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a97a
movq %r14, %rdi
callq 0x2e800
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
unsigned int ans_fold_mapping<3u>(unsigned int) | uint32_t ans_fold_mapping(uint32_t x)
{
const uint32_t radix = 8;
uint32_t radix_mask = ((1 << radix) - 1);
size_t offset = 0;
size_t thres = 1 << (fidelity + radix - 1);
while (x >= thres) {
auto digit = x & radix_mask;
x = x >> radix;
offset = offset + (1 << (fidelity - 1)) * radix_mask;
}
return x + offset;
} | movl %edi, %eax
xorl %ecx, %ecx
cmpl $0x400, %eax # imm = 0x400
jb 0x4a9a6
shrl $0x8, %eax
addl $0x3fc, %ecx # imm = 0x3FC
jmp 0x4a994
addl %ecx, %eax
retq
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
unsigned long ans_fold_compress<4u>(unsigned char*, unsigned long, unsigned int const*, unsigned long) | size_t ans_fold_compress(
uint8_t* dst, size_t dstCapacity, const uint32_t* src, size_t srcSize)
{
auto in_u32 = reinterpret_cast<const uint32_t*>(src);
auto ans_frame = ans_fold_encode<fidelity>::create(in_u32, srcSize);
uint8_t* out_u8 = reinterpret_cast<uint8_t*>(dst);
// serialize model
ans_frame.serialize(out_u8);
// start encoding, we encode 4 states at the same time for speed
std::array<uint64_t, 4> states;
states[0] = ans_frame.initial_state();
states[1] = ans_frame.initial_state();
states[2] = ans_frame.initial_state();
states[3] = ans_frame.initial_state();
size_t cur_sym = 0;
while ((srcSize - cur_sym) % 4 != 0) {
ans_frame.encode_symbol(
states[0], in_u32[srcSize - cur_sym - 1], out_u8);
cur_sym += 1;
}
while (cur_sym != srcSize) {
ans_frame.encode_symbol(
states[0], in_u32[srcSize - cur_sym - 1], out_u8);
ans_frame.encode_symbol(
states[1], in_u32[srcSize - cur_sym - 2], out_u8);
ans_frame.encode_symbol(
states[2], in_u32[srcSize - cur_sym - 3], out_u8);
ans_frame.encode_symbol(
states[3], in_u32[srcSize - cur_sym - 4], out_u8);
cur_sym += 4;
}
// flush final state
ans_frame.flush_state(states[0], out_u8);
ans_frame.flush_state(states[1], out_u8);
ans_frame.flush_state(states[2], out_u8);
ans_frame.flush_state(states[3], out_u8);
return out_u8 - reinterpret_cast<uint8_t*>(dst);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x38(%rsp), %rbx
movq %rdi, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rdx, %rsi
movq %rcx, %rdx
movq %rbx, %rdi
callq 0x4abc8
leaq 0x8(%rsp), %rsi
movq %r12, 0x30(%rsp)
movq %r12, (%rsi)
movq %rbx, %rdi
callq 0x4ad20
leaq 0x38(%rsp), %rcx
movl %r14d, %ebp
andl $0x3, %ebp
leaq -0x4(%r15,%r14,4), %rbx
leaq 0x28(%rsp), %rax
leaq 0x8(%rsp), %r13
xorl %r12d, %r12d
vbroadcastsd 0x38(%rcx), %ymm0
negq %rbp
vmovups %ymm0, -0x18(%rax)
cmpq %r12, %rbp
je 0x4aad9
movl (%rbx,%r12,4), %edx
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rcx
vzeroupper
callq 0x4ad2c
decq %r12
jmp 0x4aab6
andq $-0x4, %r14
leaq 0x38(%rsp), %rbx
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x18(%rsp), %rbp
testq %r14, %r14
je 0x4ab4f
movl -0x4(%r15,%r14,4), %edx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rcx
vzeroupper
callq 0x4ad2c
movl -0x8(%r15,%r14,4), %edx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rcx
callq 0x4ad2c
movl -0xc(%r15,%r14,4), %edx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rcx
callq 0x4ad2c
movl -0x10(%r15,%r14,4), %edx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rcx
callq 0x4ad2c
addq $-0x4, %r14
jmp 0x4aaf1
leaq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rbx
subq 0x38(%rdi), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rax
subq 0x38(%rdi), %rax
movq %rax, 0x8(%rbx)
movq 0x20(%rsp), %rax
subq 0x38(%rdi), %rax
movq %rax, 0x10(%rbx)
movq 0x28(%rsp), %rax
subq 0x38(%rdi), %rax
movq %rax, 0x18(%rbx)
subq 0x30(%rsp), %rbx
addq $0x20, %rbx
vzeroupper
callq 0x4ad8e
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4abb3
jmp 0x4abb3
leaq 0x38(%rsp), %rdi
movq %rax, %rbx
callq 0x4ad8e
movq %rbx, %rdi
callq 0x2e800
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
unsigned long ans_fold_compress<5u>(unsigned char*, unsigned long, unsigned int const*, unsigned long) | size_t ans_fold_compress(
uint8_t* dst, size_t dstCapacity, const uint32_t* src, size_t srcSize)
{
auto in_u32 = reinterpret_cast<const uint32_t*>(src);
auto ans_frame = ans_fold_encode<fidelity>::create(in_u32, srcSize);
uint8_t* out_u8 = reinterpret_cast<uint8_t*>(dst);
// serialize model
ans_frame.serialize(out_u8);
// start encoding, we encode 4 states at the same time for speed
std::array<uint64_t, 4> states;
states[0] = ans_frame.initial_state();
states[1] = ans_frame.initial_state();
states[2] = ans_frame.initial_state();
states[3] = ans_frame.initial_state();
size_t cur_sym = 0;
while ((srcSize - cur_sym) % 4 != 0) {
ans_frame.encode_symbol(
states[0], in_u32[srcSize - cur_sym - 1], out_u8);
cur_sym += 1;
}
while (cur_sym != srcSize) {
ans_frame.encode_symbol(
states[0], in_u32[srcSize - cur_sym - 1], out_u8);
ans_frame.encode_symbol(
states[1], in_u32[srcSize - cur_sym - 2], out_u8);
ans_frame.encode_symbol(
states[2], in_u32[srcSize - cur_sym - 3], out_u8);
ans_frame.encode_symbol(
states[3], in_u32[srcSize - cur_sym - 4], out_u8);
cur_sym += 4;
}
// flush final state
ans_frame.flush_state(states[0], out_u8);
ans_frame.flush_state(states[1], out_u8);
ans_frame.flush_state(states[2], out_u8);
ans_frame.flush_state(states[3], out_u8);
return out_u8 - reinterpret_cast<uint8_t*>(dst);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x38(%rsp), %rbx
movq %rdi, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rdx, %rsi
movq %rcx, %rdx
movq %rbx, %rdi
callq 0x4afdc
leaq 0x8(%rsp), %rsi
movq %r12, 0x30(%rsp)
movq %r12, (%rsi)
movq %rbx, %rdi
callq 0x4b134
leaq 0x38(%rsp), %rcx
movl %r14d, %ebp
andl $0x3, %ebp
leaq -0x4(%r15,%r14,4), %rbx
leaq 0x28(%rsp), %rax
leaq 0x8(%rsp), %r13
xorl %r12d, %r12d
vbroadcastsd 0x38(%rcx), %ymm0
negq %rbp
vmovups %ymm0, -0x18(%rax)
cmpq %r12, %rbp
je 0x4aeed
movl (%rbx,%r12,4), %edx
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rcx
vzeroupper
callq 0x4b140
decq %r12
jmp 0x4aeca
andq $-0x4, %r14
leaq 0x38(%rsp), %rbx
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x18(%rsp), %rbp
testq %r14, %r14
je 0x4af63
movl -0x4(%r15,%r14,4), %edx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rcx
vzeroupper
callq 0x4b140
movl -0x8(%r15,%r14,4), %edx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rcx
callq 0x4b140
movl -0xc(%r15,%r14,4), %edx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rcx
callq 0x4b140
movl -0x10(%r15,%r14,4), %edx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rcx
callq 0x4b140
addq $-0x4, %r14
jmp 0x4af05
leaq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rbx
subq 0x38(%rdi), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rax
subq 0x38(%rdi), %rax
movq %rax, 0x8(%rbx)
movq 0x20(%rsp), %rax
subq 0x38(%rdi), %rax
movq %rax, 0x10(%rbx)
movq 0x28(%rsp), %rax
subq 0x38(%rdi), %rax
movq %rax, 0x18(%rbx)
subq 0x30(%rsp), %rbx
addq $0x20, %rbx
vzeroupper
callq 0x4b1a2
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4afc7
jmp 0x4afc7
leaq 0x38(%rsp), %rdi
movq %rax, %rbx
callq 0x4b1a2
movq %rbx, %rdi
callq 0x2e800
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
ans_fold_encode<5u>::encode_symbol(unsigned long&, unsigned int, unsigned char*&) | void encode_symbol(uint64_t& state, uint32_t sym, uint8_t*& out_u8)
{
auto mapped_sym
= ans_fold_mapping_and_exceptions<fidelity>(sym, out_u8);
const auto& e = table[mapped_sym];
if (state >= e.sym_upper_bound) {
auto out_ptr_u32 = reinterpret_cast<uint32_t*>(out_u8);
*out_ptr_u32 = state & 0xFFFFFFFF;
out_u8 += sizeof(uint32_t);
state = state >> constants::RADIX_LOG2;
}
state = ((state / e.freq) * frame_size) + (state % e.freq) + e.base;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %r15
movl %edx, %edi
movq %rcx, %rsi
callq 0x4b1d1
movq 0x18(%r14), %rsi
movl %eax, %edx
movq (%rbx), %rax
shlq $0x4, %rdx
leaq (%rsi,%rdx), %rcx
cmpq 0x8(%rsi,%rdx), %rax
jb 0x4b183
movq (%r15), %rdx
movl %eax, (%rdx)
addq $0x4, %rdx
shrq $0x20, %rax
movq %rdx, (%r15)
movq %rax, (%rbx)
movzwl (%rcx), %esi
xorl %edx, %edx
divq %rsi
movl 0x4(%rcx), %ecx
addq %rdx, %rcx
imulq 0x30(%r14), %rax
addq %rax, %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
ans_fold_encode<5u>::~ans_fold_encode() | static ans_fold_encode create(const uint32_t* in_u32, size_t n)
{
const uint32_t MAX_SIGMA = 1 << (fidelity + 8 + 1);
ans_fold_encode model;
std::vector<uint64_t> freqs(MAX_SIGMA, 0);
uint32_t max_sym = 0;
for (size_t i = 0; i < n; i++) {
auto mapped_u32 = ans_fold_mapping<fidelity>(in_u32[i]);
freqs[mapped_u32]++;
max_sym = std::max(mapped_u32, max_sym);
}
model.nfreqs = adjust_freqs(freqs, max_sym, true);
model.frame_size = std::accumulate(
std::begin(model.nfreqs), std::end(model.nfreqs), 0);
uint64_t cur_base = 0;
uint64_t tmp = constants::K * constants::RADIX;
model.table.resize(max_sym + 1);
for (size_t sym = 0; sym < model.nfreqs.size(); sym++) {
model.table[sym].freq = model.nfreqs[sym];
model.table[sym].base = cur_base;
model.table[sym].sym_upper_bound = tmp * model.nfreqs[sym];
cur_base += model.nfreqs[sym];
}
model.lower_bound = constants::K * model.frame_size;
return model;
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x4a048
movq %rbx, %rdi
popq %rbx
jmp 0x36d6c
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
ans_fold_encode<6u>::create(unsigned int const*, unsigned long) | static ans_fold_encode create(const uint32_t* in_u32, size_t n)
{
const uint32_t MAX_SIGMA = 1 << (fidelity + 8 + 1);
ans_fold_encode model;
std::vector<uint64_t> freqs(MAX_SIGMA, 0);
uint32_t max_sym = 0;
for (size_t i = 0; i < n; i++) {
auto mapped_u32 = ans_fold_mapping<fidelity>(in_u32[i]);
freqs[mapped_u32]++;
max_sym = std::max(mapped_u32, max_sym);
}
model.nfreqs = adjust_freqs(freqs, max_sym, true);
model.frame_size = std::accumulate(
std::begin(model.nfreqs), std::end(model.nfreqs), 0);
uint64_t cur_base = 0;
uint64_t tmp = constants::K * constants::RADIX;
model.table.resize(max_sym + 1);
for (size_t sym = 0; sym < model.nfreqs.size(); sym++) {
model.table[sym].freq = model.nfreqs[sym];
model.table[sym].base = cur_base;
model.table[sym].sym_upper_bound = tmp * model.nfreqs[sym];
cur_base += model.nfreqs[sym];
}
model.lower_bound = constants::K * model.frame_size;
return model;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
leaq 0x28(%rsp), %rdx
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, %r12
movq %rdi, %rbx
andq $0x0, (%rdx)
vmovups %ymm0, 0x10(%rdi)
vmovups %ymm0, (%rdi)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x8000, %esi # imm = 0x8000
vzeroupper
callq 0x35cc8
xorl %r14d, %r14d
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x4b45e
movl (%r12,%r13,4), %edi
callq 0x4b5cc
movq 0x10(%rsp), %rdx
movl %eax, %ecx
incq (%rdx,%rcx,8)
cmpl %r14d, %eax
cmoval %eax, %r14d
incq %r13
jmp 0x4b439
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rcx
movl %r14d, %edx
movl %ecx, %r8d
callq 0x30eed
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x384e0
movq %r15, %rdi
callq 0x36d6c
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x4b4a4
addl (%rax), %ecx
addq $0x4, %rax
jmp 0x4b497
movslq %ecx, %rax
leaq 0x18(%rbx), %rdi
incl %r14d
movq %rax, 0x30(%rbx)
movq %r14, %rsi
callq 0x49e18
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
subq %rax, %rcx
addq $0x8, %rdx
sarq $0x2, %rcx
cmpq %rdi, %rcx
je 0x4b4fd
movzwl (%rax,%rdi,4), %r8d
movw %r8w, -0x8(%rdx)
movl %esi, -0x4(%rdx)
movl (%rax,%rdi,4), %r8d
incq %rdi
addl %r8d, %esi
shlq $0x24, %r8
movq %r8, (%rdx)
addq $0x10, %rdx
jmp 0x4b4d4
movq 0x30(%rbx), %rax
leaq 0x10(%rsp), %rdi
shlq $0x4, %rax
movq %rax, 0x38(%rbx)
callq 0x35d80
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4b526
leaq 0x10(%rsp), %rdi
movq %rax, %r14
callq 0x35d80
jmp 0x4b538
movq %rax, %r14
movq %rbx, %rdi
callq 0x4b5b6
movq %r14, %rdi
callq 0x2e800
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
ans_fold_encode<6u>::encode_symbol(unsigned long&, unsigned int, unsigned char*&) | void encode_symbol(uint64_t& state, uint32_t sym, uint8_t*& out_u8)
{
auto mapped_sym
= ans_fold_mapping_and_exceptions<fidelity>(sym, out_u8);
const auto& e = table[mapped_sym];
if (state >= e.sym_upper_bound) {
auto out_ptr_u32 = reinterpret_cast<uint32_t*>(out_u8);
*out_ptr_u32 = state & 0xFFFFFFFF;
out_u8 += sizeof(uint32_t);
state = state >> constants::RADIX_LOG2;
}
state = ((state / e.freq) * frame_size) + (state % e.freq) + e.base;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %r15
movl %edx, %edi
movq %rcx, %rsi
callq 0x4b5e5
movq 0x18(%r14), %rsi
movl %eax, %edx
movq (%rbx), %rax
shlq $0x4, %rdx
leaq (%rsi,%rdx), %rcx
cmpq 0x8(%rsi,%rdx), %rax
jb 0x4b597
movq (%r15), %rdx
movl %eax, (%rdx)
addq $0x4, %rdx
shrq $0x20, %rax
movq %rdx, (%r15)
movq %rax, (%rbx)
movzwl (%rcx), %esi
xorl %edx, %edx
divq %rsi
movl 0x4(%rcx), %ecx
addq %rdx, %rcx
imulq 0x30(%r14), %rax
addq %rax, %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
ans_fold_encode<6u>::~ans_fold_encode() | static ans_fold_encode create(const uint32_t* in_u32, size_t n)
{
const uint32_t MAX_SIGMA = 1 << (fidelity + 8 + 1);
ans_fold_encode model;
std::vector<uint64_t> freqs(MAX_SIGMA, 0);
uint32_t max_sym = 0;
for (size_t i = 0; i < n; i++) {
auto mapped_u32 = ans_fold_mapping<fidelity>(in_u32[i]);
freqs[mapped_u32]++;
max_sym = std::max(mapped_u32, max_sym);
}
model.nfreqs = adjust_freqs(freqs, max_sym, true);
model.frame_size = std::accumulate(
std::begin(model.nfreqs), std::end(model.nfreqs), 0);
uint64_t cur_base = 0;
uint64_t tmp = constants::K * constants::RADIX;
model.table.resize(max_sym + 1);
for (size_t sym = 0; sym < model.nfreqs.size(); sym++) {
model.table[sym].freq = model.nfreqs[sym];
model.table[sym].base = cur_base;
model.table[sym].sym_upper_bound = tmp * model.nfreqs[sym];
cur_base += model.nfreqs[sym];
}
model.lower_bound = constants::K * model.frame_size;
return model;
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x4a048
movq %rbx, %rdi
popq %rbx
jmp 0x36d6c
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
unsigned int ans_fold_mapping_and_exceptions<6u>(unsigned int, unsigned char*&) | uint32_t ans_fold_mapping_and_exceptions(uint32_t x, uint8_t*& except_out)
{
const uint32_t radix = 8;
uint32_t radix_mask = ((1 << radix) - 1);
size_t offset = 0;
size_t thres = 1 << (fidelity + radix - 1);
while (x >= thres) {
*except_out++ = x & radix_mask;
x = x >> radix;
offset = offset + (1 << (fidelity - 1)) * radix_mask;
}
return x + offset;
} | movl %edi, %eax
xorl %ecx, %ecx
cmpl $0x2000, %eax # imm = 0x2000
jb 0x4b607
movq (%rsi), %rdx
addl $0x1fe0, %ecx # imm = 0x1FE0
leaq 0x1(%rdx), %rdi
movq %rdi, (%rsi)
movb %al, (%rdx)
shrl $0x8, %eax
jmp 0x4b5e9
addl %ecx, %eax
retq
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
unsigned long ans_fold_compress<7u>(unsigned char*, unsigned long, unsigned int const*, unsigned long) | size_t ans_fold_compress(
uint8_t* dst, size_t dstCapacity, const uint32_t* src, size_t srcSize)
{
auto in_u32 = reinterpret_cast<const uint32_t*>(src);
auto ans_frame = ans_fold_encode<fidelity>::create(in_u32, srcSize);
uint8_t* out_u8 = reinterpret_cast<uint8_t*>(dst);
// serialize model
ans_frame.serialize(out_u8);
// start encoding, we encode 4 states at the same time for speed
std::array<uint64_t, 4> states;
states[0] = ans_frame.initial_state();
states[1] = ans_frame.initial_state();
states[2] = ans_frame.initial_state();
states[3] = ans_frame.initial_state();
size_t cur_sym = 0;
while ((srcSize - cur_sym) % 4 != 0) {
ans_frame.encode_symbol(
states[0], in_u32[srcSize - cur_sym - 1], out_u8);
cur_sym += 1;
}
while (cur_sym != srcSize) {
ans_frame.encode_symbol(
states[0], in_u32[srcSize - cur_sym - 1], out_u8);
ans_frame.encode_symbol(
states[1], in_u32[srcSize - cur_sym - 2], out_u8);
ans_frame.encode_symbol(
states[2], in_u32[srcSize - cur_sym - 3], out_u8);
ans_frame.encode_symbol(
states[3], in_u32[srcSize - cur_sym - 4], out_u8);
cur_sym += 4;
}
// flush final state
ans_frame.flush_state(states[0], out_u8);
ans_frame.flush_state(states[1], out_u8);
ans_frame.flush_state(states[2], out_u8);
ans_frame.flush_state(states[3], out_u8);
return out_u8 - reinterpret_cast<uint8_t*>(dst);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x38(%rsp), %rbx
movq %rdi, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rdx, %rsi
movq %rcx, %rdx
movq %rbx, %rdi
callq 0x4b804
leaq 0x8(%rsp), %rsi
movq %r12, 0x30(%rsp)
movq %r12, (%rsi)
movq %rbx, %rdi
callq 0x4b95c
leaq 0x38(%rsp), %rcx
movl %r14d, %ebp
andl $0x3, %ebp
leaq -0x4(%r15,%r14,4), %rbx
leaq 0x28(%rsp), %rax
leaq 0x8(%rsp), %r13
xorl %r12d, %r12d
vbroadcastsd 0x38(%rcx), %ymm0
negq %rbp
vmovups %ymm0, -0x18(%rax)
cmpq %r12, %rbp
je 0x4b715
movl (%rbx,%r12,4), %edx
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rcx
vzeroupper
callq 0x4b968
decq %r12
jmp 0x4b6f2
andq $-0x4, %r14
leaq 0x38(%rsp), %rbx
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x18(%rsp), %rbp
testq %r14, %r14
je 0x4b78b
movl -0x4(%r15,%r14,4), %edx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rcx
vzeroupper
callq 0x4b968
movl -0x8(%r15,%r14,4), %edx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rcx
callq 0x4b968
movl -0xc(%r15,%r14,4), %edx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rcx
callq 0x4b968
movl -0x10(%r15,%r14,4), %edx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rcx
callq 0x4b968
addq $-0x4, %r14
jmp 0x4b72d
leaq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rbx
subq 0x38(%rdi), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rax
subq 0x38(%rdi), %rax
movq %rax, 0x8(%rbx)
movq 0x20(%rsp), %rax
subq 0x38(%rdi), %rax
movq %rax, 0x10(%rbx)
movq 0x28(%rsp), %rax
subq 0x38(%rdi), %rax
movq %rax, 0x18(%rbx)
subq 0x30(%rsp), %rbx
addq $0x20, %rbx
vzeroupper
callq 0x4b9ca
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4b7ef
jmp 0x4b7ef
leaq 0x38(%rsp), %rdi
movq %rax, %rbx
callq 0x4b9ca
movq %rbx, %rdi
callq 0x2e800
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
ans_fold_encode<8u>::encode_symbol(unsigned long&, unsigned int, unsigned char*&) | void encode_symbol(uint64_t& state, uint32_t sym, uint8_t*& out_u8)
{
auto mapped_sym
= ans_fold_mapping_and_exceptions<fidelity>(sym, out_u8);
const auto& e = table[mapped_sym];
if (state >= e.sym_upper_bound) {
auto out_ptr_u32 = reinterpret_cast<uint32_t*>(out_u8);
*out_ptr_u32 = state & 0xFFFFFFFF;
out_u8 += sizeof(uint32_t);
state = state >> constants::RADIX_LOG2;
}
state = ((state / e.freq) * frame_size) + (state % e.freq) + e.base;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %r15
movl %edx, %edi
movq %rcx, %rsi
callq 0x4be0d
movq 0x18(%r14), %rsi
movl %eax, %edx
movq (%rbx), %rax
shlq $0x4, %rdx
leaq (%rsi,%rdx), %rcx
cmpq 0x8(%rsi,%rdx), %rax
jb 0x4bdbf
movq (%r15), %rdx
movl %eax, (%rdx)
addq $0x4, %rdx
shrq $0x20, %rax
movq %rdx, (%r15)
movq %rax, (%rbx)
movzwl (%rcx), %esi
xorl %edx, %edx
divq %rsi
movl 0x4(%rcx), %ecx
addq %rdx, %rcx
imulq 0x30(%r14), %rax
addq %rax, %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
| /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
ans_reorder_fold_encode<1u>::create(unsigned int const*, unsigned long) | static ans_reorder_fold_encode create(const uint32_t* in_u32, size_t n)
{
ans_reorder_fold_encode model;
// 1) identify most frequent syms
uint32_t unmapped_max_sym = 0;
for (size_t i = 0; i < n; i++) {
unmapped_max_sym = std::max(in_u32[i], unmapped_max_sym);
}
std::vector<std::pair<int64_t, uint32_t>> unmapped_freqs(
unmapped_max_sym + 1);
for (size_t i = 0; i < n; i++) {
unmapped_freqs[in_u32[i]].first--;
unmapped_freqs[in_u32[i]].second = in_u32[i];
}
std::sort(unmapped_freqs.begin(), unmapped_freqs.end());
model.sigma = 0;
for (size_t i = 0; i < unmapped_freqs.size(); i++) {
if (unmapped_freqs[i].first == 0)
break;
model.sigma++;
}
size_t no_except_thres = 1 << (fidelity + 8 - 1);
model.mapping.resize(unmapped_max_sym + 1);
if (model.sigma < no_except_thres) {
for (size_t i = 0; i < unmapped_max_sym + 1; i++) {
model.mapping[i] = i;
}
} else {
for (size_t i = 0; i <= unmapped_max_sym; i++) {
model.mapping[i] = i + no_except_thres;
}
for (size_t i = 0; i < no_except_thres; i++) {
model.mapping[unmapped_freqs[i].second] = i;
model.most_frequent.push_back(unmapped_freqs[i].second);
}
}
const uint32_t MAX_SIGMA = 1 << (fidelity + 8 + 1);
std::vector<uint64_t> freqs(MAX_SIGMA, 0);
uint32_t max_sym = 0;
for (size_t i = 0; i < n; i++) {
auto mapped_u32
= ans_reorder_fold_mapping<fidelity>(model.mapping[in_u32[i]]);
freqs[mapped_u32]++;
max_sym = std::max(mapped_u32, max_sym);
}
model.nfreqs = adjust_freqs(freqs, max_sym, true);
model.frame_size = std::accumulate(
std::begin(model.nfreqs), std::end(model.nfreqs), 0);
uint64_t cur_base = 0;
uint64_t tmp = constants::K * constants::RADIX;
model.table.resize(max_sym + 1);
for (size_t sym = 0; sym < model.nfreqs.size(); sym++) {
model.table[sym].freq = model.nfreqs[sym];
model.table[sym].base = cur_base;
model.table[sym].sym_upper_bound = tmp * model.nfreqs[sym];
cur_base += model.nfreqs[sym];
}
model.lower_bound = constants::K * model.frame_size;
return model;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
vxorps %xmm0, %xmm0, %xmm0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %eax, %eax
vmovups %zmm0, 0x20(%rdi)
vmovups %zmm0, (%rdi)
cmpq %rax, %r14
je 0x4c06e
movl (%r15,%rax,4), %ecx
cmpl %ebp, %ecx
cmoval %ecx, %ebp
incq %rax
jmp 0x4c05b
leal 0x1(%rbp), %r13d
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r13, %rsi
movq %rbx, 0x8(%rsp)
vzeroupper
callq 0x4c3c4
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x4c0b0
movl (%r15,%rcx,4), %edx
incq %rcx
movq %rdx, %rsi
shlq $0x4, %rsi
decq (%rax,%rsi)
movl %edx, 0x8(%rax,%rsi)
jmp 0x4c093
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4c541
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
andq $0x0, 0x70(%rbx)
subq %rax, %rcx
sarq $0x4, %rcx
negq %rcx
pushq $0x1
popq %rdx
leaq (%rcx,%rdx), %rsi
cmpq $0x1, %rsi
je 0x4c0f8
cmpq $0x0, (%rax)
je 0x4c0f8
movq %rdx, 0x70(%rbx)
incq %rdx
addq $0x10, %rax
jmp 0x4c0db
leaq 0x30(%rbx), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x32bbc
cmpq $0x100, 0x70(%rbx) # imm = 0x100
jae 0x4c124
movq (%r12), %rax
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x4c176
movl %ecx, (%rax,%rcx,4)
incq %rcx
jmp 0x4c117
movq (%r12), %rcx
movl %ebp, %eax
incq %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x4c142
leal 0x100(%rdx), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
jmp 0x4c12f
leaq 0x48(%rbx), %r13
pushq $0x8
popq %rbp
xorl %ebx, %ebx
cmpq $0x1008, %rbp # imm = 0x1008
je 0x4c176
movq 0x10(%rsp), %rsi
movq (%r12), %rcx
movl (%rsi,%rbp), %eax
addq %rbp, %rsi
movl %ebx, (%rcx,%rax,4)
movq %r13, %rdi
callq 0x32b9e
addq $0x10, %rbp
incl %ebx
jmp 0x4c14b
leaq 0x40(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x400, %esi # imm = 0x400
callq 0x35cc8
xorl %r13d, %r13d
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x4c1c4
movl (%r15,%rbx,4), %eax
movq (%r12), %rcx
movl (%rcx,%rax,4), %edi
callq 0x4c417
movq 0x28(%rsp), %rdx
movl %eax, %ecx
incq (%rdx,%rcx,8)
cmpl %r13d, %eax
cmoval %eax, %r13d
incq %rbx
jmp 0x4c198
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rcx
movl %r13d, %edx
movl %ecx, %r8d
callq 0x30eed
movq 0x8(%rsp), %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rsi
movq %rbx, %rdi
callq 0x384e0
movq %r14, %rdi
callq 0x36d6c
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x4c20f
addl (%rax), %ecx
addq $0x4, %rax
jmp 0x4c202
movslq %ecx, %rax
leaq 0x18(%rbx), %rdi
incl %r13d
movq %rax, 0x60(%rbx)
movq %r13, %rsi
callq 0x4c430
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
subq %rax, %rcx
addq $0x8, %rdx
sarq $0x2, %rcx
cmpq %rdi, %rcx
je 0x4c268
movzwl (%rax,%rdi,4), %r8d
movw %r8w, -0x8(%rdx)
movl %esi, -0x4(%rdx)
movl (%rax,%rdi,4), %r8d
incq %rdi
addl %r8d, %esi
shlq $0x24, %r8
movq %r8, (%rdx)
addq $0x10, %rdx
jmp 0x4c23f
movq 0x60(%rbx), %rax
leaq 0x28(%rsp), %rdi
shlq $0x4, %rax
movq %rax, 0x68(%rbx)
callq 0x35d80
leaq 0x10(%rsp), %rdi
callq 0x4c490
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c29c
leaq 0x28(%rsp), %rdi
movq %rax, %r14
callq 0x35d80
jmp 0x4c2b9
jmp 0x4c2b6
jmp 0x4c2b6
jmp 0x4c2b6
movq %rax, %r14
jmp 0x4c2c3
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x4c490
movq 0x8(%rsp), %rdi
callq 0x4c39c
movq %r14, %rdi
callq 0x2e800
nop
| /mpetri[P]ans-large-alphabet/include/ans_reorder_fold.hpp |
ans_reorder_fold_encode<1u>::encode_symbol(unsigned long&, unsigned int, unsigned char*&) | void encode_symbol(uint64_t& state, uint32_t sym, uint8_t*& out_u8)
{
auto mapped_sym = ans_reorder_fold_mapping_and_exceptions<fidelity>(
mapping[sym], out_u8);
const auto& e = table[mapped_sym];
if (state >= e.sym_upper_bound) {
auto out_ptr_u32 = reinterpret_cast<uint32_t*>(out_u8);
*out_ptr_u32 = state & 0xFFFFFFFF;
out_u8 += sizeof(uint32_t);
state = state >> constants::RADIX_LOG2;
}
state = ((state / e.freq) * frame_size) + (state % e.freq) + e.base;
} | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %eax
movq 0x30(%rdi), %rdx
movq %rdi, %r14
movq %rcx, %r15
movq %rsi, %rbx
movq %r15, %rsi
movl (%rdx,%rax,4), %edi
callq 0x4cd2b
movq 0x18(%r14), %rdx
movzwl %ax, %esi
movq (%rbx), %rax
shll $0x4, %esi
leaq (%rdx,%rsi), %rcx
cmpq 0x8(%rdx,%rsi), %rax
jb 0x4c37c
movq (%r15), %rdx
movl %eax, (%rdx)
addq $0x4, %rdx
shrq $0x20, %rax
movq %rdx, (%r15)
movq %rax, (%rbx)
movzwl (%rcx), %esi
xorl %edx, %edx
divq %rsi
movl 0x4(%rcx), %ecx
addq %rdx, %rcx
imulq 0x60(%r14), %rax
addq %rax, %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
| /mpetri[P]ans-large-alphabet/include/ans_reorder_fold.hpp |
unsigned long ans_reorder_fold_compress<4u>(unsigned char*, unsigned long, unsigned int const*, unsigned long) | size_t ans_reorder_fold_compress(
uint8_t* dst, size_t dstCapacity, const uint32_t* src, size_t srcSize)
{
auto in_u32 = reinterpret_cast<const uint32_t*>(src);
auto ans_frame = ans_reorder_fold_encode<fidelity>::create(in_u32, srcSize);
uint8_t* out_u8 = reinterpret_cast<uint8_t*>(dst);
// serialize model
ans_frame.serialize(out_u8);
// start encoding
std::array<uint64_t, 4> states;
states[0] = ans_frame.initial_state();
states[1] = ans_frame.initial_state();
states[2] = ans_frame.initial_state();
states[3] = ans_frame.initial_state();
size_t cur_sym = 0;
while ((srcSize - cur_sym) % 4 != 0) {
ans_frame.encode_symbol(
states[0], in_u32[srcSize - cur_sym - 1], out_u8);
cur_sym += 1;
}
while (cur_sym != srcSize) {
ans_frame.encode_symbol(
states[0], in_u32[srcSize - cur_sym - 1], out_u8);
ans_frame.encode_symbol(
states[1], in_u32[srcSize - cur_sym - 2], out_u8);
ans_frame.encode_symbol(
states[2], in_u32[srcSize - cur_sym - 3], out_u8);
ans_frame.encode_symbol(
states[3], in_u32[srcSize - cur_sym - 4], out_u8);
cur_sym += 4;
}
// flush final state
ans_frame.flush_state(states[0], out_u8);
ans_frame.flush_state(states[1], out_u8);
ans_frame.flush_state(states[2], out_u8);
ans_frame.flush_state(states[3], out_u8);
return out_u8 - reinterpret_cast<uint8_t*>(dst);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0x30(%rsp), %rbx
movq %rdi, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rdx, %rsi
movq %rcx, %rdx
movq %rbx, %rdi
callq 0x4db08
movq %rsp, %rsi
movq %r12, 0x28(%rsp)
movq %r12, (%rsi)
movq %rbx, %rdi
callq 0x4ddb2
leaq 0x30(%rsp), %rcx
movl %r14d, %ebp
andl $0x3, %ebp
leaq -0x4(%r15,%r14,4), %rbx
leaq 0x20(%rsp), %rax
xorl %r12d, %r12d
movq %rsp, %r13
vbroadcastsd 0x68(%rcx), %ymm0
negq %rbp
vmovups %ymm0, -0x18(%rax)
cmpq %r12, %rbp
je 0x4da18
movl (%rbx,%r12,4), %edx
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rcx
vzeroupper
callq 0x4de0e
decq %r12
jmp 0x4d9f5
andq $-0x4, %r14
leaq 0x30(%rsp), %rbx
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %rbp
movq %rsp, %r13
testq %r14, %r14
je 0x4da8c
movl -0x4(%r15,%r14,4), %edx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rcx
vzeroupper
callq 0x4de0e
movl -0x8(%r15,%r14,4), %edx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rcx
callq 0x4de0e
movl -0xc(%r15,%r14,4), %edx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rcx
callq 0x4de0e
movl -0x10(%r15,%r14,4), %edx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rcx
callq 0x4de0e
addq $-0x4, %r14
jmp 0x4da2e
leaq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rsp), %rbx
subq 0x68(%rdi), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
subq 0x68(%rdi), %rax
movq %rax, 0x8(%rbx)
movq 0x18(%rsp), %rax
subq 0x68(%rdi), %rax
movq %rax, 0x10(%rbx)
movq 0x20(%rsp), %rax
subq 0x68(%rdi), %rax
movq %rax, 0x18(%rbx)
subq 0x28(%rsp), %rbx
addq $0x20, %rbx
vzeroupper
callq 0x4de78
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4daf2
jmp 0x4daf2
leaq 0x30(%rsp), %rdi
movq %rax, %rbx
callq 0x4de78
movq %rbx, %rdi
callq 0x2e800
nop
| /mpetri[P]ans-large-alphabet/include/ans_reorder_fold.hpp |
ans_reorder_fold_encode<4u>::serialize(unsigned char*&) | size_t serialize(uint8_t*& out_u8)
{
size_t no_except_thres = 1 << (fidelity + 8 - 1);
auto out_ptr_u32 = reinterpret_cast<uint32_t*>(out_u8);
size_t bytes_written = 0;
if (sigma < no_except_thres) {
*out_ptr_u32++ = 0;
bytes_written += sizeof(uint32_t);
} else {
*out_ptr_u32++ = 1;
bytes_written += sizeof(uint32_t);
for (size_t i = 0; i < no_except_thres; i++) {
*out_ptr_u32++ = most_frequent[i];
}
out_u8 += sizeof(uint32_t) * no_except_thres;
bytes_written += sizeof(uint32_t) * no_except_thres;
}
out_u8 += sizeof(uint32_t);
bytes_written += sizeof(uint32_t);
auto interp_written_bytes
= ans_serialize_interp(nfreqs, frame_size, out_u8);
return interp_written_bytes + bytes_written;
} | pushq %rbx
movq (%rsi), %rax
cmpq $0x7ff, 0x70(%rdi) # imm = 0x7FF
movq %rsi, %rdx
ja 0x4ddcb
andl $0x0, (%rax)
pushq $0x8
popq %rbx
jmp 0x4ddf9
movl $0x1, (%rax)
xorl %esi, %esi
movq 0x48(%rdi), %rcx
cmpq $0x800, %rsi # imm = 0x800
je 0x4ddee
movl (%rcx,%rsi,4), %r8d
movl %r8d, 0x4(%rax,%rsi,4)
incq %rsi
jmp 0x4ddd7
addq $0x2000, %rax # imm = 0x2000
movl $0x2008, %ebx # imm = 0x2008
addq $0x4, %rax
movq %rax, (%rdx)
movq 0x60(%rdi), %rsi
callq 0x30d82
addq %rbx, %rax
popq %rbx
retq
| /mpetri[P]ans-large-alphabet/include/ans_reorder_fold.hpp |
unsigned short ans_reorder_fold_mapping_and_exceptions<5u>(unsigned int, unsigned char*&) | uint16_t ans_reorder_fold_mapping_and_exceptions(
uint32_t x, uint8_t*& except_out)
{
const uint32_t radix = 8;
uint32_t radix_mask = ((1 << radix) - 1);
size_t offset = 0;
size_t thres = 1 << (fidelity + radix - 1);
while (x >= thres) {
*except_out++ = x & radix_mask;
x = x >> radix;
offset = offset + (1 << (fidelity - 1)) * radix_mask;
}
return x + offset;
} | movl %edi, %eax
xorl %ecx, %ecx
cmpl $0x1000, %eax # imm = 0x1000
jb 0x4e4ab
movq (%rsi), %rdx
addl $0xff0, %ecx # imm = 0xFF0
leaq 0x1(%rdx), %rdi
movq %rdi, (%rsi)
movb %al, (%rdx)
shrl $0x8, %eax
jmp 0x4e48d
addl %ecx, %eax
retq
| /mpetri[P]ans-large-alphabet/include/ans_reorder_fold.hpp |
unsigned long ans_reorder_fold_compress<7u>(unsigned char*, unsigned long, unsigned int const*, unsigned long) | size_t ans_reorder_fold_compress(
uint8_t* dst, size_t dstCapacity, const uint32_t* src, size_t srcSize)
{
auto in_u32 = reinterpret_cast<const uint32_t*>(src);
auto ans_frame = ans_reorder_fold_encode<fidelity>::create(in_u32, srcSize);
uint8_t* out_u8 = reinterpret_cast<uint8_t*>(dst);
// serialize model
ans_frame.serialize(out_u8);
// start encoding
std::array<uint64_t, 4> states;
states[0] = ans_frame.initial_state();
states[1] = ans_frame.initial_state();
states[2] = ans_frame.initial_state();
states[3] = ans_frame.initial_state();
size_t cur_sym = 0;
while ((srcSize - cur_sym) % 4 != 0) {
ans_frame.encode_symbol(
states[0], in_u32[srcSize - cur_sym - 1], out_u8);
cur_sym += 1;
}
while (cur_sym != srcSize) {
ans_frame.encode_symbol(
states[0], in_u32[srcSize - cur_sym - 1], out_u8);
ans_frame.encode_symbol(
states[1], in_u32[srcSize - cur_sym - 2], out_u8);
ans_frame.encode_symbol(
states[2], in_u32[srcSize - cur_sym - 3], out_u8);
ans_frame.encode_symbol(
states[3], in_u32[srcSize - cur_sym - 4], out_u8);
cur_sym += 4;
}
// flush final state
ans_frame.flush_state(states[0], out_u8);
ans_frame.flush_state(states[1], out_u8);
ans_frame.flush_state(states[2], out_u8);
ans_frame.flush_state(states[3], out_u8);
return out_u8 - reinterpret_cast<uint8_t*>(dst);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0x30(%rsp), %rbx
movq %rdi, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rdx, %rsi
movq %rcx, %rdx
movq %rbx, %rdi
callq 0x4ec78
movq %rsp, %rsi
movq %r12, 0x28(%rsp)
movq %r12, (%rsi)
movq %rbx, %rdi
callq 0x4ef22
leaq 0x30(%rsp), %rcx
movl %r14d, %ebp
andl $0x3, %ebp
leaq -0x4(%r15,%r14,4), %rbx
leaq 0x20(%rsp), %rax
xorl %r12d, %r12d
movq %rsp, %r13
vbroadcastsd 0x68(%rcx), %ymm0
negq %rbp
vmovups %ymm0, -0x18(%rax)
cmpq %r12, %rbp
je 0x4eb88
movl (%rbx,%r12,4), %edx
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rcx
vzeroupper
callq 0x4ef7e
decq %r12
jmp 0x4eb65
andq $-0x4, %r14
leaq 0x30(%rsp), %rbx
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %rbp
movq %rsp, %r13
testq %r14, %r14
je 0x4ebfc
movl -0x4(%r15,%r14,4), %edx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rcx
vzeroupper
callq 0x4ef7e
movl -0x8(%r15,%r14,4), %edx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rcx
callq 0x4ef7e
movl -0xc(%r15,%r14,4), %edx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rcx
callq 0x4ef7e
movl -0x10(%r15,%r14,4), %edx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rcx
callq 0x4ef7e
addq $-0x4, %r14
jmp 0x4eb9e
leaq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rsp), %rbx
subq 0x68(%rdi), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
subq 0x68(%rdi), %rax
movq %rax, 0x8(%rbx)
movq 0x18(%rsp), %rax
subq 0x68(%rdi), %rax
movq %rax, 0x10(%rbx)
movq 0x20(%rsp), %rax
subq 0x68(%rdi), %rax
movq %rax, 0x18(%rbx)
subq 0x28(%rsp), %rbx
addq $0x20, %rbx
vzeroupper
callq 0x4efe8
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ec62
jmp 0x4ec62
leaq 0x30(%rsp), %rdi
movq %rax, %rbx
callq 0x4efe8
movq %rbx, %rdi
callq 0x2e800
nop
| /mpetri[P]ans-large-alphabet/include/ans_reorder_fold.hpp |
PDCLIB_prepwrite | int _PDCLIB_prepwrite( struct _PDCLIB_file_t * stream )
{
if ( ( stream->bufidx < stream->bufend ) || ( stream->ungetidx > 0 ) ||
( stream->status & ( _PDCLIB_FREAD | _PDCLIB_ERRORFLAG | _PDCLIB_WIDESTREAM | _PDCLIB_EOFFLAG ) ) ||
!( stream->status & ( _PDCLIB_FWRITE | _PDCLIB_FAPPEND | _PDCLIB_FRW ) ) )
{
/* Function called on illegal (e.g. input) stream. */
*_PDCLIB_errno_func() = _PDCLIB_EBADF;
stream->status |= _PDCLIB_ERRORFLAG;
return EOF;
}
stream->status |= _PDCLIB_FWRITE | _PDCLIB_BYTESTREAM;
return 0;
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
jb 0x247c
cmpq $0x0, 0x38(%rbx)
jne 0x247c
movl 0x44(%rbx), %eax
testw $0xe08, %ax # imm = 0xE08
sete %cl
testb $0x70, %al
setne %dl
testb %dl, %cl
jne 0x2490
callq 0x393c
movl $0x9, (%rax)
orb $0x2, 0x45(%rbx)
pushq $-0x1
popq %rax
popq %rbx
retq
orl $0x1010, %eax # imm = 0x1010
movl %eax, 0x44(%rbx)
xorl %eax, %eax
jmp 0x248e
| /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_prepwrite.c |
PDCLIB_print_fp | static void _PDCLIB_print_fp( int sign,
int exp,
int dec,
unsigned char const * mant,
size_t mant_dig,
struct _PDCLIB_status_t * status )
{
/* Turning sign bit into sign character. */
if ( sign )
{
sign = '-';
}
else if ( status->flags & E_plus )
{
sign = '+';
}
else if ( status->flags & E_space )
{
sign = ' ';
}
else
{
sign = '\0';
}
if ( exp == INT_MIN || exp == INT_MAX )
{
/* "nan" / "inf" */
char const * s = ( status->flags & E_lower )
? ( ( exp == INT_MIN ) ? "nan" : "inf" )
: ( ( exp == INT_MIN ) ? "NAN" : "INF" );
status->current = ( sign == '\0' ) ? 3 : 4;
if ( ! ( status->flags & E_minus ) )
{
while ( status->current < status->width )
{
PUT( ' ' );
++status->current;
}
}
if ( sign != '\0' )
{
PUT( sign );
}
while ( *s )
{
PUT( *s++ );
}
return;
}
switch ( status->flags & ( E_decimal | E_exponent | E_generic | E_hexa ) )
{
case E_hexa:
_PDCLIB_print_hexa( sign, exp, dec, mant, mant_dig, status );
break;
case E_decimal:
case E_exponent:
case E_generic:
default:
break;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %rcx, %rax
pushq $0x4
popq %rcx
testl %edi, %edi
je 0x2c2d
pushq $0x2d
jmp 0x2c4a
movl 0x4(%rbx), %ebp
testb $0x2, %bpl
jne 0x2c48
xorl %r12d, %r12d
andl $0x8, %ebp
sete %r12b
subq %r12, %rcx
shll $0x2, %ebp
jmp 0x2c4e
pushq $0x2b
popq %rbp
xorl %r12d, %r12d
leal -0x7fffffff(%rsi), %edi
cmpl $0x1, %edi
ja 0x2ceb
negl %esi
movl 0x4(%rbx), %eax
leaq 0x1537(%rip), %rdx # 0x41a0
leaq 0x1534(%rip), %rsi # 0x41a4
cmovoq %rdx, %rsi
leaq 0x152d(%rip), %rdx # 0x41a8
leaq 0x152a(%rip), %r15 # 0x41ac
cmovoq %rdx, %r15
btl $0x10, %eax
cmovbq %rsi, %r15
movq %rcx, 0x18(%rbx)
testb $0x1, %al
jne 0x2d21
pushq $0x20
popq %r14
pcmpeqd %xmm1, %xmm1
cmpq 0x28(%rbx), %rcx
jae 0x2d21
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x2cd1
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x2cc9
movl %r14d, %edi
callq 0x3788
pcmpeqd %xmm1, %xmm1
jmp 0x2cd1
movq 0x20(%rbx), %rcx
movb $0x20, (%rcx,%rax)
movdqu 0x10(%rbx), %xmm0
psubq %xmm1, %xmm0
movdqu %xmm0, 0x10(%rbx)
pshufd $0xee, %xmm0, %xmm0 # xmm0 = xmm0[2,3,2,3]
movq %xmm0, %rcx
jmp 0x2ca2
movl 0x4(%rbx), %ecx
movl %ecx, %edi
andl $0x3c0000, %edi # imm = 0x3C0000
cmpl $0x200000, %edi # imm = 0x200000
jne 0x31e9
pxor %xmm0, %xmm0
movdqa %xmm0, 0x10(%rsp)
andw $0x0, 0x20(%rsp)
btl $0x10, %ecx
jb 0x2d51
leaq 0x1f81(%rip), %r15 # 0x4ca0
jmp 0x2d58
testb %r12b, %r12b
jne 0x31ba
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x31b6
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x2f3e
movl %ebp, %edi
callq 0x3788
jmp 0x31b6
leaq 0x1f18(%rip), %r15 # 0x4c70
leal -0x1(%r8), %ecx
andl $0x7, %ecx
movl %ebp, 0x24(%rsp)
je 0x2d90
movb $-0x1, %r9b
shlb %cl, %r9b
notb %r9b
andb (%rax), %r9b
cmpq $0x4, %rcx
jb 0x2d9c
pushq $0x1
popq %rdi
movl %r9d, %r10d
andb $0xf, %r10b
movb %r10b, 0x11(%rsp)
shrb $0x4, %r9b
addq $-0x4, %rcx
jmp 0x2d9e
xorl %r9d, %r9d
xorl %edi, %edi
xorl %r10d, %r10d
xorl %ecx, %ecx
jmp 0x2da6
xorl %edi, %edi
movzbl %r9b, %r10d
pushq $-0x1
popq %r9
movl %edx, %r11d
shll %cl, %r11d
pushq $-0x1
popq %rbp
shll %cl, %ebp
notl %ebp
andl %r10d, %ebp
orl %r11d, %ebp
movb %bpl, 0x10(%rsp)
addq $0x3, %r8
shrq $0x2, %r8
decq %r8
addq %rax, %r9
movl 0x24(%rsp), %ebp
cmpq %r8, %rdi
jae 0x2dfb
movb (%r9), %al
movl %eax, %r10d
shrb $0x4, %r10b
movb %r10b, 0x11(%rsp,%rdi)
andb $0xf, %al
movb %al, 0x12(%rsp,%rdi)
addq $0x2, %rdi
decq %r9
jmp 0x2dd0
cmpb $0x0, 0x10(%rsp,%r13)
jne 0x2e04
movq %rdi, %r13
subq $0x1, %rdi
jae 0x2df3
testq %r13, %r13
sete %al
testl %edx, %edx
sete %dil
testb %al, %dil
jne 0x2e5f
subl %ecx, %esi
je 0x2e5f
cmpl $0x1, %edx
adcl $0x0, %esi
movl %esi, %ecx
shrl $0x1f, %ecx
addb %cl, %cl
addb $0x2b, %cl
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
movb %cl, 0x9(%rsp)
pushq $0x1
popq %r12
pushq $0xa
popq %r14
testl %eax, %eax
jle 0x2e6a
movl %eax, %edi
movl %r14d, %esi
callq 0x3840
movq %rax, %rcx
sarq $0x20, %rcx
movb (%r15,%rcx), %cl
movb %cl, 0x9(%rsp,%r12)
incq %r12
jmp 0x2e3c
movw $0x302b, 0x9(%rsp) # imm = 0x302B
pushq $0x2
popq %r12
movb $0x0, 0x9(%rsp,%r12)
movslq 0x30(%rbx), %rax
testq %rax, %rax
js 0x2ead
cmpq %rax, %r13
jbe 0x2ead
leaq 0x10(%rsp), %rcx
cmpb $0x8, 0x1(%rax,%rcx)
jbe 0x2f4b
movq %rax, %r14
movb 0x10(%rsp,%r14), %cl
incb %cl
movb %cl, 0x10(%rsp,%r14)
cmpb $0x10, %cl
jb 0x2eb0
movb $0x0, 0x10(%rsp,%r14)
decq %r14
jmp 0x2e91
movq %r13, %r14
movl 0x4(%rbx), %ecx
movl %ecx, %edx
shrl $0x2, %edx
andl $0x1, %edx
testq %r14, %r14
pushq $0x1
popq %r13
cmovneq %r13, %rdx
testl %eax, %eax
cmovgq %r13, %rdx
cmpl $0x1, %ebp
pushq $0x5
popq %rbp
sbbq $0x0, %rbp
addq %r12, %rbp
addq %r14, %rbp
addq %rdx, %rbp
movq %rbp, 0x18(%rbx)
testb $0x11, %cl
jne 0x2f1c
jmp 0x2f16
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x2f0f
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x2f07
pushq $0x20
popq %rdi
callq 0x3788
jmp 0x2f0f
movq 0x20(%rbx), %rcx
movb $0x20, (%rcx,%rax)
incq 0x10(%rbx)
incq %rbp
cmpq 0x28(%rbx), %rbp
jb 0x2eea
movq 0x10(%rbx), %rax
movl 0x24(%rsp), %edi
testl %edi, %edi
je 0x2f87
cmpq 0x8(%rbx), %rax
jae 0x2f7c
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x2f74
callq 0x3788
jmp 0x2f7c
movq 0x20(%rbx), %rcx
movb %bpl, (%rcx,%rax)
jmp 0x31b6
movq %rax, %r14
jne 0x2eb0
leaq 0x2(%rax), %rcx
cmpq %rcx, %r13
jae 0x2e8e
testb $0x1, 0x10(%rsp,%rax)
movq %rax, %r14
jne 0x2e8e
jmp 0x2eb0
movq 0x20(%rbx), %rcx
movb %dil, (%rcx,%rax)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq 0x8(%rbx), %rax
jae 0x2fa8
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x2fa0
pushq $0x30
popq %rdi
callq 0x3788
jmp 0x2fa8
movq 0x20(%rbx), %rcx
movb $0x30, (%rcx,%rax)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq 0x8(%rbx), %rax
jae 0x2fde
movzbl 0x6(%rbx), %edi
andl $0x1, %edi
shll $0x5, %edi
orl $0x58, %edi
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x2fd6
callq 0x3788
jmp 0x2fde
movq 0x20(%rbx), %rcx
movb %dil, (%rcx,%rax)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq 0x8(%rbx), %rax
jae 0x3012
movzbl 0x10(%rsp), %ecx
movb (%r15,%rcx), %cl
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x300b
movsbl %cl, %edi
callq 0x3788
jmp 0x3012
movq 0x20(%rbx), %rdx
movb %cl, (%rdx,%rax)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movl 0x30(%rbx), %ecx
testq %r14, %r14
je 0x302b
testl %ecx, %ecx
jne 0x3037
jmp 0x302f
testl %ecx, %ecx
jg 0x3037
movl 0x4(%rbx), %ecx
testb $0x4, %cl
je 0x3066
cmpq 0x8(%rbx), %rax
jae 0x3058
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x3050
pushq $0x2e
popq %rdi
callq 0x3788
jmp 0x3058
movq 0x20(%rbx), %rcx
movb $0x2e, (%rcx,%rax)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movl 0x4(%rbx), %ecx
andl $0x11, %ecx
cmpl $0x10, %ecx
jne 0x30e1
movq 0x18(%rbx), %rbp
cmpq 0x28(%rbx), %rbp
jae 0x30e1
cmpq 0x8(%rbx), %rax
jae 0x3099
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x3091
pushq $0x30
popq %rdi
callq 0x3788
jmp 0x3099
movq 0x20(%rbx), %rcx
movb $0x30, (%rcx,%rax)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
incq %rbp
jmp 0x3072
cmpq 0x8(%rbx), %rax
jae 0x30d3
movzbl 0x10(%rsp,%r13), %ecx
movb (%r15,%rcx), %cl
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x30cc
movsbl %cl, %edi
callq 0x3788
jmp 0x30d3
movq 0x20(%rbx), %rdx
movb %cl, (%rdx,%rax)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
incq %r13
cmpq %r14, %r13
jbe 0x30a9
pushq $0x30
popq %rbp
cmpl %r13d, 0x30(%rbx)
jl 0x311f
cmpq 0x8(%rbx), %rax
jae 0x310f
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x3107
movl %ebp, %edi
callq 0x3788
jmp 0x310f
movq 0x20(%rbx), %rcx
movb $0x30, (%rcx,%rax)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
incl %r13d
jmp 0x30e9
cmpq 0x8(%rbx), %rax
jae 0x314a
movzbl 0x6(%rbx), %edi
andl $0x1, %edi
shll $0x5, %edi
orl $0x50, %edi
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x3142
callq 0x3788
jmp 0x314a
movq 0x20(%rbx), %rcx
movb %dil, (%rcx,%rax)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq 0x8(%rbx), %rax
jae 0x3179
movb 0x9(%rsp), %cl
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x3172
movsbl %cl, %edi
callq 0x3788
jmp 0x3179
movq 0x20(%rbx), %rdx
movb %cl, (%rdx,%rax)
decq %r12
movq %r12, %rcx
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
subq $0x1, %r12
jb 0x31e9
cmpq 0x8(%rbx), %rax
jae 0x317c
movb 0x9(%rsp,%rcx), %cl
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x31ad
movsbl %cl, %edi
callq 0x3788
jmp 0x317c
movq 0x20(%rbx), %rdx
movb %cl, (%rdx,%rax)
jmp 0x317c
incq 0x10(%rbx)
movsbl (%r15), %edi
testl %edi, %edi
je 0x31e9
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x31e4
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x31dc
callq 0x3788
jmp 0x31e4
movq 0x20(%rbx), %rcx
movb %dil, (%rcx,%rax)
incq %r15
jmp 0x31b6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_fp.c |
PDCLIB_print_string | void _PDCLIB_print_string( const char * s, struct _PDCLIB_status_t * status )
{
if ( status->flags & E_char )
{
status->prec = 1;
}
else
{
if ( status->prec < 0 )
{
status->prec = strlen( s );
}
else
{
int i;
for ( i = 0; i < status->prec; ++i )
{
if ( s[i] == 0 )
{
status->prec = i;
break;
}
}
}
}
if ( !( status->flags & E_minus ) && ( status->width > ( _PDCLIB_size_t )status->prec ) )
{
while ( status->current < ( status->width - status->prec ) )
{
PUT( ' ' );
++( status->current );
}
}
while ( status->prec > 0 )
{
PUT( *( s++ ) );
--( status->prec );
++( status->current );
}
if ( status->flags & E_minus )
{
while ( status->width > status->current )
{
PUT( ' ' );
++( status->current );
}
}
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %ebp
testb $0x40, %bpl
jne 0x3591
movl 0x30(%rbx), %ecx
testl %ecx, %ecx
js 0x3596
xorl %eax, %eax
cmpq %rax, %rcx
je 0x36ba
cmpb $0x0, (%r14,%rax)
je 0x359e
incq %rax
jmp 0x357c
pushq $0x1
popq %rax
jmp 0x359e
movq %r14, %rdi
callq 0x392c
movl %eax, 0x30(%rbx)
testb $0x1, %bpl
jne 0x3658
movq 0x28(%rbx), %rcx
movslq %eax, %rdx
cmpq %rdx, %rcx
jbe 0x3658
movq 0x18(%rbx), %rdx
pushq $0x20
popq %rbp
pcmpeqd %xmm1, %xmm1
movslq %eax, %rsi
subq %rsi, %rcx
cmpq %rcx, %rdx
jae 0x3658
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x35fd
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x35f5
movl %ebp, %edi
callq 0x3788
pcmpeqd %xmm1, %xmm1
jmp 0x35fd
movq 0x20(%rbx), %rcx
movb $0x20, (%rcx,%rax)
movdqu 0x10(%rbx), %xmm0
psubq %xmm1, %xmm0
movdqu %xmm0, 0x10(%rbx)
movq 0x28(%rbx), %rcx
movl 0x30(%rbx), %eax
pshufd $0xee, %xmm0, %xmm0 # xmm0 = xmm0[2,3,2,3]
movq %xmm0, %rdx
jmp 0x35c6
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x3645
movb (%r14), %cl
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x363e
movsbl %cl, %edi
callq 0x3788
jmp 0x3645
movq 0x20(%rbx), %rdx
movb %cl, (%rdx,%rax)
incq 0x10(%rbx)
incq %r14
movl 0x30(%rbx), %eax
decl %eax
movl %eax, 0x30(%rbx)
incq 0x18(%rbx)
testl %eax, %eax
jg 0x361e
testb $0x1, 0x4(%rbx)
jne 0x3667
popq %rbx
popq %r14
popq %rbp
retq
movq 0x18(%rbx), %rax
pushq $0x20
popq %rbp
pcmpeqd %xmm1, %xmm1
cmpq %rax, 0x28(%rbx)
jbe 0x3662
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x36a0
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x3698
movl %ebp, %edi
callq 0x3788
pcmpeqd %xmm1, %xmm1
jmp 0x36a0
movq 0x20(%rbx), %rcx
movb $0x20, (%rcx,%rax)
movdqu 0x10(%rbx), %xmm0
psubq %xmm1, %xmm0
movdqu %xmm0, 0x10(%rbx)
pshufd $0xee, %xmm0, %xmm0 # xmm0 = xmm0[2,3,2,3]
movq %xmm0, %rax
jmp 0x3672
movl %ecx, %eax
jmp 0x35a1
nopl (%rax)
| /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_string.c |
puts | int puts( const char * s )
{
_PDCLIB_LOCK( stdout->mtx );
if ( _PDCLIB_prepwrite( stdout ) == EOF )
{
_PDCLIB_UNLOCK( stdout->mtx );
return EOF;
}
while ( *s != '\0' )
{
stdout->buffer[ stdout->bufidx++ ] = *s++;
if ( stdout->bufidx == stdout->bufsize )
{
if ( _PDCLIB_flushbuffer( stdout ) == EOF )
{
_PDCLIB_UNLOCK( stdout->mtx );
return EOF;
}
}
}
stdout->buffer[ stdout->bufidx++ ] = '\n';
if ( ( stdout->bufidx == stdout->bufsize ) ||
( stdout->status & ( _IOLBF | _IONBF ) ) )
{
int rc = _PDCLIB_flushbuffer( stdout );
_PDCLIB_UNLOCK( stdout->mtx );
return rc;
}
else
{
_PDCLIB_UNLOCK( stdout->mtx );
return 0;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38ba(%rip), %r14 # 0x7058
movq (%r14), %rdi
addq $0x48, %rdi
callq 0x374c
movq (%r14), %rdi
callq 0x2454
cmpl $-0x1, %eax
je 0x37ea
movb (%rbx), %al
testb %al, %al
je 0x37f2
incq %rbx
movq (%r14), %rcx
movq 0x8(%rcx), %rdx
movq 0x18(%rcx), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x18(%rcx)
movb %al, (%rdx,%rsi)
movq (%r14), %rdi
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
jne 0x37b7
callq 0x36c4
jmp 0x37b2
movq (%r14), %rdi
pushq $-0x1
popq %rbx
jmp 0x3826
movq (%r14), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x18(%rax)
movb $0xa, (%rcx,%rdx)
movq (%r14), %rdi
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x381c
testb $0x6, 0x44(%rdi)
je 0x3839
callq 0x36c4
movl %eax, %ebx
movq (%r14), %rdi
addq $0x48, %rdi
callq 0x3764
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %ebx, %ebx
jmp 0x3826
nopl (%rax)
| /DevSolar[P]pdclib/functions/stdio/puts.c |
strtol | long int strtol( const char * s, char ** endptr, int base )
{
long int rc;
char sign = '+';
const char * p = _PDCLIB_strtox_prelim( s, &sign, &base );
if ( base < 2 || base > 36 )
{
return 0;
}
if ( sign == '+' )
{
rc = ( long int )_PDCLIB_strtox_main( &p, ( unsigned )base, ( uintmax_t )LONG_MAX, ( uintmax_t )( LONG_MAX / base ), ( int )( LONG_MAX % base ), &sign );
}
else
{
rc = ( long int )_PDCLIB_strtox_main( &p, ( unsigned )base, ( uintmax_t )LONG_MIN, ( uintmax_t )( LONG_MIN / -base ), ( int )( -( LONG_MIN % base ) ), &sign );
}
if ( endptr != NULL )
{
*endptr = ( p != NULL ) ? ( char * ) p : ( char * ) s;
}
return ( sign == '+' ) ? rc : -rc;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1c(%rsp), %r15
movl %edx, (%r15)
leaq 0xf(%rsp), %rsi
movb $0x2b, (%rsi)
movq %r15, %rdx
callq 0x3a2c
movq %rax, 0x10(%rsp)
movl (%r15), %esi
leal -0x25(%rsi), %eax
cmpl $-0x23, %eax
jae 0x388b
xorl %ecx, %ecx
jmp 0x38e4
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
leaq 0xf(%rsp), %r9
cmpb $0x2b, (%r9)
leaq 0x1(%rax), %rcx
cmoveq %rax, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r8
leaq 0x10(%rsp), %rdi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x3944
testq %rbx, %rbx
je 0x38d5
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
cmovneq %rcx, %r14
movq %r14, (%rbx)
movq %rax, %rcx
negq %rcx
cmpb $0x2b, 0xf(%rsp)
cmoveq %rax, %rcx
movq %rcx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
| /DevSolar[P]pdclib/functions/stdlib/strtol.c |
memchr | void * memchr( const void * s, int c, size_t n )
{
const unsigned char * p = ( const unsigned char * ) s;
while ( n-- )
{
if ( *p == ( unsigned char ) c )
{
return ( void * ) p;
}
++p;
}
return NULL;
} | movq %rdi, %rax
subq $0x1, %rdx
jb 0x3bab
cmpb %sil, (%rax)
je 0x3bad
incq %rax
jmp 0x3b9b
xorl %eax, %eax
retq
| /DevSolar[P]pdclib/functions/string/memchr.c |
llvm::SmallVectorImpl<(anonymous namespace)::SerializedAffineMap>::assignRemote(llvm::SmallVectorImpl<(anonymous namespace)::SerializedAffineMap>&&) | void assignRemote(SmallVectorImpl &&RHS) {
this->destroy_range(this->begin(), this->end());
if (!this->isSmall())
free(this->begin());
this->BeginX = RHS.BeginX;
this->Size = RHS.Size;
this->Capacity = RHS.Capacity;
RHS.resetToSmall();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x245d0
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x245e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x32850
movq 0x10(%rsp), %rdi
callq 0x328a0
testb $0x1, %al
jne 0x38f09
movq 0x10(%rsp), %rdi
callq 0x245d0
movq %rax, %rdi
callq 0x16220
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rdi
callq 0x39040
addq $0x28, %rsp
retq
nop
| /llvm/ADT/SmallVector.h |
void llvm::SmallVectorTemplateBase<(anonymous namespace)::SerializedAffineMap, true>::uninitialized_copy<(anonymous namespace)::SerializedAffineMap, (anonymous namespace)::SerializedAffineMap>((anonymous namespace)::SerializedAffineMap*, (anonymous namespace)::SerializedAffineMap*, (anonymous namespace)::SerializedAffineMap*, std::enable_if<std::is_same<std::remove_const<(anonymous namespace)::SerializedAffineMap>::type, (anonymous namespace)::SerializedAffineMap>::value, void>::type*) | static void uninitialized_copy(
T1 *I, T1 *E, T2 *Dest,
std::enable_if_t<std::is_same<std::remove_const_t<T1>, T2>::value> * =
nullptr) {
// Use memcpy for PODs iterated by pointers (which includes SmallVector
// iterators): std::uninitialized_copy optimizes to memmove, but we can
// use memcpy here. Note that I and E are iterators and thus might be
// invalid for memcpy if they are equal.
if (I != E)
memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x39258
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
sarq $0x3, %rdx
shlq $0x3, %rdx
callq 0x160c0
addq $0x28, %rsp
retq
nopl (%rax)
| /llvm/ADT/SmallVector.h |
std::enable_if<has_SequenceTraits<std::vector<(anonymous namespace)::ScalarAssign, std::allocator<(anonymous namespace)::ScalarAssign>>>::value, void>::type llvm::yaml::yamlize<std::vector<(anonymous namespace)::ScalarAssign, std::allocator<(anonymous namespace)::ScalarAssign>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<(anonymous namespace)::ScalarAssign, std::allocator<(anonymous namespace)::ScalarAssign>>&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
void *SaveInfo;
if ( io.preflightFlowElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightFlowElement(SaveInfo);
}
}
io.endFlowSequence();
}
else {
unsigned incnt = io.beginSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
void *SaveInfo;
if ( io.preflightElement(i, SaveInfo) ) {
yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
io.postflightElement(SaveInfo);
}
}
io.endSequence();
}
} | subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x4119b
jmp 0x411b1
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x41260
movq %rax, 0x8(%rsp)
jmp 0x411ba
movl 0x24(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl %eax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jae 0x41242
movq 0x40(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq (%rdi), %rax
leaq 0x10(%rsp), %rdx
callq *0x20(%rax)
testb $0x1, %al
jne 0x411ef
jmp 0x41233
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x1c(%rsp), %eax
movl %eax, %edx
callq 0x412f0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rcx
movl $0x1, %edx
callq 0x41280
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x41235
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x411cb
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/Support/YAMLTraits.h |
(anonymous namespace)::CommandLineParser::registerSubCommand(llvm::cl::SubCommand*) | void registerSubCommand(SubCommand *sub) {
assert(count_if(RegisteredSubCommands,
[sub](const SubCommand *Sub) {
return (!sub->getName().empty()) &&
(Sub->getName() == sub->getName());
}) == 0 &&
"Duplicate subcommands");
RegisteredSubCommands.insert(sub);
// For all options that have been registered for all subcommands, add the
// option to this subcommand now.
assert(sub != &SubCommand::getAll() &&
"SubCommand::getAll() should not be registered");
for (auto &E : SubCommand::getAll().OptionsMap) {
Option *O = E.second;
if ((O->isPositional() || O->isSink() || O->isConsumeAfter()) ||
O->hasArgStr())
addOption(O, sub);
else
addLiteralOption(*O, sub, E.first());
}
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rsi
movq %rsi, 0x10(%rsp)
addq $0x118, %rsi # imm = 0x118
movq 0x68(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x51ff0
callq 0x468c0
addq $0x80, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4ef80
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4efc0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4f000
testb $0x1, %al
jne 0x46944
jmp 0x46a0c
leaq 0x40(%rsp), %rdi
callq 0x4f030
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x52080
testb $0x1, %al
jne 0x4699b
movq 0x28(%rsp), %rdi
callq 0x520a0
testb $0x1, %al
jne 0x4699b
movq 0x28(%rsp), %rdi
callq 0x520c0
testb $0x1, %al
jne 0x4699b
movq 0x28(%rsp), %rdi
callq 0x4da80
testb $0x1, %al
jne 0x4699b
jmp 0x469b1
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x50b30
jmp 0x469fb
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x520e0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq %rax, %rcx
movq %rdx, %rax
movq 0x8(%rsp), %rdx
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x50090
jmp 0x469fd
leaq 0x40(%rsp), %rdi
callq 0x4f080
jmp 0x4692c
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /Support/CommandLine.cpp |
initCommonOptions() | static void initCommonOptions() {
*CommonOptions;
initDebugCounterOptions();
initGraphWriterOptions();
initSignalsOptions();
initStatisticOptions();
initTimerOptions();
initTypeSizeOptions();
initWithColorOptions();
initDebugOptions();
initRandomSeedOptions();
} | pushq %rax
leaq 0x3bb688(%rip), %rdi # 0x4063f0
callq 0x55ae0
callq 0x65ec0
callq 0x72650
callq 0xaf110
callq 0x76f40
callq 0x7d250
callq 0x7f3d0
callq 0x873b0
callq 0x656e0
callq 0x74350
popq %rax
retq
nopl (%rax)
| /Support/CommandLine.cpp |
llvm::SmallPtrSetIteratorImpl::RetreatIfNotValid() | void RetreatIfNotValid() {
assert(Bucket >= End);
while (Bucket != End &&
(Bucket[-1] == SmallPtrSetImplBase::getEmptyMarker() ||
Bucket[-1] == SmallPtrSetImplBase::getTombstoneMarker())) {
--Bucket;
}
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x17(%rsp)
je 0x4ff8e
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x50060
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, 0x16(%rsp)
je 0x4ff86
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rax
movq %rax, (%rsp)
callq 0x50070
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
sete %al
movb %al, 0x16(%rsp)
movb 0x16(%rsp), %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x4ff98
jmp 0x4ffac
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $-0x8, %rcx
movq %rcx, (%rax)
jmp 0x4ff23
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /llvm/ADT/SmallPtrSet.h |
void* llvm::StringMapEntryBase::allocateWithKey<llvm::MallocAllocator>(unsigned long, unsigned long, llvm::StringRef, llvm::MallocAllocator&) | void *StringMapEntryBase::allocateWithKey(size_t EntrySize, size_t EntryAlign,
StringRef Key,
AllocatorTy &Allocator) {
size_t KeyLength = Key.size();
// Allocate a new item with space for the string at the end and a null
// terminator.
size_t AllocSize = EntrySize + KeyLength + 1;
void *Allocation = Allocator.Allocate(AllocSize, EntryAlign);
assert(Allocation && "Unhandled out-of-memory");
// Copy the string information.
char *Buffer = reinterpret_cast<char *>(Allocation) + EntrySize;
if (KeyLength > 0)
::memcpy(Buffer, Key.data(), KeyLength);
Buffer[KeyLength] = 0; // Null terminate for convenience of clients.
return Allocation;
} | subq $0x58, %rsp
movq %rdx, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %r8, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x188c0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
addq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x507b0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
jbe 0x50765
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x188d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rdx
callq 0x160c0
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
| /llvm/ADT/StringMapEntry.h |
(anonymous namespace)::HelpPrinterWrapper::operator=(bool) | void HelpPrinterWrapper::operator=(bool Value) {
if (!Value)
return;
// Decide which printer to invoke. If more than one option category is
// registered then it is useful to show the categorized help instead of
// uncategorized help.
if (GlobalParser->RegisteredOptionCategories.size() > 1) {
// unhide --help-list option so user can have uncategorized output if they
// want it.
CommonOptions->HLOp.setHiddenFlag(NotHidden);
CategorizedPrinter = true; // Invoke categorized printer
} else
UncategorizedPrinter = true; // Invoke uncategorized printer
} | subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0xf(%rsp)
jne 0x5b514
jmp 0x5b573
leaq 0x3aae8d(%rip), %rdi # 0x4063a8
callq 0x463e0
movq %rax, %rdi
addq $0x78, %rdi
callq 0x4fb60
cmpl $0x1, %eax
jbe 0x5b562
leaq 0x3aaeb8(%rip), %rdi # 0x4063f0
callq 0x4e4d0
movq %rax, %rdi
addq $0x80, %rdi
xorl %esi, %esi
callq 0x4f050
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x5a620
jmp 0x5b573
movq (%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x5a620
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| /Support/CommandLine.cpp |
std::pair<char const*, llvm::cl::SubCommand*> const* llvm::SmallVectorTemplateCommon<std::pair<char const*, llvm::cl::SubCommand*>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<std::pair<char const*, llvm::cl::SubCommand*>, true>>(llvm::SmallVectorTemplateBase<std::pair<char const*, llvm::cl::SubCommand*>, true>*, std::pair<char const*, llvm::cl::SubCommand*> const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x76640
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x76450
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0x5eb64
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x5ebb6
movb $0x0, 0x1f(%rsp)
movq $-0x1, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5ebc0
testb $0x1, 0x1f(%rsp)
je 0x5eba4
movq 0x38(%rsp), %rdi
callq 0x5ea60
movq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
jmp 0x5ebad
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
| /llvm/ADT/SmallVector.h |
llvm::WithColor::warning(llvm::raw_ostream&, llvm::StringRef, bool) | raw_ostream &WithColor::warning(raw_ostream &OS, StringRef Prefix,
bool DisableColors) {
if (!Prefix.empty())
OS << Prefix << ": ";
return WithColor(OS, HighlightColor::Warning,
DisableColors ? ColorMode::Disable : ColorMode::Auto)
.get()
<< "warning: ";
} | subq $0x48, %rsp
movb %cl, %al
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1d540
testb $0x1, %al
jne 0x87770
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x18800
movq %rax, %rdi
leaq 0x25272c(%rip), %rsi # 0x2d9e97
callq 0x17bc0
movq 0x30(%rsp), %rsi
movb 0x2f(%rsp), %dl
xorl %ecx, %ecx
movl $0x2, %eax
testb $0x1, %dl
cmovnel %eax, %ecx
leaq 0x8(%rsp), %rdi
movl $0x7, %edx
callq 0x87480
leaq 0x8(%rsp), %rdi
callq 0x87950
movq %rax, %rdi
leaq 0x24f925(%rip), %rsi # 0x2d70ce
callq 0x17bc0
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x87a00
movq (%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /Support/WithColor.cpp |
llvm::yaml::Scanner::scanStreamStart() | bool Scanner::scanStreamStart() {
IsStartOfStream = false;
EncodingInfo EI = getUnicodeEncoding(currentInput());
Token T;
T.Kind = Token::TK_StreamStart;
T.Range = StringRef(Current, EI.second);
TokenQueue.push_back(T);
Current += EI.second;
return true;
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movb $0x0, 0x48(%rdi)
callq 0x8b880
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x8b160
movq %rax, 0x68(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x89c70
movq 0x8(%rsp), %rax
movl $0x1, 0x20(%rsp)
movq 0x28(%rax), %rsi
movl 0x6c(%rsp), %eax
movl %eax, %edx
leaq 0x10(%rsp), %rdi
callq 0x18990
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x50, %rdi
leaq 0x20(%rsp), %rsi
callq 0x8ad00
movq 0x8(%rsp), %rax
movl 0x6c(%rsp), %edx
movq 0x28(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x28(%rax)
leaq 0x20(%rsp), %rdi
callq 0x889b0
movb $0x1, %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /Support/YAMLParser.cpp |
llvm::yaml::Scanner::scanPlainScalar() | bool Scanner::scanPlainScalar() {
StringRef::iterator Start = Current;
unsigned ColStart = Column;
unsigned LeadingBlanks = 0;
assert(Indent >= -1 && "Indent must be >= -1 !");
unsigned indent = static_cast<unsigned>(Indent + 1);
while (Current != End) {
if (*Current == '#')
break;
while (Current != End &&
((*Current != ':' && isPlainSafeNonBlank(Current)) ||
(*Current == ':' && isPlainSafeNonBlank(Current + 1)))) {
StringRef::iterator i = skip_nb_char(Current);
if (i == Current)
break;
Current = i;
++Column;
}
// Are we at the end?
if (!isBlankOrBreak(Current))
break;
// Eat blanks.
StringRef::iterator Tmp = Current;
while (isBlankOrBreak(Tmp)) {
StringRef::iterator i = skip_s_white(Tmp);
if (i != Tmp) {
if (LeadingBlanks && (Column < indent) && *Tmp == '\t') {
setError("Found invalid tab character in indentation", Tmp);
return false;
}
Tmp = i;
++Column;
} else {
i = skip_b_break(Tmp);
if (!LeadingBlanks)
LeadingBlanks = 1;
Tmp = i;
Column = 0;
++Line;
}
}
if (!FlowLevel && Column < indent)
break;
Current = Tmp;
}
if (Start == Current) {
setError("Got empty plain scalar", Start);
return false;
}
Token T;
T.Kind = Token::TK_Scalar;
T.Range = StringRef(Start, Current - Start);
TokenQueue.push_back(T);
// Plain scalars can be simple keys.
saveSimpleKeyCandidate(--TokenQueue.end(), ColStart, false);
IsSimpleKeyAllowed = false;
IsAdjacentValueAllowedInFlow = false;
return true;
} | subq $0xf8, %rsp
movq %rdi, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rax), %rcx
movq %rcx, 0xe0(%rsp)
movl 0x3c(%rax), %ecx
movl %ecx, 0xdc(%rsp)
movl $0x0, 0xd8(%rsp)
movl 0x38(%rax), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rax
cmpq 0x30(%rcx), %rax
je 0x8cd3d
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x8cae3
jmp 0x8cd3d
jmp 0x8cae5
movq 0x8(%rsp), %rdx
movq 0x28(%rdx), %rcx
xorl %eax, %eax
cmpq 0x30(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x8cb63
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x8cb26
movq 0x8(%rsp), %rdi
movq 0x28(%rdi), %rsi
callq 0x8a800
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x8cb5b
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3a, %ecx
movb %al, 0x5(%rsp)
jne 0x8cb53
movq 0x8(%rsp), %rdi
movq 0x28(%rdi), %rsi
addq $0x1, %rsi
callq 0x8a800
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x8cb6d
jmp 0x8cbb7
movq 0x8(%rsp), %rdi
movq 0x28(%rdi), %rsi
callq 0x89f70
movq 0x8(%rsp), %rcx
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
cmpq 0x28(%rcx), %rax
jne 0x8cb98
jmp 0x8cbb7
movq 0x8(%rsp), %rax
movq 0xc8(%rsp), %rcx
movq %rcx, 0x28(%rax)
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
jmp 0x8cae5
movq 0x8(%rsp), %rdi
movq 0x28(%rdi), %rsi
callq 0x8a780
testb $0x1, %al
jne 0x8cbce
jmp 0x8cd3d
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0xc0(%rsp)
movq 0x8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x8a780
testb $0x1, %al
jne 0x8cbfa
jmp 0x8cd09
movq 0x8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x8a1e0
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
cmpq 0xc0(%rsp), %rax
je 0x8ccb0
cmpl $0x0, 0xd8(%rsp)
je 0x8cc90
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %eax
cmpl 0xd4(%rsp), %eax
jae 0x8cc90
movq 0xc0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x8cc90
leaq 0x90(%rsp), %rdi
leaq 0x24a947(%rip), %rsi # 0x2d75ab
callq 0x482d0
movq 0x8(%rsp), %rdi
movq 0xc0(%rsp), %rdx
leaq 0x90(%rsp), %rsi
callq 0x8a670
movb $0x0, 0xf7(%rsp)
jmp 0x8ce40
movq 0x8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movq %rcx, 0xc0(%rsp)
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
jmp 0x8cd04
movq 0x8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x8a0d0
movq %rax, 0xb8(%rsp)
cmpl $0x0, 0xd8(%rsp)
jne 0x8ccdf
movl $0x1, 0xd8(%rsp)
movq 0x8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movq %rcx, 0xc0(%rsp)
movl $0x0, 0x3c(%rax)
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
jmp 0x8cbdf
movq 0x8(%rsp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x8cd27
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %eax
cmpl 0xd4(%rsp), %eax
jae 0x8cd27
jmp 0x8cd3d
movq 0x8(%rsp), %rax
movq 0xc0(%rsp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x8caba
movq 0x8(%rsp), %rcx
movq 0xe0(%rsp), %rax
cmpq 0x28(%rcx), %rax
jne 0x8cd85
leaq 0x68(%rsp), %rdi
leaq 0x24a87a(%rip), %rsi # 0x2d75d6
callq 0x482d0
movq 0x8(%rsp), %rdi
movq 0xe0(%rsp), %rdx
leaq 0x68(%rsp), %rsi
callq 0x8a670
movb $0x0, 0xf7(%rsp)
jmp 0x8ce40
leaq 0x30(%rsp), %rdi
callq 0x89c70
movq 0x8(%rsp), %rax
movl $0x12, 0x30(%rsp)
movq 0xe0(%rsp), %rsi
movq 0x28(%rax), %rdx
movq 0xe0(%rsp), %rax
subq %rax, %rdx
leaq 0x20(%rsp), %rdi
callq 0x18990
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
addq $0x50, %rdi
leaq 0x30(%rsp), %rsi
callq 0x8ad00
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x8bf10
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x8bf50
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl 0xdc(%rsp), %edx
movq 0x18(%rsp), %rsi
xorl %ecx, %ecx
callq 0x8a9c0
movq 0x8(%rsp), %rax
movb $0x0, 0x49(%rax)
movb $0x0, 0x4a(%rax)
movb $0x1, 0xf7(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x889b0
movb 0xf7(%rsp), %al
andb $0x1, %al
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /Support/YAMLParser.cpp |
llvm::detail::IEEEFloat::convert(llvm::fltSemantics const&, llvm::RoundingMode, bool*) | IEEEFloat::opStatus IEEEFloat::convert(const fltSemantics &toSemantics,
roundingMode rounding_mode,
bool *losesInfo) {
lostFraction lostFraction;
unsigned int newPartCount, oldPartCount;
opStatus fs;
int shift;
const fltSemantics &fromSemantics = *semantics;
bool is_signaling = isSignaling();
lostFraction = lfExactlyZero;
newPartCount = partCountForBits(toSemantics.precision + 1);
oldPartCount = partCount();
shift = toSemantics.precision - fromSemantics.precision;
bool X86SpecialNan = false;
if (&fromSemantics == &semX87DoubleExtended &&
&toSemantics != &semX87DoubleExtended && category == fcNaN &&
(!(*significandParts() & 0x8000000000000000ULL) ||
!(*significandParts() & 0x4000000000000000ULL))) {
// x86 has some unusual NaNs which cannot be represented in any other
// format; note them here.
X86SpecialNan = true;
}
// If this is a truncation of a denormal number, and the target semantics
// has larger exponent range than the source semantics (this can happen
// when truncating from PowerPC double-double to double format), the
// right shift could lose result mantissa bits. Adjust exponent instead
// of performing excessive shift.
// Also do a similar trick in case shifting denormal would produce zero
// significand as this case isn't handled correctly by normalize.
if (shift < 0 && isFiniteNonZero()) {
int omsb = significandMSB() + 1;
int exponentChange = omsb - fromSemantics.precision;
if (exponent + exponentChange < toSemantics.minExponent)
exponentChange = toSemantics.minExponent - exponent;
if (exponentChange < shift)
exponentChange = shift;
if (exponentChange < 0) {
shift -= exponentChange;
exponent += exponentChange;
} else if (omsb <= -shift) {
exponentChange = omsb + shift - 1; // leave at least one bit set
shift -= exponentChange;
exponent += exponentChange;
}
}
// If this is a truncation, perform the shift before we narrow the storage.
if (shift < 0 && (isFiniteNonZero() ||
(category == fcNaN && semantics->nonFiniteBehavior !=
fltNonfiniteBehavior::NanOnly)))
lostFraction = shiftRight(significandParts(), oldPartCount, -shift);
// Fix the storage so it can hold to new value.
if (newPartCount > oldPartCount) {
// The new type requires more storage; make it available.
integerPart *newParts;
newParts = new integerPart[newPartCount];
APInt::tcSet(newParts, 0, newPartCount);
if (isFiniteNonZero() || category==fcNaN)
APInt::tcAssign(newParts, significandParts(), oldPartCount);
freeSignificand();
significand.parts = newParts;
} else if (newPartCount == 1 && oldPartCount != 1) {
// Switch to built-in storage for a single part.
integerPart newPart = 0;
if (isFiniteNonZero() || category==fcNaN)
newPart = significandParts()[0];
freeSignificand();
significand.part = newPart;
}
// Now that we have the right storage, switch the semantics.
semantics = &toSemantics;
// If this is an extension, perform the shift now that the storage is
// available.
if (shift > 0 && (isFiniteNonZero() || category==fcNaN))
APInt::tcShiftLeft(significandParts(), newPartCount, shift);
if (isFiniteNonZero()) {
fs = normalize(rounding_mode, lostFraction);
*losesInfo = (fs != opOK);
} else if (category == fcNaN) {
if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
*losesInfo =
fromSemantics.nonFiniteBehavior != fltNonfiniteBehavior::NanOnly;
makeNaN(false, sign);
return is_signaling ? opInvalidOp : opOK;
}
// If NaN is negative zero, we need to create a new NaN to avoid converting
// NaN to -Inf.
if (fromSemantics.nanEncoding == fltNanEncoding::NegativeZero &&
semantics->nanEncoding != fltNanEncoding::NegativeZero)
makeNaN(false, false);
*losesInfo = lostFraction != lfExactlyZero || X86SpecialNan;
// For x87 extended precision, we want to make a NaN, not a special NaN if
// the input wasn't special either.
if (!X86SpecialNan && semantics == &semX87DoubleExtended)
APInt::tcSetBit(significandParts(), semantics->precision - 1);
// Convert of sNaN creates qNaN and raises an exception (invalid op).
// This also guarantees that a sNaN does not become Inf on a truncation
// that loses all payload bits.
if (is_signaling) {
makeQuiet();
fs = opInvalidOp;
} else {
fs = opOK;
}
} else if (category == fcInfinity &&
semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly) {
makeNaN(false, sign);
*losesInfo = true;
fs = opInexact;
} else if (category == fcZero &&
semantics->nanEncoding == fltNanEncoding::NegativeZero) {
// Negative zero loses info, but positive zero doesn't.
*losesInfo =
fromSemantics.nanEncoding != fltNanEncoding::NegativeZero && sign;
fs = *losesInfo ? opInexact : opOK;
// NaN is negative zero means -0 -> +0, which can lose information
sign = false;
} else {
*losesInfo = false;
fs = opOK;
}
return fs;
} | subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movb %al, 0x6f(%rsp)
movq %rcx, 0x60(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq (%rdi), %rax
movq %rax, 0x40(%rsp)
callq 0xb8f90
andb $0x1, %al
movb %al, 0x3f(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x70(%rsp), %rax
movl 0x8(%rax), %edi
addl $0x1, %edi
callq 0xb7050
movq 0x18(%rsp), %rdi
movl %eax, 0x58(%rsp)
callq 0xb6840
movl %eax, 0x54(%rsp)
movq 0x70(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x40(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, 0x4c(%rsp)
movb $0x0, 0x3e(%rsp)
leaq 0x220bc9(%rip), %rax # 0x2d890c
cmpq %rax, 0x40(%rsp)
jne 0xb7daf
leaq 0x220bbb(%rip), %rax # 0x2d890c
cmpq %rax, 0x70(%rsp)
je 0xb7daf
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
andb $0x7, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xb7daf
movq 0x18(%rsp), %rdi
callq 0xb69f0
movq %rax, %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx), %rax
cmpq $0x0, %rax
je 0xb7daa
movq 0x18(%rsp), %rdi
callq 0xb69f0
movq %rax, %rcx
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
andq (%rcx), %rax
cmpq $0x0, %rax
jne 0xb7daf
movb $0x1, 0x3e(%rsp)
cmpl $0x0, 0x4c(%rsp)
jge 0xb7e90
movq 0x18(%rsp), %rdi
callq 0xb6960
testb $0x1, %al
jne 0xb7dcd
jmp 0xb7e90
movq 0x18(%rsp), %rdi
callq 0xb6f00
movl %eax, %ecx
movq 0x18(%rsp), %rax
addl $0x1, %ecx
movl %ecx, 0x38(%rsp)
movl 0x38(%rsp), %ecx
movq 0x40(%rsp), %rdx
subl 0x8(%rdx), %ecx
movl %ecx, 0x34(%rsp)
movl 0x10(%rax), %eax
addl 0x34(%rsp), %eax
movq 0x70(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xb7e1a
movq 0x18(%rsp), %rcx
movq 0x70(%rsp), %rax
movl 0x4(%rax), %eax
subl 0x10(%rcx), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0xb7e2c
movl 0x4c(%rsp), %eax
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
jge 0xb7e52
movq 0x18(%rsp), %rax
movl 0x34(%rsp), %edx
movl 0x4c(%rsp), %ecx
subl %edx, %ecx
movl %ecx, 0x4c(%rsp)
movl 0x34(%rsp), %ecx
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0xb7e8e
movl 0x38(%rsp), %eax
xorl %ecx, %ecx
subl 0x4c(%rsp), %ecx
cmpl %ecx, %eax
jg 0xb7e8c
movq 0x18(%rsp), %rax
movl 0x38(%rsp), %ecx
addl 0x4c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, 0x34(%rsp)
movl 0x34(%rsp), %edx
movl 0x4c(%rsp), %ecx
subl %edx, %ecx
movl %ecx, 0x4c(%rsp)
movl 0x34(%rsp), %ecx
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0xb7e8e
jmp 0xb7e90
cmpl $0x0, 0x4c(%rsp)
jge 0xb7ee5
movq 0x18(%rsp), %rdi
callq 0xb6960
testb $0x1, %al
jne 0xb7ec5
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
andb $0x7, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xb7ee5
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x1, 0x10(%rax)
je 0xb7ee5
movq 0x18(%rsp), %rdi
callq 0xb69f0
movq %rax, %rdi
movl 0x54(%rsp), %esi
xorl %edx, %edx
subl 0x4c(%rsp), %edx
callq 0xb8550
movl %eax, 0x5c(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x54(%rsp), %eax
jbe 0xb7f8e
movl 0x58(%rsp), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x16500
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl 0x58(%rsp), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0xcfa90
movq 0x18(%rsp), %rdi
callq 0xb6960
testb $0x1, %al
jne 0xb7f4f
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
andb $0x7, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xb7f74
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xb69f0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movl 0x54(%rsp), %edx
callq 0xcfae0
movq 0x18(%rsp), %rdi
callq 0xb6860
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xb7ff1
cmpl $0x1, 0x58(%rsp)
jne 0xb7fef
cmpl $0x1, 0x54(%rsp)
je 0xb7fef
movq 0x18(%rsp), %rdi
movq $0x0, 0x20(%rsp)
callq 0xb6960
testb $0x1, %al
jne 0xb7fc5
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
andb $0x7, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xb7fd7
movq 0x18(%rsp), %rdi
callq 0xb69f0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
callq 0xb6860
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xb7ff1
movq 0x18(%rsp), %rax
movq 0x70(%rsp), %rcx
movq %rcx, (%rax)
cmpl $0x0, 0x4c(%rsp)
jle 0xb803f
movq 0x18(%rsp), %rdi
callq 0xb6960
testb $0x1, %al
jne 0xb8025
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
andb $0x7, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xb803f
movq 0x18(%rsp), %rdi
callq 0xb69f0
movq %rax, %rdi
movl 0x58(%rsp), %esi
movl 0x4c(%rsp), %edx
callq 0xcd8c0
movq 0x18(%rsp), %rdi
callq 0xb6960
testb $0x1, %al
jne 0xb804f
jmp 0xb807f
movq 0x18(%rsp), %rdi
movb 0x6f(%rsp), %al
movl 0x5c(%rsp), %edx
movsbl %al, %esi
callq 0xb7270
movl %eax, 0x50(%rsp)
cmpl $0x0, 0x50(%rsp)
setne %cl
movq 0x60(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
jmp 0xb82a3
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
andb $0x7, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xb81ab
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x1, 0x10(%rax)
jne 0xb80fd
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rax
cmpl $0x1, 0x10(%rax)
setne %cl
movq 0x60(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb 0x14(%rdi), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
xorl %ecx, %ecx
movzbl %al, %edx
andl $0x1, %edx
xorl %esi, %esi
movl %esi, %ecx
callq 0xb6a50
movb 0x3f(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x84(%rsp)
jmp 0xb82ae
movq 0x40(%rsp), %rax
cmpl $0x2, 0x14(%rax)
jne 0xb8128
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x2, 0x14(%rax)
je 0xb8128
movq 0x18(%rsp), %rdi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
movl %edx, %esi
callq 0xb6a50
movb $0x1, %al
cmpl $0x0, 0x5c(%rsp)
movb %al, 0xf(%rsp)
jne 0xb813d
movb 0x3e(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %cl
movq 0x60(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
testb $0x1, 0x3e(%rsp)
jne 0xb8183
movq 0x18(%rsp), %rax
leaq 0x2207ae(%rip), %rcx # 0x2d890c
cmpq %rcx, (%rax)
jne 0xb8183
movq 0x18(%rsp), %rdi
callq 0xb69f0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %esi
subl $0x1, %esi
callq 0xcfbe0
testb $0x1, 0x3f(%rsp)
je 0xb819e
movq 0x18(%rsp), %rdi
callq 0xb9010
movl $0x1, 0x50(%rsp)
jmp 0xb81a6
movl $0x0, 0x50(%rsp)
jmp 0xb82a1
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
andb $0x7, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xb8207
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x1, 0x10(%rax)
jne 0xb8207
movq 0x18(%rsp), %rdi
movb 0x14(%rdi), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
xorl %ecx, %ecx
movzbl %al, %edx
andl $0x1, %edx
xorl %esi, %esi
movl %esi, %ecx
callq 0xb6a50
movq 0x60(%rsp), %rax
movb $0x1, (%rax)
movl $0x10, 0x50(%rsp)
jmp 0xb829f
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
andb $0x7, %al
movzbl %al, %eax
cmpl $0x3, %eax
jne 0xb828d
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x2, 0x14(%rax)
jne 0xb828d
movq 0x40(%rsp), %rcx
xorl %eax, %eax
cmpl $0x2, 0x14(%rcx)
movb %al, 0xe(%rsp)
je 0xb8252
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
movb %al, 0xe(%rsp)
movq 0x18(%rsp), %rax
movb 0xe(%rsp), %dl
movq 0x60(%rsp), %rcx
andb $0x1, %dl
movb %dl, (%rcx)
movq 0x60(%rsp), %rcx
movb (%rcx), %sil
xorl %ecx, %ecx
movl $0x10, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
movl %ecx, 0x50(%rsp)
movb 0x14(%rax), %cl
andb $-0x9, %cl
orb $0x0, %cl
movb %cl, 0x14(%rax)
jmp 0xb829d
movq 0x60(%rsp), %rax
movb $0x0, (%rax)
movl $0x0, 0x50(%rsp)
jmp 0xb829f
jmp 0xb82a1
jmp 0xb82a3
movl 0x50(%rsp), %eax
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax)
| /Support/APFloat.cpp |
std::enable_if<is_hashable_data<unsigned long>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned long>(unsigned long*, unsigned long*) | std::enable_if_t<is_hashable_data<ValueT>::value, hash_code>
hash_combine_range_impl(ValueT *first, ValueT *last) {
const uint64_t seed = get_execution_seed();
const char *s_begin = reinterpret_cast<const char *>(first);
const char *s_end = reinterpret_cast<const char *>(last);
const size_t length = std::distance(s_begin, s_end);
if (length <= 64)
return hash_short(s_begin, length, seed);
const char *s_aligned_end = s_begin + (length & ~63);
hash_state state = state.create(s_begin, seed);
s_begin += 64;
while (s_begin != s_aligned_end) {
state.mix(s_begin);
s_begin += 64;
}
if (length & 63)
state.mix(s_end - 64);
return state.finalize(length);
} | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
callq 0x7c4b0
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x1e990
movq %rax, 0x40(%rsp)
cmpq $0x40, 0x40(%rsp)
ja 0xd055e
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x7c4c0
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0x7c5c0
jmp 0xd05f7
movq 0x50(%rsp), %rax
movq 0x40(%rsp), %rcx
andq $-0x40, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %rsp, %rdi
callq 0x7c5e0
movq 0x50(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0xd05bd
movq 0x50(%rsp), %rsi
movq %rsp, %rdi
callq 0x7c6b0
movq 0x50(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x50(%rsp)
jmp 0xd0594
movq 0x40(%rsp), %rax
andq $0x3f, %rax
cmpq $0x0, %rax
je 0xd05dd
movq 0x48(%rsp), %rsi
addq $-0x40, %rsi
movq %rsp, %rdi
callq 0x7c6b0
movq 0x40(%rsp), %rsi
movq %rsp, %rdi
callq 0x7c860
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0x7c5c0
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /llvm/ADT/Hashing.h |
char const* llvm::SourceMgr::SrcBuffer::getPointerForLineNumberSpecialized<unsigned char>(unsigned int) const | const char *SourceMgr::SrcBuffer::getPointerForLineNumberSpecialized(
unsigned LineNo) const {
std::vector<T> &Offsets =
GetOrCreateOffsetCache<T>(OffsetCache, Buffer.get());
// We start counting line and column numbers from 1.
if (LineNo != 0)
--LineNo;
const char *BufStart = Buffer->getBufferStart();
// The offset cache contains the location of the \n for the specified line,
// we want the start of the line. As such, we look for the previous entry.
if (LineNo == 0)
return BufStart;
if (LineNo > Offsets.size())
return nullptr;
return BufStart + Offsets[LineNo - 1] + 1;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
callq 0x31d40
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xd6c20
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0xd3abc
movl 0x34(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x34(%rsp)
movq 0x10(%rsp), %rdi
callq 0x17c10
movq %rax, %rdi
callq 0x483c0
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x34(%rsp)
jne 0xd3ae6
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xd3b48
movl 0x34(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd72b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0xd3b11
movq $0x0, 0x40(%rsp)
jmp 0xd3b48
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl 0x34(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0xd94e0
movq %rax, %rcx
movq (%rsp), %rax
movzbl (%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /Support/SourceMgr.cpp |
std::enable_if<std::is_signed_v<long>, long>::type llvm::AddOverflow<long>(long, long, long&) | std::enable_if_t<std::is_signed_v<T>, T> AddOverflow(T X, T Y, T &Result) {
#if __has_builtin(__builtin_add_overflow)
return __builtin_add_overflow(X, Y, &Result);
#else
// Perform the unsigned addition.
using U = std::make_unsigned_t<T>;
const U UX = static_cast<U>(X);
const U UY = static_cast<U>(Y);
const U UResult = UX + UY;
// Convert to signed.
Result = static_cast<T>(UResult);
// Adding two positive numbers should result in a positive number.
if (X > 0 && Y > 0)
return Result <= 0;
// Adding two negatives should result in a negative number.
if (X < 0 && Y < 0)
return Result >= 0;
return false;
#endif
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rdx
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
addq %rax, %rdx
seto %al
movq %rdx, (%rcx)
andb $0x1, %al
movzbl %al, %eax
retq
nopl (%rax)
| /llvm/Support/MathExtras.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::StringRef, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>, llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>::moveFromOldBuckets(llvm::detail::DenseSetPair<llvm::StringRef>*, llvm::detail::DenseSetPair<llvm::StringRef>*) | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
} | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf58b0
callq 0xf5990
movq %rax, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
callq 0xf6160
movq %rax, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
cmpq 0x60(%rsp), %rax
je 0xf68d2
movq 0x68(%rsp), %rdi
callq 0x79410
movq (%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
callq 0x78f00
testb $0x1, %al
jne 0xf68b5
movq 0x68(%rsp), %rdi
callq 0x79410
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x78f00
testb $0x1, %al
jne 0xf68b5
movq 0x68(%rsp), %rdi
callq 0x79410
movq 0x8(%rsp), %rdi
movq %rax, %rsi
leaq 0x18(%rsp), %rdx
callq 0xf5d20
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x68(%rsp), %rdi
callq 0x79410
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x79410
movq (%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
callq 0x79420
movq 0x68(%rsp), %rdi
callq 0x79420
movq 0x8(%rsp), %rdi
callq 0xf6370
movq 0x68(%rsp), %rdi
callq 0x79420
movq 0x68(%rsp), %rdi
callq 0x79410
movq 0x68(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x68(%rsp)
jmp 0xf678f
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::detail::DenseSetPair<void const*>* llvm::DenseMapBase<llvm::DenseMap<void const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseSetPair<void const*>>, void const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseSetPair<void const*>>::InsertIntoBucketImpl<void const*>(void const* const&, void const* const&, llvm::detail::DenseSetPair<void const*>*) | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x51ec0
movq 0x10(%rsp), %rdi
callq 0xf8740
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0xf8340
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
shll $0x2, %eax
imull $0x3, 0x20(%rsp), %ecx
cmpl %ecx, %eax
jb 0xf868a
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %esi
shll %esi
callq 0xf8750
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xf7f70
movq 0x10(%rsp), %rdi
callq 0xf8340
movl %eax, 0x20(%rsp)
jmp 0xf86e1
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
callq 0xf8770
movl 0x8(%rsp), %ecx
movl %eax, %edx
movl 0xc(%rsp), %eax
addl %edx, %ecx
subl %ecx, %eax
movl 0x20(%rsp), %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
ja 0xf86df
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0xf8750
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xf7f70
jmp 0xf86e1
movq 0x10(%rsp), %rdi
callq 0xf8780
callq 0xf8350
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf85f0
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0xef550
testb $0x1, %al
jne 0xf871a
movq 0x10(%rsp), %rdi
callq 0xf87b0
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/ADT/DenseMap.h |
mlir::OpInterface<mlir::OpAsmOpInterface, mlir::detail::OpAsmOpInterfaceInterfaceTraits>::getInterfaceFor(mlir::Operation*) | static typename InterfaceBase::Concept *getInterfaceFor(Operation *op) {
OperationName name = op->getName();
#ifndef NDEBUG
// Check that the current interface isn't an unresolved promise for the
// given operation.
if (Dialect *dialect = name.getDialect()) {
dialect_extension_detail::handleUseOfUndefinedPromisedInterface(
*dialect, name.getTypeID(), ConcreteType::getInterfaceID(),
llvm::getTypeName<ConcreteType>());
}
#endif
// Access the raw interface from the operation info.
if (std::optional<RegisteredOperationName> rInfo =
name.getRegisteredInfo()) {
if (auto *opIface = rInfo->getInterface<ConcreteType>())
return opIface;
// Fallback to the dialect to provide it with a chance to implement this
// interface for this operation.
return rInfo->getDialect().getRegisteredInterfaceForOp<ConcreteType>(
op->getName());
}
// Fallback to the dialect to provide it with a chance to implement this
// interface for this operation.
if (Dialect *dialect = name.getDialect())
return dialect->getRegisteredInterfaceForOp<ConcreteType>(name);
return nullptr;
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xfd520
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xfd620
movq %rax, 0x30(%rsp)
movb %dl, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xfd430
testb $0x1, %al
jne 0x100d4b
jmp 0x100db2
leaq 0x30(%rsp), %rdi
callq 0xfd450
movq %rax, %rdi
callq 0x100e00
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x100d76
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x100df2
leaq 0x30(%rsp), %rdi
callq 0xfd450
movq %rax, %rdi
callq 0x100e20
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0xfd520
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x100e40
movq %rax, 0x50(%rsp)
jmp 0x100df2
leaq 0x40(%rsp), %rdi
callq 0xfd920
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x100de9
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0x100e40
movq %rax, 0x50(%rsp)
jmp 0x100df2
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
| /mlir/IR/OpDefinition.h |
llvm::DenseMapBase<llvm::DenseMap<void const*, unsigned int, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, unsigned int>>, void const*, unsigned int, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, unsigned int>>::moveFromOldBuckets(llvm::detail::DenseMapPair<void const*, unsigned int>*, llvm::detail::DenseMapPair<void const*, unsigned int>*) | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x102a80
callq 0xef510
movq %rax, 0x48(%rsp)
callq 0xef520
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
je 0x1053a0
movq 0x38(%rsp), %rdi
callq 0x102b90
movq (%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0xef550
testb $0x1, %al
jne 0x105383
movq 0x38(%rsp), %rdi
callq 0x102b90
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
callq 0xef550
testb $0x1, %al
jne 0x105383
movq 0x38(%rsp), %rdi
callq 0x102b90
movq 0x18(%rsp), %rdi
movq %rax, %rsi
leaq 0x28(%rsp), %rdx
callq 0x104bd0
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x38(%rsp), %rdi
callq 0x102b90
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x102b90
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x105100
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x105100
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl (%rcx), %ecx
movl %ecx, (%rax)
callq 0x105150
movq 0x38(%rsp), %rdi
callq 0x105100
movq 0x38(%rsp), %rdi
callq 0x102b90
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
jmp 0x1052ba
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/ADT/DenseMap.h |
sanitizeIdentifier(llvm::StringRef, llvm::SmallString<16u>&, llvm::StringRef, bool) | static StringRef sanitizeIdentifier(StringRef name, SmallString<16> &buffer,
StringRef allowedPunctChars = "$._-",
bool allowTrailingDigit = true) {
assert(!name.empty() && "Shouldn't have an empty name here");
auto validChar = [&](char ch) {
return llvm::isAlnum(ch) || allowedPunctChars.contains(ch);
};
auto copyNameToBuffer = [&] {
for (char ch : name) {
if (validChar(ch))
buffer.push_back(ch);
else if (ch == ' ')
buffer.push_back('_');
else
buffer.append(llvm::utohexstr((unsigned char)ch));
}
};
// Check to see if this name is valid. If it starts with a digit, then it
// could conflict with the autogenerated numeric ID's, so add an underscore
// prefix to avoid problems.
if (isdigit(name[0]) || (!validChar(name[0]) && name[0] != ' ')) {
buffer.push_back('_');
copyNameToBuffer();
return buffer;
}
// If the name ends with a trailing digit, add a '_' to avoid potential
// conflicts with autogenerated ID's.
if (!allowTrailingDigit && isdigit(name.back())) {
copyNameToBuffer();
buffer.push_back('_');
return buffer;
}
// Check to see that the name consists of only valid identifier characters.
for (char ch : name) {
if (!validChar(ch)) {
copyNameToBuffer();
return buffer;
}
}
// If there are no invalid characters, return the original name.
return name;
} | subq $0x88, %rsp
movb %r9b, %al
movq %rdi, 0x68(%rsp)
movq %rsi, 0x70(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x60(%rsp)
movq %rdx, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x68(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36360
movsbl %al, %edi
callq 0x16510
cmpl $0x0, %eax
jne 0x1064c1
leaq 0x68(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36360
leaq 0x40(%rsp), %rdi
movsbl %al, %esi
callq 0x106990
testb $0x1, %al
jne 0x1064f6
leaq 0x68(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36360
movsbl %al, %eax
cmpl $0x20, %eax
je 0x1064f6
movq 0x50(%rsp), %rdi
movl $0x5f, %esi
callq 0x475d0
leaq 0x28(%rsp), %rdi
callq 0x1069e0
movq 0x50(%rsp), %rdi
callq 0x106af0
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
jmp 0x1065e7
testb $0x1, 0x4f(%rsp)
jne 0x106549
leaq 0x68(%rsp), %rdi
callq 0x35540
movsbl %al, %edi
callq 0x16510
cmpl $0x0, %eax
je 0x106549
leaq 0x28(%rsp), %rdi
callq 0x1069e0
movq 0x50(%rsp), %rdi
movl $0x5f, %esi
callq 0x475d0
movq 0x50(%rsp), %rdi
callq 0x106af0
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
jmp 0x1065e7
leaq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x36380
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x36390
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x1065d0
movq 0x18(%rsp), %rax
movb (%rax), %al
movb %al, 0xf(%rsp)
leaq 0x40(%rsp), %rdi
movsbl 0xf(%rsp), %esi
callq 0x106990
testb $0x1, %al
jne 0x1065be
leaq 0x28(%rsp), %rdi
callq 0x1069e0
movq 0x50(%rsp), %rdi
callq 0x106af0
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
jmp 0x1065e7
jmp 0x1065c0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x106571
movq 0x68(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rdx
addq $0x88, %rsp
retq
nopl (%rax)
| /IR/AsmPrinter.cpp |
llvm::DenseMapBase<llvm::DenseMap<mlir::Dialect*, llvm::SetVector<mlir::AsmDialectResourceHandle, llvm::SmallVector<mlir::AsmDialectResourceHandle, 0u>, llvm::DenseSet<mlir::AsmDialectResourceHandle, llvm::DenseMapInfo<mlir::AsmDialectResourceHandle, void>>, 0u>, llvm::DenseMapInfo<mlir::Dialect*, void>, llvm::detail::DenseMapPair<mlir::Dialect*, llvm::SetVector<mlir::AsmDialectResourceHandle, llvm::SmallVector<mlir::AsmDialectResourceHandle, 0u>, llvm::DenseSet<mlir::AsmDialectResourceHandle, llvm::DenseMapInfo<mlir::AsmDialectResourceHandle, void>>, 0u>>>, mlir::Dialect*, llvm::SetVector<mlir::AsmDialectResourceHandle, llvm::SmallVector<mlir::AsmDialectResourceHandle, 0u>, llvm::DenseSet<mlir::AsmDialectResourceHandle, llvm::DenseMapInfo<mlir::AsmDialectResourceHandle, void>>, 0u>, llvm::DenseMapInfo<mlir::Dialect*, void>, llvm::detail::DenseMapPair<mlir::Dialect*, llvm::SetVector<mlir::AsmDialectResourceHandle, llvm::SmallVector<mlir::AsmDialectResourceHandle, 0u>, llvm::DenseSet<mlir::AsmDialectResourceHandle, llvm::DenseMapInfo<mlir::AsmDialectResourceHandle, void>>, 0u>>>::find(mlir::Dialect const*) | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this, true);
return end();
} | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x10fda0
testb $0x1, %al
jne 0x10f68d
jmp 0x10f6eb
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x10fed0
testb $0x1, %al
jne 0x10f6a2
jmp 0x10f6b3
movq 0x18(%rsp), %rdi
callq 0x10fee0
movq %rax, 0x8(%rsp)
jmp 0x10f6c2
movq 0x18(%rsp), %rdi
callq 0x10fef0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0x1, %r8d
movq %rcx, %rdi
callq 0x10fdf0
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
jmp 0x10f6ff
movq 0x18(%rsp), %rdi
callq 0x10f740
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nop
| /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<mlir::Dialect*, llvm::SetVector<mlir::AsmDialectResourceHandle, llvm::SmallVector<mlir::AsmDialectResourceHandle, 0u>, llvm::DenseSet<mlir::AsmDialectResourceHandle, llvm::DenseMapInfo<mlir::AsmDialectResourceHandle, void>>, 0u>, llvm::DenseMapInfo<mlir::Dialect*, void>, llvm::detail::DenseMapPair<mlir::Dialect*, llvm::SetVector<mlir::AsmDialectResourceHandle, llvm::SmallVector<mlir::AsmDialectResourceHandle, 0u>, llvm::DenseSet<mlir::AsmDialectResourceHandle, llvm::DenseMapInfo<mlir::AsmDialectResourceHandle, void>>, 0u>>>, mlir::Dialect*, llvm::SetVector<mlir::AsmDialectResourceHandle, llvm::SmallVector<mlir::AsmDialectResourceHandle, 0u>, llvm::DenseSet<mlir::AsmDialectResourceHandle, llvm::DenseMapInfo<mlir::AsmDialectResourceHandle, void>>, 0u>, llvm::DenseMapInfo<mlir::Dialect*, void>, llvm::detail::DenseMapPair<mlir::Dialect*, llvm::SetVector<mlir::AsmDialectResourceHandle, llvm::SmallVector<mlir::AsmDialectResourceHandle, 0u>, llvm::DenseSet<mlir::AsmDialectResourceHandle, llvm::DenseMapInfo<mlir::AsmDialectResourceHandle, void>>, 0u>>>::LookupBucketFor<mlir::Dialect const*>(mlir::Dialect const* const&, llvm::detail::DenseMapPair<mlir::Dialect*, llvm::SetVector<mlir::AsmDialectResourceHandle, llvm::SmallVector<mlir::AsmDialectResourceHandle, 0u>, llvm::DenseSet<mlir::AsmDialectResourceHandle, llvm::DenseMapInfo<mlir::AsmDialectResourceHandle, void>>, 0u>> const*&) const | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of whether we find a tombstone while probing.
const BucketT *FoundTombstone = nullptr;
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
!KeyInfoT::isEqual(Val, TombstoneKey) &&
"Empty/Tombstone value shouldn't be inserted into map!");
unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
unsigned ProbeAmt = 1;
while (true) {
const BucketT *ThisBucket = BucketsPtr + BucketNo;
// Found Val's bucket? If so, return it.
if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
FoundBucket = ThisBucket;
return true;
}
// If we found an empty bucket, the key doesn't exist in the set.
// Insert it and return the default value.
if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
// If we've already seen a tombstone while probing, fill it in instead
// of the empty bucket we eventually probed to.
FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
return false;
}
// If this is a tombstone, remember it. If Val ends up not in the map, we
// prefer to return it than something that would require more probing.
if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
!FoundTombstone)
FoundTombstone = ThisBucket; // Remember the first tombstone found.
// Otherwise, it's a hash collision or a tombstone, continue quadratic
// probing.
BucketNo += ProbeAmt++;
BucketNo &= (NumBuckets-1);
}
} | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1100d0
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x1100e0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x10ff82
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rsp)
jmp 0x1100bb
movq $0x0, 0x40(%rsp)
callq 0x1100f0
movq %rax, 0x38(%rsp)
callq 0x110100
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rdi
callq 0x110110
movl 0x4c(%rsp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x2c(%rsp)
movl $0x1, 0x28(%rsp)
movq 0x50(%rsp), %rax
movl 0x2c(%rsp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x110150
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0x110130
testb $0x1, %al
jne 0x10fffd
jmp 0x110014
movq 0x20(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x77(%rsp)
jmp 0x1100bb
movq 0x20(%rsp), %rdi
callq 0x110150
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x110130
testb $0x1, %al
jne 0x110031
jmp 0x110063
cmpq $0x0, 0x40(%rsp)
je 0x110045
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x11004f
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movb $0x0, 0x77(%rsp)
jmp 0x1100bb
movq 0x20(%rsp), %rdi
callq 0x110150
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x110130
testb $0x1, %al
jne 0x110080
jmp 0x110092
cmpq $0x0, 0x40(%rsp)
jne 0x110092
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x28(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rsp)
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
andl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x10ffbe
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
| /llvm/ADT/DenseMap.h |
mlir::AsmDialectResourceHandle const* llvm::SmallVectorTemplateCommon<mlir::AsmDialectResourceHandle, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<mlir::AsmDialectResourceHandle, true>>(llvm::SmallVectorTemplateBase<mlir::AsmDialectResourceHandle, true>*, mlir::AsmDialectResourceHandle const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x76640
addq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x76450
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
ja 0x12ac67
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x12ad01
movb $0x0, 0x2f(%rsp)
movq $-0x1, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x12ad10
testb $0x1, %al
jne 0x12ac8a
jmp 0x12acbd
movb $0x1, 0x2f(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x111990
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x129c90
testb $0x1, 0x2f(%rsp)
je 0x12aced
movq 0x48(%rsp), %rdi
callq 0x111990
imulq $0x18, 0x20(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x12acf7
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/SmallVector.h |
llvm::CastInfo<mlir::UnrankedTensorType, mlir::Type const, void>::isPossible(mlir::Type) | static inline bool isPossible(mlir::Type ty) {
/// Return a constant true instead of a dynamic true when casting to self or
/// up the hierarchy.
if constexpr (std::is_base_of_v<To, From>) {
return true;
} else {
return To::classof(ty);
};
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x12f740
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /mlir/IR/Types.h |
mlir::detail::FloatAttrStorage* mlir::StorageUniquer::get<mlir::detail::FloatAttrStorage, mlir::Type&, llvm::APFloat const&>(llvm::function_ref<void (mlir::detail::FloatAttrStorage*)>, mlir::TypeID, mlir::Type&, llvm::APFloat const&) | Storage *get(function_ref<void(Storage *)> initFn, TypeID id,
Args &&...args) {
// Construct a value of the derived key type.
auto derivedKey = getKey<Storage>(std::forward<Args>(args)...);
// Create a hash of the derived key.
unsigned hashValue = getHash<Storage>(derivedKey);
// Generate an equality function for the derived storage.
auto isEqual = [&derivedKey](const BaseStorage *existing) {
return static_cast<const Storage &>(*existing) == derivedKey;
};
// Generate a constructor function for the derived storage.
auto ctorFn = [&](StorageAllocator &allocator) {
auto *storage = Storage::construct(allocator, std::move(derivedKey));
if (initFn)
initFn(storage);
return storage;
};
// Get an instance for the derived storage.
return static_cast<Storage *>(
getParametricStorageTypeImpl(id, hashValue, isEqual, ctorFn));
} | subq $0xd8, %rsp
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc0(%rsp)
movq %rdi, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq %r9, 0xa8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xb0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x144660
leaq 0x80(%rsp), %rdi
callq 0x1446a0
movq %rax, 0x70(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x7b5a0
movl %eax, 0x7c(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0xc8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x68(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1446d0
leaq 0x30(%rsp), %rdi
leaq 0x58(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x144700
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %edx
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
leaq 0x30(%rsp), %rax
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x26b880
movq %rax, 0x28(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x144730
movq 0x28(%rsp), %rax
addq $0xd8, %rsp
retq
nopw (%rax,%rax)
| /mlir/Support/StorageUniquer.h |
mlir::AttrTypeSubElementHandler<std::tuple<llvm::ArrayRef<mlir::Attribute>>, void>::replace(std::tuple<llvm::ArrayRef<mlir::Attribute>> const&, mlir::AttrTypeSubElementReplacements<mlir::Attribute>&, mlir::AttrTypeSubElementReplacements<mlir::Type>&) | static auto replace(const std::tuple<Ts...> ¶m,
AttrSubElementReplacements &attrRepls,
TypeSubElementReplacements &typeRepls) {
return std::apply(
[&](const Ts &...params)
-> std::tuple<decltype(AttrTypeSubElementHandler<Ts>::replace(
params, attrRepls, typeRepls))...> {
return {AttrTypeSubElementHandler<Ts>::replace(params, attrRepls,
typeRepls)...};
},
param);
} | subq $0x38, %rsp
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0x14f470
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| /mlir/IR/AttrTypeSubElements.h |
llvm::FailureOr<mlir::detail::ElementsAttrRange<mlir::DenseElementsAttr::ElementIterator<std::complex<unsigned char>>>> mlir::DenseElementsAttr::tryGetValues<std::complex<unsigned char>, unsigned char, void>() const | FailureOr<iterator_range_impl<ElementIterator<T>>> tryGetValues() const {
if (!isValidComplex(sizeof(T), std::numeric_limits<ElementT>::is_integer,
std::numeric_limits<ElementT>::is_signed))
return failure();
const char *rawData = getRawData().data();
bool splat = isSplat();
return iterator_range_impl<ElementIterator<T>>(
getType(), ElementIterator<T>(rawData, splat, 0),
ElementIterator<T>(rawData, splat, getNumElements()));
} | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x40(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x100(%rsp)
movq 0x100(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x13b2d0
testb $0x1, %al
jne 0x1593d3
movl $0x1, %edi
callq 0x25040
movq 0x40(%rsp), %rdi
movb %al, 0xff(%rsp)
movzbl 0xff(%rsp), %esi
callq 0x1595d0
jmp 0x1594f8
movq 0x50(%rsp), %rdi
callq 0x139030
movq %rax, 0xe0(%rsp)
movq %rdx, 0xe8(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x48500
movq 0x50(%rsp), %rdi
movq %rax, 0xf0(%rsp)
callq 0x138f90
movq 0x50(%rsp), %rdi
andb $0x1, %al
movb %al, 0xdf(%rsp)
callq 0x13b530
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xf0(%rsp), %rsi
movb 0xdf(%rsp), %al
leaq 0x70(%rsp), %rdi
xorl %ecx, %ecx
andb $0x1, %al
movzbl %al, %edx
callq 0x1595f0
movq 0x50(%rsp), %rdi
movq 0xf0(%rsp), %rax
movq %rax, 0x30(%rsp)
movb 0xdf(%rsp), %al
movb %al, 0x3f(%rsp)
callq 0x13b560
movq 0x30(%rsp), %rsi
movq %rax, %rcx
movb 0x3f(%rsp), %al
leaq 0x58(%rsp), %rdi
andb $0x1, %al
movzbl %al, %edx
callq 0x1595f0
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rcx
leaq 0x58(%rsp), %rax
movq (%rcx), %r8
movq %r8, (%rsp)
movq 0x8(%rcx), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x159630
movq 0x40(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x159730
movq 0x48(%rsp), %rax
addq $0x108, %rsp # imm = 0x108
retq
nopw %cs:(%rax,%rax)
nop
| /mlir/IR/BuiltinAttributes.h |
llvm::CastInfo<mlir::StringAttr, mlir::StringAttr, void>::isPossible(mlir::Attribute) | static inline bool isPossible(mlir::Attribute ty) {
/// Return a constant true instead of a dynamic true when casting to self or
/// up the hierarchy.
if constexpr (std::is_base_of_v<To, From>) {
return true;
} else {
return To::classof(ty);
}
} | movq %rdi, -0x8(%rsp)
movb $0x1, %al
andb $0x1, %al
retq
nopw (%rax,%rax)
| /mlir/IR/Attributes.h |
llvm::detail::UniqueFunctionBase<llvm::LogicalResult, mlir::Operation*, llvm::ArrayRef<mlir::Attribute>, llvm::SmallVectorImpl<mlir::OpFoldResult>&>::UniqueFunctionBase<mlir::Op<mlir::ModuleOp, mlir::OpTrait::OneRegion, mlir::OpTrait::ZeroResults, mlir::OpTrait::ZeroSuccessors, mlir::OpTrait::ZeroOperands, mlir::OpTrait::NoRegionArguments, mlir::OpTrait::NoTerminator, mlir::OpTrait::SingleBlock, mlir::OpTrait::OpInvariants, mlir::BytecodeOpInterface::Trait, mlir::OpTrait::AffineScope, mlir::OpTrait::IsIsolatedFromAbove, mlir::OpTrait::SymbolTable, mlir::SymbolOpInterface::Trait, mlir::OpAsmOpInterface::Trait, mlir::RegionKindInterface::Trait, mlir::OpTrait::HasOnlyGraphRegion>::getFoldHookFn()::'lambda'(mlir::Operation*, llvm::ArrayRef<mlir::Attribute>, llvm::SmallVectorImpl<mlir::OpFoldResult>&), mlir::Op<mlir::ModuleOp, mlir::OpTrait::OneRegion, mlir::OpTrait::ZeroResults, mlir::OpTrait::ZeroSuccessors, mlir::OpTrait::ZeroOperands, mlir::OpTrait::NoRegionArguments, mlir::OpTrait::NoTerminator, mlir::OpTrait::SingleBlock, mlir::OpTrait::OpInvariants, mlir::BytecodeOpInterface::Trait, mlir::OpTrait::AffineScope, mlir::OpTrait::IsIsolatedFromAbove, mlir::OpTrait::SymbolTable, mlir::SymbolOpInterface::Trait, mlir::OpAsmOpInterface::Trait, mlir::RegionKindInterface::Trait, mlir::OpTrait::HasOnlyGraphRegion>::getFoldHookFn()::'lambda'(mlir::Operation*, llvm::ArrayRef<mlir::Attribute>, llvm::SmallVectorImpl<mlir::OpFoldResult>&) const>(mlir::Op<mlir::ModuleOp, mlir::OpTrait::OneRegion, mlir::OpTrait::ZeroResults, mlir::OpTrait::ZeroSuccessors, mlir::OpTrait::ZeroOperands, mlir::OpTrait::NoRegionArguments, mlir::OpTrait::NoTerminator, mlir::OpTrait::SingleBlock, mlir::OpTrait::OpInvariants, mlir::BytecodeOpInterface::Trait, mlir::OpTrait::AffineScope, mlir::OpTrait::IsIsolatedFromAbove, mlir::OpTrait::SymbolTable, mlir::SymbolOpInterface::Trait, mlir::OpAsmOpInterface::Trait, mlir::RegionKindInterface::Trait, mlir::OpTrait::HasOnlyGraphRegion>::getFoldHookFn()::'lambda'(mlir::Operation*, llvm::ArrayRef<mlir::Attribute>, llvm::SmallVectorImpl<mlir::OpFoldResult>&), llvm::detail::UniqueFunctionBase<llvm::LogicalResult, mlir::Operation*, llvm::ArrayRef<mlir::Attribute>, llvm::SmallVectorImpl<mlir::OpFoldResult>&>::CalledAs<mlir::Op<mlir::ModuleOp, mlir::OpTrait::OneRegion, mlir::OpTrait::ZeroResults, mlir::OpTrait::ZeroSuccessors, mlir::OpTrait::ZeroOperands, mlir::OpTrait::NoRegionArguments, mlir::OpTrait::NoTerminator, mlir::OpTrait::SingleBlock, mlir::OpTrait::OpInvariants, mlir::BytecodeOpInterface::Trait, mlir::OpTrait::AffineScope, mlir::OpTrait::IsIsolatedFromAbove, mlir::OpTrait::SymbolTable, mlir::SymbolOpInterface::Trait, mlir::OpAsmOpInterface::Trait, mlir::RegionKindInterface::Trait, mlir::OpTrait::HasOnlyGraphRegion>::getFoldHookFn()::'lambda'(mlir::Operation*, llvm::ArrayRef<mlir::Attribute>, llvm::SmallVectorImpl<mlir::OpFoldResult>&) const>) | UniqueFunctionBase(CallableT Callable, CalledAs<CalledAsT>) {
bool IsInlineStorage = true;
void *CallableAddr = getInlineStorage();
if (sizeof(CallableT) > InlineStorageSize ||
alignof(CallableT) > alignof(decltype(StorageUnion.InlineStorage))) {
IsInlineStorage = false;
// Allocate out-of-line storage. FIXME: Use an explicit alignment
// parameter in C++17 mode.
auto Size = sizeof(CallableT);
auto Alignment = alignof(CallableT);
CallableAddr = allocate_buffer(Size, Alignment);
setOutOfLineStorage(CallableAddr, Size, Alignment);
}
// Now move into the storage.
new (CallableAddr) CallableT(std::move(Callable));
CallbackAndInlineFlag.setPointerAndInt(
&CallbacksHolder<CallableT, CalledAsT>::Callbacks, IsInlineStorage);
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
callq 0x1bf350
movq (%rsp), %rdi
movb $0x1, 0x27(%rsp)
callq 0x1bf370
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rsp)
addq $0x18, %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x24640e(%rip), %rsi # 0x405738
callq 0x1bf3e0
movq 0x8(%rsp), %rdi
movb 0x27(%rsp), %al
movq 0x10(%rsp), %rsi
andb $0x1, %al
movzbl %al, %edx
callq 0x1bf380
addq $0x38, %rsp
retq
nopl (%rax)
| /llvm/ADT/FunctionExtras.h |
llvm::StringRef llvm::getTypeName<mlir::BytecodeOpInterface::Trait<mlir::TypeID mlir::TypeID::get<mlir::BytecodeOpInterface::Trait>()::Empty>>() | inline StringRef getTypeName() {
#if defined(__clang__) || defined(__GNUC__)
StringRef Name = __PRETTY_FUNCTION__;
StringRef Key = "DesiredTypeName = ";
Name = Name.substr(Name.find(Key));
assert(!Name.empty() && "Unable to find the template parameter!");
Name = Name.drop_front(Key.size());
assert(Name.ends_with("]") && "Name doesn't end in the substitution key!");
return Name.drop_back(1);
#elif defined(_MSC_VER)
StringRef Name = __FUNCSIG__;
StringRef Key = "getTypeName<";
Name = Name.substr(Name.find(Key));
assert(!Name.empty() && "Unable to find the function name!");
Name = Name.drop_front(Key.size());
for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
if (Name.starts_with(Prefix)) {
Name = Name.drop_front(Prefix.size());
break;
}
auto AnglePos = Name.rfind('>');
assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
return Name.substr(0, AnglePos);
#else
// No known technique for statically extracting a type name on this compiler.
// We return a string that is unlikely to look like any type in LLVM.
return "UNKNOWN_TYPE";
#endif
} | subq $0x78, %rsp
leaq 0x119b69(%rip), %rsi # 0x2db214
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x17080
leaq 0x117890(%rip), %rsi # 0x2d8f51
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x17080
movq 0x8(%rsp), %rdi
movups 0x40(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x796b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq $-0x1, %rdx
callq 0x1cd50
movq (%rsp), %rdi
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movups 0x30(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
callq 0x188c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1ccd0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movups 0x10(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
movl $0x1, %esi
callq 0x1cde0
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
nopl (%rax,%rax)
| /llvm/Support/TypeName.h |
void mlir::detail::walkImmediateSubElementsImpl<mlir::Float8E5M2Type>(mlir::Float8E5M2Type, llvm::function_ref<void (mlir::Attribute)>, llvm::function_ref<void (mlir::Type)>) | void walkImmediateSubElementsImpl(T derived,
function_ref<void(Attribute)> walkAttrsFn,
function_ref<void(Type)> walkTypesFn) {
using ImplT = typename T::ImplType;
(void)derived;
(void)walkAttrsFn;
(void)walkTypesFn;
if constexpr (llvm::is_detected<has_get_as_key, ImplT>::value) {
auto key = static_cast<ImplT *>(derived.getImpl())->getAsKey();
// If we don't have any sub-elements, there is nothing to do.
if constexpr (!has_sub_attr_or_type_v<decltype(key)>)
return;
AttrTypeImmediateSubElementWalker walker(walkAttrsFn, walkTypesFn);
AttrTypeSubElementHandler<decltype(key)>::walk(key, walker);
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x20(%rsp)
retq
nopw (%rax,%rax)
| /mlir/IR/AttrTypeSubElements.h |
mlir::OperationName::Impl::Impl(mlir::StringAttr, mlir::Dialect*, mlir::TypeID, mlir::detail::InterfaceMap) | Impl(StringAttr name, Dialect *dialect, TypeID typeID,
detail::InterfaceMap interfaceMap)
: name(name), typeID(typeID), dialect(dialect),
interfaceMap(std::move(interfaceMap)) {} | subq $0x38, %rsp
movq %r8, (%rsp)
movq %rsi, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x225e40
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
leaq 0x1e1028(%rip), %rax # 0x401a88
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rdi)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rdi)
movq 0x18(%rsp), %rax
movq %rax, 0x18(%rdi)
addq $0x20, %rdi
callq 0x14df80
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x1004d0
addq $0x38, %rsp
retq
nop
| /mlir/IR/OperationSupport.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::StringRef, llvm::SmallVector<mlir::detail::StringAttrStorage*, 6u>, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::SmallVector<mlir::detail::StringAttrStorage*, 6u>>>, llvm::StringRef, llvm::SmallVector<mlir::detail::StringAttrStorage*, 6u>, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::SmallVector<mlir::detail::StringAttrStorage*, 6u>>>::getMinBucketToReserveForEntries(unsigned int) | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + 1);
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x223d4e
movl $0x0, 0x14(%rsp)
jmp 0x223d6e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x57970
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::StringRef, llvm::SmallVector<mlir::detail::StringAttrStorage*, 6u>, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::SmallVector<mlir::detail::StringAttrStorage*, 6u>>>, llvm::StringRef, llvm::SmallVector<mlir::detail::StringAttrStorage*, 6u>, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::SmallVector<mlir::detail::StringAttrStorage*, 6u>>>::initEmpty() | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst()) KeyT(EmptyKey);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0x223e80
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x223ea0
callq 0x223ec0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
callq 0x223ef0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x223f00
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x223e7a
movq 0x18(%rsp), %rdi
callq 0x223f40
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x18(%rsp)
jmp 0x223e43
addq $0x38, %rsp
retq
nop
| /llvm/ADT/DenseMap.h |
mlir::ThreadLocalCache<llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>>::get() | ValueT &get() {
// Check for an already existing instance for this thread.
CacheType &staticCache = getStaticCache();
Observer &threadInstance = staticCache[perInstanceState.get()];
if (ValueT *value = *threadInstance.ptr)
return *value;
// Otherwise, create a new instance for this thread.
{
llvm::sys::SmartScopedLock<true> threadInstanceLock(
perInstanceState->instanceMutex);
perInstanceState->instances.emplace_back(threadInstance);
}
threadInstance.keepalive = perInstanceState;
// Before returning the new instance, take the chance to clear out any used
// entries in the static map. The cache is only cleared within the same
// thread to remove the need to lock the cache itself.
staticCache.clearExpiredEntries();
return **threadInstance.ptr;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
callq 0x226510
movq (%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x2265b0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x226580
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x224a70
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x22643e
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x2264a6
movq (%rsp), %rdi
callq 0x2265c0
movq %rax, %rsi
addq $0x28, %rsi
leaq 0x10(%rsp), %rdi
callq 0x77230
movq (%rsp), %rdi
callq 0x2265c0
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x2265d0
leaq 0x10(%rsp), %rdi
callq 0x77260
movq (%rsp), %rsi
movq 0x28(%rsp), %rdi
addq $0x10, %rdi
callq 0x226670
movq 0x30(%rsp), %rdi
callq 0x2266a0
movq 0x28(%rsp), %rdi
callq 0x224a70
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
| /mlir/Support/ThreadLocalCache.h |
llvm::DenseMapIterator<mlir::TypeID, mlir::AbstractType*, llvm::DenseMapInfo<mlir::TypeID, void>, llvm::detail::DenseMapPair<mlir::TypeID, mlir::AbstractType*>, false>::DenseMapIterator(llvm::detail::DenseMapPair<mlir::TypeID, mlir::AbstractType*>*, llvm::detail::DenseMapPair<mlir::TypeID, mlir::AbstractType*>*, llvm::DebugEpochBase const&, bool) | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEmptyBuckets();
return;
}
AdvancePastEmptyBuckets();
} | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x4ff00
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
testb $0x1, 0x17(%rsp)
je 0x22b4d4
jmp 0x22b4f5
callq 0xefc20
testb $0x1, %al
jne 0x22b4df
jmp 0x22b4eb
movq 0x8(%rsp), %rdi
callq 0x22b500
jmp 0x22b4f5
movq 0x8(%rsp), %rdi
callq 0x22b5e0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<mlir::TypeID, mlir::AbstractAttribute*, llvm::DenseMapInfo<mlir::TypeID, void>, llvm::detail::DenseMapPair<mlir::TypeID, mlir::AbstractAttribute*>>, mlir::TypeID, mlir::AbstractAttribute*, llvm::DenseMapInfo<mlir::TypeID, void>, llvm::detail::DenseMapPair<mlir::TypeID, mlir::AbstractAttribute*>>::makeIterator(llvm::detail::DenseMapPair<mlir::TypeID, mlir::AbstractAttribute*>*, llvm::detail::DenseMapPair<mlir::TypeID, mlir::AbstractAttribute*>*, llvm::DebugEpochBase&, bool) | iterator makeIterator(BucketT *P, BucketT *E,
DebugEpochBase &Epoch,
bool NoAdvance=false) {
if (shouldReverseIterate<KeyT>()) {
BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
return iterator(B, E, Epoch, NoAdvance);
}
return iterator(P, E, Epoch, NoAdvance);
} | subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xefc20
testb $0x1, %al
jne 0x22b736
jmp 0x22b7a2
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x223900
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jne 0x22b767
movq 0x10(%rsp), %rdi
callq 0x2238f0
movq %rax, (%rsp)
jmp 0x22b774
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movb 0x27(%rsp), %al
leaq 0x48(%rsp), %rdi
andb $0x1, %al
movzbl %al, %r8d
callq 0x22b800
jmp 0x22b7c5
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movb 0x27(%rsp), %al
leaq 0x48(%rsp), %rdi
andb $0x1, %al
movzbl %al, %r8d
callq 0x22b800
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/ADT/DenseMap.h |
mlir::detail::IntegerSetStorage::construct(mlir::StorageUniquer::StorageAllocator&, std::tuple<unsigned int, unsigned int, llvm::ArrayRef<mlir::AffineExpr>, llvm::ArrayRef<bool>> const&) | static IntegerSetStorage *
construct(StorageUniquer::StorageAllocator &allocator, const KeyTy &key) {
auto *res =
new (allocator.allocate<IntegerSetStorage>()) IntegerSetStorage();
res->dimCount = std::get<0>(key);
res->symbolCount = std::get<1>(key);
res->constraints = allocator.copyInto(std::get<2>(key));
res->eqFlags = allocator.copyInto(std::get<3>(key));
return res;
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x2372c0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x163c0
movq 0x8(%rsp), %rdi
callq 0x2372e0
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x236cd0
movl (%rax), %ecx
movq 0x60(%rsp), %rax
movl %ecx, (%rax)
movq 0x68(%rsp), %rdi
callq 0x236d50
movl (%rax), %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
callq 0x236df0
movq 0x10(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x237310
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x58(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
callq 0x236ee0
movq 0x18(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x1e8cc0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x60(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /IR/IntegerSetDetail.h |
llvm::DenseMap<std::pair<void const*, int>, mlir::WalkResult, llvm::DenseMapInfo<std::pair<void const*, int>, void>, llvm::detail::DenseMapPair<std::pair<void const*, int>, mlir::WalkResult>>::allocateBuckets(unsigned int) | bool allocateBuckets(unsigned Num) {
NumBuckets = Num;
if (NumBuckets == 0) {
Buckets = nullptr;
return false;
}
Buckets = static_cast<BucketT *>(
allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x242817
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x24283d
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
imulq $0x18, %rax, %rdi
movl $0x8, %esi
callq 0x72fd0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::PointerIntPairInfo<void*, 1u, llvm::pointer_union_detail::PointerUnionUIntTraits<mlir::Operation*, mlir::Region*>>::updatePointer(long, void*) | static intptr_t updatePointer(intptr_t OrigValue, PointerT Ptr) {
intptr_t PtrWord =
reinterpret_cast<intptr_t>(PtrTraits::getAsVoidPointer(Ptr));
assert((PtrWord & ~PointerBitMask) == 0 &&
"Pointer is not sufficiently aligned");
// Preserve all low bits, just update the pointer.
return PtrWord | (OrigValue & ~PointerBitMask);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x245180
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
andq $0x7, %rcx
orq %rcx, %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /llvm/ADT/PointerIntPair.h |
llvm::detail::DenseMapPair<mlir::TypeID, std::unique_ptr<(anonymous namespace)::ParametricStorageUniquer, std::default_delete<(anonymous namespace)::ParametricStorageUniquer>>>* llvm::DenseMapBase<llvm::DenseMap<mlir::TypeID, std::unique_ptr<(anonymous namespace)::ParametricStorageUniquer, std::default_delete<(anonymous namespace)::ParametricStorageUniquer>>, llvm::DenseMapInfo<mlir::TypeID, void>, llvm::detail::DenseMapPair<mlir::TypeID, std::unique_ptr<(anonymous namespace)::ParametricStorageUniquer, std::default_delete<(anonymous namespace)::ParametricStorageUniquer>>>>, mlir::TypeID, std::unique_ptr<(anonymous namespace)::ParametricStorageUniquer, std::default_delete<(anonymous namespace)::ParametricStorageUniquer>>, llvm::DenseMapInfo<mlir::TypeID, void>, llvm::detail::DenseMapPair<mlir::TypeID, std::unique_ptr<(anonymous namespace)::ParametricStorageUniquer, std::default_delete<(anonymous namespace)::ParametricStorageUniquer>>>>::InsertIntoBucketImpl<mlir::TypeID>(mlir::TypeID const&, mlir::TypeID const&, llvm::detail::DenseMapPair<mlir::TypeID, std::unique_ptr<(anonymous namespace)::ParametricStorageUniquer, std::default_delete<(anonymous namespace)::ParametricStorageUniquer>>>*) | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x51ec0
movq 0x10(%rsp), %rdi
callq 0x26dbd0
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x34(%rsp)
callq 0x26d0e0
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %eax
shll $0x2, %eax
imull $0x3, 0x30(%rsp), %ecx
cmpl %ecx, %eax
jb 0x26dada
movq 0x10(%rsp), %rdi
movl 0x30(%rsp), %esi
shll %esi
callq 0x26dbe0
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x26d740
movq 0x10(%rsp), %rdi
callq 0x26d0e0
movl %eax, 0x30(%rsp)
jmp 0x26db31
movq 0x10(%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x8(%rsp)
callq 0x26dc00
movl 0x8(%rsp), %ecx
movl %eax, %edx
movl 0xc(%rsp), %eax
addl %edx, %ecx
subl %ecx, %eax
movl 0x30(%rsp), %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
ja 0x26db2f
movq 0x10(%rsp), %rdi
movl 0x30(%rsp), %esi
callq 0x26dbe0
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x26d740
jmp 0x26db31
movq 0x10(%rsp), %rdi
callq 0x26dc10
callq 0x26d020
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x26d080
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xefee0
testb $0x1, %al
jne 0x26db7e
movq 0x10(%rsp), %rdi
callq 0x26dc40
movq 0x38(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<mlir::ThreadLocalCache<llvm::DenseSet<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo>>::PerInstanceState*, mlir::ThreadLocalCache<llvm::DenseSet<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo>>::Observer, 4u, llvm::DenseMapInfo<mlir::ThreadLocalCache<llvm::DenseSet<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo>>::PerInstanceState*, void>, llvm::detail::DenseMapPair<mlir::ThreadLocalCache<llvm::DenseSet<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo>>::PerInstanceState*, mlir::ThreadLocalCache<llvm::DenseSet<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo>>::Observer>>, mlir::ThreadLocalCache<llvm::DenseSet<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo>>::PerInstanceState*, mlir::ThreadLocalCache<llvm::DenseSet<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo>>::Observer, llvm::DenseMapInfo<mlir::ThreadLocalCache<llvm::DenseSet<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo>>::PerInstanceState*, void>, llvm::detail::DenseMapPair<mlir::ThreadLocalCache<llvm::DenseSet<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo>>::PerInstanceState*, mlir::ThreadLocalCache<llvm::DenseSet<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo>>::Observer>>::destroyAll() | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->getFirst(), TombstoneKey))
P->getSecond().~ValueT();
P->getFirst().~KeyT();
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x26fa80
cmpl $0x0, %eax
jne 0x270fd2
jmp 0x271072
callq 0x26f930
movq %rax, 0x28(%rsp)
callq 0x2710e0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x26f940
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x26f950
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x271072
movq 0x18(%rsp), %rdi
callq 0x26f990
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x270140
testb $0x1, %al
jne 0x271058
movq 0x18(%rsp), %rdi
callq 0x26f990
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x270140
testb $0x1, %al
jne 0x271058
movq 0x18(%rsp), %rdi
callq 0x2710f0
movq %rax, %rdi
callq 0x271100
movq 0x18(%rsp), %rdi
callq 0x26f990
movq 0x18(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x18(%rsp)
jmp 0x271004
addq $0x38, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMap<(anonymous namespace)::ParametricStorageUniquer::HashedStorage, llvm::detail::DenseSetEmpty, (anonymous namespace)::ParametricStorageUniquer::StorageKeyInfo, llvm::detail::DenseSetPair<(anonymous namespace)::ParametricStorageUniquer::HashedStorage>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rax), %ecx
movl %ecx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x40, 0xc(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x57970
movl %eax, 0x8(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x58950
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x26ee80
cmpq $0x0, 0x10(%rsp)
jne 0x273a3e
movq (%rsp), %rdi
callq 0x26eef0
jmp 0x273a75
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0x18(%rsp), %eax
shlq $0x4, %rax
addq %rax, %rdx
callq 0x273a80
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x73000
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::StringRef, mlir::TypeID, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, mlir::TypeID>>::allocateBuckets(unsigned int) | bool allocateBuckets(unsigned Num) {
NumBuckets = Num;
if (NumBuckets == 0) {
Buckets = nullptr;
return false;
}
Buckets = static_cast<BucketT *>(
allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x27b337
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x27b35d
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
imulq $0x18, %rax, %rdi
movl $0x8, %esi
callq 0x72fd0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::StringRef, mlir::TypeID, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, mlir::TypeID>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rax), %ecx
movl %ecx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x40, 0xc(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x57970
movl %eax, 0x8(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x58950
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x27b300
cmpq $0x0, 0x10(%rsp)
jne 0x27c46e
movq (%rsp), %rdi
callq 0x27b370
jmp 0x27c4a3
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0x18(%rsp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdx
callq 0x27c4b0
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
imulq $0x18, %rax, %rsi
movl $0x8, %edx
callq 0x73000
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/DenseMap.h |
mlir::Token::isCodeCompletionFor(mlir::Token::Kind) const | bool Token::isCodeCompletionFor(Kind kind) const {
if (!isCodeCompletion() || spelling.empty())
return false;
switch (kind) {
case Kind::string:
return spelling[0] == '"';
case Kind::hash_identifier:
return spelling[0] == '#';
case Kind::percent_identifier:
return spelling[0] == '%';
case Kind::caret_identifier:
return spelling[0] == '^';
case Kind::exclamation_identifier:
return spelling[0] == '!';
default:
return false;
}
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x27cec0
testb $0x1, %al
jne 0x28a962
jmp 0x28a976
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x1d540
testb $0x1, %al
jne 0x28a976
jmp 0x28a980
movb $0x0, 0x27(%rsp)
jmp 0x28aa61
movl 0x14(%rsp), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x6, %eax
ja 0x28aa5c
movq (%rsp), %rax
leaq 0x542ef(%rip), %rcx # 0x2dec90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36360
movsbl %al, %eax
cmpl $0x22, %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x28aa61
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36360
movsbl %al, %eax
cmpl $0x23, %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x28aa61
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36360
movsbl %al, %eax
cmpl $0x25, %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x28aa61
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36360
movsbl %al, %eax
cmpl $0x5e, %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x28aa61
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36360
movsbl %al, %eax
cmpl $0x21, %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x28aa61
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
| /AsmParser/Token.cpp |
mlir::detail::Parser::parseFunctionType() | Type Parser::parseFunctionType() {
assert(getToken().is(Token::l_paren));
SmallVector<Type, 4> arguments, results;
if (parseTypeListParens(arguments) ||
parseToken(Token::arrow, "expected '->' in function type") ||
parseFunctionResultTypes(results))
return nullptr;
return builder.getFunctionType(arguments, results);
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x23af60
leaq 0x78(%rsp), %rdi
callq 0x23af60
movq 0x8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x28b610
movb %al, 0x77(%rsp)
leaq 0x77(%rsp), %rdi
callq 0x1396f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x28ae41
leaq 0x48(%rsp), %rdi
leaq 0x54162(%rip), %rsi # 0x2def4e
callq 0x482d0
movq 0x8(%rsp), %rdi
movl $0xd, %esi
leaq 0x48(%rsp), %rdx
callq 0x286f70
movb %al, 0x76(%rsp)
leaq 0x76(%rsp), %rdi
callq 0x1396f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x28ae41
movq 0x8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x28b540
movb %al, 0x47(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x1396f0
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x28ae4b
jmp 0x28ae66
leaq 0xe0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xeca70
movl $0x1, 0x40(%rsp)
jmp 0x28aebf
leaq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x238e00
leaq 0x18(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x238e00
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x132e90
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0xe0(%rsp)
movl $0x1, 0x40(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x238ae0
leaq 0xa8(%rsp), %rdi
callq 0x238ae0
movq 0xe0(%rsp), %rax
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
| /AsmParser/TypeParser.cpp |
mlir::detail::Parser::parseTupleType() | Type Parser::parseTupleType() {
consumeToken(Token::kw_tuple);
// Parse the '<'.
if (parseToken(Token::less, "expected '<' in tuple type"))
return nullptr;
// Check for an empty tuple by directly parsing '>'.
if (consumeIf(Token::greater))
return TupleType::get(getContext());
// Parse the element types and the '>'.
SmallVector<Type, 4> types;
if (parseTypeListNoParens(types) ||
parseToken(Token::greater, "expected '>' in tuple type"))
return nullptr;
return TupleType::get(getContext(), types);
} | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq 0xd8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x4c, %esi
callq 0x27ed30
leaq 0xa8(%rsp), %rdi
leaq 0x526a5(%rip), %rsi # 0x2df05a
callq 0x482d0
movq 0x18(%rsp), %rdi
movl $0x17, %esi
leaq 0xa8(%rsp), %rdx
callq 0x286f70
movb %al, 0xd7(%rsp)
leaq 0xd7(%rsp), %rdi
callq 0x1396f0
testb $0x1, %al
jne 0x28c9eb
jmp 0x28ca01
leaq 0xe0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xeca70
jmp 0x28cb2b
movq 0x18(%rsp), %rdi
movl $0x13, %esi
callq 0x27ec10
testb $0x1, %al
jne 0x28ca16
jmp 0x28ca45
movq 0x18(%rsp), %rdi
callq 0x27d0d0
movq %rax, %rdi
callq 0x1df6f0
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0x28cb2b
leaq 0x70(%rsp), %rdi
callq 0x23af60
movq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x28b7a0
movb %al, 0x6f(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0x1396f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x28cab0
leaq 0x40(%rsp), %rdi
leaq 0x525f0(%rip), %rsi # 0x2df075
callq 0x482d0
movq 0x18(%rsp), %rdi
movl $0x13, %esi
leaq 0x40(%rsp), %rdx
callq 0x286f70
movb %al, 0x6e(%rsp)
leaq 0x6e(%rsp), %rdi
callq 0x1396f0
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x28caba
jmp 0x28cad5
leaq 0xe0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xeca70
movl $0x1, 0x3c(%rsp)
jmp 0x28cb21
movq 0x18(%rsp), %rdi
callq 0x27d0d0
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x238e00
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x1df680
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0xe0(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x238ae0
movq 0xe0(%rsp), %rax
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
| /AsmParser/TypeParser.cpp |
llvm::StdThreadPool::~StdThreadPool() | StdThreadPool::~StdThreadPool() {
{
std::unique_lock<std::mutex> LockGuard(QueueLock);
EnableFlag = false;
}
QueueCondition.notify_all();
llvm::sys::ScopedReader LockGuard(ThreadsLock);
for (auto &Worker : Threads)
Worker.join();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2a7c40
movq 0x8(%rsp), %rdi
movl $0x168, %esi # imm = 0x168
callq 0x16160
addq $0x18, %rsp
retq
nopl (%rax)
| /Support/ThreadPool.cpp |
nch | static int
nch(struct parse *p, cset *cs)
{
size_t i;
size_t css = (size_t)p->g->csetsize;
int n = 0;
for (i = 0; i < css; i++)
if (CHIN(cs, i))
n++;
return(n);
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x2afc9a
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
movzbl %cl, %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rsp), %rcx
movzbl 0x8(%rcx), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2afc88
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x2afc8a
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x2afc4d
movl -0x24(%rsp), %eax
retq
nop
| /Support/regcomp.c |
llvm::itanium_demangle::OutputBuffer::grow(unsigned long) | void grow(size_t N) {
size_t Need = N + CurrentPosition;
if (Need > BufferCapacity) {
// Reduce the number of reallocations, with a bit of hysteresis. The
// number here is chosen so the first allocation will more-than-likely not
// allocate more than 1K.
Need += 1024 - 32;
BufferCapacity *= 2;
if (BufferCapacity < Need)
BufferCapacity = Need;
Buffer = static_cast<char *>(std::realloc(Buffer, BufferCapacity));
if (Buffer == nullptr)
std::abort();
}
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
addq 0x8(%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x10(%rcx), %rax
jbe 0x2b8054
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq $0x3e0, %rcx # imm = 0x3E0
movq %rcx, 0x10(%rsp)
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rax
cmpq 0x10(%rsp), %rax
jae 0x2b802b
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x16110
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x2b8052
callq 0x16820
jmp 0x2b8054
addq $0x28, %rsp
retq
nopl (%rax)
| /llvm/Demangle/Utility.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseUnresolvedName(bool) | Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedName(bool Global) {
Node *SoFar = nullptr;
// srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
// srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
if (consumeIf("srN")) {
SoFar = getDerived().parseUnresolvedType();
if (SoFar == nullptr)
return nullptr;
if (look() == 'I') {
Node *TA = getDerived().parseTemplateArgs();
if (TA == nullptr)
return nullptr;
SoFar = make<NameWithTemplateArgs>(SoFar, TA);
if (!SoFar)
return nullptr;
}
while (!consumeIf('E')) {
Node *Qual = getDerived().parseSimpleId();
if (Qual == nullptr)
return nullptr;
SoFar = make<QualifiedName>(SoFar, Qual);
if (!SoFar)
return nullptr;
}
Node *Base = getDerived().parseBaseUnresolvedName();
if (Base == nullptr)
return nullptr;
return make<QualifiedName>(SoFar, Base);
}
// [gs] <base-unresolved-name> # x or (with "gs") ::x
if (!consumeIf("sr")) {
SoFar = getDerived().parseBaseUnresolvedName();
if (SoFar == nullptr)
return nullptr;
if (Global)
SoFar = make<GlobalQualifiedName>(SoFar);
return SoFar;
}
// [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
if (std::isdigit(look())) {
do {
Node *Qual = getDerived().parseSimpleId();
if (Qual == nullptr)
return nullptr;
if (SoFar)
SoFar = make<QualifiedName>(SoFar, Qual);
else if (Global)
SoFar = make<GlobalQualifiedName>(Qual);
else
SoFar = Qual;
if (!SoFar)
return nullptr;
} while (!consumeIf('E'));
}
// sr <unresolved-type> <base-unresolved-name>
// sr <unresolved-type> <template-args> <base-unresolved-name>
else {
SoFar = getDerived().parseUnresolvedType();
if (SoFar == nullptr)
return nullptr;
if (look() == 'I') {
Node *TA = getDerived().parseTemplateArgs();
if (TA == nullptr)
return nullptr;
SoFar = make<NameWithTemplateArgs>(SoFar, TA);
if (!SoFar)
return nullptr;
}
}
DEMANGLE_ASSERT(SoFar != nullptr, "");
Node *Base = getDerived().parseBaseUnresolvedName();
if (Base == nullptr)
return nullptr;
return make<QualifiedName>(SoFar, Base);
} | subq $0x78, %rsp
movb %sil, %al
movq %rdi, 0x68(%rsp)
andb $0x1, %al
movb %al, 0x67(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x58(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x1f844(%rip), %rsi # 0x2e1c24
callq 0xb17e0
movq (%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x2b8400
testb $0x1, %al
jne 0x2c2401
jmp 0x2c255b
movq (%rsp), %rdi
callq 0x2b84a0
movq %rax, %rdi
callq 0x2c9ee0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x2c242d
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x2b8a00
movsbl %al, %eax
cmpl $0x49, %eax
jne 0x2c249e
movq (%rsp), %rdi
callq 0x2b84a0
movq %rax, %rdi
xorl %esi, %esi
callq 0x2bd640
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x2c246e
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
movq (%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x2bd8b0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x2c249c
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
jmp 0x2c249e
jmp 0x2c24a0
movq (%rsp), %rdi
movl $0x45, %esi
callq 0x2b8ab0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2c24b6
jmp 0x2c2512
movq (%rsp), %rdi
callq 0x2b84a0
movq %rax, %rdi
callq 0x2c9fd0
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x2c24e2
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
movq (%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x2ca080
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x2c2510
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
jmp 0x2c24a0
movq (%rsp), %rdi
callq 0x2b84a0
movq %rax, %rdi
callq 0x2ca0c0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x2c253e
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
movq (%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x2ca080
movq %rax, 0x70(%rsp)
jmp 0x2c277b
leaq 0x20(%rsp), %rdi
leaq 0x1f6c1(%rip), %rsi # 0x2e1c28
callq 0xb17e0
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x2b8400
testb $0x1, %al
jne 0x2c25d8
movq (%rsp), %rdi
callq 0x2b84a0
movq %rax, %rdi
callq 0x2ca0c0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x2c25af
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
testb $0x1, 0x67(%rsp)
je 0x2c25c9
movq (%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2ca210
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x2c277b
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x2b8a00
movsbl %al, %edi
callq 0x16510
cmpl $0x0, %eax
je 0x2c26a1
jmp 0x2c25f6
movq (%rsp), %rdi
callq 0x2b84a0
movq %rax, %rdi
callq 0x2c9fd0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2c2622
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
cmpq $0x0, 0x58(%rsp)
je 0x2c2644
movq (%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x2ca080
movq %rax, 0x58(%rsp)
jmp 0x2c266c
testb $0x1, 0x67(%rsp)
je 0x2c2660
movq (%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2ca210
movq %rax, 0x58(%rsp)
jmp 0x2c266a
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
jmp 0x2c266c
cmpq $0x0, 0x58(%rsp)
jne 0x2c2682
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
jmp 0x2c2684
movq (%rsp), %rdi
movl $0x45, %esi
callq 0x2b8ab0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2c25f6
jmp 0x2c273a
movq (%rsp), %rdi
callq 0x2b84a0
movq %rax, %rdi
callq 0x2c9ee0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x2c26cd
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x2b8a00
movsbl %al, %eax
cmpl $0x49, %eax
jne 0x2c2738
movq (%rsp), %rdi
callq 0x2b84a0
movq %rax, %rdi
xorl %esi, %esi
callq 0x2bd640
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2c270b
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
movq (%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x2bd8b0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x2c2736
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
jmp 0x2c2738
jmp 0x2c273a
movq (%rsp), %rdi
callq 0x2b84a0
movq %rax, %rdi
callq 0x2ca0c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2c2763
movq $0x0, 0x70(%rsp)
jmp 0x2c277b
movq (%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x2ca080
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::ConversionExpr::printLeft(llvm::itanium_demangle::OutputBuffer&) const | void printLeft(OutputBuffer &OB) const override {
OB.printOpen();
Type->print(OB);
OB.printClose();
OB.printOpen();
Expressions.printWithComma(OB);
OB.printClose();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x2b83a0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x2b7a90
movq 0x8(%rsp), %rdi
movl $0x29, %esi
callq 0x2b83d0
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x2b83a0
movq (%rsp), %rdi
addq $0x18, %rdi
movq 0x8(%rsp), %rsi
callq 0x2b7c00
movq 0x8(%rsp), %rdi
movl $0x29, %esi
callq 0x2b83d0
addq $0x18, %rsp
retq
nopl (%rax)
| /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseFloatingLiteral<long double>() | Node *AbstractManglingParser<Alloc, Derived>::parseFloatingLiteral() {
const size_t N = FloatData<Float>::mangled_size;
if (numLeft() <= N)
return nullptr;
std::string_view Data(First, N);
for (char C : Data)
if (!(C >= '0' && C <= '9') && !(C >= 'a' && C <= 'f'))
return nullptr;
First += N;
if (!consumeIf('E'))
return nullptr;
return make<FloatLiteralImpl<Float>>(Data);
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x14, 0x40(%rsp)
callq 0x2b8a90
cmpq $0x14, %rax
ja 0x2c4705
movq $0x0, 0x50(%rsp)
jmp 0x2c47dc
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x30(%rsp), %rdi
movl $0x14, %edx
callq 0x52530
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2b82c0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2c52d0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x2c47a0
movq 0x20(%rsp), %rax
movb (%rax), %al
movb %al, 0x17(%rsp)
movsbl 0x17(%rsp), %eax
cmpl $0x30, %eax
jl 0x2c476f
movsbl 0x17(%rsp), %eax
cmpl $0x39, %eax
jle 0x2c478e
movsbl 0x17(%rsp), %eax
cmpl $0x61, %eax
jl 0x2c4783
movsbl 0x17(%rsp), %eax
cmpl $0x66, %eax
jle 0x2c478e
movq $0x0, 0x50(%rsp)
jmp 0x2c47dc
jmp 0x2c4790
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2c4744
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
addq $0x14, %rax
movq %rax, (%rdi)
movl $0x45, %esi
callq 0x2b8ab0
testb $0x1, %al
jne 0x2c47c8
movq $0x0, 0x50(%rsp)
jmp 0x2c47dc
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2c58b0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseBareSourceName() | std::string_view AbstractManglingParser<Alloc, Derived>::parseBareSourceName() {
size_t Int = 0;
if (parsePositiveInteger(&Int) || numLeft() < Int)
return {};
std::string_view R(First, Int);
First += Int;
return R;
} | subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x2bc930
testb $0x1, %al
jne 0x2cb339
movq (%rsp), %rdi
callq 0x2b8a90
cmpq 0x8(%rsp), %rax
jae 0x2cb345
leaq 0x18(%rsp), %rdi
callq 0x2bc280
jmp 0x2cb36a
movq (%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0x52530
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nopl (%rax)
| /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::PointerType::printRight(llvm::itanium_demangle::OutputBuffer&) const | void printRight(OutputBuffer &OB) const override {
if (Pointee->getKind() != KObjCProtoName ||
!static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
OB += ")";
Pointee->printRight(OB);
}
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rdi
callq 0x2b7b50
movzbl %al, %eax
cmpl $0xb, %eax
jne 0x2d1d49
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2d1e00
testb $0x1, %al
jne 0x2d1daf
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x2bea20
testb $0x1, %al
jne 0x2d1d77
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x2bea90
testb $0x1, %al
jne 0x2d1d77
jmp 0x2d1d9c
leaq 0x8(%rsp), %rdi
leaq 0x4b47(%rip), %rsi # 0x2d68ca
callq 0xb17e0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2b7b60
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/Demangle/ItaniumDemangle.h |
bool sptk::WriteStream<unsigned int>(int, int, std::vector<unsigned int, std::allocator<unsigned int>> const&, std::ostream*, int*) | bool WriteStream(int write_point, int write_size,
const std::vector<T>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_size);
if (sequence_to_write.size() < static_cast<std::size_t>(end)) {
return false;
}
const int before((NULL == actual_write_size)
? 0
: static_cast<int>(output_stream->tellp()));
output_stream->write(
reinterpret_cast<const char*>(&(sequence_to_write[0]) + write_point),
sizeof(sequence_to_write[0]) * write_size);
// When output_stream is cout, actual_write_size is always zero.
if (NULL != actual_write_size) {
const int after(static_cast<int>(output_stream->tellp()));
const int type_byte(sizeof(sequence_to_write[0]));
*actual_write_size = (after - before) / type_byte;
}
return !output_stream->fail();
} | subq $0x68, %rsp
movl %edi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
cmpl $0x0, 0x60(%rsp)
jl 0x17a62
cmpl $0x0, 0x5c(%rsp)
jle 0x17a62
xorl %eax, %eax
cmpq 0x48(%rsp), %rax
jne 0x17a6c
movb $0x0, 0x67(%rsp)
jmp 0x17b6e
movl 0x60(%rsp), %eax
addl 0x5c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq 0x50(%rsp), %rdi
callq 0x15770
movslq 0x3c(%rsp), %rcx
cmpq %rcx, %rax
jae 0x17a96
movb $0x0, 0x67(%rsp)
jmp 0x17b6e
xorl %eax, %eax
cmpq 0x40(%rsp), %rax
jne 0x17aa7
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x17ac9
movq 0x48(%rsp), %rdi
callq 0x4220
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x16ff0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17b80
movq (%rsp), %rdi
movq %rax, %rsi
movslq 0x60(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq 0x5c(%rsp), %rdx
shlq $0x2, %rdx
callq 0x4320
xorl %eax, %eax
cmpq 0x40(%rsp), %rax
je 0x17b55
movq 0x48(%rsp), %rdi
callq 0x4220
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16ff0
movl %eax, 0x24(%rsp)
movl $0x4, 0xc(%rsp)
movl 0x24(%rsp), %eax
subl 0x38(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movq 0x48(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4030
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax)
| /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<float>(int, int, std::vector<float, std::allocator<float>> const&, std::ostream*, int*) | bool WriteStream(int write_point, int write_size,
const std::vector<T>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_size);
if (sequence_to_write.size() < static_cast<std::size_t>(end)) {
return false;
}
const int before((NULL == actual_write_size)
? 0
: static_cast<int>(output_stream->tellp()));
output_stream->write(
reinterpret_cast<const char*>(&(sequence_to_write[0]) + write_point),
sizeof(sequence_to_write[0]) * write_size);
// When output_stream is cout, actual_write_size is always zero.
if (NULL != actual_write_size) {
const int after(static_cast<int>(output_stream->tellp()));
const int type_byte(sizeof(sequence_to_write[0]));
*actual_write_size = (after - before) / type_byte;
}
return !output_stream->fail();
} | subq $0x68, %rsp
movl %edi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
cmpl $0x0, 0x60(%rsp)
jl 0x17d42
cmpl $0x0, 0x5c(%rsp)
jle 0x17d42
xorl %eax, %eax
cmpq 0x48(%rsp), %rax
jne 0x17d4c
movb $0x0, 0x67(%rsp)
jmp 0x17e4e
movl 0x60(%rsp), %eax
addl 0x5c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq 0x50(%rsp), %rdi
callq 0x16010
movslq 0x3c(%rsp), %rcx
cmpq %rcx, %rax
jae 0x17d76
movb $0x0, 0x67(%rsp)
jmp 0x17e4e
xorl %eax, %eax
cmpq 0x40(%rsp), %rax
jne 0x17d87
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x17da9
movq 0x48(%rsp), %rdi
callq 0x4220
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x16ff0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17e60
movq (%rsp), %rdi
movq %rax, %rsi
movslq 0x60(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq 0x5c(%rsp), %rdx
shlq $0x2, %rdx
callq 0x4320
xorl %eax, %eax
cmpq 0x40(%rsp), %rax
je 0x17e35
movq 0x48(%rsp), %rdi
callq 0x4220
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16ff0
movl %eax, 0x24(%rsp)
movl $0x4, 0xc(%rsp)
movl 0x24(%rsp), %eax
subl 0x38(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movq 0x48(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4030
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax)
| /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::RealValuedFastFourierTransform::RealValuedFastFourierTransform(int, int) | RealValuedFastFourierTransform::RealValuedFastFourierTransform(int num_order,
int fft_length)
: num_order_(num_order),
fft_length_(fft_length),
half_fft_length_(fft_length_ / 2),
fast_fourier_transform_(half_fft_length_),
is_valid_(true) {
if (num_order_ < 0 || fft_length_ <= num_order_ ||
!sptk::IsPowerOfTwo(fft_length_) || !fast_fourier_transform_.IsValid()) {
is_valid_ = false;
return;
}
const int table_size(fft_length_ - fft_length_ / 4 + 1);
const double argument(sptk::kPi / fft_length_ * 2);
sine_table_.resize(table_size);
for (int i(0); i < table_size; ++i) {
sine_table_[i] = std::sin(argument * i);
}
sine_table_[fft_length_ / 2] = 0.0;
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x11c2e(%rip), %rcx # 0x396a0
addq $0x10, %rcx
movq %rcx, (%rax)
movl 0x4c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x48(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
movq %rax, %rdi
addq $0x18, %rdi
movq %rdi, 0x10(%rsp)
movl 0x10(%rax), %esi
callq 0x298d0
movq 0x20(%rsp), %rdi
movb $0x1, 0x48(%rdi)
addq $0x50, %rdi
movq %rdi, 0x18(%rsp)
callq 0x8be0
movq 0x20(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jl 0x27b1a
movq 0x20(%rsp), %rcx
movl 0xc(%rcx), %eax
cmpl 0x8(%rcx), %eax
jle 0x27b1a
movq 0x20(%rsp), %rax
movl 0xc(%rax), %edi
callq 0x118e0
movb %al, 0xf(%rsp)
jmp 0x27af2
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x27afc
jmp 0x27b1a
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x10130
movb %al, 0xe(%rsp)
jmp 0x27b10
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x27b4f
jmp 0x27b1a
movq 0x20(%rsp), %rax
movb $0x0, 0x48(%rax)
jmp 0x27c1a
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x8790
movq 0x10(%rsp), %rdi
callq 0x9290
jmp 0x27c1f
movq 0x20(%rsp), %rdi
movl 0xc(%rdi), %edx
movl %edx, %ecx
addl $0x3, %ecx
testl %edx, %edx
movl %edx, %eax
cmovsl %ecx, %eax
sarl $0x2, %eax
negl %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, 0x38(%rsp)
cvtsi2sdl 0xc(%rdi), %xmm1
movsd 0x42df(%rip), %xmm0 # 0x2be60
divsd %xmm1, %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
addq $0x50, %rdi
movslq 0x38(%rsp), %rsi
callq 0xb490
jmp 0x27b9f
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x38(%rsp), %eax
jge 0x27bf4
movsd 0x30(%rsp), %xmm0
cvtsi2sdl 0x2c(%rsp), %xmm1
mulsd %xmm1, %xmm0
callq 0x4090
movq 0x20(%rsp), %rdi
movsd %xmm0, (%rsp)
addq $0x50, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8770
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x27ba7
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x50, %rdi
movl 0xc(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movslq %eax, %rsi
callq 0x8770
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x4450
nopl (%rax)
| /sp-nitech[P]SPTK/src/math/real_valued_fast_fourier_transform.cc |
lest::tags(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>) | inline texts tags( text name, texts result = texts() )
{
size_t none = std::string::npos;
size_t lb = name.find_first_of( "[" );
size_t rb = name.find_first_of( "]" );
if ( lb == none || rb == none )
return result;
result.push_back( name.substr( lb, rb - lb + 1 ) );
return tags( name.substr( rb + 1 ), result );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x5caa1(%rip), %rsi # 0x6ab26
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x4310
movq %rax, %r13
leaq 0x5c03c(%rip), %rsi # 0x6a0da
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x4310
movq %rax, %r12
cmpq $-0x1, %r13
setne %al
cmpq $-0x1, %r12
setne %cl
testb %cl, %al
jne 0xe0e5
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
jmp 0xe20b
movq %r12, %rcx
subq %r13, %rcx
incq %rcx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4230
movq %r14, %rdi
movq %rbp, %rsi
callq 0xdba4
leaq 0x18(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0xe127
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4210
incq %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq $-0x1, %rcx
callq 0x4230
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r13), %rax
cmpq %rbp, %rax
je 0xe167
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0xe16f
movups (%rbp), %xmm0
movups %xmm0, (%r15)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rbp, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x9cb2
leaq 0x60(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xe067
leaq 0x60(%rsp), %rdi
movaps (%rdi), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x8fc0
leaq 0x48(%rsp), %rdi
callq 0x8fc0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xe1f4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4210
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe20b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4210
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x8fc0
jmp 0xe22f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xe246
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4210
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe25d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4210
movq %rbx, %rdi
callq 0x43e0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xe250
jmp 0xe25d
| /martinmoene[P]any-lite/test/lest/lest_cpp03.hpp |
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> lest::make<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, char const*>(char const* const*, char const* const*) | C make( T const * first, T const * const last )
{
C result;
for ( ; first != last; ++first )
{
result.push_back( *first );
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpq %rdx, %rsi
je 0xf29e
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, 0x30(%rsp)
leaq 0x48(%rsp), %rbx
leaq 0x38(%rsp), %r12
leaq 0xf(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq (%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x40d0
movq %rbp, %rdi
movq %r12, %rsi
callq 0xdba4
movq 0x38(%rsp), %rdi
cmpq %rbx, %rdi
je 0xf284
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x4210
addq $0x8, %r15
cmpq %r14, %r15
jne 0xf254
movaps 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rbx
jmp 0xf2a0
xorl %eax, %eax
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
leaq 0x10(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x8fc0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xf2f0
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %rbx, %rdi
je 0xf2f0
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x4210
leaq 0x10(%rsp), %rdi
callq 0x8fc0
movq %r14, %rdi
callq 0x43e0
nop
| /martinmoene[P]any-lite/test/lest/lest_cpp03.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> lest::to_string<(anonymous namespace)::State, (anonymous namespace)::State>((anonymous namespace)::State const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, (anonymous namespace)::State const&) | std::string to_string( L const & lhs, std::string op, R const & rhs )
{
std::ostringstream os; os << to_string( lhs ) << " " << op << " " << to_string( rhs ); return os.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x42c0
movq %rsp, %rdi
movq %r12, %rsi
callq 0x653c4
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x4270
movq %rax, %r12
leaq 0x58e5(%rip), %rsi # 0x6ab45
movl $0x1, %edx
movq %rax, %rdi
callq 0x4270
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x4270
movq %rax, %r15
leaq 0x58bf(%rip), %rsi # 0x6ab45
movl $0x1, %edx
movq %rax, %rdi
callq 0x4270
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x653c4
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r15, %rdi
callq 0x4270
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x652cd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4210
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x652e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4210
leaq 0x48(%rsp), %rsi
movq %rsp, %rdi
callq 0x4340
movq (%rsp), %rcx
cmpq %r14, %rcx
je 0x65311
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
movq %rcx, (%rbx)
movq %rdx, 0x10(%rbx)
jmp 0x65326
movups 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movups %xmm0, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq 0x11c87(%rip), %rsi # 0x76fb8
leaq 0x40(%rsp), %rdi
callq 0x4120
leaq 0xb0(%rsp), %rdi
callq 0x40a0
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6537b
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65383
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4210
jmp 0x65383
jmp 0x65380
movq %rax, %rbx
jmp 0x6539e
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6539e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4210
movq 0x11c13(%rip), %rsi # 0x76fb8
leaq 0x40(%rsp), %rdi
callq 0x4120
leaq 0xb0(%rsp), %rdi
callq 0x40a0
movq %rbx, %rdi
callq 0x43e0
| /martinmoene[P]any-lite/test/lest/lest_cpp03.hpp |
nonstd::any_lite::any::holder<(anonymous namespace)::InitList>::clone() const | virtual placeholder * clone() const any_override
{
return new holder( held );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x30, %edi
callq 0x4200
movq %rax, %rbx
leaq 0x8(%r14), %rsi
leaq 0x11297(%rip), %rax # 0x76b18
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
callq 0x68e28
movb 0x20(%r14), %al
movb %al, 0x20(%rbx)
movl 0x2c(%r14), %eax
movabsq $0x300000003, %rcx # imm = 0x300000003
movq %rcx, 0x24(%rbx)
movl %eax, 0x2c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x4210
movq %r14, %rdi
callq 0x43e0
| /martinmoene[P]any-lite/include/nonstd/any.hpp |
main | static void test_invalids()
{
struct invalid_instructions invalids[] = {{
CS_ARCH_ARM,
CS_MODE_THUMB,
"Thumb",
1,
{{
(unsigned char *)"\xbd\xe8\x1e\xff",
4,
"invalid thumb2 pop because sp used and because both pc and lr are "
"present at the same time"
}},
}};
struct invalid_instructions * invalid = NULL;
uint64_t address = 0x1000;
cs_insn *insn;
int i;
int j;
size_t count;
printf("\nShould be invalid\n"
"-----------------\n");
for (i = 0; i < sizeof(invalids)/sizeof(invalids[0]); i++) {
cs_err err;
invalid = invalids + i;
err = cs_open(invalid->arch, invalid->mode, &handle);
if (err) {
printf("Failed on cs_open() with error returned: %u\n", err);
continue;
}
cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON);
cs_option(handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_NOREGNAME);
for (j = 0; j < invalid->num_invalid_codes; ++j) {
struct invalid_code *invalid_code = NULL;
char *hex_str = NULL;
invalid_code = invalid->invalid_codes + j;
hex_str = hex_string(invalid_code->code, invalid_code->size);
printf("%s %s: %s\n", invalid->platform_comment, hex_str, invalid_code->comment);
free(hex_str);
count = cs_disasm(handle,
invalid_code->code, invalid_code->size, address, 0, &insn
);
if (count) {
size_t k;
printf(" ERROR:\n");
for (k = 0; k < count; k++) {
printf(" 0x%"PRIx64":\t%s\t%s\n",
insn[k].address, insn[k].mnemonic, insn[k].op_str);
print_insn_detail(&insn[k]);
}
cs_free(insn, count);
} else {
printf(" SUCCESS: invalid\n");
}
}
cs_close(&handle);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x838, %rsp # imm = 0x838
leaq 0x7e298(%rip), %rdi # 0xc151c
callq 0x43070
leaq 0x2508e8(%rip), %rdx # 0x293b78
pushq $0x10
popq %rsi
xorl %edi, %edi
callq 0x43af5
testl %eax, %eax
je 0x432b3
leaq 0x7ddda(%rip), %rdi # 0xc107f
movl %eax, %esi
xorl %eax, %eax
callq 0x430a0
jmp 0x4341e
movq 0x2508be(%rip), %rdi # 0x293b78
pushq $0x2
popq %rsi
pushq $0x3
popq %rbx
movq %rbx, %rdx
callq 0x43c51
movq 0x2508a9(%rip), %rdi # 0x293b78
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq 0x43c51
movb $0x1, %al
leaq 0x7ddd4(%rip), %rbp # 0xc10b7
leaq 0x30(%rsp), %r12
leaq 0x18(%rsp), %r13
leaq 0x10(%rsp), %rbx
xorl %ecx, %ecx
testb $0x1, %al
je 0x43412
imulq $0x18, %rcx, %r15
leaq 0x124e69(%rip), %rax # 0x168170
movq 0x18(%r15,%rax), %rdi
movq %rdi, (%rsp)
movq 0x20(%r15,%rax), %rsi
movq %rsi, 0x20(%rsp)
callq 0x43639
movq %rax, %r14
leaq 0x124e47(%rip), %rax # 0x168170
movq 0x28(%r15,%rax), %rcx
leaq 0x7dd77(%rip), %rdi # 0xc10ac
leaq 0x7dcdd(%rip), %rsi # 0xc1019
movq %r14, %rdx
xorl %eax, %eax
callq 0x430a0
movq %r14, %rdi
callq 0x43030
movq 0x250823(%rip), %rdi # 0x293b78
movl $0x1000, %ecx # imm = 0x1000
movq (%rsp), %rsi
movq 0x20(%rsp), %rdx
xorl %r8d, %r8d
leaq 0x8(%rsp), %r9
callq 0x43d57
testq %rax, %rax
je 0x433fc
movq %rax, %r14
leaq 0x7e1d3(%rip), %rdi # 0xc1556
callq 0x43070
movq %r14, (%rsp)
movq %r14, %r15
xorl %r14d, %r14d
movq 0x8(%rsp), %rdi
subq $0x1, %r15
jb 0x433f1
leaq (%rdi,%r14), %rdx
addq $0x22, %rdx
movq -0x1a(%rdx), %rsi
leaq (%rdi,%r14), %rcx
addq $0x42, %rcx
movq %rbp, %rdi
xorl %eax, %eax
callq 0x430a0
movq 0x8(%rsp), %rcx
addq %r14, %rcx
andq $0x0, 0x18(%rsp)
movq $0x800, 0x10(%rsp) # imm = 0x800
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x436be
movq %r12, %rdi
callq 0x43070
addq $0xf0, %r14
jmp 0x43392
movq (%rsp), %rsi
callq 0x442f2
jmp 0x43408
leaq 0x7e13e(%rip), %rdi # 0xc1541
callq 0x43070
xorl %eax, %eax
pushq $0x1
popq %rcx
jmp 0x432f4
leaq 0x25075f(%rip), %rdi # 0x293b78
callq 0x43bff
leaq 0x250753(%rip), %rdx # 0x293b78
pushq $0x10
popq %rsi
xorl %edi, %edi
callq 0x43af5
testl %eax, %eax
je 0x43448
leaq 0x7dc45(%rip), %rdi # 0xc107f
movl %eax, %esi
xorl %eax, %eax
callq 0x430a0
jmp 0x43625
movq 0x250729(%rip), %rdi # 0x293b78
pushq $0x2
popq %rsi
pushq $0x3
popq %rbx
movq %rbx, %rdx
callq 0x43c51
movq 0x250714(%rip), %rdi # 0x293b78
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq 0x43c51
leaq 0x7e0eb(%rip), %rdi # 0xc1561
callq 0x43070
leaq 0x30(%rsp), %r13
xorl %ebx, %ebx
cmpq $0x3, %rbx
je 0x43619
andq $0x0, 0x8(%rsp)
movq $0x800, 0x10(%rsp) # imm = 0x800
movq %rbx, (%rsp)
imulq $0x28, %rbx, %rbp
leaq 0x124e66(%rip), %rbx # 0x168310
movq 0x18(%rbp,%rbx), %r15
movq 0x20(%rbp,%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x43639
movl 0x28(%rbp,%rbx), %r12d
movq 0x38(%rbp,%rbx), %r8
movq 0x30(%rbp,%rbx), %rbx
leaq 0x7dff5(%rip), %rdi # 0xc14ca
leaq 0x7db3d(%rip), %rsi # 0xc1019
movq %rax, %rdx
movl %r12d, %ecx
movq %rbx, %r9
xorl %eax, %eax
callq 0x430a0
movq 0x250685(%rip), %rdi # 0x293b78
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
leaq 0x18(%rsp), %r9
callq 0x43d57
testq %rax, %rax
je 0x435e0
movq %rbx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq %rax, %r12
xorl %r15d, %r15d
leaq 0x7db92(%rip), %rbx # 0xc10bb
subq $0x1, %r12
jb 0x43599
movq 0x8(%rsp), %rbp
leaq (%rsp,%rbp), %rdi
addq $0x30, %rdi
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %rax
leaq 0x22(%rax,%r15), %r8
movq -0x1a(%r8), %rcx
leaq (%rax,%r15), %r9
addq $0x42, %r9
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x430b0
cltq
subq %rax, %r14
movq %r14, 0x10(%rsp)
addq %rax, %rbp
movq %rbp, 0x8(%rsp)
movq 0x18(%rsp), %rcx
addq %r15, %rcx
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x436be
addq $0xf0, %r15
jmp 0x43529
movq %r13, %rdi
callq 0x43080
movq %rax, %r14
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x43080
cmpq %r14, %rax
cmovaq %rax, %r14
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x43120
testl %eax, %eax
je 0x435f2
leaq 0x7df13(%rip), %rdi # 0xc14e4
movq %r13, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x430a0
jmp 0x435fe
leaq 0x7df9b(%rip), %rdi # 0xc1582
callq 0x43070
movq (%rsp), %rbx
jmp 0x43611
leaq 0x7df98(%rip), %rdi # 0xc1591
callq 0x43070
movq (%rsp), %rbx
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x442f2
incq %rbx
jmp 0x43482
leaq 0x250558(%rip), %rdi # 0x293b78
callq 0x43bff
xorl %eax, %eax
addq $0x838, %rsp # imm = 0x838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/suite/arm/test_arm_regression.c |
hex_string | static char *hex_string(unsigned char *str, size_t len)
{
// returns a malloced string that has the hex version of the string in it
// null if failed to malloc
char *hex_out;
size_t i;
hex_out = (char *) malloc(len*2 + 1); // two ascii characters per input character, plus trailing null
if (!hex_out) { goto Exit; }
for (i = 0; i < len; ++i) {
snprintf(hex_out + (i*2), 2, "%02x", str[i]);
}
hex_out[len*2] = 0; // trailing null
Exit:
return hex_out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(,%rsi,2), %rdi
callq 0x43110
testq %rax, %rax
je 0x436af
leaq (%rbx,%rbx), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x7e1c6(%rip), %r12 # 0xc1835
pushq $0x2
popq %r13
movq %rax, 0x10(%rsp)
movq %rax, %rbp
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x436a1
movzbl (%r14,%r15), %ecx
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x430b0
incq %r15
addq $0x2, %rbp
jmp 0x4367e
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/suite/arm/test_arm_regression.c |
snprint_insn_detail | static void snprint_insn_detail(char * buf, size_t * cur, size_t * left, cs_insn *ins)
{
size_t used = 0;
#define _this_printf(...) \
{ \
size_t used = 0; \
used = snprintf(buf + *cur, *left, __VA_ARGS__); \
*left -= used; \
*cur += used; \
}
cs_arm *arm;
int i;
// detail can be NULL on "data" instruction if SKIPDATA option is turned ON
if (ins->detail == NULL)
return;
arm = &(ins->detail->arm);
if (arm->op_count)
_this_printf("\top_count: %u\n", arm->op_count);
for (i = 0; i < arm->op_count; i++) {
cs_arm_op *op = &(arm->operands[i]);
switch((int)op->type) {
default:
break;
case ARM_OP_REG:
_this_printf("\t\toperands[%u].type: REG = %s\n", i, cs_reg_name(handle, op->reg));
break;
case ARM_OP_IMM:
_this_printf("\t\toperands[%u].type: IMM = 0x%x\n", i, op->imm);
break;
case ARM_OP_FP:
_this_printf("\t\toperands[%u].type: FP = %f\n", i, op->fp);
break;
case ARM_OP_MEM:
_this_printf("\t\toperands[%u].type: MEM\n", i);
if (op->mem.base != X86_REG_INVALID)
_this_printf("\t\t\toperands[%u].mem.base: REG = %s\n",
i, cs_reg_name(handle, op->mem.base));
if (op->mem.index != X86_REG_INVALID)
_this_printf("\t\t\toperands[%u].mem.index: REG = %s\n",
i, cs_reg_name(handle, op->mem.index));
if (op->mem.scale != 1)
_this_printf("\t\t\toperands[%u].mem.scale: %u\n", i, op->mem.scale);
if (op->mem.disp != 0)
_this_printf("\t\t\toperands[%u].mem.disp: 0x%x\n", i, op->mem.disp);
break;
case ARM_OP_PIMM:
_this_printf("\t\toperands[%u].type: P-IMM = %u\n", i, op->imm);
break;
case ARM_OP_CIMM:
_this_printf("\t\toperands[%u].type: C-IMM = %u\n", i, op->imm);
break;
}
if (op->shift.type != ARM_SFT_INVALID && op->shift.value) {
if (op->shift.type < ARM_SFT_ASR_REG) {
// shift with constant value
_this_printf("\t\t\tShift: %u = %u\n", op->shift.type, op->shift.value);
} else {
// shift with register
_this_printf("\t\t\tShift: %u = %s\n", op->shift.type,
cs_reg_name(handle, op->shift.value));
}
}
}
if (arm->cc != ARM_CC_AL && arm->cc != ARM_CC_INVALID) {
_this_printf("\tCode condition: %u\n", arm->cc);
}
if (arm->update_flags) {
_this_printf("\tUpdate-flags: True\n");
}
if (arm->writeback) {
_this_printf("\tWrite-back: True\n");
}
#undef _this_printf
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xe8(%rcx), %rbp
testq %rbp, %rbp
je 0x43a10
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movzbl 0x50(%rbp), %ecx
testl %ecx, %ecx
je 0x4370c
movq (%rbx), %rdi
addq %r12, %rdi
movq (%r15), %rsi
leaq 0x7d9cc(%rip), %rdx # 0xc10c9
xorl %eax, %eax
callq 0x430b0
cltq
subq %rax, (%r15)
addq %rax, (%rbx)
leaq 0x74(%rbp), %r14
xorl %r13d, %r13d
movq %r15, (%rsp)
movq %r12, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
movzbl 0x50(%rbp), %eax
cmpq %rax, %r13
jae 0x4399b
movl -0x10(%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x4378f
leaq 0x7d8c3(%rip), %rdx # 0xc1004
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
movq (%rbx), %r15
addq %r12, %r15
movq (%rsp), %rax
movq (%rax), %r12
movq 0x25041a(%rip), %rdi # 0x293b78
movl -0xc(%r14), %esi
callq 0x44528
movq %r15, %rdi
movq (%rsp), %r15
movq %r12, %rsi
movq 0x8(%rsp), %r12
leaq 0x7d95b(%rip), %rdx # 0xc10d8
movl %r13d, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0x430b0
jmp 0x4390f
cmpl $0x40, %eax
je 0x437b6
cmpl $0x41, %eax
jne 0x43917
movq (%rbx), %rdi
addq %r12, %rdi
movq (%r15), %rsi
movl -0xc(%r14), %r8d
leaq 0x7da27(%rip), %rdx # 0xc11d8
jmp 0x43905
movq (%rbx), %rdi
addq %r12, %rdi
movq (%r15), %rsi
movl -0xc(%r14), %r8d
leaq 0x7da2f(%rip), %rdx # 0xc11f9
jmp 0x43905
movq (%rbx), %rdi
addq %r12, %rdi
movq (%r15), %rsi
leaq 0x7d957(%rip), %rdx # 0xc1136
movl %r13d, %ecx
xorl %eax, %eax
callq 0x430b0
movslq %eax, %rbp
subq %rbp, (%r15)
addq (%rbx), %rbp
movq %rbp, (%rbx)
movl -0xc(%r14), %esi
testl %esi, %esi
je 0x4383d
addq %r12, %rbp
movq (%rsp), %rax
movq (%rax), %r15
movq 0x25036a(%rip), %rdi # 0x293b78
callq 0x44528
movq %rbp, %rdi
movq %r15, %rsi
movq (%rsp), %r15
leaq 0x7d92c(%rip), %rdx # 0xc1150
movl %r13d, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0x430b0
movslq %eax, %rbp
subq %rbp, (%r15)
addq (%rbx), %rbp
movq %rbp, (%rbx)
movl -0x8(%r14), %esi
testl %esi, %esi
je 0x43885
addq %r12, %rbp
movq (%rsp), %rax
movq (%rax), %r15
movq 0x250322(%rip), %rdi # 0x293b78
callq 0x44528
movq %rbp, %rdi
movq %r15, %rsi
movq (%rsp), %r15
leaq 0x7d908(%rip), %rdx # 0xc1174
movl %r13d, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0x430b0
movslq %eax, %rbp
subq %rbp, (%r15)
addq (%rbx), %rbp
movq %rbp, (%rbx)
movl -0x4(%r14), %r8d
cmpl $0x1, %r8d
je 0x438b5
addq %r12, %rbp
movq (%r15), %rsi
movq %rbp, %rdi
leaq 0x7d8fa(%rip), %rdx # 0xc1199
movl %r13d, %ecx
xorl %eax, %eax
callq 0x430b0
movslq %eax, %rbp
subq %rbp, (%r15)
addq (%rbx), %rbp
movq %rbp, (%rbx)
movl (%r14), %r8d
testl %r8d, %r8d
je 0x43917
addq %r12, %rbp
movq (%r15), %rsi
movq %rbp, %rdi
leaq 0x7d8eb(%rip), %rdx # 0xc11b8
jmp 0x43905
movq (%rbx), %rdi
addq %r12, %rdi
movq (%r15), %rsi
movsd -0xc(%r14), %xmm0
leaq 0x7d833(%rip), %rdx # 0xc1118
movl %r13d, %ecx
movb $0x1, %al
callq 0x430b0
jmp 0x4390f
movq (%rbx), %rdi
addq %r12, %rdi
movq (%r15), %rsi
movl -0xc(%r14), %r8d
leaq 0x7d7f2(%rip), %rdx # 0xc10f7
movl %r13d, %ecx
xorl %eax, %eax
callq 0x430b0
cltq
subq %rax, (%r15)
addq %rax, (%rbx)
movl -0x18(%r14), %ebp
testl %ebp, %ebp
je 0x4398a
movl -0x14(%r14), %r8d
testl %r8d, %r8d
je 0x4398a
movq %r12, %rax
movq (%rbx), %r12
addq %rax, %r12
movq (%r15), %r15
cmpl $0x5, %ebp
ja 0x43951
movq %r12, %rdi
movq %r15, %rsi
leaq 0x7d8d4(%rip), %rdx # 0xc121a
movl %ebp, %ecx
xorl %eax, %eax
callq 0x430b0
jmp 0x43979
movq 0x250220(%rip), %rdi # 0x293b78
movl %r8d, %esi
callq 0x44528
movq %r12, %rdi
movq %r15, %rsi
leaq 0x7d8c0(%rip), %rdx # 0xc122d
movl %ebp, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0x430b0
cltq
movq (%rsp), %r15
subq %rax, (%r15)
addq %rax, (%rbx)
movq 0x8(%rsp), %r12
incq %r13
addq $0x28, %r14
movq 0x10(%rsp), %rbp
jmp 0x43721
movl 0x44(%rbp), %ecx
testl %ecx, %ecx
je 0x439c6
cmpl $0xf, %ecx
je 0x439c6
movq (%rbx), %rdi
addq %r12, %rdi
movq (%r15), %rsi
leaq 0x7d889(%rip), %rdx # 0xc1240
xorl %eax, %eax
callq 0x430b0
cltq
subq %rax, (%r15)
addq %rax, (%rbx)
cmpb $0x1, 0x48(%rbp)
jne 0x439eb
movq (%rbx), %rdi
addq %r12, %rdi
movq (%r15), %rsi
leaq 0x7d879(%rip), %rdx # 0xc1255
xorl %eax, %eax
callq 0x430b0
cltq
subq %rax, (%r15)
addq %rax, (%rbx)
cmpb $0x1, 0x49(%rbp)
jne 0x43a10
addq (%rbx), %r12
movq (%r15), %rsi
leaq 0x7d86c(%rip), %rdx # 0xc126a
movq %r12, %rdi
xorl %eax, %eax
callq 0x430b0
cltq
subq %rax, (%r15)
addq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /bughoho[P]capstone/suite/arm/test_arm_regression.c |
archs_enable | static void archs_enable(void)
{
static bool initialized = false;
if (initialized)
return;
#ifdef CAPSTONE_HAS_ARM
ARM_enable();
#endif
#ifdef CAPSTONE_HAS_ARM64
AArch64_enable();
#endif
#ifdef CAPSTONE_HAS_MIPS
Mips_enable();
#endif
#ifdef CAPSTONE_HAS_POWERPC
PPC_enable();
#endif
#ifdef CAPSTONE_HAS_SPARC
Sparc_enable();
#endif
#ifdef CAPSTONE_HAS_SYSZ
SystemZ_enable();
#endif
#ifdef CAPSTONE_HAS_X86
X86_enable();
#endif
#ifdef CAPSTONE_HAS_XCORE
XCore_enable();
#endif
initialized = true;
} | cmpb $0x0, 0x2501e7(%rip) # 0x293c44
jne 0x43a93
pushq %rax
callq 0x44d70
callq 0x44ea0
callq 0x44f70
callq 0x45064
callq 0x47800
callq 0x478d8
callq 0x4513c
callq 0x479a4
movb $0x1, 0x2501b5(%rip) # 0x293c44
addq $0x8, %rsp
retq
| /bughoho[P]capstone/cs.c |
cs_support | CAPSTONE_EXPORT
bool cs_support(int query)
{
archs_enable();
if (query == CS_ARCH_ALL)
return all_arch == ((1 << CS_ARCH_ARM) | (1 << CS_ARCH_ARM64) |
(1 << CS_ARCH_MIPS) | (1 << CS_ARCH_X86) |
(1 << CS_ARCH_PPC) | (1 << CS_ARCH_SPARC) |
(1 << CS_ARCH_SYSZ) | (1 << CS_ARCH_XCORE));
if ((unsigned int)query < CS_ARCH_MAX)
return all_arch & (1 << query);
if (query == CS_SUPPORT_DIET) {
#ifdef CAPSTONE_DIET
return true;
#else
return false;
#endif
}
if (query == CS_SUPPORT_X86_REDUCE) {
#if defined(CAPSTONE_HAS_X86) && defined(CAPSTONE_X86_REDUCE)
return true;
#else
return false;
#endif
}
// unsupported query
return false;
} | pushq %rbx
movl %edi, %ebx
callq 0x43a56
cmpl $0xffff, %ebx # imm = 0xFFFF
jne 0x43ab3
cmpl $0xff, 0x250192(%rip) # 0x293c40
sete %al
jmp 0x43ac8
cmpl $0x7, %ebx
ja 0x43ac6
movl 0x250182(%rip), %eax # 0x293c40
btl %ebx, %eax
setb %al
jmp 0x43ac8
xorl %eax, %eax
popq %rbx
retq
| /bughoho[P]capstone/cs.c |
DecodePostIdxReg | static DecodeStatus DecodePostIdxReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned add = fieldFromInstruction_4(Insn, 4, 1);
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, add);
return S;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
andl $0xf, %esi
callq 0x4f6b1
movl %eax, %ebp
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x501d9
shrl $0x4, %ebx
andl $0x1, %ebx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44ace
jmp 0x501db
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeArmMOVTWInstruction | static DecodeStatus DecodeArmMOVTWInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned imm = 0;
imm |= (fieldFromInstruction_4(Insn, 0, 12) << 0);
imm |= (fieldFromInstruction_4(Insn, 16, 4) << 12);
if (MCInst_getOpcode(Inst) == ARM_MOVTi16)
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rd, Address, Decoder)))
return MCDisassembler_Fail;
MCOperand_CreateImm0(Inst, imm);
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r15d
shrl $0xc, %r15d
andl $0xf, %r15d
callq 0x44a14
cmpl $0xd8, %eax
jne 0x50312
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4f6b1
movl %eax, %r14d
orl $0x2, %eax
cmpl $0x3, %eax
je 0x50316
jmp 0x5037c
pushq $0x3
popq %r14
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4f6b1
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x3, %ecx
je 0x50333
cmpl $0x1, %ecx
jne 0x5037e
pushq $0x1
popq %r14
movl %ebp, %r15d
shrl $0x1c, %r15d
movl %ebp, %eax
andl $0xfff, %eax # imm = 0xFFF
shrl $0x4, %ebp
andl $0xf000, %ebp # imm = 0xF000
orl %eax, %ebp
movl %ebp, %esi
movq %rbx, %rdi
callq 0x44ace
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4f571
movl %eax, %ecx
movl %eax, %eax
leaq 0x7bf20(%rip), %rdx # 0xcc28c
movslq (%rdx,%rax,4), %rsi
addq %rdx, %rsi
movl %r14d, %eax
jmpq *%rsi
movl %ecx, %eax
jmp 0x5037e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeAddrMode2IdxInstruction | static DecodeStatus DecodeAddrMode2IdxInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
ARM_AM_AddrOpc Op;
ARM_AM_ShiftOpc Opc;
bool writeback;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned reg = fieldFromInstruction_4(Insn, 25, 1);
unsigned P = fieldFromInstruction_4(Insn, 24, 1);
unsigned W = fieldFromInstruction_4(Insn, 21, 1);
unsigned idx_mode = 0, amt, tmp;
// On stores, the writeback operand precedes Rt.
switch (MCInst_getOpcode(Inst)) {
case ARM_STR_POST_IMM:
case ARM_STR_POST_REG:
case ARM_STRB_POST_IMM:
case ARM_STRB_POST_REG:
case ARM_STRT_POST_REG:
case ARM_STRT_POST_IMM:
case ARM_STRBT_POST_REG:
case ARM_STRBT_POST_IMM:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
// On loads, the writeback operand comes after Rt.
switch (MCInst_getOpcode(Inst)) {
case ARM_LDR_POST_IMM:
case ARM_LDR_POST_REG:
case ARM_LDRB_POST_IMM:
case ARM_LDRB_POST_REG:
case ARM_LDRBT_POST_REG:
case ARM_LDRBT_POST_IMM:
case ARM_LDRT_POST_REG:
case ARM_LDRT_POST_IMM:
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
break;
default:
break;
}
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
Op = ARM_AM_add;
if (!fieldFromInstruction_4(Insn, 23, 1))
Op = ARM_AM_sub;
writeback = (P == 0) || (W == 1);
if (P && writeback)
idx_mode = ARMII_IndexModePre;
else if (!P && writeback)
idx_mode = ARMII_IndexModePost;
if (writeback && (Rn == 15 || Rn == Rt))
S = MCDisassembler_SoftFail; // UNPREDICTABLE
if (reg) {
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
Opc = ARM_AM_lsl;
switch( fieldFromInstruction_4(Insn, 5, 2)) {
case 0:
Opc = ARM_AM_lsl;
break;
case 1:
Opc = ARM_AM_lsr;
break;
case 2:
Opc = ARM_AM_asr;
break;
case 3:
Opc = ARM_AM_ror;
break;
default:
return MCDisassembler_Fail;
}
amt = fieldFromInstruction_4(Insn, 7, 5);
if (Opc == ARM_AM_ror && amt == 0)
Opc = ARM_AM_rrx;
imm = ARM_AM_getAM2Opc(Op, amt, Opc, idx_mode);
MCOperand_CreateImm0(Inst, imm);
} else {
MCOperand_CreateReg0(Inst, 0);
tmp = ARM_AM_getAM2Opc(Op, imm, ARM_AM_lsl, idx_mode);
MCOperand_CreateImm0(Inst, tmp);
}
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
shrl $0x10, %r15d
andl $0xf, %r15d
callq 0x44a14
pushq $0x3
popq %r12
addl $0xfffffe62, %eax # imm = 0xFFFFFE62
cmpl $0x1b, %eax
ja 0x503db
movl $0xf00000f, %ecx # imm = 0xF00000F
btl %eax, %ecx
jae 0x503db
movq %r14, %rdi
movl %r15d, %esi
callq 0x4f54f
movl %eax, %r12d
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x50591
movl %ebp, %r13d
shrl $0xc, %r13d
andl $0xf, %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0x4f54f
xorl %ebx, %ebx
cmpl $0x3, %eax
je 0x50405
cmpl $0x1, %eax
jne 0x50593
pushq $0x1
popq %r12
movq %r14, %rdi
callq 0x44a14
addl $0xffffff68, %eax # imm = 0xFFFFFF68
cmpl $0x25, %eax
ja 0x50444
movabsq $0x3c0000000f, %rcx # imm = 0x3C0000000F
btq %rax, %rcx
jae 0x50444
movq %r14, %rdi
movl %r15d, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x50444
cmpl $0x1, %eax
jne 0x50593
pushq $0x1
popq %r12
movq %r14, %rdi
movl %r15d, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x50461
cmpl $0x1, %eax
jne 0x50593
pushq $0x1
popq %r12
movl %ebp, %ebx
andl $0x800000, %ebx # imm = 0x800000
movl %ebp, %eax
shrl $0x18, %eax
pushq $0x1
popq %rdx
andl %edx, %eax
movl %ebp, %ecx
andl $0x1200000, %ecx # imm = 0x1200000
cmpl %r13d, %r15d
movl %r12d, %r13d
cmovel %edx, %r13d
cmpl $0xf, %r15d
cmovel %edx, %r13d
cmpl $0x1000000, %ecx # imm = 0x1000000
cmovel %r12d, %r13d
setne %cl
andb %al, %cl
movzbl %cl, %ecx
testl %eax, %eax
pushq $0x2
popq %r15
cmovnel %ecx, %r15d
btl $0x19, %ebp
jb 0x504dc
movl %ebp, %r12d
andl $0xfff, %r12d # imm = 0xFFF
movq %r14, %rdi
xorl %esi, %esi
callq 0x44aa1
shrl $0xb, %ebx
orl %r12d, %ebx
shll $0x10, %r15d
orl %ebx, %r15d
xorl $0x5000, %r15d # imm = 0x5000
jmp 0x50560
movl %edx, %r12d
movl %ebp, %esi
andl $0xf, %esi
movq %r14, %rdi
callq 0x4f6b1
cmpl $0x3, %eax
je 0x504fd
cmpl $0x1, %eax
jne 0x50591
movl %r12d, %r13d
movl %ebp, %eax
shrl $0x5, %eax
andl $0x3, %eax
leaq 0x7bd90(%rip), %rcx # 0xcc29c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4000, %eax # imm = 0x4000
jmp 0x50531
movl $0x2000, %eax # imm = 0x2000
jmp 0x50531
movl $0x8000, %eax # imm = 0x8000
movb $0x1, %cl
jmp 0x50533
movl $0x6000, %eax # imm = 0x6000
xorl %ecx, %ecx
movl %ebp, %edx
shrl $0x7, %edx
andl $0x1f, %edx
testb %cl, %cl
movl $0xa000, %ecx # imm = 0xA000
cmovel %eax, %ecx
testl %edx, %edx
cmovnel %eax, %ecx
shrl $0xb, %ebx
orl %ecx, %ebx
shll $0x10, %r15d
orl %ebx, %r15d
orl %edx, %r15d
xorl $0x1000, %r15d # imm = 0x1000
shrl $0x1c, %ebp
movl %r15d, %esi
movq %r14, %rdi
callq 0x44ace
movq %r14, %rdi
movl %ebp, %esi
callq 0x4f571
movl %eax, %ecx
leaq 0x7bd2b(%rip), %rdx # 0xcc2ac
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
movl %r13d, %ebx
jmpq *%rcx
movl %eax, %ebx
jmp 0x50593
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeSTRPreImm | static DecodeStatus DecodeSTRPreImm(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12);
imm |= fieldFromInstruction_4(Insn, 16, 4) << 13;
imm |= fieldFromInstruction_4(Insn, 23, 1) << 12;
pred = fieldFromInstruction_4(Insn, 28, 4);
if (Rn == 0xF || Rn == Rt) S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeAddrModeImm12Operand(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r15d
shrl $0x10, %r15d
andl $0xf, %r15d
movl %esi, %r12d
shrl $0xc, %r12d
andl $0xf, %r12d
xorl %eax, %eax
cmpl %r12d, %r15d
setne %al
cmpl $0xf, %r15d
leal 0x1(%rax,%rax), %r13d
pushq $0x1
popq %rbp
cmovel %ebp, %r13d
movl %r15d, %esi
callq 0x4f54f
xorl %edx, %edx
cmpl $0x3, %eax
je 0x50650
cmpl $0x1, %eax
jne 0x506c3
movl %ebp, %r13d
movq %r14, %rdi
movl %r12d, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x50669
cmpl $0x1, %eax
jne 0x506c1
pushq $0x1
popq %r13
movl %ebx, %eax
andl $0xfff, %eax # imm = 0xFFF
shll $0xd, %r15d
orl %eax, %r15d
movl %ebx, %esi
shrl $0xb, %esi
andl $0x1000, %esi # imm = 0x1000
orl %r15d, %esi
movq %r14, %rdi
callq 0x505a4
cmpl $0x3, %eax
je 0x5069b
cmpl $0x1, %eax
jne 0x506c1
pushq $0x1
popq %r13
shrl $0x1c, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f571
movl %eax, %ecx
leaq 0x7bc0b(%rip), %rdx # 0xcc2bc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
movl %r13d, %edx
jmpq *%rcx
movl %eax, %edx
jmp 0x506c3
xorl %edx, %edx
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeSORegMemOperand | static DecodeStatus DecodeSORegMemOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
ARM_AM_ShiftOpc ShOp;
unsigned shift;
unsigned Rn = fieldFromInstruction_4(Val, 13, 4);
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
unsigned type = fieldFromInstruction_4(Val, 5, 2);
unsigned imm = fieldFromInstruction_4(Val, 7, 5);
unsigned U = fieldFromInstruction_4(Val, 12, 1);
ShOp = ARM_AM_lsl;
switch (type) {
case 0:
ShOp = ARM_AM_lsl;
break;
case 1:
ShOp = ARM_AM_lsr;
break;
case 2:
ShOp = ARM_AM_asr;
break;
case 3:
ShOp = ARM_AM_ror;
break;
}
if (ShOp == ARM_AM_ror && imm == 0)
ShOp = ARM_AM_rrx;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, Decoder)))
return MCDisassembler_Fail;
if (U)
shift = ARM_AM_getAM2Opc(ARM_AM_add, imm, ShOp, 0);
else
shift = ARM_AM_getAM2Opc(ARM_AM_sub, imm, ShOp, 0);
MCOperand_CreateImm0(Inst, shift);
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
shrl $0xd, %esi
andl $0xf, %esi
movl %ebp, %eax
shrl $0x5, %eax
andl $0x3, %eax
movl %ebp, %r13d
shrl $0x7, %r13d
andl $0x1f, %r13d
xorl %r14d, %r14d
leaq 0x7bb03(%rip), %rcx # 0xcc2dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4000, %eax # imm = 0x4000
jmp 0x507fe
movl $0x2000, %eax # imm = 0x2000
jmp 0x507fe
movl $0x8000, %eax # imm = 0x8000
movb $0x1, %cl
jmp 0x50800
movl $0x6000, %eax # imm = 0x6000
xorl %ecx, %ecx
testb %cl, %cl
movl $0xa000, %r15d # imm = 0xA000
cmovel %eax, %r15d
testl %r13d, %r13d
cmovnel %eax, %r15d
movq %rbx, %rdi
callq 0x4f54f
movl %eax, %r12d
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x50861
movl %ebp, %esi
andl $0xf, %esi
movq %rbx, %rdi
callq 0x4f54f
cmpl $0x3, %eax
je 0x50843
cmpl $0x1, %eax
jne 0x50861
pushq $0x1
popq %r14
jmp 0x50846
movl %r12d, %r14d
movl $0x1000, %eax # imm = 0x1000
andl %eax, %ebp
orl %r13d, %ebp
orl %ebp, %r15d
xorl %eax, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x44ace
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeSTRPreReg | static DecodeStatus DecodeSTRPreReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12);
imm |= fieldFromInstruction_4(Insn, 16, 4) << 13;
imm |= fieldFromInstruction_4(Insn, 23, 1) << 12;
pred = fieldFromInstruction_4(Insn, 28, 4);
if (Rn == 0xF || Rn == Rt) S = MCDisassembler_SoftFail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rn, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rt, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodeSORegMemOperand(Inst, imm, Address, Decoder)))
return MCDisassembler_Fail;
if (!Check(&S, DecodePredicateOperand(Inst, pred, Address, Decoder)))
return MCDisassembler_Fail;
return S;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r15d
shrl $0x10, %r15d
andl $0xf, %r15d
movl %esi, %r12d
shrl $0xc, %r12d
andl $0xf, %r12d
xorl %eax, %eax
cmpl %r12d, %r15d
setne %al
cmpl $0xf, %r15d
leal 0x1(%rax,%rax), %r13d
pushq $0x1
popq %rbp
cmovel %ebp, %r13d
movl %r15d, %esi
callq 0x4f54f
xorl %edx, %edx
cmpl $0x3, %eax
je 0x508c8
cmpl $0x1, %eax
jne 0x5093b
movl %ebp, %r13d
movq %r14, %rdi
movl %r12d, %esi
callq 0x4f54f
cmpl $0x3, %eax
je 0x508e1
cmpl $0x1, %eax
jne 0x50939
pushq $0x1
popq %r13
movl %ebx, %eax
andl $0xfff, %eax # imm = 0xFFF
shll $0xd, %r15d
orl %eax, %r15d
movl %ebx, %esi
shrl $0xb, %esi
andl $0x1000, %esi # imm = 0x1000
orl %r15d, %esi
movq %r14, %rdi
callq 0x507a6
cmpl $0x3, %eax
je 0x50913
cmpl $0x1, %eax
jne 0x50939
pushq $0x1
popq %r13
shrl $0x1c, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f571
movl %eax, %ecx
leaq 0x7b9c3(%rip), %rdx # 0xcc2ec
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
movl %r13d, %edx
jmpq *%rcx
movl %eax, %edx
jmp 0x5093b
xorl %edx, %edx
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.