name string | code string | asm string | file string |
|---|---|---|---|
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... | 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
test... | /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,%r... | /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
te... | /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;
... | 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... | /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^-... | 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 ... | /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... | 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
j... | /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 < div... | 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... | 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 %r10... | /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.
... | 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 0x11... | /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(... | /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... | 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
... | /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>;
... | 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, %ed... | /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,
... | 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 ... | /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)... | 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 %e... | /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);
... | 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
... | /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>, ... | 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_wi... | 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 ... | /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>, ... | 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_wi... | 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 ... | /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[... | 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, %... | /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>, ch... | 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 != '}')
ret... | 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 ... | /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_h... | 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'... | 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
cmp... | /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();
}
... | 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
mo... | /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;
}
ret... | 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(... | /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_... | 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 '... | 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 ... | /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_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... | 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,... | /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_che... | 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 == '{') {
... | 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
mov... | /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
... | /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_chec... | 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>()... | 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... | /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... | 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'... | 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
cmp... | /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*&, c... | 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>()... | 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... | /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 %... | /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... | /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_DEPRE... | 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, ... | /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) {
... | 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), ... | /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()::'la... | 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_wi... | 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 ... | /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[... | 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 ... | /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_c... | 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 %... | /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... | 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... | 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... | /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()::'la... | 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_wi... | 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 ... | /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_c... | 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_appende... | 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_wi... | 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 ... | /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 %e... | /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_DEPRE... | 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, ... | /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::basi... | 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... | 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... | /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::basi... | 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... | 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... | /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_c... | 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()::'l... | 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_wi... | 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 ... | /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[... | 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, %... | /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_append... | 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_wi... | 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 ... | /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_DEPRE... | 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, ... | /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_uin... | 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), ... | /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 = writ... | 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, 0x3... | /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.cbe... | 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 0x2... | /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()... | 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_wi... | 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 ... | /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::... | 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... | 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... | /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_c... | 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::... | 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... | 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... | /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, %e... | /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, det... | 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, det... | 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, det... | 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, det... | 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 ... | 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, %rd... | /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, det... | 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 ... | 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, det... | 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
ad... | /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... | 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_sp... | 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 = 0x7FF... | /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... | 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;... | 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 $... | /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... | 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');
... | 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 ... | /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_... | 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_wi... | 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)... | /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
p... | /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>>> ... | 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_wi... | 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(... | /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++ = ... | 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 ... | /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>>> ... | 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_wi... | 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(... | /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>>> ... | 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_wi... | 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(... | /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>>> ... | 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_wi... | 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(... | /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_iterato... | 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');
... | 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 ... | /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>>>... | 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_wi... | 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(... | /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>>>... | 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_wi... | 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(... | /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... | 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 ... | 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,... | /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:... | 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');
... | 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, ... | /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;
*... | 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, %ra... | /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::detai... | 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_wi... | 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(... | /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::detai... | 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_wi... | 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(... | /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::detai... | 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_wi... | 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(... | /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<ch... | 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, %... | /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, ... | 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... | 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
mov... | /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::Ann... | 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
... | /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 0... | /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
jn... | /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)... | /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
l... | /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)
... | 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, %r... | /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_p... | 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... | /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 0x1eed... | /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), ... | /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 %es... | /diatomic[P]diy/include/diy/serialization.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.