name string | code string | asm string | file string |
|---|---|---|---|
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 %rdi, 0x8(%rsp)
cmpq %rsi, %rdi
je 0x15f05
movzbl (%rdi), %eax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x7d, %eax
je 0x15e1a
cmpl $0x3a, %eax
jne 0x15e2f
movq %rbx, %rdi
callq 0x15f1e
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leal -0x30(%rax... | /quesnel[P]baryonyx/external/fmt/include/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
cmpq %rsi, %rax
je 0x15f89
movb (%rax), %cl
leal -0x30(%rcx), %r8d
cmpb $0x9, %r8b
ja 0x15f89
incq %rax
xorl %ebx, %ebx
cmpl $0xccccccc, %ebx # imm = 0xCCCCCCC
ja 0x15f71
imull $0xa, %ebx, %r8d
movzbl %cl, %ecx
movq %rax, (%rdi)
leal -0x30(%r8,%rcx), %ebx
cmpq %rsi, %rax
je 0x15f6b
m... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::get_dynamic_spec<fmt::v7::detail::width_checker, fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>, fmt::v7::detail::error_handler>(fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>, fmt::v7::d... | FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
return static_cast<int>(value);
} | subq $0x18, %rsp
movl 0x30(%rsp), %ecx
leaq 0xf(%rsp), %rax
movq %rax, 0x10(%rsp)
decl %ecx
cmpl $0xe, %ecx
ja 0x1605a
leaq 0x43e419(%rip), %rdx # 0x45442c
leaq 0x20(%rsp), %rax
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rax), %rax
jmp 0x16064
movq (%rax), %rsi
leaq 0x10(%rsp), %rdi
callq 0x160d0
j... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char const* fmt::v7::detail::parse_arg_id<char, fmt::v7::detail::precision_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*, ... | 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 %rdi, 0x8(%rsp)
cmpq %rsi, %rdi
je 0x16358
movzbl (%rdi), %eax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x7d, %eax
je 0x1626d
cmpl $0x3a, %eax
jne 0x16282
movq %rbx, %rdi
callq 0x16370
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leal -0x30(%rax... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::parse_nonnegative_int<char, fmt::v7::detail::precision_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*... | 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
cmpq %rsi, %rax
je 0x163db
movb (%rax), %cl
leal -0x30(%rcx), %r8d
cmpb $0x9, %r8b
ja 0x163db
incq %rax
xorl %ebx, %ebx
cmpl $0xccccccc, %ebx # imm = 0xCCCCCCC
ja 0x163c3
imull $0xa, %ebx, %r8d
movzbl %cl, %ecx
movq %rax, (%rdi)
leal -0x30(%r8,%rcx), %ebx
cmpq %rsi, %rax
je 0x163bd
m... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::get_dynamic_spec<fmt::v7::detail::precision_checker, fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>, fmt::v7::detail::error_handler>(fmt::v7::basic_format_arg<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>, fmt::v... | FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
return static_cast<int>(value);
} | subq $0x18, %rsp
movl 0x30(%rsp), %ecx
leaq 0xf(%rsp), %rax
movq %rax, 0x10(%rsp)
decl %ecx
cmpl $0xe, %ecx
ja 0x164ad
leaq 0x43e002(%rip), %rdx # 0x454468
leaq 0x20(%rsp), %rax
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rax), %rax
jmp 0x164b7
movq (%rax), %rsi
leaq 0x10(%rsp), %rdi
callq 0x164f8
j... | /quesnel[P]baryonyx/external/fmt/include/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 0x10(%rdi), %rax
movq %rdi, %rbx
testq %rax, %rax
je 0x1664a
movq (%rax), %rsi
movq 0x8(%rax), %rdx
jmp 0x1665e
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
movabsq $0x1000000200000, %rdx # imm = 0x1000000200000
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
callq 0x194da
movq %rax, (%rbx)
popq %... | /quesnel[P]baryonyx/external/fmt/include/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()<double, 0>(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
movq 0x10(%rdi), %rax
movq %rdi, %rbx
testq %rax, %rax
je 0x16686
movq (%rax), %rsi
movq 0x8(%rax), %rdx
jmp 0x1669a
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
movabsq $0x1000000200000, %rdx # imm = 0x1000000200000
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
callq 0x1a4cb
movq %rax, (%rbx)
popq %... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::operator()(fmt::v7::basic_string_view<char>) | iterator operator()(basic_string_view<Char> value) {
if (specs_) {
check_string_type_spec(specs_->type, error_handler());
write(value, *specs_);
} else {
write(value);
}
return out_;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x10(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rax, %rax
je 0x1676d
movsbl 0x8(%rax), %edi
leaq 0xf(%rsp), %rsi
callq 0x1a87f
movq 0x10(%rbx), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1921c
jmp 0x1677b
movq %rbx, %rdi
mo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::write_int<int>(int, 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
vmovups (%rdi), %xmm0
movq %rdi, %rbx
vmovaps %xmm0, (%rsp)
movq %rdx, 0x10(%rsp)
movl %esi, 0x18(%rsp)
andl $0x0, 0x20(%rsp)
testl %esi, %esi
js 0x1685e
movb 0x9(%rdx), %al
shrb $0x4, %al
andb $0x7, %al
cmpb $0x2, %al
jb 0x16871
pushq $0x2b
popq %rax
pushq $0x20
popq %rcx
cmovel ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::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 0x10(%rdi), %rax
movq %rdi, %rbx
cmpb $0x0, 0x9(%rax)
jns 0x16966
movl 0x20(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb $0x30, 0x1c(%rbx,%rcx)
movl 0x20(%rbx), %ecx
movb 0x8(%rax), %al
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb %al, 0x1c(%rbx,%rcx)
movl 0x18(%rbx), ... | /quesnel[P]baryonyx/external/fmt/include/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 0x10(%rdi), %rax
movq %rdi, %rbx
cmpb $0x0, 0x9(%rax)
jns 0x169d0
movl 0x20(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb $0x30, 0x1c(%rbx,%rcx)
movl 0x20(%rbx), %ecx
movb 0x8(%rax), %al
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb %al, 0x1c(%rbx,%rcx)
movl 0x18(%rbx), ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::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
movl 0x18(%rdi), %edi
callq 0x172d1
movq 0x10(%rbx), %r8
cmpb $0x0, 0x9(%r8)
jns 0x16a3f
cmpl %eax, 0x4(%r8)
jg 0x16a3f
cmpl $0x0, 0x18(%rbx)
je 0x16a3f
movl 0x20(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movb $0x30, 0x1c(%rbx,%rcx)
movq (%rbx), %rdi
movl 0x20(%r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned int>::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 0x8(%rdi), %rsi
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x17579
cmpq $0x0, 0x8(%r14)
je 0x16ae0
movq 0x8(%rbx), %rdi
callq 0x175d9
movl %eax, %ebp
testb %al, %al
je 0x16aed
movl 0x18(%rbx), %edi
callq 0x... | /quesnel[P]baryonyx/external/fmt/include/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_dec()::'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 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::write_int_data<char>::write_int_data(int, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&) | write_int_data(int num_digits, string_view prefix,
const basic_format_specs<Char>& specs)
: size(prefix.size() + to_unsigned(num_digits)), padding(0) {
if (specs.align == align::numeric) {
auto width = to_unsigned(specs.width);
if (width > size) {
padding = width - size;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %edi
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebp
callq 0x1085f
movl %eax, %eax
addq %r15, %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb 0x9(%r14), %al
andb $0xf, %al
cmpb $0x4, %al
jne 0x16d57
movl (%r14), %edi
callq 0x1085f
movl %e... | /quesnel[P]baryonyx/external/fmt/include/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_dec()::'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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x440462(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/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_hex()::'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 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x4402e5(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/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
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r15b, %ecx
testq %rax, %rax
je 0x1704d
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x17083
jmp 0x17... | /quesnel[P]baryonyx/external/fmt/include/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" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cas... | movslq %edx, %r8
testl %ecx, %ecx
leaq 0x43e49b(%rip), %r9 # 0x45552a
leaq 0x44091a(%rip), %rdx # 0x4579b0
leaq -0x1(%rdi,%r8), %rcx
leaq (%rdi,%r8), %rax
cmovneq %r9, %rdx
movl %esi, %edi
movl %esi, %r8d
andl $0xf, %r8d
shrl $0x4, %edi
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx)
decq %rcx
cmpl $0xf, %esi
movl %edi,... | /quesnel[P]baryonyx/external/fmt/include/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 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x4400b1(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<1u, 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 $0x28, %rsp
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r15b, %ecx
testq %rax, %rax
je 0x17276
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x172a9
jmp 0x17... | /quesnel[P]baryonyx/external/fmt/include/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" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cas... | movslq %edx, %rcx
movl %esi, %edx
leaq (%rdi,%rcx), %rax
leaq -0x1(%rdi,%rcx), %rcx
movl %esi, %edi
shrl %edx
andb $0x1, %dil
orb $0x30, %dil
movb %dil, (%rcx)
decq %rcx
cmpl $0x1, %esi
movl %edx, %esi
ja 0x172b7
retq
| /quesnel[P]baryonyx/external/fmt/include/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_oct()::'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 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/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_oct()::'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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43fea0(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<3u, 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
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r15b, %ecx
testq %rax, %rax
je 0x17488
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x174be
jmp 0x17... | /quesnel[P]baryonyx/external/fmt/include/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43fd0e(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/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 int>(unsigned int, 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
vmovups (%rdi), %xmm0
movq %rdi, %rbx
vmovaps %xmm0, (%rsp)
movq %rdx, 0x10(%rsp)
movl %esi, 0x18(%rsp)
andl $0x0, 0x20(%rsp)
movb 0x9(%rdx), %al
shrb $0x4, %al
andb $0x7, %al
cmpb $0x2, %al
jb 0x17680
pushq $0x2b
popq %rax
pushq $0x20
popq %rcx
cmovel %eax, %ecx
movb %cl, 0x1c(%r... | /quesnel[P]baryonyx/external/fmt/include/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
vmovups (%rdi), %xmm0
movq %rdi, %rbx
vmovaps %xmm0, (%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
andl $0x0, 0x24(%rsp)
testq %rsi, %rsi
js 0x176e8
movb 0x9(%rdx), %al
shrb $0x4, %al
andb $0x7, %al
cmpb $0x2, %al
jb 0x176fd
pushq $0x2b
popq %rax
pushq $0x20
popq %rcx
cmovel ... | /quesnel[P]baryonyx/external/fmt/include/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 0x17746
cmpl $0x42, %edi
je 0x17756
cmpl $0x4c, %edi
je 0x1775e
cmpl $0x58, %edi
je 0x1774e
cmpl $0x62, %edi
je 0x17756
cmpl $0x63, %edi
je 0x1776e
cmpl $0x78, %edi
je 0x1774e
cmpl $0x6f, %edi
je 0x17766
cmpl $0x64, %edi
jne 0x17776
movq %rsi, %rdi
jmp 0x17780
movq %rsi, %rdi
jmp 0x177c4
movq %rsi, ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::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 0x10(%rdi), %rax
movq %rdi, %rbx
cmpb $0x0, 0x9(%rax)
jns 0x177f4
movl 0x24(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movb $0x30, 0x20(%rbx,%rcx)
movl 0x24(%rbx), %ecx
movb 0x8(%rax), %al
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movb %al, 0x20(%rbx,%rcx)
movq 0x18(%rbx), ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::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 0x10(%rdi), %rax
movq %rdi, %rbx
cmpb $0x0, 0x9(%rax)
jns 0x17860
movl 0x24(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movb $0x30, 0x20(%rbx,%rcx)
movl 0x24(%rbx), %ecx
movb 0x8(%rax), %al
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movb %al, 0x20(%rbx,%rcx)
movq 0x18(%rbx), ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::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 0x18(%rdi), %rdi
callq 0x1802e
movq 0x10(%rbx), %r8
cmpb $0x0, 0x9(%r8)
jns 0x178d3
cmpl %eax, 0x4(%r8)
jg 0x178d3
cmpq $0x0, 0x18(%rbx)
je 0x178d3
movl 0x24(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x24(%rbx)
movb $0x30, 0x20(%rbx,%rcx)
movq (%rbx), %rdi
movl 0x24(%r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned long>::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 0x8(%rdi), %rsi
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x17579
cmpq $0x0, 0x8(%r14)
je 0x17975
movq 0x8(%rbx), %rdi
callq 0x175d9
movl %eax, %ebp
testb %al, %al
je 0x17982
movq 0x18(%rbx), %rdi
callq 0x... | /quesnel[P]baryonyx/external/fmt/include/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_dec()::'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 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/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 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/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_hex()::'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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43f4e1(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/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 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/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_bin()::'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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43f359(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<1u, 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 $0x48, %rsp
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r15b, %ecx
testq %rax, %rax
je 0x17fcf
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x18002
jmp 0x17ff... | /quesnel[P]baryonyx/external/fmt/include/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_oct()::'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 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::format_uint<3u, 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" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cas... | movslq %edx, %rcx
movq %rsi, %rdx
leaq (%rdi,%rcx), %rax
leaq -0x1(%rdi,%rcx), %rcx
movl %esi, %edi
shrq $0x3, %rdx
andb $0x7, %dil
orb $0x30, %dil
movb %dil, (%rcx)
decq %rcx
cmpq $0x7, %rsi
movq %rdx, %rsi
ja 0x1822b
retq
| /quesnel[P]baryonyx/external/fmt/include/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 0x1841d
cmpl $0x42, %edi
je 0x1842d
cmpl $0x4c, %edi
je 0x18435
cmpl $0x58, %edi
je 0x18425
cmpl $0x62, %edi
je 0x1842d
cmpl $0x63, %edi
je 0x18445
cmpl $0x78, %edi
je 0x18425
cmpl $0x6f, %edi
je 0x1843d
cmpl $0x64, %edi
jne 0x1844d
movq %rsi, %rdi
jmp 0x18456
movq %rsi, %rdi
jmp 0x1849e
movq %rsi, ... | /quesnel[P]baryonyx/external/fmt/include/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 0x8(%rdi), %rsi
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x17579
cmpq $0x0, 0x8(%r14)
je 0x18661
movq 0x8(%rbx), %rdi
callq 0x175d9
movl %eax, %ebp
testb %al, %al
je 0x1866e
movq 0x20(%rbx), %rdi
movq 0x2... | /quesnel[P]baryonyx/external/fmt/include/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_dec()::'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 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43e95d(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/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 0x16d0c
vmovups (%r13), %xmm0
movq (%r13), %rdx
movq 0x70(%rsp), %rax
movl 0x78(%rsp), %esi
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r15, (%rcx)... | /quesnel[P]baryonyx/external/fmt/include/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_hex()... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43e7c3(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<4u, char, fmt::v7::detail::buffer_appender<char>, unsigned __int128>(fmt::v7::detail::buffer_appender<char>, unsigned __int128, 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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl %ecx, %edi
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r12b, %r8d
testq %rax, %rax
je 0x18b7f
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char* fmt::v7::detail::format_uint<4u, 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" : data::hex_digits;
unsigned digit = (value & ((1 << BASE_BITS) - 1));
*--buffer = static_cas... | movslq %ecx, %r9
leaq 0x43c969(%rip), %r10 # 0x45552a
leaq 0x43ede8(%rip), %rcx # 0x4579b0
testl %r8d, %r8d
leaq (%rdi,%r9), %rax
leaq -0x1(%rdi,%r9), %rdi
cmovneq %r10, %rcx
pushq $0xf
popq %r8
movq %rdx, %r9
movl %esi, %r10d
andl $0xf, %r10d
movq %rdx, %r11
shldq $0x3c, %rsi, %r11
shrq $0x4, %r9
movb (%rcx,%r10... | /quesnel[P]baryonyx/external/fmt/include/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_bin()... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43e549(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::format_uint<1u, char, fmt::v7::detail::buffer_appender<char>, unsigned __int128>(fmt::v7::detail::buffer_appender<char>, unsigned __int128, 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 %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl %ecx, %edi
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
callq 0x1085f
movl %eax, %esi
movq %rbx, %rdi
callq 0xf8b2
movzbl %r12b, %r8d
testq %rax, %rax
je 0x18def
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %r... | /quesnel[P]baryonyx/external/fmt/include/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 __int128>::on_num()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_ap... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43e130(%rip), %rcx # 0x457229
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&) | OutputIt write(OutputIt out, basic_string_view<StrChar> s,
const basic_format_specs<Char>& specs) {
auto data = s.data();
auto size = s.size();
if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
size = code_point_index(s, to_unsigned(specs.precision));
auto width = specs.width !... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movl 0x4(%rcx), %edi
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
testl %edi, %edi
js 0x19268
callq 0x1085f
movl %eax, %eax
cmpq %r14, %rax
jae 0x19268
movl 0x4(%rbx), %edi
callq 0x1085f
movl %eax, %eax
cmpq %rax, %r14
cmovaeq %rax, %r14
cm... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_padded<(fmt::v7::align::type)1, fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_char<char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %rbx
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbp, %rax
movzbl 0xe(%rbx), %esi
leaq 0x43dad7(%rip), %rcx # 0x456f48
movq %r12, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, fmt::v7::detail::buffer_appender<char>, float, 0>(fmt::v7::detail::buffer_appender<char>, float, 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 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x260, %rsp # imm = 0x260
leaq 0x10(%rsp), %r12
movq %rdi, %r15
movq %rcx, %r14
vmovaps %xmm0, 0x20(%rsp)
movq %rsi, (%r12)
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
movq %rdx, 0x8(%r12)
callq 0x12720
vmovdqa 0x20(%rsp), %xmm0
movq %rax, %rbx
movq %rax... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
int fmt::v7::detail::snprintf_float<double>(double, int, fmt::v7::detail::float_specs, fmt::v7::detail::buffer<char>&) | int snprintf_float(T value, int precision, float_specs specs,
buffer<char>& buf) {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
static_assert(!std::is_same<T, float>::value, "");
// Subtract 1 to account... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rdx), %rax
vmovsd %xmm0, 0x10(%rsp)
cmpq 0x10(%rdx), %rax
jbe 0x19a0d
shrq $0x20, %rsi
movq %rdx, %rbx
leal -0x1(%rdi), %eax
testl %edi, %edi
pushq $0x5
popq %rbp
cmovnsl %eax, %ebp
cmpb $0x2, %sil
movb $0x25, 0x1(%rsp)
cmovae... | /quesnel[P]baryonyx/external/fmt/include/fmt/format-inl.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
fldt 0x2b0(%rsp)
fld %st(0)
fstpt 0x24(%rsp)
fstpt 0x40(%rsp)
leaq 0x30(%rsp), %r12
movq %rdi, %r15
movq %rcx, %r14
movswq 0x48(%rsp), %r13
movq %rsi, (%r12)
leaq 0x60(%rsp), %rsi
movq %r12, %rdi
movq %rdx, 0x8(... | /quesnel[P]baryonyx/external/fmt/include/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 $0xa8, %rsp
movq %rcx, 0x38(%rsp)
movb %r8b, 0xb(%rsp)
movq %rcx, %r14
shrq $0x28, %r14
movq %rcx, %r13
shrq $0x20, %r13
xorl %ebx, %ebx
movq %rcx, %rbp
movq %rdx, 0x18(%rsp)
movq %rsi, %r12
movq %rdi, 0x20(%rsp)
movl %r8d, 0x34(%rsp)
movq (%rsi), %... | /quesnel[P]baryonyx/external/fmt/include/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movl (%rsi), %edi
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, %r14
callq 0x1085f
movl %eax, %eax
xorl %r15d, %r15d
subq %rbx, %rax
movzbl 0xe(%r14), %esi
leaq 0x439dc3(%rip), %rcx # 0x456f48
movq %r1... | /quesnel[P]baryonyx/external/fmt/include/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %edi
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r14
callq 0x1085f
movl %eax, %eax
xorl %r12d, %r12d
subq %rbp, %rax
movzbl 0xe(%r14), %esi
leaq 0x439bcf(%rip), %rcx # 0x457229
movq %rbx, %rdi
cmo... | /quesnel[P]baryonyx/external/fmt/include/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 0x1d7c4
movq %rdi, %r14
movq %rsi, %rdi
movq %rsi, %rbx
callq 0xb220
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1d807
pushq $0x10
popq %rdi
callq 0xb210
movq %rax, %rbx
leaq 0x437d3d(%rip), %rsi # 0x455513
movq %rax, ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
decltype(fp.begin()) fmt::v7::formatter<fmt::v7::basic_string_view<char>, char, void>::parse<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>>(fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>&) | FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
using handler_type = detail::dynamic_specs_handler<ParseContext>;
auto type = detail::type_constant<T, Char>::value;
detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
t... | pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rsp), %rdx
movq %rdi, %rbx
movq %rdi, (%rdx)
movq %rdi, 0x8(%rdx)
movq %rsi, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
movl $0xd, 0x20(%rdx)
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
addq %rdi, %rsi
callq 0x1e85b
movsbl 0x8(%rbx), %edi
leaq 0xf(%rsp), %rsi
movq %rax, %r14
callq 0x1... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char const* fmt::v7::detail::parse_format_specs<char, fmt::v7::detail::specs_checker<fmt::v7::detail::dynamic_specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>>>&>(char const*, char const*, fmt::v7::detail::specs_checker<fmt::v7::detail::dynamic_specs_handler<fmt::v7::basic_format_... | 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 0x1e928
movq %rbx, %rdi
movq %rdx, %r14
movq %rsi, %r15
callq 0x1e94e
movq %rax, %rbx
cmpq %r15, %rax
je 0x1e928
movzbl (%rbx), %eax
cmpl $0x20, %eax
je 0x1e8ac
cmpl $0x2d, %eax
je 0x1e8a2
cmpl $0x2b, %eax
jne 0x1e8b7
movq %r14, %rdi
callq 0x1ea1e
jmp ... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
char const* fmt::v7::detail::parse_align<char, fmt::v7::detail::specs_checker<fmt::v7::detail::dynamic_specs_handler<fmt::v7::basic_format_parse_context<char, fmt::v7::detail::error_handler>>>&>(char const*, char const*, fmt::v7::detail::specs_checker<fmt::v7::detail::dynamic_specs_handler<fmt::v7::basic_format_parse_c... | FMT_CONSTEXPR const Char* parse_align(const Char* begin, const Char* end,
Handler&& handler) {
FMT_ASSERT(begin != end, "");
auto align = align::none;
auto p = begin + code_point_length(begin);
if (p >= end) p = begin;
for (;;) {
switch (to_ascii(*p)) {
case '<':
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0x1ea05
movzbl (%rdi), %eax
movq %rdx, %rbx
leaq 0x435935(%rip), %rdx # 0x4542a0
movq %rdi, %r14
movl %eax, %ecx
shrl $0x3, %ecx
movsbq (%rcx,%rdx), %r15
movl $0x80ff0000, %edx # imm = 0x80FF0000
btl %ecx, %edx
adcq %rdi, %r15
cmpq %rsi,... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
decltype(fp0.out()) fmt::v7::formatter<fmt::v7::basic_string_view<char>, char, void>::format<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>>(fmt::v7::basic_string_view<char> const&, fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&) | auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
specs_.width_ref, ctx);
detail::handle_dynamic_spec<detail::precision_checker>(
specs_.precision, specs_.precisio... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq 0x20(%rdi), %rax
movq %rsi, %rbx
movq %rdx, %rsi
movq %rdx, %r14
movq %rdi, %r15
movq %rax, 0x10(%rsp)
vmovups 0x10(%rdi), %xmm0
vmovups %xmm0, (%rsp)
callq 0x1f255
movq 0x38(%r15), %rax
leaq 0x4(%r15), %rdi
movq %r14, %rsi
movq %rax, 0x10(%rsp)
vmovups 0x28(%r15),... | /quesnel[P]baryonyx/external/fmt/include/fmt/format.h |
void fmt::v7::detail::write_buffer<char>(std::basic_ostream<char, std::char_traits<char>>&, fmt::v7::detail::buffer<char>&) | void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
const Char* buf_data = buf.data();
using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
unsigned_streamsize size = buf.size();
unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
do {
unsigned_stre... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %r12
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
movq %rdi, %rbx
cmpq %r13, %r12
movq %r13, %r15
movq %rbx, %rdi
movq %r14, %rsi
cmovbq %r12, %r15
movq %r15, %rdx
callq 0xb2d0
addq %r15, %r14
subq %r15, %r12
jn... | /quesnel[P]baryonyx/external/fmt/include/fmt/ostream.h |
void fmt::v7::print<char [7], std::basic_string_view<char, std::char_traits<char>> const&, int, char>(std::basic_ostream<char, std::char_traits<char>>&, char const (&) [7], std::basic_string_view<char, std::char_traits<char>> const&, int&&) | void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
vprint(os, to_string_view(format_str),
fmt::make_args_checked<Args...>(format_str, args...));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r15
movq %rsi, %rdi
movq %rcx, %rbx
movq %rdx, %r14
callq 0xf277
movq (%r14), %rcx
movq 0x8(%r14), %rsi
movl (%rbx), %edi
movq %rsp, %r8
movq %rsi, (%r8)
movq %rcx, 0x8(%r8)
movq %rdi, 0x10(%r8)
pushq $0x1d
popq %rcx
movq %r15, %rdi
movq %rax, %rsi
callq 0x1... | /quesnel[P]baryonyx/external/fmt/include/fmt/ostream.h |
bench::show_to_console(std::vector<bench::element, std::allocator<bench::element>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void show_to_console(const std::vector<element>& current, std::string name)
{
const auto model_size{ models.size() };
const auto solver_size{ solvers.size() };
std::vector<int> row_length(solvers.size(), 5);
int current_row_length = { 10 };
for (size_t i{ 0 }; i != model_si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x8(%rdi), %rax
movq 0x20(%rdi), %r13
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, %r14
subq (%rdi), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
subq 0x18(%rdi), %r13
leaq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0x70(%r... | /quesnel[P]baryonyx/app/src/benchmark.cpp |
bench::push_back_model(std::basic_string_view<char, std::char_traits<char>>) | bool push_back_model(std::string_view name)
{
auto mdl = model::make_model(name);
if (!mdl)
return false;
models.emplace_back(*mdl);
return true;
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x8(%rsp), %rbx
movq %rdi, %r14
movq %rbx, %rdi
callq 0x239ce
movb 0x28(%rbx), %bl
cmpb $0x1, %bl
jne 0x2332c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x23a2c
leaq 0x8(%rsp), %rdi
callq 0x23d2a
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rdi
m... | /quesnel[P]baryonyx/app/src/benchmark.cpp |
csv_whitespace::make_table() | static mask* make_table()
{
auto* v = new mask[table_size];
std::copy_n(classic_table(), table_size, v);
// Comma will be classified as whitespace.
v[static_cast<int>(',')] |= space;
// Space will be classified as character with graphic representation.
v[static_cast... | pushq %rbx
movl $0x200, %edi # imm = 0x200
callq 0xb2a0
movq %rax, %rbx
callq 0xb4a0
movl $0x200, %edx # imm = 0x200
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb070
orb $0x20, 0x59(%rbx)
movw $0xc04, 0x40(%rbx) # imm = 0xC04
movq %rbx, %rax
popq %rbx
retq
| /quesnel[P]baryonyx/app/src/benchmark.cpp |
void sort_on_value<__gnu_cxx::__normal_iterator<result*, std::vector<result, std::allocator<result>>>>(__gnu_cxx::__normal_iterator<result*, std::vector<result, std::allocator<result>>>, __gnu_cxx::__normal_iterator<result*, std::vector<result, std::allocator<result>>>, baryonyx::objective_function_type) | void
sort_on_value(Iterator first,
Iterator last,
baryonyx::objective_function_type type)
{
if (type == baryonyx::objective_function_type::minimize)
std::sort(first, last, [](const auto& lhs, const auto& rhs) {
if (is_valid(lhs.value)) {
if (is_valid(r... | cmpl $0x1, %edx
jne 0x24ddf
jmp 0x245cd
| /quesnel[P]baryonyx/app/src/benchmark.cpp |
void fmt::v7::vprint<char [38], char>(_IO_FILE*, fmt::v7::text_style const&, char const (&) [38], fmt::v7::basic_format_args<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<fmt::v7::type_identity<char>::type>, fmt::v7::type_identity<char>::type>>) | void vprint(std::FILE* f, const text_style& ts, const S& format,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
basic_memory_buffer<Char> buf;
detail::vformat_to(buf, ts, to_string_view(format), args);
buf.push_back(Char(0));
detail::fputs(buf.data(), f);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
leaq 0x30(%rsp), %rax
movq %rcx, %r15
leaq 0x6137a5(%rip), %rcx # 0x63a4b8
movq %r8, %r14
movq %rsi, %r12
movq %rdi, %rbx
andq $0x0, -0x10(%rax)
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x... | /quesnel[P]baryonyx/external/fmt/include/fmt/color.h |
void fmt::v7::vprint<char [65], char>(_IO_FILE*, fmt::v7::text_style const&, char const (&) [65], fmt::v7::basic_format_args<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<fmt::v7::type_identity<char>::type>, fmt::v7::type_identity<char>::type>>) | void vprint(std::FILE* f, const text_style& ts, const S& format,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
basic_memory_buffer<Char> buf;
detail::vformat_to(buf, ts, to_string_view(format), args);
buf.push_back(Char(0));
detail::fputs(buf.data(), f);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
leaq 0x30(%rsp), %rax
movq %rcx, %r15
leaq 0x613546(%rip), %rcx # 0x63a4b8
movq %r8, %r14
movq %rsi, %r12
movq %rdi, %rbx
andq $0x0, -0x10(%rax)
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x... | /quesnel[P]baryonyx/external/fmt/include/fmt/color.h |
baryonyx::split(baryonyx::context const&, baryonyx::problem const&, int) | std::tuple<problem, problem>
split(const context& ctx, const problem& pb, int variable_index_to_affect)
{
bx_expects(variable_index_to_affect >= 0 &&
variable_index_to_affect < length(pb.vars.values));
info(ctx,
" - Preprocessor starts split of variable {} (size: {})\n",
pb.va... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
testl %ecx, %ecx
js 0x2d0ee
movq 0xb0(%rdx), %rax
movl %ecx, %ebp
movq %rdx, %r14
subq 0xa8(%rdx), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
cmpl %ebp, %eax
jle 0x2d0ee
movl %ebp, %r12d
shlq $0x4, %r12
addq 0x90... | /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::preprocessor<baryonyx::problem>::preprocessor(baryonyx::context const&, baryonyx::problem const&) | explicit preprocessor(const bx::context& ctx_, const Problem& pb_)
: ctx(ctx_)
, pb(pb_)
, equal_constraints(pb.equal_constraints.size())
, greater_constraints(pb.greater_constraints.size())
, less_constraints(pb.less_constraints.size())
, cache(pb.vars.values.size())
{
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x40(%rdi), %rax
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x48(%rdi), %r14
movq %rdi, %rbx
movq %rax, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
vmovups %xmm0, 0x20(%rdi)
movl $0x3f800000, 0x30(%rdi) # imm = 0x3F... | /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::preprocessor<baryonyx::problem>::affects() | void affects()
{
while (!lifo.empty()) {
auto top = lifo.pop();
vars.emplace(top.index, top.value);
debug(ctx,
" - variable {} assigned to {}.\n",
pb.vars.names[top.index],
top.value);
for (int cst : c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0xc8(%rdi), %rax
leaq 0x10(%rdi), %rcx
leaq 0x4c(%rsp), %rbp
movq %rdi, %rbx
movq %rax, 0x20(%rsp)
movq %rcx, 0x40(%rsp)
movq 0xc8(%rbx), %rax
cmpq 0xd0(%rbx), %rax
je 0x2ffbb
movq 0x20(%rsp), %rdi
callq 0x301e0
movq 0x40(%rsp), %rd... | /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::pp_lifo::emplace(int, bool) | bool emplace(int variable, bool value)
{
auto it = std::find_if(
data.cbegin(), data.cend(), [&variable](const auto& elem) {
return elem.index == variable;
});
if (it != data.cend())
return false;
data.emplace_back(variable, value);
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq (%rdi), %r14
movl %esi, %r12d
movq %rdi, %rbx
movq %rax, %r15
subq %r14, %r15
movq %r15, %rcx
sarq $0x5, %rcx
pushq $0x18
popq %rsi
xorl %r8d, %r8d
testq %rcx, %rcx
jle 0x30086
cmpl %r12d, -0x18(%r14,%rsi)
je 0x300a8
... | /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::preprocessor<baryonyx::problem>::reduce(baryonyx::constraint const&) | auto reduce(const bx::constraint& constraint) -> std::tuple<int, int, int>
{
int constraint_result{ constraint.value };
int remaining_index{ -1 };
int factor;
int var_id;
for (int i = 0, e = bx::length(constraint.elements); i != e; ++i) {
// Searches if the vari... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rdx), %rax
movl 0x28(%rdx), %ebp
movl $0x2003, %ecx # imm = 0x2003
movq %rsi, %r15
addq $0x10, %r15
movq %rdx, %r14
movq %rdi, 0x10(%rsp)
subq 0x10(%rdx), %rax
bextrq %rcx, %rax, %r12
pushq $-0x1
popq %rax
movl %eax,... | /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::preprocessor<baryonyx::raw_problem>::reduce_equal_constraint(baryonyx::constraint const&) | auto reduce_equal_constraint(const bx::constraint& constraint)
-> std::tuple<int, bool>
{
int factor, variable, result;
std::tie(factor, variable, result) = reduce(constraint);
if (variable < 0)
return std::make_tuple(-1, false);
bool affect_0 = (factor * 0 == re... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0xc(%rsp), %r14
movq %rdi, %rbx
movq %r14, %rdi
callq 0x30948
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %rcx
movq %rsp, %rax
movq %r14, %rsi
movq %rax, (%rdi)
movq %r15, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
callq 0x319f4
movl (%r15), %edx
testl %edx, %e... | /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
(anonymous namespace)::preprocessor<baryonyx::raw_problem>::constraints_exclude_copy(std::vector<std::pair<int, bool>, std::allocator<std::pair<int, bool>>> const&, std::vector<int, std::allocator<int>> const&, std::vector<baryonyx::constraint, std::allocator<baryonyx::constraint>> const&, std::vector<baryonyx::constra... | void constraints_exclude_copy(
const std::vector<std::pair<int, bool>>& mapping,
const std::vector<int>& constraints_size,
const std::vector<bx::constraint>& constraints,
std::vector<bx::constraint>& copy) const
{
for (int i = 0, e = bx::length(constraints); i != e; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdx), %rax
movq %rcx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
movq %rdx, 0x8(%rsp)
subq (%rdx), %rax
pushq $0x30
popq %rcx
cqto
xorl %r15d, %r15d
idivq %rcx
movl %eax, %ebp
cmpq %rbp, %r15
je 0x30b67
movq 0x10(%rsp), %rax
mo... | /quesnel[P]baryonyx/lib/src/preprocessor.cpp |
void write_constraints<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::problem>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::problem const&) | void
write_constraints(FormatContext& ctx, const Problem& pb)
{
for (std::size_t i = 0, e = pb.equal_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.equal_constraints[i], " = ");
for (std::size_t i = 0, e = pb.greater_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rsi), %rax
movq %rsi, %rbx
movq %rdi, %r14
subq 0x48(%rsi), %rax
pushq $0x30
popq %r13
cqto
leaq 0x4289ee(%rip), %r12 # 0x45c30f
xorl %ebp, %ebp
idivq %r13
movq %rax, %r15
subq $0x1, %r15
jb 0x3394a
movq 0x48(%rbx), %rdx
movq %r1... | /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_bounds<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::problem>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::problem const&) | void
write_bounds(FormatContext& ctx, const Problem& p)
{
for (std::size_t i{ 0 }, e{ p.vars.names.size() }; i != e; ++i) {
if (p.vars.values[i].min != 0)
fmt::format_to(
ctx.out(), "{} >= {}\n", p.vars.names[i], p.vars.values[i].min);
if (p.vars.values[i].max != std::nume... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x98(%rsi), %r13
movq %rsi, %rbx
movq %rdi, %r14
subq 0x90(%rsi), %r13
sarq $0x4, %r13
pushq $0x4
popq %rbp
leaq 0x425e45(%rip), %r12 # 0x45987d
xorl %r15d, %r15d
subq $0x1, %r13
jb 0x33a9f
movq 0xa8(%rbx), %rcx
cmpl $0x0, -0x4(%rcx,%r... | /quesnel[P]baryonyx/lib/src/problem.hpp |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [5], std::basic_string_view<char, std::char_traits<char>> const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [5], std::basic_string_view<char, std::char_traits<char>> cons... | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, %rdi
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
callq 0xf277
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
pushq $0xd
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1ad14
addq $0x28, %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [8], double const&, std::basic_string_view<char, std::char_traits<char>> const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [8], double const&, std::basic_string_view<char... | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rdx), %rax
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
callq 0xf277
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movl $0xda, %edx
movq %rbx, %rdi
movq %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [10], double, std::basic_string_view<char, std::char_traits<char>> const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [10], double&&, std::basic_string_view<char, std::cha... | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rdx), %rax
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
callq 0xf277
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movl $0xda, %edx
movq %rbx, %rdi
movq %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
void write_constraint<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::problem, baryonyx::constraint>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::problem const&, baryonyx::constraint const&, char const*) | void
write_constraint(FormatContext& ctx,
const Problem& p,
const Constraint& cst,
const char* separator)
{
if (!cst.label.empty())
fmt::format_to(ctx.out(), "{}: ", cst.label);
write_function_element(ctx, p, cst.elements);
fmt::format_to(ctx.out(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, (%rdx)
je 0x33d8b
movq (%r14), %rdi
leaq 0x425aef(%rip), %rsi # 0x459872
movq %rbx, %rdx
callq 0x33aae
leaq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x33dbf
movq (%r14), %rd... | /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_function_element<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::problem, std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>>>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::problem const&, std::ve... | void
write_function_element(FormatContext& ctx, const Problem& p, const Function& f)
{
for (auto& elem : f) {
if (elem.factor < 0)
fmt::format_to(ctx.out(),
" {} {}",
elem.factor,
p.vars.names[elem.variable_index]);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %r15
movq 0x8(%rdx), %r12
leaq 0x42f96d(%rip), %r13 # 0x463745
leaq 0x425a66(%rip), %rbp # 0x459845
movq %rsi, %rbx
movq %rdi, %r14
cmpq %r12, %r15
je 0x33e43
cmpl $0x0, (%r15)
js 0x33e11
je 0x33e32
movslq 0x4(%r15), %rcx
mo... | /quesnel[P]baryonyx/lib/src/problem.hpp |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [6], char const*&, int const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [6], char const*&, int const&) | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rdx), %rax
movl (%rcx), %ecx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
callq 0xf277
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
pushq $0x1c
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1ad14
addq $0x38, %rs... | /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [7], int const&, std::basic_string_view<char, std::char_traits<char>> const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [7], int const&, std::basic_string_view<char, std:... | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movl (%rdx), %eax
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
callq 0xf277
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movl $0xd1, %edx
movq %rbx, %rdi
movq %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
std::enable_if<true, fmt::v7::detail::buffer_appender<char>>::type fmt::v7::format_to<fmt::v7::detail::buffer_appender<char>, char [8], int const&, std::basic_string_view<char, std::char_traits<char>> const&, true>(fmt::v7::detail::buffer_appender<char>, char const (&) [8], int const&, std::basic_string_view<char, std:... | inline auto format_to(OutputIt out, const S& format_str, Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
return vformat_to(out, to_string_view(format_str), vargs);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movl (%rdx), %eax
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
leaq 0x10(%rsp), %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, (%r14)
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
callq 0xf277
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movl $0xd1, %edx
movq %rbx, %rdi
movq %r... | /quesnel[P]baryonyx/external/fmt/include/fmt/core.h |
void write_function_element<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem, std::vector<baryonyx::objective_function_element, std::allocator<baryonyx::objective_function_element>>>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx:... | void
write_function_element(FormatContext& ctx, const Problem& p, const Function& f)
{
for (auto& elem : f) {
if (elem.factor < 0)
fmt::format_to(ctx.out(),
" {} {}",
elem.factor,
p.vars.names[elem.variable_index]);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %r15
movq 0x8(%rdx), %rbp
vxorpd %xmm1, %xmm1, %xmm1
leaq 0x42566e(%rip), %r12 # 0x459846
leaq 0x42f566(%rip), %r13 # 0x463745
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rbp, %r15
je 0x34250
vmovsd (%r15), %xmm0
vucomisd %xmm0, %... | /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_constraints<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&) | void
write_constraints(FormatContext& ctx, const Problem& pb)
{
for (std::size_t i = 0, e = pb.equal_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.equal_constraints[i], " = ");
for (std::size_t i = 0, e = pb.greater_constraints.size(); i != e; ++i)
write_constraint(ctx, pb, pb.g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rsi), %rax
movq %rsi, %rbx
movq %rdi, %r14
subq 0x48(%rsi), %rax
pushq $0x30
popq %r13
cqto
leaq 0x427fb8(%rip), %r12 # 0x45c30f
xorl %ebp, %ebp
idivq %r13
movq %rax, %r15
subq $0x1, %r15
jb 0x34380
movq 0x48(%rbx), %rdx
movq %r1... | /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_bounds<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&) | void
write_bounds(FormatContext& ctx, const Problem& p)
{
for (std::size_t i{ 0 }, e{ p.vars.names.size() }; i != e; ++i) {
if (p.vars.values[i].min != 0)
fmt::format_to(
ctx.out(), "{} >= {}\n", p.vars.names[i], p.vars.values[i].min);
if (p.vars.values[i].max != std::nume... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x98(%rsi), %r13
movq %rsi, %rbx
movq %rdi, %r14
subq 0x90(%rsi), %r13
sarq $0x4, %r13
pushq $0x4
popq %rbp
leaq 0x425449(%rip), %r12 # 0x45987d
xorl %r15d, %r15d
subq $0x1, %r13
jb 0x3449b
movq 0xa8(%rbx), %rcx
cmpl $0x0, -0x4(%rcx,%r... | /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_constraint<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem, baryonyx::constraint>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&, baryonyx::constraint const&, char const*) | void
write_constraint(FormatContext& ctx,
const Problem& p,
const Constraint& cst,
const char* separator)
{
if (!cst.label.empty())
fmt::format_to(ctx.out(), "{}: ", cst.label);
write_function_element(ctx, p, cst.elements);
fmt::format_to(ctx.out(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, (%rdx)
je 0x344d9
movq (%r14), %rdi
leaq 0x4253a1(%rip), %rsi # 0x459872
movq %rbx, %rdx
callq 0x33aae
leaq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3450d
movq (%r14), %rd... | /quesnel[P]baryonyx/lib/src/problem.hpp |
void write_function_element<fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>, baryonyx::raw_problem, std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>>>(fmt::v7::basic_format_context<fmt::v7::detail::buffer_appender<char>, char>&, baryonyx::raw_problem const&,... | void
write_function_element(FormatContext& ctx, const Problem& p, const Function& f)
{
for (auto& elem : f) {
if (elem.factor < 0)
fmt::format_to(ctx.out(),
" {} {}",
elem.factor,
p.vars.names[elem.variable_index]);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %r15
movq 0x8(%rdx), %r12
leaq 0x42f21f(%rip), %r13 # 0x463745
leaq 0x425318(%rip), %rbp # 0x459845
movq %rsi, %rbx
movq %rdi, %r14
cmpq %r12, %r15
je 0x34591
cmpl $0x0, (%r15)
js 0x3455f
je 0x34580
movslq 0x4(%r15), %rcx
mo... | /quesnel[P]baryonyx/lib/src/problem.hpp |
baryonyx::itm::select_float(baryonyx::context const&, baryonyx::problem const&, bool) | static result
select_float(const context& ctx, const problem& pb, bool is_optimization)
{
const auto f = static_cast<int>(ctx.parameters.float_type);
if (f == 0)
return select_mode<float_sel<0>>(ctx, pb, is_optimization);
else if (f == 1)
return select_mode<float_sel<1>>(ctx, pb, is_optimiz... | pushq %rbx
movq %rdi, %rbx
movl 0xd0(%rsi), %r9d
movl 0xf0(%rdx), %r8d
movq 0x28(%rdx), %rax
movq 0x30(%rdx), %rdi
cmpl $0x1, %r9d
je 0x3461e
testl %r9d, %r9d
jne 0x34641
testl %r8d, %r8d
je 0x34664
cmpq %rdi, %rax
je 0x346ba
movq %rbx, %rdi
testb %cl, %cl
je 0x346ea
callq 0x58425
jmp 0x34766
testl %r8d, %r8d
je 0x3468... | /quesnel[P]baryonyx/lib/src/random-solver.cpp |
baryonyx::result baryonyx::itm::optimize_problem<baryonyx::itm::solver_random_inequalities_101coeff<float, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<float>>, float, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<float>>(baryonyx::context const&, baryonyx::problem const&) | inline result
optimize_problem(const context& ctx, const problem& pb)
{
result r;
if (ctx.start)
ctx.start(ctx.parameters);
auto constraints{ make_merged_constraints(ctx, pb) };
if (constraints.empty() || pb.vars.values.empty()) {
r.status = result_status::success;
r.solutions.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
vxorpd %xmm0, %xmm0, %xmm0
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa... | /quesnel[P]baryonyx/lib/src/itm-optimizer-common.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.