name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
diy::mpi::io::file::file(diy::mpi::communicator const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
|
diy::mpi::io::file::
file(const communicator& comm__, const std::string& filename, int mode)
: comm_(comm__)
{
#if DIY_HAS_MPI
int ret = MPI_File_open(diy::mpi::mpi_cast(comm__.handle()), const_cast<char*>(filename.c_str()), mode, MPI_INFO_NULL, &diy::mpi::mpi_cast(fh));
if (ret)
throw std::runtime_error("DIY cannot open file: " + filename);
#else
(void)comm__; (void)filename; (void)mode;
DIY_UNSUPPORTED_MPI_CALL(MPI_File_open);
#endif
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdi, (%rbx)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%rdx), %rsi
leaq 0x18(%rbx), %r8
movq 0x362e4(%rip), %rax # 0x40fc8
movl %ecx, %edx
movq %rax, %rcx
callq 0x62f0
testl %eax, %eax
jne 0xacfd
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %r14
leaq 0x1d789(%rip), %rsi # 0x28498
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0xafe0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6720
xorl %ebp, %ebp
movq 0x362bb(%rip), %rsi # 0x40ff0
movq 0x36254(%rip), %rdx # 0x40f90
movq %r14, %rdi
callq 0x67a0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x6230
testb %bpl, %bpl
jne 0xad5b
jmp 0xad68
movq %rax, %r15
movq %r14, %rdi
callq 0x6340
jmp 0xad68
movq %rax, %r15
movq %rbx, %rdi
callq 0x85aa
movq %r15, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/mpi/io.cpp
|
diy::Link::fix(diy::Assigner const&)
|
void fix(const Assigner& assigner) { for (unsigned i = 0; i < neighbors_.size(); ++i) { neighbors_[i].proc = assigner.rank(neighbors_[i].gid); } }
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rcx
xorl %eax, %eax
movl %eax, %r15d
movq 0x10(%r14), %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0xaeaa
movl (%rcx,%r15,8), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x8(%r14), %rcx
movl %eax, 0x4(%rcx,%r15,8)
leal 0x1(%r15), %eax
jmp 0xae7b
popq %rbx
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/link.hpp
|
diy::Serialization<std::vector<diy::io::detail::GidOffsetCount, std::allocator<diy::io::detail::GidOffsetCount>>>::load(diy::BinaryBuffer&, std::vector<diy::io::detail::GidOffsetCount, std::allocator<diy::io::detail::GidOffsetCount>>&)
|
static void load(BinaryBuffer& bb, Vector& v)
{
size_t s;
diy::load(bb, s);
v.resize(s, U());
if (s > 0)
diy::load(bb, &v[0], s);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq %rsp, %r15
pushq $0x8
popq %rdx
movq %r15, %rsi
callq *0x20(%rax)
leaq 0x8(%rsp), %rdx
orl $-0x1, (%rdx)
movq (%r15), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdx)
movq %r14, %rdi
callq 0xb0ac
movq (%r15), %rdx
testq %rdx, %rdx
je 0xb0a1
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xb0e7
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/diatomic[P]diy/include/diy/serialization.hpp
|
void fmt::v7::detail::buffer<char>::append<char>(char const*, char const*)
|
void buffer<T>::append(const U* begin, const U* end) {
do {
auto count = to_unsigned(end - begin);
try_reserve(size_ + count);
auto free_cap = capacity_ - size_;
if (free_cap < count) count = free_cap;
std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count));
size_ += count;
begin += count;
} while (begin != end);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movq %rbx, %r13
subq %r14, %r13
leaq (%rdi,%r13), %rsi
movq 0x18(%r15), %r12
cmpq %rsi, %r12
jae 0xe0a5
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq 0x10(%r15), %rdi
movq 0x18(%r15), %r12
subq %rdi, %r12
cmpq %r13, %r12
cmovaeq %r13, %r12
testq %r12, %r12
je 0xe0c7
addq 0x8(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6730
movq 0x10(%r15), %rdi
addq %r12, %rdi
movq %rdi, 0x10(%r15)
addq %r12, %r14
cmpq %rbx, %r14
jne 0xe082
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
void fmt::v7::detail::fallback_format<long double>(long double, int, bool, fmt::v7::detail::buffer<char>&, int&)
|
void fallback_format(Double d, int num_digits, bool binary32, buffer<char>& buf,
int& exp10) {
bigint numerator; // 2 * R in (FPP)^2.
bigint denominator; // 2 * S in (FPP)^2.
// lower and upper are differences between value and corresponding boundaries.
bigint lower; // (M^- in (FPP)^2).
bigint upper_store; // upper's value if different from lower.
bigint* upper = nullptr; // (M^+ in (FPP)^2).
fp value;
// Shift numerator and denominator by an extra bit or two (if lower boundary
// is closer) to make lower and upper integers. This eliminates multiplication
// by 2 during later computations.
const bool is_predecessor_closer =
binary32 ? value.assign(static_cast<float>(d)) : value.assign(d);
int shift = is_predecessor_closer ? 2 : 1;
uint64_t significand = value.f << shift;
if (value.e >= 0) {
numerator.assign(significand);
numerator <<= value.e;
lower.assign(1);
lower <<= value.e;
if (shift != 1) {
upper_store.assign(1);
upper_store <<= value.e + 1;
upper = &upper_store;
}
denominator.assign_pow10(exp10);
denominator <<= shift;
} else if (exp10 < 0) {
numerator.assign_pow10(-exp10);
lower.assign(numerator);
if (shift != 1) {
upper_store.assign(numerator);
upper_store <<= 1;
upper = &upper_store;
}
numerator *= significand;
denominator.assign(1);
denominator <<= shift - value.e;
} else {
numerator.assign(significand);
denominator.assign_pow10(exp10);
denominator <<= shift - value.e;
lower.assign(1);
if (shift != 1) {
upper_store.assign(1ULL << 1);
upper = &upper_store;
}
}
// Invariant: value == (numerator / denominator) * pow(10, exp10).
if (num_digits < 0) {
// Generate the shortest representation.
if (!upper) upper = &lower;
bool even = (value.f & 1) == 0;
num_digits = 0;
char* data = buf.data();
for (;;) {
int digit = numerator.divmod_assign(denominator);
bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower.
// numerator + upper >[=] pow10:
bool high = add_compare(numerator, *upper, denominator) + even > 0;
data[num_digits++] = static_cast<char>('0' + digit);
if (low || high) {
if (!low) {
++data[num_digits - 1];
} else if (high) {
int result = add_compare(numerator, numerator, denominator);
// Round half to even.
if (result > 0 || (result == 0 && (digit % 2) != 0))
++data[num_digits - 1];
}
buf.try_resize(to_unsigned(num_digits));
exp10 -= num_digits - 1;
return;
}
numerator *= 10;
lower *= 10;
if (upper != &lower) *upper *= 10;
}
}
// Generate the given number of digits.
exp10 -= num_digits - 1;
if (num_digits == 0) {
buf.try_resize(1);
denominator *= 10;
buf[0] = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
return;
}
buf.try_resize(to_unsigned(num_digits));
for (int i = 0; i < num_digits - 1; ++i) {
int digit = numerator.divmod_assign(denominator);
buf[i] = static_cast<char>('0' + digit);
numerator *= 10;
}
int digit = numerator.divmod_assign(denominator);
auto result = add_compare(numerator, numerator, denominator);
if (result > 0 || (result == 0 && (digit % 2) != 0)) {
if (digit == 9) {
const auto overflow = '0' + 10;
buf[num_digits - 1] = overflow;
// Propagate the carry.
for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
buf[i] = '0';
++buf[i - 1];
}
if (buf[0] == overflow) {
buf[0] = '1';
++exp10;
}
return;
}
++digit;
}
buf[num_digits - 1] = static_cast<char>('0' + digit);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp # imm = 0x308
movq %rcx, 0x10(%rsp)
leaq 0xf8(%rsp), %rax
andq $0x0, 0x10(%rax)
leaq 0x2f6a9(%rip), %rcx # 0x40508
movq %rcx, (%rax)
pushq $0x20
popq %r8
leaq (%rax,%r8), %r9
movq %r9, 0x8(%rax)
movq %r8, 0x18(%rax)
andl $0x0, 0xa8(%rax)
leaq 0x48(%rsp), %rax
andq $0x0, 0x10(%rax)
movq %rdx, (%rsp)
movq %rcx, (%rax)
leaq (%rax,%r8), %rdx
movq %rdx, 0x8(%rax)
movq %r8, 0x18(%rax)
andl $0x0, 0xa8(%rax)
leaq 0x1a8(%rsp), %rdx
andq $0x0, 0x10(%rdx)
movq %rcx, (%rdx)
leaq (%rdx,%r8), %rax
movq %rax, 0x8(%rdx)
movq %r8, 0x18(%rdx)
andl $0x0, 0xa8(%rdx)
leaq 0x258(%rsp), %rdx
andq $0x0, 0x10(%rdx)
movl %edi, %r13d
movq %rcx, (%rdx)
leaq (%rdx,%r8), %rax
movq %rax, 0x8(%rdx)
movq %r8, 0x18(%rdx)
movq %rdx, 0x8(%rsp)
andl $0x0, 0xa8(%rdx)
fldt 0x340(%rsp)
andq $0x0, 0x20(%rsp)
andl $0x0, 0x28(%rsp)
testl %esi, %esi
je 0x10fa0
fstps 0x3c(%rsp)
movss 0x3c(%rsp), %xmm0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x1155a
movl %eax, %r14d
movzbl %al, %ebp
incl %ebp
movq (%rbx), %r12
movl %ebp, %ecx
shlq %cl, %r12
cmpl $0x0, 0x8(%rbx)
jns 0x10fab
movq 0x10(%rsp), %rax
movl (%rax), %esi
testl %esi, %esi
js 0x11309
leaq 0xf8(%rsp), %rdi
movq %r12, %rsi
callq 0x1159e
movq 0x10(%rsp), %rax
movl (%rax), %esi
leaq 0x48(%rsp), %rdi
callq 0x1163c
subl 0x28(%rsp), %ebp
leaq 0x48(%rsp), %rdi
movl %ebp, %esi
callq 0x115c8
leaq 0x1a8(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x1159e
testb %r14b, %r14b
je 0x1135e
pushq $0x2
popq %rsi
leaq 0x258(%rsp), %rdi
callq 0x1159e
jmp 0x11042
fstp %st(0)
pushq $0x1
popq %rbp
xorl %r12d, %r12d
xorl %r14d, %r14d
leaq 0xf8(%rsp), %rdi
movq %r12, %rsi
callq 0x1159e
movl 0x28(%rsp), %esi
leaq 0xf8(%rsp), %rdi
callq 0x115c8
leaq 0x1a8(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x1159e
movl 0x28(%rsp), %esi
leaq 0x1a8(%rsp), %rdi
callq 0x115c8
testb %r14b, %r14b
je 0x1101c
leaq 0x258(%rsp), %rdi
pushq $0x1
popq %rsi
movq %rdi, 0x8(%rsp)
callq 0x1159e
movl 0x28(%rsp), %esi
incl %esi
leaq 0x258(%rsp), %rdi
callq 0x115c8
jmp 0x11025
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %esi
leaq 0x48(%rsp), %rdi
callq 0x1163c
leaq 0x48(%rsp), %rdi
movl %ebp, %esi
callq 0x115c8
testl %r13d, %r13d
js 0x110a3
leal -0x1(%r13), %eax
movq 0x10(%rsp), %rcx
subl %eax, (%rcx)
movl %r13d, %r15d
subl $0x1, %r15d
jae 0x111b8
pushq $0x1
popq %rsi
movq (%rsp), %rdi
callq 0xdb16
leaq 0x48(%rsp), %rdi
pushq $0xa
popq %rsi
callq 0x11d84
leaq 0xf8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rdi, %rsi
callq 0x117b8
testl %eax, %eax
setg %al
orb $0x30, %al
movq (%rsp), %rcx
movq 0x8(%rcx), %rcx
movb %al, (%rcx)
jmp 0x112c6
movq 0x8(%rsp), %rax
testq %rax, %rax
movq %rax, %rcx
leaq 0x1a8(%rsp), %rax
cmoveq %rax, %rcx
movq %rcx, 0x40(%rsp)
movl 0x20(%rsp), %ebp
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
notl %ebp
andl $0x1, %ebp
movl %ebp, %eax
negl %eax
movl %eax, 0x1c(%rsp)
xorl %r14d, %r14d
leaq 0xf8(%rsp), %r12
pushq $0xa
popq %rbx
movq %r12, %rdi
leaq 0x48(%rsp), %rsi
callq 0x116fe
movl %eax, %r15d
movq %r12, %rdi
leaq 0x1a8(%rsp), %rsi
callq 0x11745
movl %eax, %r13d
movq %r12, %rdi
movq 0x40(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x117b8
leal 0x30(%r15), %ecx
movq 0x30(%rsp), %rdx
movb %cl, (%rdx,%r14)
cmpl %ebp, %r13d
jl 0x1116a
cmpl 0x1c(%rsp), %eax
jg 0x1116a
movq %r12, %rdi
movl %ebx, %esi
callq 0x11d84
leaq 0x1a8(%rsp), %rdi
movl %ebx, %esi
callq 0x11d84
cmpq $0x0, 0x8(%rsp)
je 0x11165
movq 0x8(%rsp), %rdi
movl %ebx, %esi
callq 0x11d84
incq %r14
jmp 0x110eb
cmpl %ebp, %r13d
jge 0x1127c
cmpl 0x1c(%rsp), %eax
jle 0x11289
leaq 0xf8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rdi, %rsi
callq 0x117b8
testl %eax, %eax
jg 0x111a8
setne %al
testb $0x1, %r15b
sete %cl
orb %al, %cl
jne 0x11289
movq 0x30(%rsp), %rax
movb (%rax,%r14), %al
incb %al
jmp 0x11280
movl %r13d, %esi
movq (%rsp), %rdi
callq 0xdb16
movl %r15d, %r12d
xorl %r13d, %r13d
leaq 0xf8(%rsp), %rbx
leaq 0x48(%rsp), %r14
pushq $0xa
popq %rbp
cmpq %r13, %r12
je 0x11207
movq %rbx, %rdi
movq %r14, %rsi
callq 0x116fe
addb $0x30, %al
movq (%rsp), %rcx
movq 0x8(%rcx), %rcx
movb %al, (%rcx,%r13)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x11d84
incq %r13
jmp 0x111da
leaq 0xf8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x116fe
movl %eax, %ebx
leaq 0xf8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rdi, %rsi
callq 0x117b8
testl %eax, %eax
jg 0x11241
setne %al
testb $0x1, %bl
sete %cl
orb %al, %cl
jne 0x112a4
cmpl $0x9, %ebx
jne 0x112a2
movq (%rsp), %rdx
movq 0x8(%rdx), %rax
movslq %r15d, %rcx
movb $0x3a, (%rax,%rcx)
movq 0x8(%rdx), %rax
testl %r15d, %r15d
jle 0x112b7
movl %r15d, %ecx
cmpb $0x3a, (%rax,%rcx)
jne 0x112b7
movb $0x30, (%rax,%rcx)
decl %r15d
movq (%rsp), %rdx
movq 0x8(%rdx), %rax
incb (%rax,%r15)
jmp 0x11255
leal 0x31(%r15), %eax
movq 0x30(%rsp), %rcx
movb %al, (%rcx,%r14)
leaq 0x1(%r14), %rax
movl %eax, %esi
movq (%rsp), %rdi
callq 0xdb16
movq 0x10(%rsp), %rax
subl %r14d, (%rax)
jmp 0x112c6
incl %ebx
addb $0x30, %bl
movq (%rsp), %rax
movq 0x8(%rax), %rax
movslq %r15d, %rcx
movb %bl, (%rax,%rcx)
jmp 0x112c6
cmpb $0x3a, (%rax)
jne 0x112c6
movb $0x31, (%rax)
movq 0x10(%rsp), %rax
incl (%rax)
leaq 0x258(%rsp), %rdi
callq 0x11bc6
leaq 0x1a8(%rsp), %rdi
callq 0x11bc6
leaq 0x48(%rsp), %rdi
callq 0x11bc6
leaq 0xf8(%rsp), %rdi
callq 0x11bc6
addq $0x308, %rsp # imm = 0x308
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
negl %esi
leaq 0xf8(%rsp), %rdi
callq 0x1163c
leaq 0x1a8(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x116ba
testb %r14b, %r14b
je 0x1136c
leaq 0x258(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
movq %rdi, 0x8(%rsp)
callq 0x116ba
pushq $0x1
popq %rsi
leaq 0x258(%rsp), %rdi
callq 0x115c8
jmp 0x11375
movq $0x0, 0x8(%rsp)
jmp 0x11042
movq $0x0, 0x8(%rsp)
leaq 0xf8(%rsp), %rdi
movq %r12, %rsi
callq 0x11be4
leaq 0x48(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x1159e
subl 0x28(%rsp), %ebp
leaq 0x48(%rsp), %rdi
movl %ebp, %esi
callq 0x115c8
jmp 0x11042
jmp 0x113b7
jmp 0x113b7
jmp 0x113b7
jmp 0x113b7
jmp 0x113b7
jmp 0x113b7
jmp 0x113b7
jmp 0x113b7
movq %rax, %rbx
leaq 0x258(%rsp), %rdi
callq 0x11bc6
leaq 0x1a8(%rsp), %rdi
callq 0x11bc6
leaq 0x48(%rsp), %rdi
callq 0x11bc6
leaq 0xf8(%rsp), %rdi
callq 0x11bc6
movq %rbx, %rdi
callq 0x67d0
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h
|
fmt::v7::detail::fixed_handler::on_digit(char, unsigned long, unsigned long, unsigned long, int, bool)
|
digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
uint64_t error, int, bool integral) {
FMT_ASSERT(remainder < divisor, "");
buf[size++] = digit;
if (!integral && error >= remainder) return digits::error;
if (size < precision) return digits::more;
if (!integral) {
// Check if error * 2 < divisor with overflow prevention.
// The check is not needed for the integral part because error = 1
// and divisor > (1 << 32) there.
if (error >= divisor || error >= divisor - error) return digits::error;
} else {
FMT_ASSERT(error == 1 && divisor > 2, "");
}
auto dir = get_round_direction(divisor, remainder, error);
if (dir != round_direction::up)
return dir == round_direction::down ? digits::done : digits::error;
++buf[size - 1];
for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
buf[i] = '0';
++buf[i - 1];
}
if (buf[0] > '9') {
buf[0] = '1';
if (fixed)
buf[size++] = '0';
else
++exp10;
}
return digits::done;
}
|
pushq %rbx
movq %rdi, %rbx
movb 0x10(%rsp), %dil
movl %edi, %eax
xorb $0x1, %al
movq (%rbx), %r9
movslq 0x8(%rbx), %r10
leal 0x1(%r10), %r11d
movl %r11d, 0x8(%rbx)
movb %sil, (%r9,%r10)
cmpq %rcx, %r8
setae %r9b
pushq $0x2
popq %rsi
testb %al, %r9b
jne 0x114ea
movl 0x8(%rbx), %r9d
xorl %eax, %eax
cmpl 0xc(%rbx), %r9d
jl 0x114ec
testb %dil, %dil
jne 0x114a9
movq %rdx, %rax
subq %r8, %rax
setbe %dil
cmpq %r8, %rax
setbe %al
orb %dil, %al
movl %esi, %eax
jne 0x114ec
movq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x11525
cmpl $0x1, %eax
jne 0x114ee
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
incb -0x1(%rax,%rcx)
movl 0x8(%rbx), %eax
movq (%rbx), %rcx
cmpl $0x2, %eax
jl 0x114fc
cmpb $0x39, -0x1(%rcx,%rax)
jle 0x114fc
movb $0x30, -0x1(%rcx,%rax)
movq (%rbx), %rcx
incb -0x2(%rcx,%rax)
decq %rax
jmp 0x114ca
movl %esi, %eax
popq %rbx
retq
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
setne %al
incl %eax
jmp 0x114ec
pushq $0x1
popq %rax
cmpb $0x39, (%rcx)
jle 0x114ec
movb $0x31, (%rcx)
cmpb $0x1, 0x14(%rbx)
jne 0x11520
movq (%rbx), %rcx
movslq 0x8(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x8(%rbx)
movb $0x30, (%rcx,%rdx)
jmp 0x114ec
incl 0x10(%rbx)
jmp 0x114ec
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h
|
fmt::v7::detail::get_round_direction(unsigned long, unsigned long, unsigned long)
|
inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
uint64_t error) {
FMT_ASSERT(remainder < divisor, ""); // divisor - remainder won't overflow.
FMT_ASSERT(error < divisor, ""); // divisor - error won't overflow.
FMT_ASSERT(error < divisor - error, ""); // error * 2 won't overflow.
// Round down if (remainder + error) * 2 <= divisor.
if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
return round_direction::down;
// Round up if (remainder - error) * 2 >= divisor.
if (remainder >= error &&
remainder - error >= divisor - (remainder - error)) {
return round_direction::up;
}
return round_direction::unknown;
}
|
movq %rdi, %rax
subq %rsi, %rax
cmpq %rsi, %rax
jb 0x11542
leaq (%rdx,%rdx), %rax
movq %rdi, %r8
subq %rsi, %r8
subq %rsi, %r8
cmpq %r8, %rax
jbe 0x11552
subq %rdx, %rsi
jb 0x1154f
subq %rsi, %rdi
cmpq %rdi, %rsi
jae 0x11556
xorl %eax, %eax
retq
pushq $0x2
jmp 0x11558
pushq $0x1
popq %rax
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h
|
fmt::v7::detail::bigint::assign(unsigned long)
|
void assign(uint64_t n) {
size_t num_bigits = 0;
do {
bigits_[num_bigits++] = n & ~bigit(0);
n >>= bigit_bits;
} while (n != 0);
bigits_.resize(num_bigits);
exp_ = 0;
}
|
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
xorl %esi, %esi
movl %eax, (%rcx,%rsi,4)
incq %rsi
shrq $0x20, %rax
jne 0x115ab
movq %rbx, %rdi
callq 0x1196c
andl $0x0, 0xa8(%rbx)
popq %rbx
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h
|
fmt::v7::detail::bigint::operator<<=(int)
|
FMT_NOINLINE bigint& operator<<=(int shift) {
assert(shift >= 0);
exp_ += shift / bigit_bits;
shift %= bigit_bits;
if (shift == 0) return *this;
bigit carry = 0;
for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
bigit c = bigits_[i] >> (bigit_bits - shift);
bigits_[i] = (bigits_[i] << shift) + carry;
carry = c;
}
if (carry != 0) bigits_.push_back(carry);
return *this;
}
|
pushq %rbx
subq $0x10, %rsp
movl %esi, %eax
movq %rdi, %rbx
pushq $0x20
popq %rsi
cltd
idivl %esi
addl %eax, 0xa8(%rdi)
testl %edx, %edx
je 0x11633
andl $0x0, 0xc(%rsp)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
subl %edx, %esi
xorl %r9d, %r9d
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x11621
movl (%rax,%r8,4), %r10d
movl %r10d, %r11d
movl %esi, %ecx
shrl %cl, %r11d
movl %edx, %ecx
shll %cl, %r10d
addl %r9d, %r10d
movl %r10d, (%rax,%r8,4)
movl %r11d, 0xc(%rsp)
incq %r8
movl %r11d, %r9d
jmp 0x115f7
testl %r9d, %r9d
je 0x11633
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x119a2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h
|
fmt::v7::detail::bigint::assign_pow10(int)
|
void assign_pow10(int exp) {
assert(exp >= 0);
if (exp == 0) return assign(1);
// Find the top bit.
int bitmask = 1;
while (exp >= bitmask) bitmask <<= 1;
bitmask >>= 1;
// pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
// repeated squaring and multiplication.
assign(5);
bitmask >>= 1;
while (bitmask != 0) {
square();
if ((exp & bitmask) != 0) *this *= 5;
bitmask >>= 1;
}
*this <<= exp; // Multiply by pow(2, exp) by shifting.
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x116a4
movl %esi, %ebp
pushq $0x1
popq %rax
movl %eax, %r15d
leal (%r15,%r15), %eax
cmpl %ebp, %r15d
jle 0x1164f
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x1159e
sarl $0x2, %r15d
pushq $0x5
popq %r14
testl %r15d, %r15d
je 0x11690
movq %rbx, %rdi
callq 0x119e0
testl %ebp, %r15d
je 0x1168b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11d84
sarl %r15d
jmp 0x1166e
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x115c8
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1159e
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h
|
fmt::v7::detail::bigint::assign(fmt::v7::detail::bigint const&)
|
void assign(const bigint& other) {
auto size = other.bigits_.size();
bigits_.resize(size);
auto data = other.bigits_.data();
std::copy(data, data + size, make_checked(bigits_.data(), size));
exp_ = other.exp_;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq %r15, %rsi
callq 0x1196c
testq %r15, %r15
je 0x116ea
movq 0x8(%r14), %rsi
shlq $0x2, %r15
movq 0x8(%rbx), %rdi
movq %r15, %rdx
callq 0x6730
movl 0xa8(%r14), %eax
movl %eax, 0xa8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h
|
fmt::v7::detail::compare(fmt::v7::detail::bigint const&, fmt::v7::detail::bigint const&)
|
size_t size() const FMT_NOEXCEPT { return size_; }
|
movq 0x10(%rdi), %r8
movl 0xa8(%rdi), %eax
addl %r8d, %eax
movl 0x10(%rsi), %ecx
movl 0xa8(%rsi), %edx
addl %ecx, %edx
cmpl %edx, %eax
jne 0x1179b
movl %r8d, %edx
subl %ecx, %r8d
xorl %eax, %eax
testl %r8d, %r8d
cmovgl %r8d, %eax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
cmpl %edx, %eax
jge 0x117a3
decl %ecx
movl -0x4(%rdi,%rdx,4), %r8d
decq %rdx
movl (%rsi,%rcx,4), %r9d
cmpl %r9d, %r8d
je 0x11778
xorl %eax, %eax
cmpl %r8d, %r9d
adcl $-0x1, %eax
orl $0x1, %eax
retq
setg %al
movzbl %al, %eax
jmp 0x117b0
xorl %eax, %eax
cmpl %edx, %ecx
je 0x117b7
xorl %eax, %eax
cmpl %edx, %ecx
setl %al
leal -0x1(,%rax,2), %eax
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/core.h
|
fmt::v7::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::grow(unsigned long)
|
void basic_memory_buffer<T, SIZE, Allocator>::grow(size_t size) {
#ifdef FMT_FUZZ
if (size > 5000) throw std::runtime_error("fuzz mode - won't grow that much");
#endif
size_t old_capacity = this->capacity();
size_t new_capacity = old_capacity + old_capacity / 2;
if (size > new_capacity) new_capacity = size;
T* old_data = this->data();
T* new_data =
std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
// The following code doesn't throw, so the raw pointer above doesn't leak.
std::uninitialized_copy(old_data, old_data + this->size(),
detail::make_checked(new_data, new_capacity));
this->set(new_data, new_capacity);
// deallocate must not throw according to the standard, but even if it does,
// the buffer already uses the new storage and will deallocate it in
// destructor.
if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rbx
movq 0x18(%rdi), %r14
movq %r14, %r12
shrq %r12
addq %r14, %r12
cmpq %rsi, %r12
cmovbeq %rsi, %r12
addq $0xa0, %rdi
movq %r12, %rsi
callq 0x1193c
movq %rax, %r13
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x11908
shlq $0x2, %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x6730
movq %r13, 0x8(%r15)
movq %r12, 0x18(%r15)
addq $0x20, %r15
cmpq %r15, %rbx
je 0x11931
shlq $0x2, %r14
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6450
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::bigint::square()
|
void square() {
basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
int num_bigits = static_cast<int>(bigits_.size());
int num_result_bigits = 2 * num_bigits;
bigits_.resize(to_unsigned(num_result_bigits));
using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
auto sum = accumulator_t();
for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
// Compute bigit at position bigit_index of the result by adding
// cross-product terms n[i] * n[j] such that i + j == bigit_index.
for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
// Most terms are multiplied twice which can be optimized in the future.
sum += static_cast<double_bigit>(n[i]) * n[j];
}
(*this)[bigit_index] = static_cast<bigit>(sum);
sum >>= bits<bigit>::value; // Compute the carry.
}
// Do the same for the top half.
for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
++bigit_index) {
for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
sum += static_cast<double_bigit>(n[i++]) * n[j--];
(*this)[bigit_index] = static_cast<bigit>(sum);
sum >>= bits<bigit>::value;
}
--num_result_bigits;
remove_leading_zeros();
exp_ *= 2;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x11b08
movq 0x10(%rbx), %r15
leal (%r15,%r15), %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1196c
movq 0x8(%rbx), %rdx
xorl %esi, %esi
testl %r15d, %r15d
movl $0x0, %edi
cmovgl %r15d, %edi
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rdi, %rsi
je 0x11a6e
movq 0x10(%rsp), %r8
movq %r8, %r9
movq %rsi, %r10
cmpq $-0x1, %r10
je 0x11a5d
movl (%r9), %r11d
movl %r10d, %r12d
movl (%r8,%r12,4), %r12d
imulq %r11, %r12
addq %r12, %rax
adcq $0x0, %rcx
decq %r10
addq $0x4, %r9
jmp 0x11a39
movl %eax, (%rdx,%rsi,4)
shrdq $0x20, %rcx, %rax
shrq $0x20, %rcx
incq %rsi
jmp 0x11a29
movq 0x8(%rbx), %rdx
leal -0x1(%r15), %esi
movslq %esi, %rsi
movslq %r15d, %rdi
pushq $0x1
popq %r8
cmpl %r14d, %r15d
jge 0x11ac8
movslq %r8d, %r9
movq 0x10(%rsp), %r10
movq %rsi, %r11
cmpq %rdi, %r9
jge 0x11ab0
movl (%r10,%r9,4), %r12d
incq %r9
movl (%r10,%r11,4), %r13d
decq %r11
imulq %r12, %r13
addq %r13, %rax
adcq $0x0, %rcx
jmp 0x11a90
movl %r15d, %r9d
movl %eax, (%rdx,%r9,4)
shrdq $0x20, %rcx, %rax
shrq $0x20, %rcx
incl %r15d
incl %r8d
jmp 0x11a80
movq %rbx, %rdi
callq 0x11b2e
shll 0xa8(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x11bc6
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x11af3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11bc6
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h
|
fmt::v7::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::move(fmt::v7::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>&)
|
void move(basic_memory_buffer& other) {
alloc_ = std::move(other.alloc_);
T* data = other.data();
size_t size = other.size(), capacity = other.capacity();
if (data == other.store_) {
this->set(store_, capacity);
std::uninitialized_copy(other.store_, other.store_ + size,
detail::make_checked(store_, capacity));
} else {
this->set(data, capacity);
// Set pointer to the inline array so that delete is not called
// when deallocating.
other.set(other.store_, 0);
}
this->resize(size);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %rcx
addq $0x20, %rsi
cmpq %rsi, %rdx
je 0x11b96
movq %rdx, 0x8(%rbx)
movq %rcx, 0x18(%rbx)
movq %rsi, 0x8(%rax)
andq $0x0, 0x18(%rax)
jmp 0x11bb4
leaq 0x20(%rbx), %rdi
movq %rdi, 0x8(%rbx)
movq %rcx, 0x18(%rbx)
testq %r14, %r14
je 0x11bb4
leaq (,%r14,4), %rdx
callq 0x6730
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1196c
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::bigint::subtract_aligned(fmt::v7::detail::bigint const&)
|
void subtract_aligned(const bigint& other) {
FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
FMT_ASSERT(compare(*this, other) >= 0, "");
bigit borrow = 0;
int i = other.exp_ - exp_;
for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
subtract_bigits(i, other.bigits_[j], borrow);
while (borrow > 0) subtract_bigits(i, 0, borrow);
remove_leading_zeros();
}
|
pushq %rbx
movl 0xa8(%rsi), %eax
subl 0xa8(%rdi), %eax
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rsi
movq 0x8(%rdi), %r9
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x11d1b
leaq (%rax,%r8), %r10
movl (%rdx,%r8,4), %r11d
movl %r10d, %r10d
movl %ecx, %ecx
movl (%r9,%r10,4), %ebx
addq %r11, %rcx
subq %rcx, %rbx
movl %ebx, (%r9,%r10,4)
shrq $0x3f, %rbx
incq %r8
movl %ebx, %ecx
jmp 0x11cf0
movq 0x8(%rdi), %rdx
addl %r8d, %eax
testl %ecx, %ecx
je 0x11d39
movl %ecx, %ecx
movl (%rdx,%rax,4), %esi
subq %rcx, %rsi
movl %esi, (%rdx,%rax,4)
shrq $0x3f, %rsi
movl %esi, %ecx
jmp 0x11d22
popq %rbx
jmp 0x11b2e
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h
|
fmt::v7::detail::bigint::multiply(unsigned int)
|
void multiply(uint32_t value) {
const double_bigit wide_value = value;
bigit carry = 0;
for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
double_bigit result = bigits_[i] * wide_value + carry;
bigits_[i] = static_cast<bigit>(result);
carry = static_cast<bigit>(result >> bigit_bits);
}
if (carry != 0) bigits_.push_back(carry);
}
|
pushq %rax
movl %esi, %eax
andl $0x0, 0x4(%rsp)
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rsi
xorl %edx, %edx
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x11dbc
movl (%rcx,%r8,4), %r9d
imulq %rax, %r9
movl %edx, %edx
addq %r9, %rdx
movl %edx, (%rcx,%r8,4)
shrq $0x20, %rdx
movl %edx, 0x4(%rsp)
incq %r8
jmp 0x11d99
testl %edx, %edx
je 0x11dca
leaq 0x4(%rsp), %rsi
callq 0x119a2
popq %rax
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h
|
fmt::v7::detail::big_decimal_fp fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp, char>(fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(fmt::v7::detail::big_decimal_fp, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp, char>(fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda'(fmt::v7::detail::buffer_appender<char>)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl (%rsi), %eax
xorl %ebx, %ebx
subq %rcx, %rax
cmovaeq %rax, %rbx
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x17102(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %rbx, %r15
shrq %cl, %r15
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r12
imulq %rbx, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0xda49
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe8c9
movq %r14, %rdi
movq %rax, %rsi
callq 0x11e70
subq %r15, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8c9
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::big_decimal_fp fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp, char>(fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda1'(fmt::v7::detail::buffer_appender<char>)&>(fmt::v7::detail::big_decimal_fp, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_float<fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp, char>(fmt::v7::detail::buffer_appender<char>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda1'(fmt::v7::detail::buffer_appender<char>)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl (%rsi), %eax
xorl %ebx, %ebx
subq %rcx, %rax
cmovaeq %rax, %rbx
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x16efa(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %rbx, %r15
shrq %cl, %r15
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r12
imulq %rbx, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0xda49
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe8c9
movq %r14, %rdi
movq %rax, %rsi
callq 0x12194
subq %r15, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8c9
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<4u, char, fmt::v7::detail::buffer_appender<char>, unsigned long>(fmt::v7::detail::buffer_appender<char>, unsigned long, int, bool)
|
inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[num_bits<UInt>() / BASE_BITS + 1];
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str<Char>(buffer, buffer + num_digits, out);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
callq 0xda64
movzbl %r15b, %ecx
testq %rax, %rax
je 0x12500
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x12533
jmp 0x12525
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x12533
movslq %ebp, %rax
leaq (%rsp,%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xdb8a
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
void fmt::v7::detail::parse_format_string<false, char, fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>&>(fmt::v7::basic_string_view<char>, fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>&)::pfs_writer::operator()(char const*, char const*)
|
FMT_CONSTEXPR void operator()(const Char* pbegin, const Char* pend) {
if (pbegin == pend) return;
for (;;) {
const Char* p = nullptr;
if (!find<IS_CONSTEXPR>(pbegin, pend, '}', p))
return handler_.on_text(pbegin, pend);
++p;
if (p == pend || *p != '}')
return handler_.on_error("unmatched '}' in format string");
handler_.on_text(pbegin, p);
pbegin = p + 1;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq %rdx, %rsi
je 0x128ea
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x7d
popq %rbp
leaq 0x8(%rsp), %r12
andq $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r12, %rcx
callq 0x12854
testb %al, %al
je 0x128dc
movq 0x8(%rsp), %rdx
incq %rdx
movq %rdx, 0x8(%rsp)
cmpq %rbx, %rdx
je 0x128f7
cmpb $0x7d, (%rdx)
jne 0x128f7
movq (%r14), %rdi
movq %r15, %rsi
callq 0x12578
movq 0x8(%rsp), %r15
incq %r15
jmp 0x12896
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12578
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
leaq 0x15c9a(%rip), %rsi # 0x2859b
callq 0xd8f6
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char const* fmt::v7::detail::parse_arg_id<char, fmt::v7::detail::id_adapter<fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>&, char>&>(char const*, char const*, fmt::v7::detail::id_adapter<fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>&, char>&)
|
FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) {
FMT_ASSERT(begin != end, "");
Char c = *begin;
if (c == '}' || c == ':') {
handler();
return begin;
}
if (c >= '0' && c <= '9') {
int index = 0;
if (c != '0')
index = parse_nonnegative_int(begin, end, handler);
else
++begin;
if (begin == end || (*begin != '}' && *begin != ':'))
handler.on_error("invalid format string");
else
handler(index);
return begin;
}
if (!is_name_start(c)) {
handler.on_error("invalid format string");
return begin;
}
auto it = begin;
do {
++it;
} while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
return it;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
movzbl (%rdi), %eax
cmpl $0x7d, %eax
je 0x12927
cmpl $0x3a, %eax
jne 0x1293c
movq %rbx, %rdi
callq 0x12d10
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %r15
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x12957
cmpb $0x30, %al
jne 0x129b9
incq %r14
movq %r14, 0x8(%rsp)
xorl %eax, %eax
jmp 0x129cf
cmpb $0x5f, %al
je 0x12974
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x12974
leaq 0x15c50(%rip), %rsi # 0x285ba
movq %rbx, %rdi
callq 0x12d78
jmp 0x1292f
leaq 0x1(%r14), %rax
cmpq %r15, %rax
je 0x129a0
movb (%rax), %cl
leal -0x30(%rcx), %edx
incq %rax
cmpb $0xa, %dl
jb 0x12978
cmpb $0x5f, %cl
je 0x12978
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jb 0x12978
decq %rax
movq %rax, %r15
movq %r15, %rdx
subq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12da4
movq %r15, %r14
jmp 0x1292f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12d25
movq (%r14), %r14
cmpq %r15, %r14
je 0x129ee
movzbl (%r14), %ecx
cmpl $0x3a, %ecx
je 0x129e2
cmpl $0x7d, %ecx
jne 0x129ee
movq %rbx, %rdi
movl %eax, %esi
callq 0x12d82
jmp 0x129fd
leaq 0x15bc5(%rip), %rsi # 0x285ba
movq %rbx, %rdi
callq 0x12d78
movq 0x8(%rsp), %r14
jmp 0x1292f
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::format_handler<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>::on_format_specs(int, char const*, char const*)
|
const Char* on_format_specs(int id, const Char* begin, const Char* end) {
auto arg = get_arg(context, id);
if (arg.type() == type::custom_type) {
advance_to(parse_context, begin);
visit_format_arg(custom_formatter<Context>(parse_context, context), arg);
return parse_context.begin();
}
auto specs = basic_format_specs<Char>();
if (begin + 1 < end && begin[1] == '}' && is_ascii_letter(*begin)) {
specs.type = static_cast<char>(*begin++);
} else {
using parse_context_t = basic_format_parse_context<Char>;
specs_checker<specs_handler<parse_context_t, Context>> handler(
specs_handler<parse_context_t, Context>(specs, parse_context,
context),
arg.type());
begin = parse_format_specs(begin, end, handler);
if (begin == end || *begin != '}')
on_error("missing '}' in format string");
}
context.advance_to(visit_format_arg(
arg_formatter<OutputIt, Char>(context, &parse_context, &specs), arg));
return begin;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rcx, %r12
movq %rdx, %r13
movl %esi, %edx
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12cb4
movl 0x10(%r14), %ecx
cmpl $0xf, %ecx
jne 0x12a65
leaq 0x8(%r15), %rsi
movq 0x8(%r15), %rax
movq %r13, 0x8(%r15)
subq %r13, %rax
addq %rax, 0x10(%r15)
movq 0x20(%rsp), %rdi
movq %rbx, %rdx
callq *0x28(%rsp)
movq 0x8(%r15), %r14
jmp 0x12c4d
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rax, 0x10(%rsp)
movl $0x200000, 0x18(%rsp) # imm = 0x200000
andw $0x0, 0x1c(%rsp)
movb $0x1, 0x1e(%rsp)
leaq 0x1(%r13), %r14
cmpq %r12, %r14
jae 0x12aad
cmpb $0x7d, (%r14)
jne 0x12aad
movb (%r13), %al
movl %eax, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x12aad
movb %al, 0x18(%rsp)
jmp 0x12af1
leaq 0x8(%r15), %rax
leaq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rsi, (%rdx)
movq %rax, 0x8(%rdx)
movq %rbx, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
movl %ecx, 0x20(%rdx)
movq %r13, %rdi
movq %r12, %rsi
callq 0x12ee6
cmpq %r12, %rax
je 0x12ca5
movq %rax, %r14
cmpb $0x7d, (%rax)
jne 0x12ca5
movl 0x30(%rsp), %ecx
leaq 0x8(%r15), %rdx
movq 0x20(%r15), %rax
movq 0x38(%r15), %rsi
movq %rax, 0x40(%rsp)
movq %rsi, 0x48(%rsp)
leaq 0x10(%rsp), %rsi
movq %rsi, 0x50(%rsp)
movq %rbx, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
andq $0x0, 0x68(%rsp)
decl %ecx
cmpl $0xe, %ecx
ja 0x12c4a
leaq 0x1565d(%rip), %rax # 0x28190
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x20(%rsp), %esi
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x13d16
jmp 0x12c47
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x13ce0
jmp 0x12c4a
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x13c16
jmp 0x12c4a
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
callq 0x156da
jmp 0x12c47
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x13c50
jmp 0x12c4a
movsd 0x20(%rsp), %xmm0
leaq 0x40(%rsp), %rdi
callq 0x13b90
jmp 0x12c4a
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x14ac2
jmp 0x12c47
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x1567c
jmp 0x12c47
movsbl 0x20(%rsp), %esi
leaq 0x40(%rsp), %rdi
callq 0x13b2c
jmp 0x12c4a
movl 0x20(%rsp), %esi
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x14a64
jmp 0x12c47
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
callq 0x16454
movq (%r15), %rax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x13ca8
jmp 0x12c4a
movzbl 0x20(%rsp), %esi
leaq 0x40(%rsp), %rdi
callq 0x13afa
jmp 0x12c4a
fldt 0x20(%rsp)
fstpt (%rsp)
leaq 0x40(%rsp), %rdi
callq 0x13bcc
jmp 0x12c4a
movss 0x20(%rsp), %xmm0
leaq 0x40(%rsp), %rdi
callq 0x13b54
jmp 0x12c4a
leaq 0x1593d(%rip), %rsi # 0x285e9
movq %r15, %rdi
callq 0xd8f6
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
int fmt::v7::basic_format_args<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>::get_id<char>(fmt::v7::basic_string_view<char>) const
|
int get_id(basic_string_view<Char> name) const {
if (!has_named_args()) return -1;
const auto& named_args =
(is_packed() ? values_[-1] : args_[-1].value_).named_args;
for (size_t i = 0; i < named_args.size; ++i) {
if (named_args.data[i].name == name) return named_args.data[i].id;
}
return -1;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq (%rdi), %rcx
pushq $-0x1
popq %rax
btq $0x3e, %rcx
jae 0x12e6d
movq %rsi, %r15
movq 0x8(%rdi), %r13
xorl %ebp, %ebp
testq %rcx, %rcx
setns %bpl
shll $0x4, %ebp
orq $-0x20, %rbp
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpq 0x8(%r13,%rbp), %r14
jae 0x12e5f
movq (%r13,%rbp), %rax
movq (%rax,%rbx), %r12
movq %r12, %rdi
callq 0x6200
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq (%rsp), %rcx
callq 0x12e7c
testb %al, %al
jne 0x12e64
incq %r14
addq $0x10, %rbx
jmp 0x12e28
pushq $-0x1
popq %rax
jmp 0x12e6d
movq (%r13,%rbp), %rax
movl 0x8(%rax,%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/core.h
|
char const* fmt::v7::detail::parse_format_specs<char, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&>(char const*, char const*, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&)
|
FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
SpecHandler&& handler) {
if (begin == end) return begin;
begin = parse_align(begin, end, handler);
if (begin == end) return begin;
// Parse sign.
switch (to_ascii(*begin)) {
case '+':
handler.on_plus();
++begin;
break;
case '-':
handler.on_minus();
++begin;
break;
case ' ':
handler.on_space();
++begin;
break;
}
if (begin == end) return begin;
if (*begin == '#') {
handler.on_hash();
if (++begin == end) return begin;
}
// Parse zero flag.
if (*begin == '0') {
handler.on_zero();
if (++begin == end) return begin;
}
begin = parse_width(begin, end, handler);
if (begin == end) return begin;
// Parse precision.
if (*begin == '.') {
begin = parse_precision(begin, end, handler);
}
// Parse type.
if (begin != end && *begin != '}') handler.on_type(*begin++);
return begin;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x12fb3
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, %rdi
callq 0x12fbc
movq %rax, %rbx
cmpq %r15, %rax
je 0x12fb3
movzbl (%rbx), %eax
cmpl $0x20, %eax
je 0x12f37
cmpl $0x2d, %eax
je 0x12f2d
cmpl $0x2b, %eax
jne 0x12f42
movq %r14, %rdi
callq 0x13062
jmp 0x12f3f
movq %r14, %rdi
callq 0x13080
jmp 0x12f3f
movq %r14, %rdi
callq 0x1309e
incq %rbx
cmpq %r15, %rbx
je 0x12fb3
movb (%rbx), %al
cmpb $0x23, %al
jne 0x12f5f
movq %r14, %rdi
callq 0x130bc
incq %rbx
cmpq %r15, %rbx
je 0x12fb3
movb (%rbx), %al
cmpb $0x30, %al
jne 0x12f73
movq %r14, %rdi
callq 0x130d2
incq %rbx
cmpq %r15, %rbx
je 0x12fb3
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x130f7
movq %rax, %rbx
cmpq %r15, %rax
je 0x12fb3
cmpb $0x2e, (%rbx)
jne 0x12f9f
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1317f
movq %rax, %rbx
cmpq %r15, %rbx
je 0x12fb3
movb (%rbx), %al
cmpb $0x7d, %al
je 0x12fb3
incq %rbx
movq (%r14), %rcx
movb %al, 0x8(%rcx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char const* fmt::v7::detail::parse_width<char, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&>(char const*, char const*, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&)
|
FMT_CONSTEXPR const Char* parse_width(const Char* begin, const Char* end,
Handler&& handler) {
FMT_ASSERT(begin != end, "");
if ('0' <= *begin && *begin <= '9') {
handler.on_width(parse_nonnegative_int(begin, end, handler));
} else if (*begin == '{') {
++begin;
if (begin != end)
begin = parse_arg_id(begin, end, width_adapter<Handler, Char>(handler));
if (begin == end || *begin != '}')
return handler.on_error("invalid format string"), begin;
++begin;
}
return begin;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, (%rsp)
movb (%rdi), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x1312f
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x13347
movq (%r14), %rcx
movl %eax, (%rcx)
movq (%rbx), %rbx
jmp 0x13172
movq %rdi, %rbx
cmpb $0x7b, %al
jne 0x13172
incq %rbx
cmpq %r15, %rbx
je 0x13154
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1339a
movq %rax, %rbx
cmpq %r15, %rbx
je 0x13163
cmpb $0x7d, (%rbx)
jne 0x13163
incq %rbx
jmp 0x13172
leaq 0x15450(%rip), %rsi # 0x285ba
movq %r14, %rdi
callq 0x13248
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char const* fmt::v7::detail::parse_precision<char, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&>(char const*, char const*, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&)
|
FMT_CONSTEXPR const Char* parse_precision(const Char* begin, const Char* end,
Handler&& handler) {
++begin;
auto c = begin != end ? *begin : Char();
if ('0' <= c && c <= '9') {
handler.on_precision(parse_nonnegative_int(begin, end, handler));
} else if (c == '{') {
++begin;
if (begin != end) {
begin =
parse_arg_id(begin, end, precision_adapter<Handler, Char>(handler));
}
if (begin == end || *begin++ != '}')
return handler.on_error("invalid format string"), begin;
} else {
return handler.on_error("missing precision specifier"), begin;
}
handler.end_precision();
return begin;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
leaq 0x1(%rdi), %r12
movq %r12, 0x8(%rsp)
cmpq %rsi, %r12
je 0x13229
movq %rsi, %r15
movsbl (%r12), %eax
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0x131d8
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x13347
movq (%rbx), %rcx
movl %eax, 0x4(%rcx)
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x13ad8
movq 0x8(%rsp), %r12
jmp 0x13238
cmpb $0x7b, %al
jne 0x13229
movq %rdi, %r14
addq $0x2, %r14
cmpq %r15, %r14
je 0x131fe
leaq 0x10(%rsp), %rdx
movq %rbx, (%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x137a7
movq %rax, %r14
cmpq %r15, %r14
je 0x13215
leaq 0x1(%r14), %rax
movq %rax, 0x8(%rsp)
cmpb $0x7d, (%r14)
movq %rax, %r14
je 0x131c5
leaq 0x1539e(%rip), %rsi # 0x285ba
movq %rbx, %rdi
callq 0x13248
movq %r14, %r12
jmp 0x13238
leaq 0x154e9(%rip), %rsi # 0x28719
movq %rbx, %rdi
callq 0x13248
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::fill_t<char>::operator=(fmt::v7::basic_string_view<char>)
|
FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {
auto size = s.size();
if (size > max_size) {
FMT_THROW(format_error("invalid fill"));
return;
}
for (size_t i = 0; i < size; ++i) data_[i] = s[i];
size_ = static_cast<unsigned char>(size);
}
|
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x4, %rdx
ja 0x132b5
xorl %eax, %eax
cmpq %rax, %rdx
je 0x132aa
movb (%rsi,%rax), %cl
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x1329a
movb %dl, 0x4(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
leaq 0x153cc(%rip), %rsi # 0x28693
movq %rax, %rdi
callq 0xd93c
leaq 0x2cee2(%rip), %rsi # 0x401b8
movq 0x2dcbb(%rip), %rdx # 0x40f98
movq %rbx, %rdi
callq 0x67a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
int fmt::v7::detail::parse_nonnegative_int<char, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&>(char const*&, char const*, fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&)
|
FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
ErrorHandler&& eh) {
FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
unsigned value = 0;
// Convert to unsigned to prevent a warning.
constexpr unsigned max_int = max_value<int>();
unsigned big = max_int / 10;
do {
// Check for overflow.
if (value > big) {
value = max_int + 1;
break;
}
value = value * 10 + unsigned(*begin - '0');
++begin;
} while (begin != end && '0' <= *begin && *begin <= '9');
if (value > max_int) eh.on_error("number is too big");
return static_cast<int>(value);
}
|
pushq %rbx
movq (%rdi), %rax
incq %rax
xorl %ebx, %ebx
cmpl $0xccccccc, %ebx # imm = 0xCCCCCCC
ja 0x13382
imull $0xa, %ebx, %ecx
movsbl -0x1(%rax), %r8d
leal (%rcx,%r8), %ebx
addl $-0x30, %ebx
movq %rax, (%rdi)
cmpq %rsi, %rax
je 0x1337c
movb (%rax), %cl
addb $-0x30, %cl
incq %rax
cmpb $0xa, %cl
jb 0x13350
testl %ebx, %ebx
jns 0x13396
jmp 0x13387
movl $0x80000000, %ebx # imm = 0x80000000
leaq 0x151ab(%rip), %rsi # 0x28539
movq %rdx, %rdi
callq 0x13248
movl %ebx, %eax
popq %rbx
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char const* fmt::v7::detail::parse_arg_id<char, fmt::v7::detail::width_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>>(char const*, char const*, fmt::v7::detail::width_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>&&)
|
FMT_CONSTEXPR const Char* parse_arg_id(const Char* begin, const Char* end,
IDHandler&& handler) {
FMT_ASSERT(begin != end, "");
Char c = *begin;
if (c == '}' || c == ':') {
handler();
return begin;
}
if (c >= '0' && c <= '9') {
int index = 0;
if (c != '0')
index = parse_nonnegative_int(begin, end, handler);
else
++begin;
if (begin == end || (*begin != '}' && *begin != ':'))
handler.on_error("invalid format string");
else
handler(index);
return begin;
}
if (!is_name_start(c)) {
handler.on_error("invalid format string");
return begin;
}
auto it = begin;
do {
++it;
} while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
return it;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
movzbl (%rdi), %eax
cmpl $0x7d, %eax
je 0x133bb
cmpl $0x3a, %eax
jne 0x133d0
movq %rbx, %rdi
callq 0x1349c
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %r15
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x133eb
cmpb $0x30, %al
jne 0x1344d
incq %r14
movq %r14, 0x8(%rsp)
xorl %eax, %eax
jmp 0x13463
cmpb $0x5f, %al
je 0x13408
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x13408
leaq 0x151bc(%rip), %rsi # 0x285ba
movq %rbx, %rdi
callq 0x134f8
jmp 0x133c3
leaq 0x1(%r14), %rax
cmpq %r15, %rax
je 0x13434
movb (%rax), %cl
leal -0x30(%rcx), %edx
incq %rax
cmpb $0xa, %dl
jb 0x1340c
cmpb $0x5f, %cl
je 0x1340c
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jb 0x1340c
decq %rax
movq %rax, %r15
movq %r15, %rdx
subq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13508
movq %r15, %r14
jmp 0x133c3
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x134a4
movq (%r14), %r14
cmpq %r15, %r14
je 0x13482
movzbl (%r14), %ecx
cmpl $0x3a, %ecx
je 0x13476
cmpl $0x7d, %ecx
jne 0x13482
movq %rbx, %rdi
movl %eax, %esi
callq 0x13500
jmp 0x13491
leaq 0x15131(%rip), %rsi # 0x285ba
movq %rbx, %rdi
callq 0x134f8
movq 0x8(%rsp), %r14
jmp 0x133c3
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
int fmt::v7::detail::parse_nonnegative_int<char, fmt::v7::detail::width_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>&>(char const*&, char const*, fmt::v7::detail::width_adapter<fmt::v7::detail::specs_checker<fmt::v7::detail::specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>>&, char>&)
|
FMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,
ErrorHandler&& eh) {
FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
unsigned value = 0;
// Convert to unsigned to prevent a warning.
constexpr unsigned max_int = max_value<int>();
unsigned big = max_int / 10;
do {
// Check for overflow.
if (value > big) {
value = max_int + 1;
break;
}
value = value * 10 + unsigned(*begin - '0');
++begin;
} while (begin != end && '0' <= *begin && *begin <= '9');
if (value > max_int) eh.on_error("number is too big");
return static_cast<int>(value);
}
|
pushq %rbx
movq (%rdi), %rax
incq %rax
xorl %ebx, %ebx
cmpl $0xccccccc, %ebx # imm = 0xCCCCCCC
ja 0x134df
imull $0xa, %ebx, %ecx
movsbl -0x1(%rax), %r8d
leal (%rcx,%r8), %ebx
addl $-0x30, %ebx
movq %rax, (%rdi)
cmpq %rsi, %rax
je 0x134d9
movb (%rax), %cl
addb $-0x30, %cl
incq %rax
cmpb $0xa, %cl
jb 0x134ad
testl %ebx, %ebx
jns 0x134f3
jmp 0x134e4
movl $0x80000000, %ebx # imm = 0x80000000
leaq 0x1504e(%rip), %rsi # 0x28539
movq %rdx, %rdi
callq 0x134f8
movl %ebx, %eax
popq %rbx
retq
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::operator()<float, 0>(float)
|
iterator operator()(T value) {
auto specs = specs_ ? *specs_ : format_specs();
if (const_check(is_supported_floating_point(value)))
out_ = detail::write(out_, value, specs, locale_);
else
FMT_ASSERT(false, "unsupported float argument type");
return out_;
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x13b6a
movq (%rax), %rsi
movq 0x8(%rax), %rdx
jmp 0x13b7e
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
movabsq $0x1000000200000, %rdx # imm = 0x1000000200000
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
callq 0x1677c
movq %rax, (%rbx)
popq %rbx
retq
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::operator()<long double, 0>(long double)
|
iterator operator()(T value) {
auto specs = specs_ ? *specs_ : format_specs();
if (const_check(is_supported_floating_point(value)))
out_ = detail::write(out_, value, specs, locale_);
else
FMT_ASSERT(false, "unsupported float argument type");
return out_;
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
fldt 0x20(%rsp)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x13bea
movq (%rax), %rsi
movq 0x8(%rax), %rdx
jmp 0x13bfe
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
movabsq $0x1000000200000, %rdx # imm = 0x1000000200000
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
fstpt (%rsp)
callq 0x10001
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::arg_formatter<fmt::v7::detail::buffer_appender<char>, char>::operator()(fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>::handle)
|
iterator operator()(typename basic_format_arg<context_type>::handle handle) {
if (ptr_) advance_to(*parse_ctx_, ptr_);
handle.format(*parse_ctx_, ctx_);
return ctx_.out();
}
|
pushq %rbx
movq %rdx, %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
testq %rdx, %rdx
je 0x13d04
movq (%rsi), %rdi
movq %rdx, (%rsi)
subq %rdx, %rdi
addq %rdi, 0x8(%rsi)
movq 0x18(%rbx), %rdx
movq %rcx, %rdi
callq *%rax
movq 0x18(%rbx), %rax
movq (%rax), %rax
popq %rbx
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
void fmt::v7::detail::handle_int_type_spec<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>&>(char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>&)
|
FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
switch (spec) {
case 0:
case 'd':
handler.on_dec();
break;
case 'x':
case 'X':
handler.on_hex();
break;
case 'b':
case 'B':
handler.on_bin();
break;
case 'o':
handler.on_oct();
break;
#ifdef FMT_DEPRECATED_N_SPECIFIER
case 'n':
#endif
case 'L':
handler.on_num();
break;
case 'c':
handler.on_chr();
break;
default:
handler.on_error();
}
}
|
testl %edi, %edi
je 0x13db8
cmpl $0x42, %edi
je 0x13dc8
cmpl $0x4c, %edi
je 0x13dd0
cmpl $0x58, %edi
je 0x13dc0
cmpl $0x62, %edi
je 0x13dc8
cmpl $0x63, %edi
je 0x13de0
cmpl $0x78, %edi
je 0x13dc0
cmpl $0x6f, %edi
je 0x13dd8
cmpl $0x64, %edi
jne 0x13de8
movq %rsi, %rdi
jmp 0x13df2
movq %rsi, %rdi
jmp 0x13e32
movq %rsi, %rdi
jmp 0x13e9a
movq %rsi, %rdi
jmp 0x13f64
movq %rsi, %rdi
jmp 0x13f02
movq %rsi, %rdi
jmp 0x14140
pushq %rax
movq %rsi, %rdi
callq 0x14156
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()
|
void on_bin() {
if (specs.alt) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = static_cast<char>(specs.type);
}
int num_digits = count_digits<1>(abs_value);
out = write_int(out, num_digits, get_prefix(), specs,
[this, num_digits](iterator it) {
return format_uint<1, Char>(it, abs_value, num_digits);
});
}
|
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpb $0x0, 0x9(%rax)
jns 0x13eca
movl 0x20(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb $0x30, 0x1c(%rbx,%rcx)
movb 0x8(%rax), %al
movl 0x20(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb %al, 0x1c(%rbx,%rcx)
movl 0x18(%rbx), %edi
callq 0x14546
leaq 0x1c(%rbx), %rdx
movl 0x20(%rbx), %ecx
movq (%rbx), %rdi
movq 0x10(%rbx), %r8
movq %rbx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movl %eax, %esi
callq 0x14556
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl (%rsi), %eax
xorl %ebx, %ebx
subq %rcx, %rax
cmovaeq %rax, %rbx
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x14c63(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %rbx, %r15
shrq %cl, %r15
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r12
imulq %rbx, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0xda49
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe8c9
movq %r14, %rdi
movq %rax, %rsi
callq 0x1442c
subq %r15, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8c9
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<4u, char, fmt::v7::detail::buffer_appender<char>, unsigned int>(fmt::v7::detail::buffer_appender<char>, unsigned int, int, bool)
|
inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[num_bits<UInt>() / BASE_BITS + 1];
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str<Char>(buffer, buffer + num_digits, out);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %edx, %esi
callq 0xda64
movzbl %r15b, %ecx
testq %rax, %rax
je 0x144cd
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x14506
jmp 0x144f8
leaq 0xf(%rsp), %r15
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x14506
movslq %ebp, %rax
leaq (%rsp,%rax), %rsi
addq $0xf, %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xdb8a
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char* fmt::v7::detail::format_uint<4u, char, unsigned int>(char*, unsigned int, int, bool)
|
inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
: digits[digit]);
} while ((value >>= BASE_BITS) != 0);
return end;
}
|
movslq %edx, %r8
leaq (%rdi,%r8), %rax
leaq 0x14065(%rip), %r9 # 0x28579
leaq 0x1406f(%rip), %rdx # 0x2858a
testl %ecx, %ecx
cmovneq %r9, %rdx
leaq (%rdi,%r8), %rcx
decq %rcx
movl %esi, %edi
movl %esi, %r8d
andl $0xf, %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx)
shrl $0x4, %edi
decq %rcx
cmpl $0xf, %esi
movl %edi, %esi
ja 0x1452a
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>))
|
OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x14204
movq (%r13), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
movups (%r13), %xmm0
movups %xmm0, 0x10(%rcx)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rcx)
movl 0x78(%rsp), %eax
movl %eax, 0x28(%rcx)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x145bc
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl (%rsi), %eax
xorl %ebx, %ebx
subq %rcx, %rax
cmovaeq %rax, %rbx
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x14a4e(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %rbx, %r15
shrq %cl, %r15
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r12
imulq %rbx, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0xda49
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe8c9
movq %r14, %rdi
movq %rax, %rsi
callq 0x14640
subq %r15, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8c9
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char* fmt::v7::detail::format_uint<1u, char, unsigned int>(char*, unsigned int, int, bool)
|
inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
: digits[digit]);
} while ((value >>= BASE_BITS) != 0);
return end;
}
|
movslq %edx, %rcx
leaq (%rdi,%rcx), %rax
addq %rdi, %rcx
decq %rcx
movl %esi, %edx
movl %esi, %edi
andb $0x1, %dil
orb $0x30, %dil
movb %dil, (%rcx)
shrl %edx
decq %rcx
cmpl $0x1, %esi
movl %edx, %esi
ja 0x14718
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_num()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::on_num()::'lambda'(fmt::v7::detail::buffer_appender<char>)&&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl (%rsi), %eax
xorl %ebx, %ebx
subq %rcx, %rax
cmovaeq %rax, %rbx
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x146ee(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %rbx, %r15
shrq %cl, %r15
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r12
imulq %rbx, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0xda49
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe8c9
movq %r14, %rdi
movq %rax, %rsi
callq 0x14a4e
subq %r15, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8c9
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
void fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::write_int<long long>(long long, fmt::v7::basic_format_specs<char> const&)
|
void write_int(T value, const format_specs& spec) {
using uint_type = uint32_or_64_or_128_t<T>;
int_writer<iterator, Char, uint_type> w(out_, locale_, value, spec);
handle_int_type_spec(spec.type, w);
out_ = w.out;
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movups (%rdi), %xmm0
movaps %xmm0, (%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
andl $0x0, 0x24(%rsp)
testq %rsi, %rsi
js 0x14b0a
movb 0x9(%rdx), %al
shrb $0x4, %al
andb $0x7, %al
cmpb $0x2, %al
jb 0x14b1f
pushq $0x2b
popq %rax
pushq $0x20
popq %rcx
cmovel %eax, %ecx
movb %cl, 0x20(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0x14b1f
movb $0x2d, 0x20(%rsp)
movl $0x1, 0x24(%rsp)
negq %rsi
movq %rsi, 0x18(%rsp)
movsbl 0x8(%rdx), %edi
movq %rsp, %r14
movq %r14, %rsi
callq 0x14b3c
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
void fmt::v7::detail::handle_int_type_spec<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>&>(char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>&)
|
FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
switch (spec) {
case 0:
case 'd':
handler.on_dec();
break;
case 'x':
case 'X':
handler.on_hex();
break;
case 'b':
case 'B':
handler.on_bin();
break;
case 'o':
handler.on_oct();
break;
#ifdef FMT_DEPRECATED_N_SPECIFIER
case 'n':
#endif
case 'L':
handler.on_num();
break;
case 'c':
handler.on_chr();
break;
default:
handler.on_error();
}
}
|
testl %edi, %edi
je 0x14b68
cmpl $0x42, %edi
je 0x14b78
cmpl $0x4c, %edi
je 0x14b80
cmpl $0x58, %edi
je 0x14b70
cmpl $0x62, %edi
je 0x14b78
cmpl $0x63, %edi
je 0x14b90
cmpl $0x78, %edi
je 0x14b70
cmpl $0x6f, %edi
je 0x14b88
cmpl $0x64, %edi
jne 0x14b98
movq %rsi, %rdi
jmp 0x14ba2
movq %rsi, %rdi
jmp 0x14be4
movq %rsi, %rdi
jmp 0x14c4e
movq %rsi, %rdi
jmp 0x14d1c
movq %rsi, %rdi
jmp 0x14cb8
movq %rsi, %rdi
jmp 0x14ef6
pushq %rax
movq %rsi, %rdi
callq 0x14f0c
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>))
|
OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x14204
movq (%r13), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
movups (%r13), %xmm0
movups %xmm0, 0x10(%rcx)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rcx)
movl 0x78(%rsp), %eax
movl %eax, 0x28(%rcx)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1510b
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_bin()::'lambda'(fmt::v7::detail::buffer_appender<char>))
|
OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x14204
movq (%r13), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
movups (%r13), %xmm0
movups %xmm0, 0x10(%rcx)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rcx)
movl 0x78(%rsp), %eax
movl %eax, 0x28(%rcx)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x15279
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char* fmt::v7::detail::format_uint<1u, char, unsigned long>(char*, unsigned long, int, bool)
|
inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
: digits[digit]);
} while ((value >>= BASE_BITS) != 0);
return end;
}
|
movslq %edx, %rcx
leaq (%rdi,%rcx), %rax
addq %rdi, %rcx
decq %rcx
movq %rsi, %rdx
movl %esi, %edi
andb $0x1, %dil
orb $0x30, %dil
movb %dil, (%rcx)
shrq %rdx
decq %rcx
cmpq $0x1, %rsi
movq %rdx, %rsi
ja 0x153d8
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl (%rsi), %eax
xorl %ebx, %ebx
subq %rcx, %rax
cmovaeq %rax, %rbx
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x13b9a(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %rbx, %r15
shrq %cl, %r15
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r12
imulq %rbx, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0xda49
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe8c9
movq %r14, %rdi
movq %rax, %rsi
callq 0x154f4
subq %r15, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8c9
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<3u, char, fmt::v7::detail::buffer_appender<char>, unsigned long>(fmt::v7::detail::buffer_appender<char>, unsigned long, int, bool)
|
inline It format_uint(It out, UInt value, int num_digits, bool upper = false) {
if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
format_uint<BASE_BITS>(ptr, value, num_digits, upper);
return out;
}
// Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
char buffer[num_bits<UInt>() / BASE_BITS + 1];
format_uint<BASE_BITS>(buffer, value, num_digits, upper);
return detail::copy_str<Char>(buffer, buffer + num_digits, out);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
callq 0xda64
movzbl %r15b, %ecx
testq %rax, %rax
je 0x1558b
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x155be
jmp 0x155b0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x155be
movslq %ebp, %rax
leaq (%rsp,%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xdb8a
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_num()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::on_num()::'lambda'(fmt::v7::detail::buffer_appender<char>)&&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl (%rsi), %eax
xorl %ebx, %ebx
subq %rcx, %rax
cmovaeq %rax, %rbx
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x13a29(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %rbx, %r15
shrq %cl, %r15
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r12
imulq %rbx, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0xda49
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe8c9
movq %r14, %rdi
movq %rax, %rsi
callq 0x15666
subq %r15, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8c9
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
void fmt::v7::detail::handle_int_type_spec<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>&>(char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>&)
|
FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
switch (spec) {
case 0:
case 'd':
handler.on_dec();
break;
case 'x':
case 'X':
handler.on_hex();
break;
case 'b':
case 'B':
handler.on_bin();
break;
case 'o':
handler.on_oct();
break;
#ifdef FMT_DEPRECATED_N_SPECIFIER
case 'n':
#endif
case 'L':
handler.on_num();
break;
case 'c':
handler.on_chr();
break;
default:
handler.on_error();
}
}
|
testl %edi, %edi
je 0x157a5
cmpl $0x42, %edi
je 0x157b5
cmpl $0x4c, %edi
je 0x157bd
cmpl $0x58, %edi
je 0x157ad
cmpl $0x62, %edi
je 0x157b5
cmpl $0x63, %edi
je 0x157cd
cmpl $0x78, %edi
je 0x157ad
cmpl $0x6f, %edi
je 0x157c5
cmpl $0x64, %edi
jne 0x157d5
movq %rsi, %rdi
jmp 0x157de
movq %rsi, %rdi
jmp 0x15824
movq %rsi, %rdi
jmp 0x15892
movq %rsi, %rdi
jmp 0x1596a
movq %rsi, %rdi
jmp 0x15900
movq %rsi, %rdi
jmp 0x15b4c
pushq %rax
movq %rsi, %rdi
callq 0x15b62
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()
|
void on_hex() {
if (specs.alt) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = specs.type;
}
int num_digits = count_digits<4>(abs_value);
out = write_int(out, num_digits, get_prefix(), specs,
[this, num_digits](iterator it) {
return format_uint<4, Char>(it, abs_value, num_digits,
specs.type != 'x');
});
}
|
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpb $0x0, 0x9(%rax)
jns 0x15854
movl 0x34(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x34(%rbx)
movb $0x30, 0x30(%rbx,%rcx)
movb 0x8(%rax), %al
movl 0x34(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x34(%rbx)
movb %al, 0x30(%rbx,%rcx)
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x15cff
leaq 0x30(%rbx), %rdx
movl 0x34(%rbx), %ecx
movq (%rbx), %rdi
movq 0x10(%rbx), %r8
movq %rbx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movl %eax, %esi
callq 0x15d29
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_oct()
|
void on_oct() {
int num_digits = count_digits<3>(abs_value);
if (specs.alt && specs.precision <= num_digits && abs_value != 0) {
// Octal prefix '0' is counted as a digit, so only add it if precision
// is not greater than the number of digits.
prefix[prefix_size++] = '0';
}
out = write_int(out, num_digits, get_prefix(), specs,
[this, num_digits](iterator it) {
return format_uint<3, Char>(it, abs_value, num_digits);
});
}
|
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq 0x28(%rbx), %rsi
callq 0x1618f
movq 0x10(%rbx), %r8
cmpb $0x0, 0x9(%r8)
jns 0x1593e
cmpl %eax, 0x4(%r8)
jg 0x1593e
movq 0x28(%rbx), %rcx
orq 0x20(%rbx), %rcx
je 0x1593e
movl 0x34(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x34(%rbx)
movb $0x30, 0x30(%rbx,%rcx)
movq (%rbx), %rdi
leaq 0x30(%rbx), %rdx
movl 0x34(%rbx), %ecx
movq %rbx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movl %eax, %esi
callq 0x161b9
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_num()
|
void on_num() {
std::string groups = grouping<Char>(locale);
if (groups.empty()) return on_dec();
auto sep = thousands_sep<Char>(locale);
if (!sep) return on_dec();
int num_digits = count_digits(abs_value);
int size = num_digits, n = num_digits;
std::string::const_iterator group = groups.cbegin();
while (group != groups.cend() && n > *group && *group > 0 &&
*group != max_value<char>()) {
size += sep_size;
n -= *group;
++group;
}
if (group == groups.cend()) size += sep_size * ((n - 1) / groups.back());
char digits[40];
format_decimal(digits, abs_value, num_digits);
basic_memory_buffer<Char> buffer;
size += static_cast<int>(prefix_size);
const auto usize = to_unsigned(size);
buffer.resize(usize);
basic_string_view<Char> s(&sep, sep_size);
// Index of a decimal digit with the least significant digit having index 0.
int digit_index = 0;
group = groups.cbegin();
auto p = buffer.data() + size - 1;
for (int i = num_digits - 1; i > 0; --i) {
*p-- = static_cast<Char>(digits[i]);
if (*group <= 0 || ++digit_index % *group != 0 ||
*group == max_value<char>())
continue;
if (group + 1 != groups.cend()) {
digit_index = 0;
++group;
}
std::uninitialized_copy(s.data(), s.data() + s.size(),
make_checked(p, s.size()));
p -= s.size();
}
*p-- = static_cast<Char>(*digits);
if (prefix_size != 0) *p = static_cast<Char>('-');
auto data = buffer.data();
out = write_padded<align::right>(
out, specs, usize, usize,
[=](iterator it) { return copy_str<Char>(data, data + size, it); });
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x270, %rsp # imm = 0x270
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x149a0
cmpq $0x0, 0x8(%r14)
je 0x159e3
movq 0x8(%rbx), %rdi
callq 0x14a00
movl %eax, %ebp
testb %al, %al
je 0x159f0
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0xde92
movl %eax, %r14d
movq (%rsp), %rdx
movq 0x8(%rsp), %rsi
leal (%rsi,%rax), %ecx
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x15a0b
movsbl (%rdx,%rdi), %r9d
movl %eax, %r8d
subl %r9d, %r8d
jle 0x159fd
addb $-0x7f, %r9b
cmpb $-0x7e, %r9b
jb 0x159fd
incq %rdi
movl %r8d, %eax
jmp 0x159bf
movq %rbx, %rdi
callq 0x157de
jmp 0x15b0e
movq %rbx, %rdi
callq 0x157de
jmp 0x15b0e
leaq (%r14,%rdi), %rcx
cmpq %rdi, %rsi
je 0x15a0b
movl %ecx, %r15d
jmp 0x15a1b
decl %eax
movsbl -0x1(%rdx,%rsi), %esi
cltd
idivl %esi
movl %eax, %r15d
addl %ecx, %r15d
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
leaq 0x20(%rsp), %rdi
movl %r14d, %ecx
callq 0xdf06
leaq 0x78(%rsp), %rax
andq $0x0, -0x10(%rax)
leaq 0x2aa87(%rip), %rcx # 0x404c8
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
movslq 0x34(%rbx), %rax
movslq %r15d, %r12
addq %rax, %r12
movl %r12d, %r15d
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0xdb16
movq (%rsp), %rdi
movq 0x60(%rsp), %rax
leaq (%rax,%r12), %rsi
decq %rsi
xorl %r8d, %r8d
xorl %ecx, %ecx
cmpl $0x1, %r14d
jle 0x15ace
movb 0x1f(%rsp,%r14), %al
decq %r14
movb %al, (%rsi)
decq %rsi
movsbl (%rdi), %r9d
testl %r9d, %r9d
jle 0x15a80
incl %ecx
movl %ecx, %eax
cltd
idivl %r9d
cmpb $0x7f, %r9b
je 0x15a80
testl %edx, %edx
jne 0x15a80
movq (%rsp), %rax
addq 0x8(%rsp), %rax
leaq 0x1(%rdi), %rdx
cmpq %rax, %rdx
cmovneq %rdx, %rdi
cmovnel %r8d, %ecx
movb %bpl, (%rsi)
decq %rsi
jmp 0x15a80
movb 0x20(%rsp), %al
movb %al, (%rsi)
cmpl $0x0, 0x34(%rbx)
je 0x15ade
movb $0x2d, -0x1(%rsi)
movq 0x60(%rsp), %rax
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
leaq 0x48(%rsp), %r8
movq %rax, (%r8)
movl %r12d, 0x8(%r8)
movq %r15, %rdx
movq %r15, %rcx
callq 0x163c4
movq %rax, (%rbx)
leaq 0x58(%rsp), %rdi
callq 0x1a5f0
movq %rsp, %rdi
callq 0x6230
addq $0x270, %rsp # imm = 0x270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15b39
jmp 0x15b2a
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1a5f0
jmp 0x15b3c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6230
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char fmt::v7::detail::write_padded<(fmt::v7::align::type)2, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&>(char, fmt::v7::basic_format_specs<fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)> const&, unsigned long, unsigned long, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_dec()::'lambda'(fmt::v7::detail::buffer_appender<char>))::'lambda'(fmt::v7::detail::buffer_appender<char>)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl (%rsi), %eax
xorl %ebx, %ebx
subq %rcx, %rax
cmovaeq %rax, %rbx
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x133fb(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %rbx, %r15
shrq %cl, %r15
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r12
imulq %rbx, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0xda49
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe8c9
movq %r14, %rdi
movq %rax, %rsi
callq 0x15c94
subq %r15, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe8c9
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_hex()::'lambda'(fmt::v7::detail::buffer_appender<char>))
|
OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x14204
movq (%r13), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
movups (%r13), %xmm0
movups %xmm0, 0x10(%rcx)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rcx)
movl 0x78(%rsp), %eax
movl %eax, 0x28(%rcx)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x15d8f
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char* fmt::v7::detail::format_uint<1u, char, unsigned __int128>(char*, unsigned __int128, int, bool)
|
inline Char* format_uint(Char* buffer, UInt value, int num_digits,
bool upper = false) {
buffer += num_digits;
Char* end = buffer;
do {
const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
: digits[digit]);
} while ((value >>= BASE_BITS) != 0);
return end;
}
|
movslq %ecx, %rcx
leaq (%rdi,%rcx), %rax
addq %rdi, %rcx
decq %rcx
pushq $0x1
popq %rdi
movq %rdx, %r8
movl %esi, %r9d
andb $0x1, %r9b
orb $0x30, %r9b
movb %r9b, (%rcx)
movq %rdx, %r9
shldq $0x3f, %rsi, %r9
shrq %r8
decq %rcx
cmpq %rsi, %rdi
movl $0x0, %esi
sbbq %rdx, %rsi
movq %r9, %rsi
movq %r8, %rdx
jb 0x1615f
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>))
|
OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size, [=](iterator it) {
if (prefix.size() != 0)
it = copy_str<Char>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, data.padding, static_cast<Char>('0'));
return f(it);
});
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
callq 0x14204
movq (%r13), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, (%rcx)
movq %r14, 0x8(%rcx)
movups (%r13), %xmm0
movups %xmm0, 0x10(%rcx)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rcx)
movl 0x78(%rsp), %eax
movl %eax, 0x28(%rcx)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1621f
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
void fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::write_int<unsigned __int128>(unsigned __int128, fmt::v7::basic_format_specs<char> const&)
|
void write_int(T value, const format_specs& spec) {
using uint_type = uint32_or_64_or_128_t<T>;
int_writer<iterator, Char, uint_type> w(out_, locale_, value, spec);
handle_int_type_spec(spec.type, w);
out_ = w.out;
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movups (%rdi), %xmm0
movaps %xmm0, (%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
andl $0x0, 0x34(%rsp)
movb 0x9(%rcx), %al
shrb $0x4, %al
andb $0x7, %al
cmpb $0x2, %al
jb 0x1649a
pushq $0x2b
popq %rax
pushq $0x20
popq %rdx
cmovel %eax, %edx
movb %dl, 0x30(%rsp)
movl $0x1, 0x34(%rsp)
movsbl 0x8(%rcx), %edi
movq %rsp, %r14
movq %r14, %rsi
callq 0x15779
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> fmt::v7::to_string<unsigned int, 0>(unsigned int)
|
inline std::string to_string(T value) {
// The buffer should be large enough to store the number including the sign or
// "false" for bool.
constexpr int max_size = detail::digits10<T>() + 2;
char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
char* begin = buffer;
return std::string(begin, detail::write<char>(begin, value));
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xd(%rsp), %r14
movq %r14, %rdi
callq 0x1823e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb7ae
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> fmt::v7::to_string<long long, 0>(long long)
|
inline std::string to_string(T value) {
// The buffer should be large enough to store the number including the sign or
// "false" for bool.
constexpr int max_size = detail::digits10<T>() + 2;
char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
char* begin = buffer;
return std::string(begin, detail::write<char>(begin, value));
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1829a
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb7ae
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> fmt::v7::to_string<unsigned long long, 0>(unsigned long long)
|
inline std::string to_string(T value) {
// The buffer should be large enough to store the number including the sign or
// "false" for bool.
constexpr int max_size = detail::digits10<T>() + 2;
char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
char* begin = buffer;
return std::string(begin, detail::write<char>(begin, value));
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1830e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb7ae
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> fmt::v7::to_string<__int128, 0>(__int128)
|
inline std::string to_string(T value) {
// The buffer should be large enough to store the number including the sign or
// "false" for bool.
constexpr int max_size = detail::digits10<T>() + 2;
char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
char* begin = buffer;
return std::string(begin, detail::write<char>(begin, value));
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1836d
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb7ae
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char* fmt::v7::detail::write<char, char*, __int128, 0>(char*, __int128)
|
OutputIt write(OutputIt out, T value) {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(abs_value);
auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
auto it = reserve(out, size);
if (auto ptr = to_pointer<Char>(it, size)) {
if (negative) *ptr++ = static_cast<Char>('-');
format_decimal<Char>(ptr, abs_value, num_digits);
return out;
}
if (negative) *it++ = static_cast<Char>('-');
it = format_decimal<Char>(it, abs_value, num_digits).end;
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
js 0x18388
movq %r12, %r15
jmp 0x18391
xorl %r15d, %r15d
negq %rbx
sbbq %r12, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xde92
testq %r12, %r12
jns 0x183a8
movb $0x2d, (%r14)
incq %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %eax, %ecx
callq 0xdf06
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> fmt::v7::to_string<unsigned __int128, 0>(unsigned __int128)
|
inline std::string to_string(T value) {
// The buffer should be large enough to store the number including the sign or
// "false" for bool.
constexpr int max_size = detail::digits10<T>() + 2;
char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
char* begin = buffer;
return std::string(begin, detail::write<char>(begin, value));
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x183fc
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb7ae
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char* fmt::v7::detail::write<char, char*, unsigned __int128, 0>(char*, unsigned __int128)
|
OutputIt write(OutputIt out, T value) {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(abs_value);
auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
auto it = reserve(out, size);
if (auto ptr = to_pointer<Char>(it, size)) {
if (negative) *ptr++ = static_cast<Char>('-');
format_decimal<Char>(ptr, abs_value, num_digits);
return out;
}
if (negative) *it++ = static_cast<Char>('-');
it = format_decimal<Char>(it, abs_value, num_digits).end;
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xde92
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0xdf06
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> fmt::v7::to_string<bool, 0>(bool)
|
inline std::string to_string(T value) {
// The buffer should be large enough to store the number including the sign or
// "false" for bool.
constexpr int max_size = detail::digits10<T>() + 2;
char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
char* begin = buffer;
return std::string(begin, detail::write<char>(begin, value));
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, %r14d
xorq $0x5, %r14
leaq 0x100d6(%rip), %rcx # 0x2851e
leaq 0x100d4(%rip), %rax # 0x28523
testl %esi, %esi
cmovneq %rcx, %rax
leaq 0xb(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x63a0
leaq (%rsp,%r14), %rdx
addq $0xb, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb7ae
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, float, 0>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, float)
|
OutputIt write(OutputIt out, T value) {
if (const_check(!is_supported_floating_point(value))) return out;
using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
using uint = typename dragonbox::float_info<floaty>::carrier_uint;
auto bits = bit_cast<uint>(value);
auto fspecs = float_specs();
auto sign_bit = bits & (uint(1) << (num_bits<uint>() - 1));
if (sign_bit != 0) {
fspecs.sign = sign::minus;
value = -value;
}
static const auto specs = basic_format_specs<Char>();
uint mask = exponent_mask<floaty>();
if ((bits & mask) == mask)
return write_nonfinite(out, std::isinf(value), specs, fspecs);
auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
return write_float(out, dec, specs, fspecs, static_cast<Char>('.'));
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movd %xmm0, %eax
andq $0x0, (%rsp)
testl %eax, %eax
jns 0x184f2
movl $0x100, 0x4(%rsp) # imm = 0x100
pxor 0xfb3e(%rip), %xmm0 # 0x28030
notl %eax
testl $0x7f800000, %eax # imm = 0x7F800000
jne 0x18523
movd %xmm0, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
xorl %esi, %esi
cmpl $0x7f800000, %eax # imm = 0x7F800000
sete %sil
leaq 0x112d6(%rip), %rdx # 0x297ec
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x1854d
jmp 0x18547
callq 0xe1f4
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq (%rsp), %rcx
leaq 0x112b1(%rip), %rdx # 0x297ec
pushq $0x2e
popq %r8
movq %rbx, %rdi
callq 0x185b4
addq $0x10, %rsp
popq %rbx
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_nonfinite<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, bool, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs const&)
|
OutputIt write_nonfinite(OutputIt out, bool isinf,
const basic_format_specs<Char>& specs,
const float_specs& fspecs) {
auto str =
isinf ? (fspecs.upper ? "INF" : "inf") : (fspecs.upper ? "NAN" : "nan");
constexpr size_t str_size = 3;
auto sign = fspecs.sign;
auto size = str_size + (sign ? 1 : 0);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded(out, specs, size, [=](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
return copy_str<Char>(str, str + str_size, it);
});
}
|
subq $0x18, %rsp
movl 0x4(%rcx), %r8d
btl $0x10, %r8d
leaq 0xffcc(%rip), %rax # 0x2852d
leaq 0xffc1(%rip), %rcx # 0x28529
cmovaeq %rax, %rcx
leaq 0xffc2(%rip), %rax # 0x28535
leaq 0xffb7(%rip), %r9 # 0x28531
cmovaeq %rax, %r9
testl %esi, %esi
cmovneq %rcx, %r9
shrl $0x8, %r8d
xorl %eax, %eax
andl $0xff, %r8d
setne %al
addq $0x3, %rax
leaq 0x8(%rsp), %rcx
movl %r8d, (%rcx)
movq %r9, 0x8(%rcx)
movq %rdx, %rsi
movq %rax, %rdx
callq 0x188cc
addq $0x18, %rsp
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)
|
OutputIt write_float(OutputIt out, const DecimalFP& fp,
const basic_format_specs<Char>& specs, float_specs fspecs,
Char decimal_point) {
auto significand = fp.significand;
int significand_size = get_significand_size(fp);
static const Char zero = static_cast<Char>('0');
auto sign = fspecs.sign;
size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
int output_exp = fp.exponent + significand_size - 1;
auto use_exp_format = [=]() {
if (fspecs.format == float_format::exp) return true;
if (fspecs.format != float_format::general) return false;
// Use the fixed notation if the exponent is in [exp_lower, exp_upper),
// e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
const int exp_lower = -4, exp_upper = 16;
return output_exp < exp_lower ||
output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
};
if (use_exp_format()) {
int num_zeros = 0;
if (fspecs.showpoint) {
num_zeros = (std::max)(fspecs.precision - significand_size, 0);
size += to_unsigned(num_zeros);
} else if (significand_size == 1) {
decimal_point = Char();
}
auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
int exp_digits = 2;
if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;
size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
char exp_char = fspecs.upper ? 'E' : 'e';
auto write = [=](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
// Insert a decimal point after the first digit and add an exponent.
it = write_significand(it, significand, significand_size, 1,
decimal_point);
if (num_zeros > 0) it = std::fill_n(it, num_zeros, zero);
*it++ = static_cast<Char>(exp_char);
return write_exponent<Char>(output_exp, it);
};
return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
: base_iterator(out, write(reserve(out, size)));
}
int exp = fp.exponent + significand_size;
if (fp.exponent >= 0) {
// 1234e5 -> 123400000[.0+]
size += to_unsigned(fp.exponent);
int num_zeros = fspecs.precision - exp;
#ifdef FMT_FUZZ
if (num_zeros > 5000)
throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
#endif
if (fspecs.showpoint) {
if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 1;
if (num_zeros > 0) size += to_unsigned(num_zeros);
}
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
it = write_significand<Char>(it, significand, significand_size);
it = std::fill_n(it, fp.exponent, zero);
if (!fspecs.showpoint) return it;
*it++ = decimal_point;
return num_zeros > 0 ? std::fill_n(it, num_zeros, zero) : it;
});
} else if (exp > 0) {
// 1234e-2 -> 12.34[0+]
int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
it = write_significand(it, significand, significand_size, exp,
decimal_point);
return num_zeros > 0 ? std::fill_n(it, num_zeros, zero) : it;
});
}
// 1234e-6 -> 0.001234
int num_zeros = -exp;
if (significand_size == 0 && fspecs.precision >= 0 &&
fspecs.precision < num_zeros) {
num_zeros = fspecs.precision;
}
size += 2 + to_unsigned(num_zeros);
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
*it++ = zero;
if (num_zeros == 0 && significand_size == 0 && !fspecs.showpoint) return it;
*it++ = decimal_point;
it = std::fill_n(it, num_zeros, zero);
return write_significand<Char>(it, significand, significand_size);
});
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %rbp
movq %rdx, 0x18(%rsp)
movq %rsi, %r15
movq %rdi, 0x30(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x24(%rsp)
movb %r8b, 0x7(%rsp)
movl (%rsi), %eax
movl %eax, 0x40(%rsp)
movl %eax, 0x14(%rsp)
movq %rsi, %rdi
callq 0xea2f
movl %eax, %r14d
movl %eax, 0x10(%rsp)
movq %rbp, %r12
shrq $0x20, %r12
movq %rbp, %r13
shrq $0x28, %r13
xorl %eax, %eax
andl $0xff, %r13d
movl %r13d, 0xc(%rsp)
setne %al
addl %r14d, %eax
movq %rax, 0x28(%rsp)
movl 0x4(%r15), %ebx
leal (%rbx,%r14), %eax
decl %eax
leaq 0x88(%rsp), %rdi
movq %rbp, (%rdi)
movl %eax, 0x3c(%rsp)
movl %eax, 0x8(%rdi)
callq 0x189fe
testb %al, %al
je 0x18670
addl %r14d, %ebx
btl $0x14, %r12d
jb 0x186aa
xorl %eax, %eax
cmpl $0x1, %r14d
movl 0x24(%rsp), %edi
movzbl %dil, %edi
cmovel %eax, %edi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %r8
jmp 0x186c5
movslq 0x4(%r15), %rdx
leal (%r14,%rdx), %eax
movl %eax, 0x44(%rsp)
testq %rdx, %rdx
js 0x18750
addq 0x28(%rsp), %rdx
subl %eax, %ebp
movl %ebp, 0x8(%rsp)
btl $0x14, %r12d
movq 0x30(%rsp), %rdi
jb 0x187e4
movq 0x18(%rsp), %rsi
jmp 0x1880f
subl %r14d, %ebp
xorl %eax, %eax
testl %ebp, %ebp
cmovgl %ebp, %eax
movq 0x28(%rsp), %r8
addq %rax, %r8
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %edi
pushq $0x1
popq %rcx
subl %ebx, %ecx
testl %ebx, %ebx
movl 0x3c(%rsp), %r9d
cmovgl %r9d, %ecx
xorl %edx, %edx
cmpl $0x3e8, %ecx # imm = 0x3E8
setge %dl
addq $0x3, %rdx
cmpl $0x64, %ecx
pushq $0x2
popq %rcx
cmovgeq %rdx, %rcx
cmpb $0x1, %dil
pushq $0x3
popq %rdx
sbbq $0x0, %rdx
addq %r8, %rdx
addq %rcx, %rdx
btl $0x10, %r12d
setae %cl
shlb $0x5, %cl
orb $0x45, %cl
movl %r13d, 0x50(%rsp)
movl 0x40(%rsp), %r8d
movl %r8d, 0x54(%rsp)
movl %r14d, 0x58(%rsp)
movb %dil, 0x5c(%rsp)
movl %eax, 0x60(%rsp)
movb %cl, 0x64(%rsp)
movl %r9d, 0x68(%rsp)
cmpl $0x0, (%rsi)
jle 0x187c5
leaq 0x50(%rsp), %rcx
movq 0x30(%rsp), %rdi
callq 0x18a2b
jmp 0x18852
testl %eax, %eax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rcx
jle 0x1886a
shll $0xb, %r12d
sarl $0x1f, %r12d
subl %r14d, %ebp
xorl %eax, %eax
andl %r12d, %ebp
leaq 0x8(%rsp), %rsi
movl %ebp, (%rsi)
cmovlel %eax, %ebp
leaq 0x1(%rbp,%rcx), %rdx
leaq 0xc(%rsp), %rax
leaq 0x50(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x14(%rsp), %rax
movq %rax, 0x8(%rcx)
leaq 0x10(%rsp), %rax
movq %rax, 0x10(%rcx)
leaq 0x44(%rsp), %rax
movq %rax, 0x18(%rcx)
leaq 0x7(%rsp), %rax
movq %rax, 0x20(%rcx)
movq %rsi, 0x28(%rcx)
movq 0x18(%rsp), %rsi
callq 0x18aae
jmp 0x18852
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x18979
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x18a36
jmp 0x18855
testl %ebp, %ebp
setg %al
cmpb $0x2, %r12b
sete %cl
orb %al, %cl
movq 0x18(%rsp), %rsi
je 0x187ff
testl %ebp, %ebp
jg 0x1880a
jmp 0x1880f
movl $0x1, 0x8(%rsp)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq %rax, %rdx
leaq 0xc(%rsp), %rax
leaq 0x50(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x14(%rsp), %rax
movq %rax, 0x8(%rcx)
leaq 0x10(%rsp), %rax
movq %rax, 0x10(%rcx)
movq %r15, 0x18(%rcx)
leaq 0x48(%rsp), %rax
movq %rax, 0x20(%rcx)
leaq 0x7(%rsp), %rax
movq %rax, 0x28(%rcx)
leaq 0x8(%rsp), %rax
movq %rax, 0x30(%rcx)
callq 0x18aa3
movq %rax, %rbx
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
negl %eax
cmpl %eax, %ebp
movl %eax, %edx
cmovll %ebp, %edx
testl %ebp, %ebp
cmovsl %eax, %edx
testl %r14d, %r14d
cmovnel %eax, %edx
leaq 0x8(%rsp), %rax
movl %edx, (%rax)
addl $0x2, %edx
addq %rcx, %rdx
leaq 0xc(%rsp), %rsi
leaq 0x50(%rsp), %rcx
movq %rsi, (%rcx)
movq %rax, 0x8(%rcx)
leaq 0x10(%rsp), %rax
movq %rax, 0x10(%rcx)
leaq 0x48(%rsp), %rax
movq %rax, 0x18(%rcx)
leaq 0x7(%rsp), %rax
movq %rax, 0x20(%rcx)
leaq 0x14(%rsp), %rax
movq %rax, 0x28(%rcx)
movq 0x18(%rsp), %rsi
callq 0x18ab9
jmp 0x18852
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_padded<(fmt::v7::align::type)1, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_nonfinite<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, bool, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs const&)::'lambda'(char*)&>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_nonfinite<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, bool, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs const&)::'lambda'(char*)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r15d, %r15d
subq %rcx, %rax
cmovaeq %rax, %r15
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x10455(%rip), %rcx # 0x28d58
movb (%rax,%rcx), %cl
movq %r15, %r13
shrq %cl, %r13
movzbl 0xe(%rsi), %esi
addq $0xa, %r14
imulq %r15, %rsi
addq %rdx, %rsi
callq 0x18979
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1899a
movl (%r12), %ecx
testq %rcx, %rcx
je 0x18946
leaq 0x1041f(%rip), %rdx # 0x28d5d
movb (%rcx,%rdx), %cl
movb %cl, (%rax)
incq %rax
movq 0x8(%r12), %rcx
movzwl (%rcx), %edx
movb 0x2(%rcx), %cl
movb %cl, 0x2(%rax)
movw %dx, (%rax)
addq $0x3, %rax
subq %r13, %r15
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1899a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char* fmt::v7::detail::fill<char*, char>(char*, unsigned long, fmt::v7::detail::fill_t<char> const&)
|
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t<Char>& fill) {
auto fill_size = fill.size();
if (fill_size == 1) return std::fill_n(it, n, fill[0]);
for (size_t i = 0; i < n; ++i) it = std::copy_n(fill.data(), fill_size, it);
return it;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x4(%rdx), %r12d
cmpq $0x1, %r12
jne 0x189e0
testq %r14, %r14
je 0x189d1
leaq (%rbx,%r14), %r12
movzbl (%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x62a0
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
subq $0x1, %r14
jb 0x189d1
testb %r12b, %r12b
je 0x189f9
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6730
addq %r12, %rbx
jmp 0x189e0
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::dragonbox::decimal_fp<float> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda'(char*)&>(fmt::v7::detail::dragonbox::decimal_fp<float>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda'(char*)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x1054c(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %r14, %r12
shrq %cl, %r12
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r13
imulq %r14, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0x18979
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1899a
movq %r15, %rdi
movq %rax, %rsi
callq 0x18a36
subq %r12, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1899a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char* fmt::v7::detail::write_exponent<char, char*>(int, char*)
|
It write_exponent(int exp, It it) {
FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
if (exp < 0) {
*it++ = static_cast<Char>('-');
exp = -exp;
} else {
*it++ = static_cast<Char>('+');
}
if (exp >= 100) {
const char* top = data::digits[exp / 100];
if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
*it++ = static_cast<Char>(top[1]);
exp %= 100;
}
const char* d = data::digits[exp];
*it++ = static_cast<Char>(d[0]);
*it++ = static_cast<Char>(d[1]);
return it;
}
|
movl %edi, %eax
shrl $0x1f, %eax
addb %al, %al
addb $0x2b, %al
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
movb %al, (%rsi)
leaq 0x1(%rsi), %rcx
cmpl $0x64, %r8d
jb 0x18b9d
pushq $0x64
popq %rdi
movl %r8d, %eax
xorl %edx, %edx
divl %edi
cmpl $0x3e8, %r8d # imm = 0x3E8
jb 0x18b8a
leaq 0x10053(%rip), %rcx # 0x28bd0
movb (%rcx,%rax,2), %cl
movb %cl, 0x1(%rsi)
addq $0x2, %rsi
movq %rsi, %rcx
leaq 0x1003f(%rip), %rsi # 0x28bd0
movb 0x1(%rsi,%rax,2), %al
movb %al, (%rcx)
incq %rcx
movl %edx, %r8d
movl %r8d, %eax
leaq 0x10029(%rip), %rdx # 0x28bd0
movzwl (%rdx,%rax,2), %eax
movw %ax, (%rcx)
addq $0x2, %rcx
movq %rcx, %rax
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::dragonbox::decimal_fp<float> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda0'(char*)&>(fmt::v7::detail::dragonbox::decimal_fp<float>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda0'(char*)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x1045a(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %r14, %r12
shrq %cl, %r12
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r13
imulq %r14, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0x18979
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1899a
movq %r15, %rdi
movq %rax, %rsi
callq 0x18c36
subq %r12, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1899a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::dragonbox::decimal_fp<float> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda1'(char*)&>(fmt::v7::detail::dragonbox::decimal_fp<float>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda1'(char*)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x10344(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %r14, %r12
shrq %cl, %r12
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r13
imulq %r14, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0x18979
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1899a
movq %r15, %rdi
movq %rax, %rsi
callq 0x18d4c
subq %r12, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1899a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::dragonbox::decimal_fp<float> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda2'(char*)&>(fmt::v7::detail::dragonbox::decimal_fp<float>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<float> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda2'(char*)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x10260(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %r14, %r12
shrq %cl, %r12
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r13
imulq %r14, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0x18979
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1899a
movq %r15, %rdi
movq %rax, %rsi
callq 0x18e30
subq %r12, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1899a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)
|
OutputIt write_float(OutputIt out, const DecimalFP& fp,
const basic_format_specs<Char>& specs, float_specs fspecs,
Char decimal_point) {
auto significand = fp.significand;
int significand_size = get_significand_size(fp);
static const Char zero = static_cast<Char>('0');
auto sign = fspecs.sign;
size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
int output_exp = fp.exponent + significand_size - 1;
auto use_exp_format = [=]() {
if (fspecs.format == float_format::exp) return true;
if (fspecs.format != float_format::general) return false;
// Use the fixed notation if the exponent is in [exp_lower, exp_upper),
// e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
const int exp_lower = -4, exp_upper = 16;
return output_exp < exp_lower ||
output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
};
if (use_exp_format()) {
int num_zeros = 0;
if (fspecs.showpoint) {
num_zeros = (std::max)(fspecs.precision - significand_size, 0);
size += to_unsigned(num_zeros);
} else if (significand_size == 1) {
decimal_point = Char();
}
auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
int exp_digits = 2;
if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;
size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
char exp_char = fspecs.upper ? 'E' : 'e';
auto write = [=](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
// Insert a decimal point after the first digit and add an exponent.
it = write_significand(it, significand, significand_size, 1,
decimal_point);
if (num_zeros > 0) it = std::fill_n(it, num_zeros, zero);
*it++ = static_cast<Char>(exp_char);
return write_exponent<Char>(output_exp, it);
};
return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
: base_iterator(out, write(reserve(out, size)));
}
int exp = fp.exponent + significand_size;
if (fp.exponent >= 0) {
// 1234e5 -> 123400000[.0+]
size += to_unsigned(fp.exponent);
int num_zeros = fspecs.precision - exp;
#ifdef FMT_FUZZ
if (num_zeros > 5000)
throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
#endif
if (fspecs.showpoint) {
if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 1;
if (num_zeros > 0) size += to_unsigned(num_zeros);
}
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
it = write_significand<Char>(it, significand, significand_size);
it = std::fill_n(it, fp.exponent, zero);
if (!fspecs.showpoint) return it;
*it++ = decimal_point;
return num_zeros > 0 ? std::fill_n(it, num_zeros, zero) : it;
});
} else if (exp > 0) {
// 1234e-2 -> 12.34[0+]
int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
it = write_significand(it, significand, significand_size, exp,
decimal_point);
return num_zeros > 0 ? std::fill_n(it, num_zeros, zero) : it;
});
}
// 1234e-6 -> 0.001234
int num_zeros = -exp;
if (significand_size == 0 && fspecs.precision >= 0 &&
fspecs.precision < num_zeros) {
num_zeros = fspecs.precision;
}
size += 2 + to_unsigned(num_zeros);
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
*it++ = zero;
if (num_zeros == 0 && significand_size == 0 && !fspecs.showpoint) return it;
*it++ = decimal_point;
it = std::fill_n(it, num_zeros, zero);
return write_significand<Char>(it, significand, significand_size);
});
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %rbp
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
movq %rcx, 0x40(%rsp)
movl %r8d, 0x1c(%rsp)
movb %r8b, 0x3(%rsp)
movq (%rsi), %rax
movq %rax, 0x48(%rsp)
movq %rax, 0x30(%rsp)
movq %rsi, %rdi
callq 0xfaee
movl %eax, %r14d
movl %eax, 0xc(%rsp)
movq %rbp, %r12
shrq $0x20, %r12
movq %rbp, %r13
shrq $0x28, %r13
xorl %eax, %eax
andl $0xff, %r13d
movl %r13d, 0x8(%rsp)
setne %al
addl %r14d, %eax
movq %rax, 0x20(%rsp)
movl 0x8(%r15), %ebx
leal (%rbx,%r14), %eax
decl %eax
leaq 0x88(%rsp), %rdi
movq %rbp, (%rdi)
movl %eax, 0x38(%rsp)
movl %eax, 0x8(%rdi)
callq 0x192ac
testb %al, %al
je 0x1904f
addl %r14d, %ebx
btl $0x14, %r12d
jb 0x19089
xorl %eax, %eax
cmpl $0x1, %r14d
movl 0x1c(%rsp), %edi
movzbl %dil, %edi
cmovel %eax, %edi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %r8
jmp 0x190a4
movslq 0x8(%r15), %rdx
leal (%r14,%rdx), %eax
movl %eax, 0x3c(%rsp)
testq %rdx, %rdx
js 0x1912f
addq 0x20(%rsp), %rdx
subl %eax, %ebp
movl %ebp, 0x4(%rsp)
btl $0x14, %r12d
movq 0x28(%rsp), %rdi
jb 0x191c3
movq 0x10(%rsp), %rsi
jmp 0x191ee
subl %r14d, %ebp
xorl %eax, %eax
testl %ebp, %ebp
cmovgl %ebp, %eax
movq 0x20(%rsp), %r8
addq %rax, %r8
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edi
pushq $0x1
popq %rcx
subl %ebx, %ecx
testl %ebx, %ebx
movl 0x38(%rsp), %r9d
cmovgl %r9d, %ecx
xorl %edx, %edx
cmpl $0x3e8, %ecx # imm = 0x3E8
setge %dl
addq $0x3, %rdx
cmpl $0x64, %ecx
pushq $0x2
popq %rcx
cmovgeq %rdx, %rcx
cmpb $0x1, %dil
pushq $0x3
popq %rdx
sbbq $0x0, %rdx
addq %r8, %rdx
addq %rcx, %rdx
btl $0x10, %r12d
setae %cl
shlb $0x5, %cl
orb $0x45, %cl
movl %r13d, 0x50(%rsp)
movq 0x48(%rsp), %r8
movq %r8, 0x58(%rsp)
movl %r14d, 0x60(%rsp)
movb %dil, 0x64(%rsp)
movl %eax, 0x68(%rsp)
movb %cl, 0x6c(%rsp)
movl %r9d, 0x70(%rsp)
cmpl $0x0, (%rsi)
jle 0x191a4
leaq 0x50(%rsp), %rcx
movq 0x28(%rsp), %rdi
callq 0x192d9
jmp 0x19231
testl %eax, %eax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rcx
jle 0x19249
shll $0xb, %r12d
sarl $0x1f, %r12d
subl %r14d, %ebp
xorl %eax, %eax
andl %r12d, %ebp
leaq 0x4(%rsp), %rsi
movl %ebp, (%rsi)
cmovlel %eax, %ebp
leaq 0x1(%rbp,%rcx), %rdx
leaq 0x8(%rsp), %rax
leaq 0x50(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rcx)
leaq 0xc(%rsp), %rax
movq %rax, 0x10(%rcx)
leaq 0x3c(%rsp), %rax
movq %rax, 0x18(%rcx)
leaq 0x3(%rsp), %rax
movq %rax, 0x20(%rcx)
movq %rsi, 0x28(%rcx)
movq 0x10(%rsp), %rsi
callq 0x1935d
jmp 0x19231
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x18979
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x192e4
jmp 0x19234
testl %ebp, %ebp
setg %al
cmpb $0x2, %r12b
sete %cl
orb %al, %cl
movq 0x10(%rsp), %rsi
je 0x191de
testl %ebp, %ebp
jg 0x191e9
jmp 0x191ee
movl $0x1, 0x4(%rsp)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq %rax, %rdx
leaq 0x8(%rsp), %rax
leaq 0x50(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rcx)
leaq 0xc(%rsp), %rax
movq %rax, 0x10(%rcx)
movq %r15, 0x18(%rcx)
leaq 0x40(%rsp), %rax
movq %rax, 0x20(%rcx)
leaq 0x3(%rsp), %rax
movq %rax, 0x28(%rcx)
leaq 0x4(%rsp), %rax
movq %rax, 0x30(%rcx)
callq 0x19352
movq %rax, %rbx
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
negl %eax
cmpl %eax, %ebp
movl %eax, %edx
cmovll %ebp, %edx
testl %ebp, %ebp
cmovsl %eax, %edx
testl %r14d, %r14d
cmovnel %eax, %edx
leaq 0x4(%rsp), %rax
movl %edx, (%rax)
addl $0x2, %edx
addq %rcx, %rdx
leaq 0x8(%rsp), %rsi
leaq 0x50(%rsp), %rcx
movq %rsi, (%rcx)
movq %rax, 0x8(%rcx)
leaq 0xc(%rsp), %rax
movq %rax, 0x10(%rcx)
leaq 0x40(%rsp), %rax
movq %rax, 0x18(%rcx)
leaq 0x3(%rsp), %rax
movq %rax, 0x20(%rcx)
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rcx)
movq 0x10(%rsp), %rsi
callq 0x19368
jmp 0x19231
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::dragonbox::decimal_fp<double> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda'(char*)&>(fmt::v7::detail::dragonbox::decimal_fp<double>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda'(char*)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0xfc9d(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %r14, %r12
shrq %cl, %r12
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r13
imulq %r14, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0x18979
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1899a
movq %r15, %rdi
movq %rax, %rsi
callq 0x192e4
subq %r12, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1899a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::dragonbox::decimal_fp<double> fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda2'(char*)&>(fmt::v7::detail::dragonbox::decimal_fp<double>, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double>, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::dragonbox::decimal_fp<double> const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda2'(char*)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0xfa1f(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %r14, %r12
shrq %cl, %r12
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r13
imulq %r14, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0x18979
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1899a
movq %r15, %rdi
movq %rax, %rsi
callq 0x19672
subq %r12, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1899a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, long double, 0>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, long double, fmt::v7::basic_format_specs<char>, fmt::v7::detail::locale_ref)
|
OutputIt write(OutputIt out, T value, basic_format_specs<Char> specs,
locale_ref loc = {}) {
if (const_check(!is_supported_floating_point(value))) return out;
float_specs fspecs = parse_float_type_spec(specs);
fspecs.sign = specs.sign;
if (std::signbit(value)) { // value < 0 is false for NaN so use signbit.
fspecs.sign = sign::minus;
value = -value;
} else if (fspecs.sign == sign::minus) {
fspecs.sign = sign::none;
}
if (!std::isfinite(value))
return write_nonfinite(out, std::isinf(value), specs, fspecs);
if (specs.align == align::numeric && fspecs.sign) {
auto it = reserve(out, 1);
*it++ = static_cast<Char>(data::signs[fspecs.sign]);
out = base_iterator(out, it);
fspecs.sign = sign::none;
if (specs.width != 0) --specs.width;
}
memory_buffer buffer;
if (fspecs.format == float_format::hex) {
if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);
snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
return write_bytes(out, {buffer.data(), buffer.size()}, specs);
}
int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;
if (fspecs.format == float_format::exp) {
if (precision == max_value<int>())
FMT_THROW(format_error("number is too big"));
else
++precision;
}
if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
fspecs.use_grisu = is_fast_float<T>();
int exp = format_float(promote_float(value), precision, fspecs, buffer);
fspecs.precision = precision;
Char point =
fspecs.locale ? decimal_point<Char>(loc) : static_cast<Char>('.');
auto fp = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
return write_float(out, fp, specs, fspecs, point);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rcx, %r14
movq %rdi, %r15
fldt 0x2b0(%rsp)
fld %st(0)
fstpt 0x24(%rsp)
fstpt 0x40(%rsp)
movswq 0x48(%rsp), %r13
leaq 0x30(%rsp), %r12
movq %rsi, (%r12)
movq %rdx, 0x8(%r12)
leaq 0x60(%rsp), %rsi
movq %r12, %rdi
callq 0x102c9
movq %rax, %rbx
movq %rax, 0x18(%rsp)
movzbl 0x9(%r12), %eax
movl %eax, %ecx
shrl $0x4, %ecx
shrq $0x20, %rbx
andl $0x7, %ecx
movl %ecx, %edx
shll $0x8, %edx
andl $0xffff00ff, %ebx # imm = 0xFFFF00FF
orl %ebx, %edx
movl %edx, 0x1c(%rsp)
testq %r13, %r13
js 0x197e9
fldt 0x24(%rsp)
cmpb $0x1, %cl
jne 0x197fb
movl %ebx, 0x1c(%rsp)
jmp 0x197fd
orl $0x100, %ebx # imm = 0x100
movl %ebx, 0x1c(%rsp)
fldt 0x24(%rsp)
fchs
jmp 0x197fd
movl %edx, %ebx
flds 0xe805(%rip) # 0x28008
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
je 0x198eb
andb $0xf, %al
cmpb $0x4, %al
jne 0x19858
movl %ebx, %eax
andl $0xff00, %eax # imm = 0xFF00
je 0x19858
fstpt 0x24(%rsp)
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x18979
movzbl %bh, %ecx
leaq 0xf526(%rip), %rdx # 0x28d5d
movb (%rcx,%rdx), %cl
movb %cl, (%rax)
andl $0xffff00ff, %ebx # imm = 0xFFFF00FF
movl %ebx, 0x1c(%rsp)
movl 0x30(%rsp), %eax
testl %eax, %eax
je 0x19854
decl %eax
movl %eax, 0x30(%rsp)
fldt 0x24(%rsp)
leaq 0x80(%rsp), %rax
andq $0x0, -0x10(%rax)
leaq 0x26c5c(%rip), %rcx # 0x404c8
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
cmpb $0x3, %bl
jne 0x1990d
shrl $0x8, %ebx
andl $0xff, %ebx
je 0x198ae
movl %ebx, %eax
leaq 0xf4c4(%rip), %rsi # 0x28d5d
addq %rax, %rsi
leaq 0x60(%rsp), %rdi
fstpt 0x24(%rsp)
callq 0xdb4c
fldt 0x24(%rsp)
movl 0x34(%rsp), %edi
movq 0x18(%rsp), %rsi
fstpt (%rsp)
leaq 0x60(%rsp), %rdx
callq 0x10391
fldz
fstp %st(0)
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %r15, %rdi
callq 0x19a19
fldz
movq %rax, %rbx
fstp %st(0)
jmp 0x1999c
fstp %st(0)
setae %al
movzbl %al, %esi
leaq 0x30(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movq %r15, %rdi
callq 0x1854d
movq %rax, %rbx
jmp 0x199a6
cmpb $0x0, 0x38(%rsp)
movl 0x34(%rsp), %eax
pushq $0x6
popq %rbp
cmovel %eax, %ebp
testl %eax, %eax
cmovnsl %eax, %ebp
cmpb $0x1, %bl
jne 0x19934
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
je 0x199bb
incl %ebp
andl $0xfff7ffff, %ebx # imm = 0xFFF7FFFF
movl %ebx, 0x1c(%rsp)
movq 0x18(%rsp), %r12
fstpt (%rsp)
leaq 0x60(%rsp), %rdx
movl %ebp, %edi
movq %r12, %rsi
callq 0x105df
movl %eax, %ebx
movl %ebp, 0x18(%rsp)
movb $0x2e, %al
btq $0x31, %r12
jae 0x1996c
movq %r14, %rdi
callq 0x11dcc
movq 0x68(%rsp), %rcx
leaq 0x50(%rsp), %rsi
movq %rcx, (%rsi)
movl 0x70(%rsp), %ecx
movl %ecx, 0x8(%rsi)
movl %ebx, 0xc(%rsi)
movq 0x18(%rsp), %rcx
movsbl %al, %r8d
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x19a39
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x1a5f0
movq %rbx, %rax
addq $0x278, %rsp # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
fstp %st(0)
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %r14
leaq 0xeb6a(%rip), %rsi # 0x28539
movq %rax, %rdi
callq 0xd93c
leaq 0x267da(%rip), %rsi # 0x401b8
movq 0x275b3(%rip), %rdx # 0x40f98
movq %r14, %rdi
callq 0x67a0
jmp 0x19a04
movq %rax, %rbx
movq %r14, %rdi
callq 0x6340
jmp 0x19a07
jmp 0x19a04
jmp 0x19a04
jmp 0x19a04
fstp %st(0)
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x1a5f0
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)
|
OutputIt write_float(OutputIt out, const DecimalFP& fp,
const basic_format_specs<Char>& specs, float_specs fspecs,
Char decimal_point) {
auto significand = fp.significand;
int significand_size = get_significand_size(fp);
static const Char zero = static_cast<Char>('0');
auto sign = fspecs.sign;
size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
int output_exp = fp.exponent + significand_size - 1;
auto use_exp_format = [=]() {
if (fspecs.format == float_format::exp) return true;
if (fspecs.format != float_format::general) return false;
// Use the fixed notation if the exponent is in [exp_lower, exp_upper),
// e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
const int exp_lower = -4, exp_upper = 16;
return output_exp < exp_lower ||
output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
};
if (use_exp_format()) {
int num_zeros = 0;
if (fspecs.showpoint) {
num_zeros = (std::max)(fspecs.precision - significand_size, 0);
size += to_unsigned(num_zeros);
} else if (significand_size == 1) {
decimal_point = Char();
}
auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
int exp_digits = 2;
if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;
size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
char exp_char = fspecs.upper ? 'E' : 'e';
auto write = [=](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
// Insert a decimal point after the first digit and add an exponent.
it = write_significand(it, significand, significand_size, 1,
decimal_point);
if (num_zeros > 0) it = std::fill_n(it, num_zeros, zero);
*it++ = static_cast<Char>(exp_char);
return write_exponent<Char>(output_exp, it);
};
return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
: base_iterator(out, write(reserve(out, size)));
}
int exp = fp.exponent + significand_size;
if (fp.exponent >= 0) {
// 1234e5 -> 123400000[.0+]
size += to_unsigned(fp.exponent);
int num_zeros = fspecs.precision - exp;
#ifdef FMT_FUZZ
if (num_zeros > 5000)
throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
#endif
if (fspecs.showpoint) {
if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 1;
if (num_zeros > 0) size += to_unsigned(num_zeros);
}
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
it = write_significand<Char>(it, significand, significand_size);
it = std::fill_n(it, fp.exponent, zero);
if (!fspecs.showpoint) return it;
*it++ = decimal_point;
return num_zeros > 0 ? std::fill_n(it, num_zeros, zero) : it;
});
} else if (exp > 0) {
// 1234e-2 -> 12.34[0+]
int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
it = write_significand(it, significand, significand_size, exp,
decimal_point);
return num_zeros > 0 ? std::fill_n(it, num_zeros, zero) : it;
});
}
// 1234e-6 -> 0.001234
int num_zeros = -exp;
if (significand_size == 0 && fspecs.precision >= 0 &&
fspecs.precision < num_zeros) {
num_zeros = fspecs.precision;
}
size += 2 + to_unsigned(num_zeros);
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = static_cast<Char>(data::signs[sign]);
*it++ = zero;
if (num_zeros == 0 && significand_size == 0 && !fspecs.showpoint) return it;
*it++ = decimal_point;
it = std::fill_n(it, num_zeros, zero);
return write_significand<Char>(it, significand, significand_size);
});
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %rbp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
movq %rcx, 0x40(%rsp)
movl %r8d, 0x1c(%rsp)
movb %r8b, 0x3(%rsp)
movq (%rsi), %rax
movq %rax, 0x48(%rsp)
movq %rax, 0x30(%rsp)
movl 0x8(%rsi), %r13d
movl %r13d, 0xc(%rsp)
movq %rcx, %r15
shrq $0x20, %r15
movq %rcx, %r12
shrq $0x28, %r12
xorl %eax, %eax
andl $0xff, %r12d
movl %r12d, 0x8(%rsp)
setne %al
addl %r13d, %eax
movq %rax, 0x20(%rsp)
movl 0xc(%rsi), %ebx
leal (%rbx,%r13), %eax
decl %eax
leaq 0x88(%rsp), %rdi
movq %rcx, (%rdi)
movl %eax, 0x38(%rsp)
movl %eax, 0x8(%rdi)
callq 0x19df6
testb %al, %al
je 0x19af1
addl %r13d, %ebx
btl $0x14, %r15d
jb 0x19b2b
xorl %eax, %eax
cmpl $0x1, %r13d
movl 0x1c(%rsp), %edi
movzbl %dil, %edi
cmovel %eax, %edi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %r8
jmp 0x19b46
movslq 0xc(%r14), %rdx
leal (%rdx,%r13), %eax
movl %eax, 0x3c(%rsp)
testq %rdx, %rdx
js 0x19bd1
addq 0x20(%rsp), %rdx
subl %eax, %ebp
movl %ebp, 0x4(%rsp)
btl $0x14, %r15d
movq 0x28(%rsp), %rdi
jb 0x19c65
movq 0x10(%rsp), %rsi
jmp 0x19c90
subl %r13d, %ebp
xorl %eax, %eax
testl %ebp, %ebp
cmovgl %ebp, %eax
movq 0x20(%rsp), %r8
addq %rax, %r8
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edi
pushq $0x1
popq %rcx
subl %ebx, %ecx
testl %ebx, %ebx
movl 0x38(%rsp), %r10d
cmovgl %r10d, %ecx
xorl %edx, %edx
cmpl $0x3e8, %ecx # imm = 0x3E8
setge %dl
addq $0x3, %rdx
cmpl $0x64, %ecx
pushq $0x2
popq %rcx
cmovgeq %rdx, %rcx
cmpb $0x1, %dil
pushq $0x3
popq %rdx
sbbq $0x0, %rdx
addq %r8, %rdx
addq %rcx, %rdx
btl $0x10, %r15d
setae %cl
shlb $0x5, %cl
orb $0x45, %cl
movl %r12d, 0x50(%rsp)
movq 0x48(%rsp), %r8
movq %r8, 0x58(%rsp)
movl %r13d, 0x60(%rsp)
movb %dil, 0x64(%rsp)
movl %eax, 0x68(%rsp)
movb %cl, 0x6c(%rsp)
movl %r10d, 0x70(%rsp)
cmpl $0x0, (%rsi)
jle 0x19c46
leaq 0x50(%rsp), %rcx
movq 0x28(%rsp), %rdi
callq 0x19e23
jmp 0x19cd3
testl %eax, %eax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rcx
jle 0x19ceb
shll $0xb, %r15d
sarl $0x1f, %r15d
subl %r13d, %ebp
xorl %eax, %eax
andl %r15d, %ebp
leaq 0x4(%rsp), %rsi
movl %ebp, (%rsi)
cmovlel %eax, %ebp
leaq 0x1(%rbp,%rcx), %rdx
leaq 0x8(%rsp), %rax
leaq 0x50(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rcx)
leaq 0xc(%rsp), %rax
movq %rax, 0x10(%rcx)
leaq 0x3c(%rsp), %rax
movq %rax, 0x18(%rcx)
leaq 0x3(%rsp), %rax
movq %rax, 0x20(%rcx)
movq %rsi, 0x28(%rcx)
movq 0x10(%rsp), %rsi
callq 0x19ecc
jmp 0x19cd3
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x18979
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x19e2e
jmp 0x19cd6
testl %ebp, %ebp
setg %al
cmpb $0x2, %r15b
sete %cl
orb %al, %cl
movq 0x10(%rsp), %rsi
je 0x19c80
testl %ebp, %ebp
jg 0x19c8b
jmp 0x19c90
movl $0x1, 0x4(%rsp)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq %rax, %rdx
leaq 0x8(%rsp), %rax
leaq 0x50(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rcx)
leaq 0xc(%rsp), %rax
movq %rax, 0x10(%rcx)
movq %r14, 0x18(%rcx)
leaq 0x40(%rsp), %rax
movq %rax, 0x20(%rcx)
leaq 0x3(%rsp), %rax
movq %rax, 0x28(%rcx)
leaq 0x4(%rsp), %rax
movq %rax, 0x30(%rcx)
callq 0x19ec1
movq %rax, %rbx
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
negl %eax
cmpl %eax, %ebp
movl %eax, %edx
cmovll %ebp, %edx
testl %ebp, %ebp
cmovsl %eax, %edx
testl %r13d, %r13d
cmovnel %eax, %edx
leaq 0x4(%rsp), %rax
movl %edx, (%rax)
addl $0x2, %edx
addq %rcx, %rdx
leaq 0x8(%rsp), %rsi
leaq 0x50(%rsp), %rcx
movq %rsi, (%rcx)
movq %rax, 0x8(%rcx)
leaq 0xc(%rsp), %rax
movq %rax, 0x10(%rcx)
leaq 0x40(%rsp), %rax
movq %rax, 0x18(%rcx)
leaq 0x3(%rsp), %rax
movq %rax, 0x20(%rcx)
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rcx)
movq 0x10(%rsp), %rsi
callq 0x19ed7
jmp 0x19cd3
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
char* fmt::v7::detail::write_significand<char*, char>(char*, char const*, int, int, char)
|
inline OutputIt write_significand(OutputIt out, const char* significand,
int significand_size, int integral_size,
Char decimal_point) {
out = detail::copy_str<Char>(significand, significand + integral_size, out);
if (!decimal_point) return out;
*out++ = decimal_point;
return detail::copy_str<Char>(significand + integral_size,
significand + significand_size, out);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r12d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movslq %ecx, %r15
testl %r15d, %r15d
je 0x19f8b
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6730
addq %r15, %rbx
testb %r12b, %r12b
je 0x19fbb
movb %r12b, (%rbx)
incq %rbx
movslq %ebp, %rax
movq %rax, %r12
subq %r15, %r12
cmpl %r15d, %eax
je 0x19fb8
addq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6730
addq %r12, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::big_decimal_fp fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda0'(char*)&>(fmt::v7::detail::big_decimal_fp, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda0'(char*)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0xf049(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %r14, %r12
shrq %cl, %r12
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r13
imulq %r14, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0x18979
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1899a
movq %r15, %rdi
movq %rax, %rsi
callq 0x1a048
subq %r12, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1899a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::big_decimal_fp fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda1'(char*)&>(fmt::v7::detail::big_decimal_fp, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda1'(char*)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0xef28(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %r14, %r12
shrq %cl, %r12
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r13
imulq %r14, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0x18979
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1899a
movq %r15, %rdi
movq %rax, %rsi
callq 0x1a168
subq %r12, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1899a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
fmt::v7::detail::big_decimal_fp fmt::v7::detail::write_padded<(fmt::v7::align::type)2, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda2'(char*)&>(fmt::v7::detail::big_decimal_fp, fmt::v7::basic_format_specs<char> const&, unsigned long, unsigned long, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_float<std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp, char>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, fmt::v7::detail::big_decimal_fp const&, fmt::v7::basic_format_specs<char> const&, fmt::v7::detail::float_specs, char)::'lambda2'(char*)&)
|
inline OutputIt write_padded(OutputIt out,
const basic_format_specs<Char>& specs, size_t size,
size_t width, F&& f) {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
auto* shifts = align == align::left ? data::left_padding_shifts
: data::right_padding_shifts;
size_t left_padding = padding >> shifts[specs.align];
auto it = reserve(out, size + padding * specs.fill.size());
it = fill(it, left_padding, specs.fill);
it = f(it);
it = fill(it, padding - left_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzbl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0xee43(%rip), %rcx # 0x29039
movb (%rax,%rcx), %cl
movq %r14, %r12
shrq %cl, %r12
movzbl 0xe(%rsi), %eax
leaq 0xa(%rsi), %r13
imulq %r14, %rax
addq %rdx, %rax
movq %rax, %rsi
callq 0x18979
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1899a
movq %r15, %rdi
movq %rax, %rsi
callq 0x1a24e
subq %r12, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1899a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char const*)
|
OutputIt write(OutputIt out, const Char* value) {
if (!value) {
FMT_THROW(format_error("string pointer is null"));
} else {
auto length = std::char_traits<Char>::length(value);
out = write(out, basic_string_view<Char>(value, length));
}
return out;
}
|
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1a354
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x6200
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a397
pushq $0x10
popq %rdi
callq 0x6260
movq %rax, %rbx
leaq 0xe1fc(%rip), %rsi # 0x28562
movq %rax, %rdi
callq 0xd93c
leaq 0x25e43(%rip), %rsi # 0x401b8
movq 0x26c1c(%rip), %rdx # 0x40f98
movq %rbx, %rdi
callq 0x67a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> fmt::v7::detail::write_ptr<char, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned long>(std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned long, fmt::v7::basic_format_specs<char> const*)
|
OutputIt write_ptr(OutputIt out, UIntPtr value,
const basic_format_specs<Char>* specs) {
int num_digits = count_digits<4>(value);
auto size = to_unsigned(num_digits) + size_t(2);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
auto write = [=](iterator it) {
*it++ = static_cast<Char>('0');
*it++ = static_cast<Char>('x');
return format_uint<4, Char>(it, value, num_digits);
};
return specs ? write_padded<align::right>(out, *specs, size, write)
: base_iterator(out, write(reserve(out, size)));
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x123f0
movl %eax, %edx
addq $0x2, %rdx
movq %r15, (%rsp)
movl %eax, 0x8(%rsp)
testq %r14, %r14
je 0x1a491
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a4b4
movq %rax, %rbx
jmp 0x1a4a7
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x18979
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1a4c0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/thirdparty/fmt/format.h
|
diy::Master::ProcessBlock::operator()()
|
void operator()()
{
master.log->debug("Processing with thread: {}", this_thread::get_id());
std::vector<int> local;
do
{
int cur = (*idx.access())++;
if ((size_t)cur >= blocks.size())
return;
int i = blocks[cur];
int gid = master.gid(i);
stats::Annotation::Guard g( stats::Annotation("diy.block").set(gid) );
if (master.block(i))
{
if (local.size() == (size_t)local_limit)
master.unload(local);
local.push_back(i);
}
master.log->debug("Processing block: {}", gid);
bool skip = all_skip(i);
IncomingQueuesMap ¤t_incoming = master.incoming_[master.exchange_round_].map;
if (master.block(i) == 0) // block unloaded
{
if (skip)
master.load_queues(i); // even though we are skipping the block, the queues might be necessary
else
{
if (local.size() == (size_t)local_limit) // reached the local limit
master.unload(local);
master.load(i);
local.push_back(i);
}
}
for (auto& cmd : master.commands_)
{
cmd->execute(skip ? 0 : master.block(i), master.proxy(i));
// no longer need them, so get rid of them
current_incoming[gid].clear();
}
if (skip && master.block(i) == 0)
master.unload_queues(i); // even though we are skipping the block, the queues might be necessary
} while(true);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x38(%rsp), %rbp
movq 0x18(%r14), %rsi
movq %rbp, %rdi
callq 0x1ba86
movq 0x38(%rsp), %rax
movslq (%rax), %r15
leal 0x1(%r15), %ecx
movl %ecx, (%rax)
leaq 0x40(%rsp), %rdi
callq 0xba12
movq 0x8(%r14), %rdi
callq 0x1b670
cmpq %r15, %rax
jbe 0x1acaa
movq 0x8(%r14), %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x1bd5a
movslq (%rax), %rsi
movl %esi, 0x8(%rsp)
movq (%r14), %rdi
movq 0x100(%rdi), %rax
movl (%rax,%rsi,4), %eax
movl %eax, 0xc(%rsp)
movq 0xa0(%rdi), %rax
cmpq $0x0, (%rax,%rsi,8)
je 0x1ab6f
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
sarq $0x2, %rax
movslq 0x10(%r14), %rcx
cmpq %rcx, %rax
jne 0x1ab5c
leaq 0x10(%rsp), %rsi
callq 0x1baa0
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa816
movl 0x8(%rsp), %esi
movq %r14, %rdi
callq 0x1bae8
movb %al, 0x7(%rsp)
movq (%r14), %rsi
leaq 0x178(%rsi), %rdi
addq $0x1f4, %rsi # imm = 0x1F4
callq 0x1acf4
movq %rax, 0x30(%rsp)
movq (%r14), %rdi
movslq 0x8(%rsp), %rsi
movq 0xa0(%rdi), %rax
cmpq $0x0, (%rax,%rsi,8)
jne 0x1abf6
cmpb $0x0, 0x7(%rsp)
je 0x1abba
callq 0x1bb38
jmp 0x1abf6
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
sarq $0x2, %rax
movslq 0x10(%r14), %rcx
cmpq %rcx, %rax
jne 0x1abe2
leaq 0x10(%rsp), %rsi
callq 0x1baa0
movq (%r14), %rdi
movl 0x8(%rsp), %esi
callq 0x1bb6c
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa816
movq (%r14), %rax
movq 0x200(%rax), %rbx
movq 0x208(%rax), %r12
cmpq %r12, %rbx
je 0x1ac7b
movq %r14, %r13
movq (%r14), %rsi
movslq 0x8(%rsp), %rdx
cmpb $0x0, 0x7(%rsp)
je 0x1ac23
xorl %r14d, %r14d
jmp 0x1ac2e
movq 0xa0(%rsi), %rax
movq (%rax,%rdx,8), %r14
movq (%rbx), %rbp
leaq 0x38(%rsp), %r15
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x1bb90
movq (%rbp), %rax
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x10(%rax)
movq %r15, %rbp
movq %r15, %rdi
callq 0x1bc04
movq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1ae5e
movq %rax, %rdi
callq 0x1bd26
addq $0x8, %rbx
movq %r13, %r14
jmp 0x1ac07
cmpb $0x0, 0x7(%rsp)
je 0x1aacf
movq (%r14), %rdi
movslq 0x8(%rsp), %rsi
movq 0xa0(%rdi), %rax
cmpq $0x0, (%rax,%rsi,8)
jne 0x1aacf
callq 0xbb94
jmp 0x1aacf
leaq 0x10(%rsp), %rdi
callq 0x8d50
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1acdf
jmp 0x1acdf
jmp 0x1acdf
jmp 0x1acdf
jmp 0x1acdf
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1bc04
jmp 0x1ace2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8d50
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/detail/master/execution.hpp
|
diy::Master::unload(std::vector<int, std::allocator<int>>&)
|
void unload(std::vector<int>& loaded) { for(unsigned i = 0; i < loaded.size(); ++i) unload(loaded[i]); loaded.clear(); }
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, %r15d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r15, %rdx
jbe 0x1bad8
movl (%rax,%r15,4), %esi
movq %r14, %rdi
callq 0xbab8
leal 0x1(%r15), %eax
jmp 0x1baad
cmpq %rax, %rcx
je 0x1bae1
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/diatomic[P]diy/include/diy/master.hpp
|
diy::Master::ProcessBlock::all_skip(int) const
|
bool all_skip(int i) const
{
bool skip = true;
for (auto& cmd : master.commands_)
{
if (!cmd->skip(i, master))
{
skip = false;
break;
}
}
return skip;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x200(%rax), %rcx
movq 0x208(%rax), %r15
movq %rcx, %r12
cmpq %r15, %rcx
je 0x1bb26
movq (%r12), %rdi
movq (%r14), %rdx
movq (%rdi), %rax
movl %ebx, %esi
callq *0x18(%rax)
leaq 0x8(%r12), %rcx
testb %al, %al
jne 0x1bb06
cmpq %r15, %r12
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/detail/master/execution.hpp
|
diy::MemoryBuffer::MemoryBuffer(diy::MemoryBuffer&&)
|
MemoryBuffer(MemoryBuffer&&) =default;
|
leaq 0x23d6b(%rip), %rax # 0x40358
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x20(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
movups 0x30(%rsi), %xmm1
movups %xmm1, 0x30(%rdi)
movq 0x40(%rsi), %rax
movq %rax, 0x40(%rdi)
movups %xmm0, 0x30(%rsi)
andq $0x0, 0x40(%rsi)
retq
|
/diatomic[P]diy/include/diy/serialization.hpp
|
diy::AMRLink::AMRLink(int, int, int, diy::Bounds<int> const&, diy::Bounds<int> const&)
|
AMRLink(int dim, int level, int refinement, const Bounds& core, const Bounds& bounds):
AMRLink(dim, level, refinement * Point::one(dim), core, bounds) {}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, (%rsp)
movq %r8, %r14
movl %ecx, %r13d
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r12
movslq %esi, %rsi
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x1de3a
leaq 0x8(%rsp), %rdi
movl %r13d, %esi
movq %rbx, %rdx
callq 0x1de11
leaq 0x8(%rsp), %rcx
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %r8
movq (%rsp), %r9
callq 0x1de4c
leaq 0x8(%rsp), %rdi
callq 0x1e7a2
leaq 0x48(%rsp), %rdi
callq 0x1e7a2
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1e7a2
jmp 0x1dcc2
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1e7a2
movq %rbx, %rdi
callq 0x67d0
|
/diatomic[P]diy/include/diy/link.hpp
|
itlib::small_vector<int, 4ul, 0ul, std::allocator<int>>::choose_data(unsigned long)
|
T* choose_data(size_t desired_capacity)
{
if (m_begin == m_dynamic_data)
{
// we're at the dyn buffer, so see if it needs resize or revert to static
if (desired_capacity > m_dynamic_capacity)
{
while (m_dynamic_capacity < desired_capacity)
{
// grow by roughly 1.5
m_dynamic_capacity *= 3;
++m_dynamic_capacity;
m_dynamic_capacity /= 2;
}
m_dynamic_data = atraits::allocate(get_alloc(), m_dynamic_capacity);
return m_dynamic_data;
}
else if (desired_capacity < RevertToStaticSize)
{
// we're reverting to the static buffer
return static_begin_ptr();
}
else
{
// if the capacity and we don't revert to static, just do nothing
return m_dynamic_data;
}
}
else
{
assert(m_begin == static_begin_ptr()); // corrupt begin ptr?
if (desired_capacity > StaticCapacity)
{
// we must move to dyn memory
// see if we have enough
if (desired_capacity > m_dynamic_capacity)
{
// we need to allocate more
// we don't have anything to destroy, so we can also deallocate the buffer
if (m_dynamic_data)
{
atraits::deallocate(get_alloc(), m_dynamic_data, m_dynamic_capacity);
}
m_dynamic_capacity = desired_capacity;
m_dynamic_data = atraits::allocate(get_alloc(), m_dynamic_capacity);
}
return m_dynamic_data;
}
else
{
// we have enough capacity as it is
return static_begin_ptr();
}
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x1ddd6
cmpq $0x5, %r14
jb 0x1de02
movq 0x30(%rbx), %rsi
cmpq %r14, %rsi
jae 0x1de09
testq %rax, %rax
je 0x1ddca
shlq $0x2, %rsi
movq %rax, %rdi
callq 0x6450
movq %r14, 0x30(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x1ddf7
movq 0x30(%rbx), %rsi
cmpq %r14, %rsi
jb 0x1ddef
jmp 0x1de09
leaq (%rsi,%rsi,2), %rsi
incq %rsi
shrq %rsi
movq %rsi, 0x30(%rbx)
cmpq %r14, %rsi
jb 0x1dde1
movq %rbx, %rdi
callq 0xa7a4
movq %rax, 0x38(%rbx)
jmp 0x1de09
addq $0x20, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/diatomic[P]diy/include/diy/thirdparty/itlib/small_vector.hpp
|
itlib::small_vector<int, 4ul, 0ul, std::allocator<int>>::small_vector(itlib::small_vector<int, 4ul, 0ul, std::allocator<int>>&&)
|
small_vector(small_vector&& v) noexcept
: m_alloc(std::move(v.get_alloc()))
, m_capacity(v.m_capacity)
, m_dynamic_capacity(v.m_dynamic_capacity)
, m_dynamic_data(v.m_dynamic_data)
{
if (v.m_begin == v.static_begin_ptr())
{
m_begin = m_end = static_begin_ptr();
for (auto p = v.m_begin; p != v.m_end; ++p)
{
atraits::construct(get_alloc(), m_end, std::move(*p));
++m_end;
}
v.clear();
}
else
{
m_begin = v.m_begin;
m_end = v.m_end;
}
v.m_dynamic_capacity = 0;
v.m_dynamic_data = nullptr;
v.m_begin = v.m_end = v.static_begin_ptr();
v.m_capacity = StaticCapacity;
}
|
movq 0x18(%rsi), %rax
movq %rax, 0x18(%rdi)
leaq 0x30(%rsi), %rax
movq 0x30(%rsi), %rcx
movq %rcx, 0x30(%rdi)
movq 0x38(%rsi), %rcx
movq %rcx, 0x38(%rdi)
movq 0x8(%rsi), %rdx
leaq 0x20(%rsi), %rcx
cmpq %rcx, %rdx
je 0x1dfce
movq %rdx, 0x8(%rdi)
movq 0x10(%rsi), %rdx
movq %rdx, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rsi)
movq %rcx, 0x8(%rsi)
movq $0x4, 0x18(%rsi)
retq
leaq 0x20(%rdi), %rdx
movq %rdx, 0x10(%rdi)
movq %rdx, 0x8(%rdi)
movq 0x8(%rsi), %rdx
leaq 0x24(%rdi), %r8
cmpq 0x10(%rsi), %rdx
je 0x1dfb7
movl (%rdx), %r9d
movl %r9d, -0x4(%r8)
movq %r8, 0x10(%rdi)
addq $0x4, %rdx
addq $0x4, %r8
jmp 0x1dfe2
nop
|
/diatomic[P]diy/include/diy/thirdparty/itlib/small_vector.hpp
|
itlib::small_vector<int, 4ul, 0ul, std::allocator<int>>::~small_vector()
|
~small_vector()
{
clear();
if (m_dynamic_data)
{
atraits::deallocate(get_alloc(), m_dynamic_data, m_dynamic_capacity);
}
}
|
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movq 0x38(%rdi), %rdi
movq %rcx, 0x10(%rax)
testq %rdi, %rdi
je 0x1e7c3
movq 0x30(%rax), %rsi
shlq $0x2, %rsi
jmp 0x6450
retq
|
/diatomic[P]diy/include/diy/thirdparty/itlib/small_vector.hpp
|
diy::Serialization<diy::AMRLink::Description>::load(diy::BinaryBuffer&, diy::AMRLink::Description&)
|
static void load(diy::BinaryBuffer& bb, diy::AMRLink::Description& x)
{
diy::load(bb, x.level);
diy::load(bb, x.refinement);
diy::load(bb, x.core);
diy::load(bb, x.bounds);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
pushq $0x4
popq %rdx
callq *0x20(%rax)
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1eddc
leaq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x1eede
addq $0xc8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1eede
|
/diatomic[P]diy/include/diy/link.hpp
|
diy::Serialization<diy::DynamicPoint<int, 4ul>>::load(diy::BinaryBuffer&, diy::DynamicPoint<int, 4ul>&)
|
static void load(BinaryBuffer& bb, Point& p)
{
size_t s;
diy::load(bb, s);
p.resize(s);
if (s > 0)
diy::load(bb, &p[0], s);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x8(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rsi
callq *0x20(%rax)
movq (%r15), %rsi
movq %r14, %rdi
callq 0x1ee2a
movq (%r15), %rdx
testq %rdx, %rdx
je 0x1ee20
movq 0x8(%r14), %rsi
shlq $0x2, %rdx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/diatomic[P]diy/include/diy/dynamic-point.hpp
|
diy::Serialization<std::vector<diy::AMRLink::Description, std::allocator<diy::AMRLink::Description>>>::load(diy::BinaryBuffer&, std::vector<diy::AMRLink::Description, std::allocator<diy::AMRLink::Description>>&)
|
static void load(BinaryBuffer& bb, Vector& v)
{
size_t s;
diy::load(bb, s);
v.resize(s, U());
if (s > 0)
diy::load(bb, &v[0], s);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x8(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rsi
callq *0x20(%rax)
movq (%r15), %r15
leaq 0x10(%rsp), %r12
movl $0x148, %edx # imm = 0x148
movq %r12, %rdi
xorl %esi, %esi
callq 0x62a0
movq %r12, %rdi
callq 0x1efda
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1ef9a
leaq 0x10(%rsp), %rdi
callq 0x1e738
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0x1ef75
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1f049
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1e738
movq %rbx, %rdi
callq 0x67d0
nop
|
/diatomic[P]diy/include/diy/serialization.hpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.