name string | code string | asm string | file string |
|---|---|---|---|
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;
... | 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_fol... | 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 = 0x100... | /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))... | 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... | 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... | /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... | 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... | /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);... | 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 $0x2... | /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_fol... | 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_fol... | 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 = 0x800... | /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);... | 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 $0x2... | /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_fol... | 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;
... | 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... | 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... | /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);... | 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 $0x2... | /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);
}
... | 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, %... | /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<u... | 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), ... | /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);
// seriali... | 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), %r... | /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);
... | 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 %r... | /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 >> r... | 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);
// seriali... | 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), %r... | /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_FR... | 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... | /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 s... | 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 0x2c4... | /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 ( ... | 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... | /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 )
... | 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)... | /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 )b... | 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 $0... | /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 0... | /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)::SerializedAffi... | 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
// u... | 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,... | /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::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) {
... | 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... | /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 subcomm... | 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)
mov... | /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,... | /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
// term... | 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(... | /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) {
// unhi... | 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(%r... | /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::S... | 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::Take... | 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... | /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()
... | 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(%rs... | /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)... | /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 (Cur... | 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 ... | /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 &f... | 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
add... | /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::distan... | 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... | /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->getBufferS... | 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
m... | /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... | 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>>::moveFro... | 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::isEqu... | 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), %ra... | /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*>>:... | 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 th... | 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
shl... | /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::handleUseOf... | 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... | /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::DenseMapP... | 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::isEqu... | 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), %... | /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) {
... | 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(%... | /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::... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | 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(%rs... | /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::det... | 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... | 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)
... | /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&, ... | 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::Take... | 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(%... | /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);
// Ge... | 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, ... | /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(
... | 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
r... | /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();
... | 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)
... | /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::OpTrai... | 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-... | 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 # 0x40573... | /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.en... | 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), %r... | /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_de... | 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 ... | /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... | 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 + ... | 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 $0... | /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... | 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... | 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
mo... | /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.
... | 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
call... | /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::... | 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>()) {
RetreatPastEm... | 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
mo... | /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::AbstractAt... | 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,... | 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)... | /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:... | 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... | /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, %... | /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.
retu... | 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<(anonymou... | 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 th... | 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
s... | /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::Hashed... | 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->... | 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, 0x... | /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->moveFromOldBu... | 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... | /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, %... | /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->moveFromOldBu... | 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... | /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 Ki... | 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 $-0x... | /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.getFunctionTy... | 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
mov... | /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... | 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 0x13... | /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, %ec... | /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;
BufferC... | 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 %rc... | /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 (consume... | 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... | /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
... | /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;
i... | 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)
... | /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
mo... | /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(%r... | /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 ... | 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... | /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 ... | 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... | /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_vali... | 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, %... | /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( n... | 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
xo... | /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::... | 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(... | /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, %r1... | /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 = 0x300000... | /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_i... | 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... | /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;... | 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, %r... | /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" instruct... | 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 # 0xc1... | /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
... | 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)... | 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, Dec... | 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(I... | 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
... | /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, 1... | 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
b... | /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... | 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... | /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 = fieldF... | 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), ... | /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... | 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... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.