name string | code string | asm string | file string |
|---|---|---|---|
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<long double>, true>::local_affect<baryonyx::bit_array, baryonyx::sparse_matrix<int>::row_value*>(baryonyx::bit_array&, baryonyx::sparse_matrix<int>::row_value*, int, int, int, long double, long do... | bool local_affect(Xtype& x,
Iterator it,
int k,
int selected,
int r_size,
const Float kappa,
const Float delta)
{
constexpr Float one{ 1 };
constexpr Float two{ 2 };
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
fldt 0x90(%rsp)
fldt 0x80(%rsp)
movl %r8d, 0x14(%rsp)
movl %r9d, 0x10(%rsp)
movq %rdx, %r15
movslq %ecx, %rdx
movl %ecx, 0x24(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rcx
shlq $0x4, %rdx
fldt (%rcx,%rdx)
addq %rdx, %rcx
mo... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::solver_inequalities_Zcoeff(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, int, int, baryonyx::itm::quadratic_cost_type<long double> const&, std::vect... | solver_inequalities_Zcoeff(random_engine& rng_,
int m_,
int n_,
const cost_type& c_,
const std::vector<merged_constraint>& csts)
: logger("solver_inequalities_Zcoeff")
, rng(rng_)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
andq $0x0, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rsi, 0x8(%rdi)
movq %rdi, %r15
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r12d
movq %r9, 0x28(%rsp)
movq %r9, %rsi
movq %rbx, %rdi
callq 0x2f90c
movl 0x38(%r15), %esi
leaq 0x50(%r15), %r13
mo... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::branch_and_bound_solver<baryonyx::itm::minimize_tag, long double>::solve<std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoe... | int solve(R& reduced_cost, int r_size, int bk_min, int bk_max)
{
bx_assert(r_size >= 4);
bx_assert(bk_min <= bk_max);
b_min = bk_min;
b_max = bk_max;
items.resize(r_size);
if (!subvector.init(r_size))
throw solver_failure(solver_error_tag::no_solver_avai... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x3, %edx
jle 0x43e3ae
cmpl %r8d, %ecx
jg 0x43e3cf
leaq 0x20(%rdi), %r13
movl %ecx, 0x74(%rdi)
movl %edx, %ebx
movq %rsi, %r14
movl %edx, %r12d
movq %rdi, %r15
movl %r8d, 0x78(%rdi)
movq %r12, %rsi
movq %r13, %rdi
callq 0x42219a
movq %r1... | /quesnel[P]baryonyx/lib/src/branch-and-bound-solver.hpp |
int baryonyx::itm::exhaustive_solver<baryonyx::itm::minimize_tag, long double>::solve<std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoeff<lon... | int solve(int k, R& reduced_cost, int r_size)
{
const auto it_constraint = constraints.find(k);
bx_expects(it_constraint != constraints.end());
items.resize(r_size);
for (int i = 0; i != r_size; ++i) {
items[i].r = reduced_cost[i].value;
items[i].variable = r... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0xc(%rsp), %rax
movq %rdi, %r15
addq $0x48, %rdi
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, (%rax)
andq $0x0, 0xc(%rax)
movq %rax, %rsi
callq 0x423d08
leaq 0x50(%r15), %rcx
movq %rax, %r13
cmpq %rcx, %r13
je 0x43e604
movslq %ebx, %r12
movq %r1... | /quesnel[P]baryonyx/lib/src/exhaustive-solver.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>... | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x70(%rsp)
leaq 0x10(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
fldt 0x110(%rsp)
fstpt 0x9c(%rsp)
fldt 0x100(%rsp)
fstpt 0x90(%rsp)
fldt 0xf0(%rsp)
fstpt 0x84(%rsp)
fldt 0xe0(%rsp)
fstpt 0x78... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int fmt::v7::detail::parse_nonnegative_int<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_pars... | 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 0x44865a
movb (%rax), %cl
leal -0x30(%rcx), %r8d
cmpb $0x9, %r8b
ja 0x44865a
incq %rax
xorl %ebx, %ebx
cmpl $0xccccccc, %ebx # imm = 0xCCCCCCC
ja 0x448642
imull $0xa, %ebx, %r8d
movzbl %cl, %ecx
movq %rax, (%rdi)
leal -0x30(%r8,%rcx), %ebx
cmpq %rsi, %rax
je 0x4486... | /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 0x448ba3
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 |
std::pair<phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int>, phmap::Hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, phmap::EqualTo<std::__cxx11::basic_string<char, std::char_traits<... | std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args) {
size_t hashval = this->hash(k);
size_t offset = this->_find_key(k, hashval);
if (offset == (size_t)-1) {
offset = this->prepare_insert(hashval);
this->emplace_at(offset, std::piecewise_construct,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
movq %rdx, %rsi
callq 0x1af4
movabsq $-0x21a0462d9cfba717, %rcx # imm = 0xDE5FB9D2630458E9
mulq %rcx
movq %rdx, %r12
addq %rax, %r12
movq %r14, %rdi
movq %r13, %rsi
mov... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
ed_double | static void
ed_double(struct ed *out, const struct ed *P)
{
fld_t a, b, c, d, e, f, g, h;
fld_sub(a, P->y, P->x);
fld_sq(a, a);
fld_add(b, P->y, P->x);
fld_sq(b, b);
fld_sq(c, P->t);
fld_mul(c, c, con_2d);
fld_sq(d, P->z);
fld_scale2(d, d);
fld_sub(e, b, a);
fld_sub(f, d, c);
fld_add(g, d, c);
fld_ad... | subq $0x188, %rsp # imm = 0x188
movq %rdi, 0x180(%rsp)
movq %rsi, 0x178(%rsp)
leaq 0x150(%rsp), %rdi
movq 0x178(%rsp), %rsi
addq $0x28, %rsi
movq 0x178(%rsp), %rdx
callq 0x4d40
leaq 0x150(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x1ed0
leaq 0x120(%rsp), %rdi
movq 0x178(%rsp), %rsi
addq $0x28, %rsi
movq 0x178... | /phlay[P]libeddsa/lib/ed.c |
TiXmlBase::IsAlphaNum(unsigned char, TiXmlEncoding) | int TiXmlBase::IsAlphaNum( unsigned char anyByte, TiXmlEncoding /*encoding*/ )
{
// This will only work for low-ascii, everything else is assumed to be a valid
// letter. I'm not sure this is the best approach, but it is quite tricky trying
// to figure out alhabetical vs. not across encoding. So take a very
// co... | cmpb $0x7e, %dil
ja 0x4049bb
movzbl %dil, %edi
jmp 0x4d3e30
pushq $0x1
popq %rax
retq
nop
| /PathPlanning[P]LIAN/tinyxml/tinyxmlparser.cpp |
TiXmlBase::GetChar(char const*, char*, int*, TiXmlEncoding) | inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding )
{
assert( p );
if ( encoding == TIXML_ENCODING_UTF8 )
{
*length = utf8ByteTable[ *((const unsigned char*)p) ];
assert( *length >= 0 && *length < 5 );
}
else
{
*length = 1;
}
if ( *length == 1... | testq %rdi, %rdi
je 0x4061d1
cmpl $0x1, %ecx
jne 0x4061ae
movzbl (%rdi), %eax
leaq 0x18b370(%rip), %r8 # 0x5914f0
movl (%r8,%rax,4), %r8d
movl %r8d, (%rdx)
testl %r8d, %r8d
je 0x4061c6
cmpl $0x1, %r8d
je 0x4061b4
xorl %eax, %eax
movb (%rdi,%rax), %cl
movslq %r8d, %r8
testb %cl, %cl
je 0x4061ca
cmpq %r8, %rax
jge 0x... | /PathPlanning[P]LIAN/tinyxml/tinyxml.h |
TiXmlNode::InsertAfterChild(TiXmlNode*, TiXmlNode const&) | TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis )
{
if ( !afterThis || afterThis->parent != this ) {
return 0;
}
if ( addThis.Type() == TiXmlNode::DOCUMENT )
{
if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
re... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x4068de
movq %rsi, %r14
movq %rdi, %r15
cmpq %rdi, 0x18(%rsi)
je 0x4068e9
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0x20(%rdx)
je 0x40691e
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x4068de
movq %rax,... | /PathPlanning[P]LIAN/tinyxml/tinyxml.cpp |
TiXmlNode::NextSiblingElement(char const*) const | const TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const
{
const TiXmlNode* node;
for ( node = NextSibling( _value );
node;
node = node->NextSibling( _value ) )
{
if ( node->ToElement() )
return node->ToElement();
}
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x406b3e
testq %rax, %rax
je 0x406d0b
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x28(%rax)
testq %rax, %rax
je 0x406cda
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x28(%... | /PathPlanning[P]LIAN/tinyxml/tinyxml.cpp |
TiXmlAttributeSet::Add(TiXmlAttribute*) | void TiXmlAttributeSet::Add( TiXmlAttribute* addMe )
{
#ifdef TIXML_USE_STL
assert( !Find( TIXML_STRING( addMe->Name() ) ) ); // Shouldn't be multiply adding to the set.
#else
assert( !Find( addMe->Name() ) ); // Shouldn't be multiply adding to the set.
#endif
addMe->next = &sentinel;
addMe->prev = sentinel.... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
addq $0x10, %rsi
callq 0x406f42
testq %rax, %rax
jne 0x4071b6
movq %r14, 0x38(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq %rbx, 0x38(%rax)
movq %rbx, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18ae07(%rip),... | /PathPlanning[P]LIAN/tinyxml/tinyxml.cpp |
TiXmlDocument::SaveFile(_IO_FILE*) const | bool TiXmlDocument::SaveFile( FILE* fp ) const
{
if ( useMicrosoftBOM )
{
const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
fputc( TIXML_UTF_LEAD_0, fp );
fputc( TIXML_UTF_LEAD_1, fp );
fputc( TIXML_UTF_LEAD_2, fp );... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x6c(%rdi)
jne 0x4079ed
movl $0xef, %edi
movq %rbx, %rsi
callq 0x4f9950
movl $0xbb, %edi
movq %rbx, %rsi
callq 0x4f9950
movl $0xbf, %edi
movq %rbx, %rsi
callq 0x4f9950
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *0x1... | /PathPlanning[P]LIAN/tinyxml/tinyxml.cpp |
TiXmlDocument::Print(_IO_FILE*, int) const | void TiXmlDocument::Print( FILE* cfile, int depth ) const
{
assert( cfile );
for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
{
node->Print( cfile, depth );
fprintf( cfile, "\n" );
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x407aa0
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
addq $0x28, %r15
pushq $0xa
popq %rbp
movq (%r15), %r15
testq %r15, %r15
je 0x407a95
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq *0x10(%rax)
movl %ebp, %edi
mov... | /PathPlanning[P]LIAN/tinyxml/tinyxml.cpp |
TiXmlDocument::Accept(TiXmlVisitor*) const | bool TiXmlDocument::Accept( TiXmlVisitor* visitor ) const
{
if ( visitor->VisitEnter( *this ) )
{
for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
{
if ( !node->Accept( visitor ) )
break;
}
}
return visitor->VisitExit( *this );
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
testb %al, %al
je 0x407afe
leaq 0x28(%rbx), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x407afe
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x88(%rax)
addq $0x48, %r15
testb ... | /PathPlanning[P]LIAN/tinyxml/tinyxml.cpp |
TiXmlAttribute::Print(_IO_FILE*, int, TiXmlString*) const | void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const
{
TIXML_STRING n, v;
EncodeString( name, &n );
EncodeString( value, &v );
if (value.find ('\"') == TIXML_STRING::npos) {
if ( cfile ) {
fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() );
}
if ( str ) {
(*str) += n; (*st... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x6196f8, %rax # imm = 0x6196F8
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rax, (%rsp)
addq $0x20, %rdi
callq 0x4064b6
addq $0x28, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x4064b6
pushq $0x22
popq %rsi
m... | /PathPlanning[P]LIAN/tinyxml/tinyxml.cpp |
TiXmlAttribute::SetDoubleValue(double) | void TiXmlAttribute::SetDoubleValue( double _value )
{
char buf [256];
#if defined(TIXML_SNPRINTF)
TIXML_SNPRINTF( buf, sizeof(buf), "%lf", _value);
#else
sprintf (buf, "%lf", _value);
#endif
SetValue (buf);
} | pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbx
leaq 0x18a1b8(%rip), %rdx # 0x591e84
movq %rsp, %r14
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
movb $0x1, %al
callq 0x4e6670
addq $0x28, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40612c
addq $0x108, %rsp #... | /PathPlanning[P]LIAN/tinyxml/tinyxml.cpp |
TiXmlDeclaration::TiXmlDeclaration(char const*, char const*, char const*) | TiXmlDeclaration::TiXmlDeclaration( const char * _version,
const char * _encoding,
const char * _standalone )
: TiXmlNode( TiXmlNode::DECLARATION )
{
version = _version;
encoding = _encoding;
standalone = _standalone;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x5
popq %rsi
callq 0x40663a
leaq 0x207620(%rip), %rax # 0x60f618
movq %rax, (%rbx)
leaq 0x50(%rbx), %rdi
movq $0x6196f8, %rax # imm = 0x6196F8
movq %rax, 0x50(%... | /PathPlanning[P]LIAN/tinyxml/tinyxml.cpp |
TiXmlDeclaration::TiXmlDeclaration(TiXmlDeclaration const&) | TiXmlDeclaration::TiXmlDeclaration( const TiXmlDeclaration& copy )
: TiXmlNode( TiXmlNode::DECLARATION )
{
copy.CopyTo( this );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r13
movq %rdi, %rbx
pushq $0x5
popq %rsi
callq 0x40663a
leaq 0x207582(%rip), %rax # 0x60f618
movq %rax, (%rbx)
leaq 0x50(%rbx), %r14
movq $0x6196f8, %rax # imm = 0x6196F8
movq %rax, 0x50(%rbx)
leaq 0x58(%rbx), %r15
movq %rax, 0x58(%rbx)
leaq ... | /PathPlanning[P]LIAN/tinyxml/tinyxml.cpp |
TiXmlAttribute::TiXmlAttribute(char const*, char const*) | TiXmlAttribute( const char * _name, const char * _value )
{
name = _name;
value = _value;
document = 0;
prev = next = 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
orq $-0x1, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq $0x60f318, %rax # imm = 0x60F318
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r14
movq $0x6196f8, %rax # imm = 0x6196F8
movq %rax, 0x20(%rdi)
leaq 0x28(%rdi), %r... | /PathPlanning[P]LIAN/tinyxml/tinyxml.h |
TiXmlDeclaration::~TiXmlDeclaration() | virtual ~TiXmlDeclaration() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x206b99(%rip), %rax # 0x60f618
movq %rax, (%rdi)
addq $0x60, %rdi
callq 0x40644c
leaq 0x58(%rbx), %rdi
callq 0x40644c
leaq 0x50(%rbx), %rdi
callq 0x40644c
movq %rbx, %rdi
popq %rbx
jmp 0x408912
| /PathPlanning[P]LIAN/tinyxml/tinyxml.h |
TiXmlString::assign(char const*, unsigned long) | TiXmlString& TiXmlString::assign(const char* str, size_type len)
{
size_type cap = capacity();
if (len > cap || cap > 3*(len + 8))
{
TiXmlString tmp;
tmp.init(len);
memcpy(tmp.start(), str, len);
swap(tmp);
}
else
{
memmove(start(), str, len);
set_size(len);
}
return *this;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rdi), %rax
cmpq %rdx, %rax
jb 0x408c05
leaq (%r14,%r14,2), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
jbe 0x408c48
leaq 0x210aec(%rip), %rax # 0x6196f8
leaq 0x8(%rsp), %rdi
m... | /PathPlanning[P]LIAN/tinyxml/tinystr.cpp |
TiXmlString::append(char const*, unsigned long) | TiXmlString& TiXmlString::append(const char* str, size_type len)
{
size_type newsize = length() + len;
if (newsize > capacity())
{
reserve (newsize + capacity());
}
memmove(finish(), str, len);
set_size(newsize);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rsi
leaq (%rcx,%rdx), %r12
cmpq %rsi, %r12
jbe 0x408cbf
addq %r12, %rsi
movq %rbx, %rdi
callq 0x408b5c
movq (%rbx), %rax
movq (%rax), %rcx
leaq (%rax,%rcx), %rdi
ad... | /PathPlanning[P]LIAN/tinyxml/tinystr.cpp |
operator+(char const*, TiXmlString const&) | TiXmlString operator + (const char* a, const TiXmlString & b)
{
TiXmlString tmp;
TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>( strlen(a) );
tmp.reserve(a_len + b.length());
tmp.append(a, a_len);
tmp += b;
return tmp;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x210925(%rip), %rax # 0x6196f8
movq %rax, (%rdi)
movq %rsi, %rdi
callq 0x401110
movq %rax, %r12
movq (%r14), %rax
movq (%rax), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x408b5c
movq %rbx, %rdi
movq %r15, %r... | /PathPlanning[P]LIAN/tinyxml/tinystr.cpp |
LianSearch::~LianSearch() | LianSearch::~LianSearch() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x206add(%rip), %rax # 0x60f918
movq %rax, (%rdi)
addq $0x158, %rdi # imm = 0x158
callq 0x40b86e
leaq 0x140(%rbx), %rdi
callq 0x40d19e
leaq 0x128(%rbx), %rdi
callq 0x40b8fa
leaq 0x110(%rbx), %rdi
callq 0x40b8fa
leaq 0xf8(%rbx), %rdi
callq 0x40bb60
leaq 0xe0(%rbx), %rdi
call... | /PathPlanning[P]LIAN/liansearch.cpp |
LianSearch::LianSearch(float, int, float, unsigned int, float, bool, float, int, double, int) | LianSearch::LianSearch(float angleLimit_, int distance_, float weight_,
unsigned int steplimit_, float curvatureHeuristicWeight_, bool postsmoother_,
float decreaseDistanceFactor_, int distanceMin_,
double PivotRadius_, int numOfParentsToIncreaseRa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0x1c(%rsp)
movsd %xmm4, 0x30(%rsp)
movl %r8d, 0x18(%rsp)
movss %xmm3, 0x14(%rsp)
movl %ecx, %r12d
movss %xmm2, 0x10(%rsp)
movl %edx, %r13d
movss %xmm1, 0xc(%rsp)
movl %esi, %r15d
movss %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x... | /PathPlanning[P]LIAN/liansearch.cpp |
LianSearch::calculateCircle(int) | void LianSearch::calculateCircle(int radius) { //here radius - radius of the circle in cells
circleNodes.clear();
circleNodes.resize(listOfDistancesSize);
for(int k = 0; k < listOfDistancesSize; ++k) {
radius = listOfDistances[k];
circleNodes[k].clear();
std::vector<circleNode>... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0xc8(%rdi), %r12
movq %r12, %rdi
callq 0x40b4ca
movslq 0xa0(%rbx), %rsi
movq %r12, %rdi
callq 0x40b4d2
xorl %edx, %edx
leaq 0x10(%rsp), %rbp
movabsq $-0x4010000000000000, %r14 # imm = 0xBFF0000000000000
pushq $0x18
p... | /PathPlanning[P]LIAN/liansearch.cpp |
_cxx_global_var_init | int main() {
int cube[8] = {};
for (int &i : cube) {
std::cin >> i;
}
if (cube[0] + cube[2] + cube[5] + cube[7] != cube[1] + cube[3] + cube[4] + cube[6]) {
std::cout << "IMPOSSIBLE";
return 0;
}
// обнуляем вершину А (cube[0])
if (cube[0] > 0) {
... | pushq %rbp
movq %rsp, %rbp
leaq 0x2fae(%rip), %rdi # 0x4059
callq 0x1080
movq 0x2f41(%rip), %rdi # 0x3ff8
leaq 0x2f9b(%rip), %rsi # 0x4059
leaq 0x2f8b(%rip), %rdx # 0x4050
callq 0x1050
popq %rbp
retq
nopl (%rax)
| /KaluginaMarina[P]algorithms_and_data_structures/1155.cpp |
llvm::Error llvm::handleErrorImpl<void mlir::lsp::MessageHandler::notification<mlir::lsp::DidOpenTextDocumentParams, (anonymous namespace)::LSPServer>(llvm::StringLiteral, (anonymous namespace)::LSPServer*, void ((anonymous namespace)::LSPServer::*)(mlir::lsp::DidOpenTextDocumentParams const&))::'lambda'(llvm::json::Va... | Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
HandlerT &&Handler, HandlerTs &&... Handlers) {
if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
std:... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
leaq 0x86d4f(%rip), %rsi # 0x974a1
callq *0x30(%rax)
movq (%r15), %r14
movq $0x0, (%r15)
testb %al, %al
je 0x10787
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x5ed2b(%rip), %rd... | /llvm/Support/Error.h |
llvm::unique_function<void (llvm::Expected<std::vector<mlir::lsp::DocumentLink, std::allocator<mlir::lsp::DocumentLink>>>)>::unique_function<llvm::unique_function<void (llvm::Expected<llvm::json::Value>)>>(llvm::unique_function<void (llvm::Expected<llvm::json::Value>)>, std::enable_if<!std::is_same<llvm::remove_cvref<l... | unique_function(
CallableT Callable,
detail::EnableUnlessSameType<CallableT, unique_function> * = nullptr,
detail::EnableIfCallable<CallableT, R, P...> * = nullptr)
: Base(std::forward<CallableT>(Callable),
typename Base::template CalledAs<CallableT>{}) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf9f4
movq $0x0, 0x18(%rbx)
movl $0x20, %edi
movl $0x8, %esi
callq 0x59844
movq %rax, (%rbx)
movq $0x20, 0x8(%rbx)
movq $0x8, 0x10(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0xf9f4
leaq 0x84c1f(%rip), %rax # 0x973e0
... | /llvm/ADT/FunctionExtras.h |
mlir::lsp::TableGenServer::findReferencesOf(mlir::lsp::URIForFile const&, mlir::lsp::Position const&, std::vector<mlir::lsp::Location, std::allocator<mlir::lsp::Location>>&) | void lsp::TableGenServer::findReferencesOf(const URIForFile &uri,
const Position &pos,
std::vector<Location> &references) {
auto fileIt = impl->files.find(uri.file());
if (fileIt != impl->files.end())
fileIt->second->findRefer... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rbx
leaq 0x38(%rbx), %r13
movq (%rsi), %rbp
movq 0x8(%rsi), %r15
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5e1d6
movq %r13, %rdi
movq %rbp, %rsi
movq ... | /Tools/tblgen-lsp-server/TableGenServer.cpp |
llvm::SmallVectorTemplateBase<mlir::lsp::SourceMgrInclude, false>::destroy_range(mlir::lsp::SourceMgrInclude*, mlir::lsp::SourceMgrInclude*) | static void destroy_range(T *S, T *E) {
while (S != E) {
--E;
E->~T();
}
} | cmpq %rdi, %rsi
je 0x147c2
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $-0x20, %r14
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x14793
movq (%r14), %rsi
incq %rsi
callq 0x9360
movq -0x30(%r14), %rdi
leaq -0x20(%r14), %rax
cmpq %rdi, %rax
je 0x147ab
movq (%rax), %rsi
incq %rsi
callq 0x9360
leaq ... | /llvm/ADT/SmallVector.h |
mlir::lsp::fromJSON(llvm::json::Value const&, mlir::lsp::TextDocumentContentChangeEvent&, llvm::json::Path) | bool mlir::lsp::fromJSON(const llvm::json::Value &value,
TextDocumentContentChangeEvent &result,
llvm::json::Path path) {
llvm::json::ObjectMapper o(value, path);
return o && o.map("range", result.range) &&
o.map("rangeLength", result.rangeLength) && o.map(... | pushq %rbx
subq $0x40, %rsp
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movaps 0x50(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x8(%rdi), %rcx
xorl %edx, %edx
cmpw $0x7, (%rdi)
cmoveq %rcx, %rdx
movq %rdx, (%rsp)
movq %rax, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
jne 0x1d90b
movq %rsi, %rbx
leaq 0x53f0e(%rip), %rsi # 0x... | /Tools/lsp-server-support/Protocol.cpp |
mlir::lsp::convertTokenLocToRange(llvm::SMLoc, llvm::StringRef) | SMRange lsp::convertTokenLocToRange(SMLoc loc, StringRef identifierChars) {
if (!loc.isValid())
return SMRange();
const char *curPtr = loc.getPointer();
// Check if this is a string token.
if (*curPtr == '"') {
curPtr = lexLocStringTok(curPtr + 1);
// Otherwise, default to handling an identifier.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1fb1a
movzbl (%rbx), %eax
movq %rbx, %r14
testl %eax, %eax
je 0x1fb1d
cmpl $0x22, %eax
jne 0x1fb32
leaq 0x1(%rbx), %r13
movb 0x1(%rbx), %r12b
testb %r12b, %r12b
je 0x1fb7a
leaq 0x502f6(%rip), %r15 # 0x... | /Tools/lsp-server-support/SourceMgrUtils.cpp |
void mlir::lsp::Logger::info<llvm::StringRef&>(char const*, llvm::StringRef&) | static void info(const char *fmt, Ts &&...vals) {
log(Level::Info, fmt, llvm::formatv(fmt, std::forward<Ts>(vals)...));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x203b2
movq %rbx, %rdi
callq 0x9160
jmp 0x203b4
xorl %eax, %eax
leaq 0x30(%rsp), %rcx
movq %rbx, -0x30(%rcx)
movq %rax, -0x28(%rcx)
movq %rcx, -0x20(%rcx)
movq $0x1, -0x18(%rcx)
leaq 0x20(%rsp), %rax
leaq 0x7487f(%rip), %rcx ... | /mlir/Tools/lsp-server-support/Logging.h |
mlir::lsp::JSONTransport::notify(llvm::StringRef, llvm::json::Value) | void JSONTransport::notify(StringRef method, llvm::json::Value params) {
sendMessage(llvm::json::Object{
{"jsonrpc", "2.0"},
{"method", method},
{"params", std::move(params)},
});
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
leaq 0x4ee87(%rip), %rsi # 0x6fe47
leaq 0x50(%rsp), %r15
movl $0x7, %edx
movq %r15, %rdi
callq 0xdd0c
leaq 0x68(%rsp), %rdi
leaq 0x4ee71(%... | /Tools/lsp-server-support/Transport.cpp |
mlir::lsp::JSONTransport::readDelimitedMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | LogicalResult JSONTransport::readDelimitedMessage(std::string &json) {
json.clear();
llvm::SmallString<128> line;
while (succeeded(readLine(in, line))) {
StringRef lineRef = line.str().trim();
if (lineRef.starts_with("//")) {
// Found a delimiter for the message.
if (lineRef == kDefaultSplitMa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq (%rsi), %rcx
movb $0x0, (%rcx)
leaq 0x28(%rsp), %rbp
movq %rbp, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq $0x80, -0x8(%rbp)
movq 0x18(%rdi), %rdi
leaq 0x10(%rsp), %r... | /Tools/lsp-server-support/Transport.cpp |
llvm::BitRecTy::typeIsConvertibleTo(llvm::RecTy const*) const | RecTyKind getRecTyKind() const { return Kind; } | movl 0x8(%rsi), %ecx
cmpl %ecx, 0x8(%rdi)
sete %al
cmpl $0x2, %ecx
sete %dl
orb %al, %dl
movb $0x1, %al
jne 0x2332d
cmpl $0x1, %ecx
jne 0x2332e
cmpl $0x1, 0x20(%rsi)
sete %al
retq
xorl %eax, %eax
retq
nop
| /llvm/TableGen/Record.h |
llvm::BitInit::convertInitializerTo(llvm::RecTy*) const | RecordKeeper &getRecordKeeper() const { return RK; } | movl 0x8(%rsi), %eax
testl %eax, %eax
je 0x24236
cmpl $0x1, %eax
je 0x24209
cmpl $0x2, %eax
jne 0x24234
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
movzbl 0x18(%rdi), %esi
movq %rax, %rdi
jmp 0x2423a
cmpl $0x1, 0x20(%rsi)
jne 0x24234
pushq %rax
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
movq %rsp, %rsi
movq %rdi, (%rs... | /llvm/TableGen/Record.h |
llvm::detail::DenseMapPair<llvm::Init*, llvm::MapResolver::MappedValue>* llvm::DenseMapBase<llvm::DenseMap<llvm::Init*, llvm::MapResolver::MappedValue, llvm::DenseMapInfo<llvm::Init*, void>, llvm::detail::DenseMapPair<llvm::Init*, llvm::MapResolver::MappedValue>>, llvm::Init*, llvm::MapResolver::MappedValue, llvm::Dens... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x30f4d
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x3... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorImpl<llvm::Record*>::append<llvm::Record* const*, void>(llvm::Record* const*, llvm::Record* const*) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x3, %r13
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %ecx
movq %rax, %rdx
addq %r13, %rdx
cmpq %rcx, %rdx
jbe 0x313be
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %r... | /llvm/ADT/SmallVector.h |
llvm::hashing::detail::hash_short(char const*, unsigned long, unsigned long) | inline uint64_t hash_short(const char *s, size_t length, uint64_t seed) {
if (length >= 4 && length <= 8)
return hash_4to8_bytes(s, length, seed);
if (length > 8 && length <= 16)
return hash_9to16_bytes(s, length, seed);
if (length > 16 && length <= 32)
return hash_17to32_bytes(s, length, seed);
if ... | leaq -0x4(%rsi), %rax
cmpq $0x4, %rax
ja 0x31b64
movl (%rdi), %eax
leaq (%rsi,%rax,8), %rcx
movl -0x4(%rdi,%rsi), %eax
xorq %rdx, %rax
xorq %rax, %rcx
movabsq $-0x622015f714c7d297, %rdx # imm = 0x9DDFEA08EB382D69
imulq %rdx, %rcx
xorq %rcx, %rax
shrq $0x2f, %rcx
xorq %rax, %rcx
imulq %rdx, %rcx
movq %rcx, %rax
shrq $0x... | /llvm/ADT/Hashing.h |
llvm::TGLexer::processEOF() | bool TGLexer::processEOF() {
SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
if (ParentIncludeLoc != SMLoc()) {
// If prepExitInclude() detects a problem with the preprocessing
// control stack, it will return false. Pretend that we reached
// the final EOF and stop lexing more tokens b... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x58(%rdi), %ecx
decl %ecx
movq (%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movq 0x10(%rax,%rcx,8), %r14
testq %r14, %r14
je 0x343a2
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x343b8
testb %al, %al
je 0x343b1
movq (%rbx), %rdi
movq %r14, %rsi... | /TableGen/TGLexer.cpp |
llvm::TGLexer::LexExclaim() | tgtok::TokKind TGLexer::LexExclaim() {
if (!isalpha(*CurPtr))
return ReturnError(CurPtr - 1, "Invalid \"!operator\"");
const char *Start = CurPtr++;
while (isalpha(*CurPtr))
++CurPtr;
// Check to see which operator this is.
tgtok::TokKind Kind =
StringSwitch<tgtok::TokKind>(StringRef(Start, Cu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movsbl (%r14), %edi
callq 0x9580
testl %eax, %eax
je 0x35704
leaq 0x1(%r14), %r12
xorl %r15d, %r15d
leaq (%r12,%r15), %rax
movq %rax, 0x8(%rbx)
movsbl (%r12,%r15), %edi
callq 0x9580
incq %r15
testl %eax, %eax
jne 0x356b2
m... | /TableGen/TGLexer.cpp |
llvm::TGParser::ParseIfBody(llvm::MultiClass*, llvm::StringRef) | bool TGParser::ParseIfBody(MultiClass *CurMultiClass, StringRef Kind) {
// An if-statement introduces a new scope for local variables.
TGVarScope *BodyScope = PushScope();
if (Lex.getCode() != tgtok::l_brace) {
// A single object.
if (ParseObject(CurMultiClass))
return true;
} else {
SMLoc Br... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x446f6
movq %rax, %r14
cmpl $0x6, 0x28(%rbx)
jne 0x44623
movq %rbx, %rdi
callq 0x34324
movq %rax, %r15
movq 0x8(%rbx), %rax
xorl %esi, %esi
cmpq 0x10(%rbx), %rax
sete... | /TableGen/TGParser.cpp |
llvm::SmallVectorTemplateBase<llvm::Record::DumpInfo, true>::push_back(llvm::Record::DumpInfo) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x463a0
movq (%r14), %rax
movl %edx, %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %rsi
movl... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorTemplateBase<std::pair<llvm::Init*, llvm::Init*>, true>::push_back(std::pair<llvm::Init*, llvm::Init*>) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x467ee
movq (%r14), %rax
movl %edx, %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %rsi
movl... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<llvm::Init*>::operator=(llvm::SmallVectorImpl<llvm::Init*> const&) | SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (C... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x46aa2
movq %rsi, %r15
movl 0x8(%rsi), %r14d
movl 0x8(%rbx), %r12d
cmpl %r14d, %r12d
jae 0x46a45
cmpl %r14d, 0xc(%rbx)
jae 0x46a5f
movl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<llvm::RecordVal>::operator=(llvm::SmallVectorImpl<llvm::RecordVal> const&) | SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (C... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x46bcf
movq %rsi, %r15
movl 0x8(%rsi), %ebp
movl 0x8(%rbx), %eax
cmpl %ebp, %eax
jae 0x46af6
cmpl %ebp, 0xc(%rbx)
jae 0x46b4f
movq %rbx, %rdi
callq 0x46c08
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x304dc... | /llvm/ADT/SmallVector.h |
llvm::cl::Option::addCategory(llvm::cl::OptionCategory&) | void Option::addCategory(OptionCategory &C) {
assert(!Categories.empty() && "Categories cannot be empty.");
// Maintain backward compatibility by replacing the default GeneralCategory
// if it's still set. Otherwise, just add the new one. The GeneralCategory
// must be explicitly added if you want multiple ca... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x49084
leaq 0x4e4ee(%rip), %r15 # 0x97510
cmpq %r15, %rbx
je 0x49038
movq 0x40(%r14), %rax
movq (%rax), %r12
callq 0x49084
cmpq %r15, %r12
je 0x49071
movq %rsp, %rdx
movq %rbx, (%rdx)
movq 0x40(%r14), %rdi
movl 0x48(%r14),... | /Support/CommandLine.cpp |
llvm::SmallVectorImpl<char>::append(unsigned long, char) | void append(size_type NumInputs, ValueParamT Elt) {
const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumInputs);
std::uninitialized_fill_n(this->end(), NumInputs, *EltPtr);
this->set_size(this->size() + NumInputs);
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq (%rdi,%rsi), %rdx
cmpq 0x10(%rbx), %rdx
ja 0x4f2be
testq %r14, %r14
je 0x4f2b2
addq (%rbx), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x9200
movq 0x8(%rbx), %rdi
addq %r14, %rdi
movq %rdi, 0x8(%rbx)
popq %rbx
p... | /llvm/ADT/SmallVector.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [18], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::cat, llvm::cl::sub>(char const (&) [18], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::cat const&, llvm::cl::sub const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x50(%rsp), %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0xbd4e
movb $0x0, 0x80(%r14)
movq $0x0, 0x90(%r14)
leaq 0x449b8(%rip), %rax ... | /llvm/Support/CommandLine.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::cl::OptionCategory*, std::vector<llvm::cl::Option*, std::allocator<llvm::cl::Option*>>, llvm::DenseMapInfo<llvm::cl::OptionCategory*, void>, llvm::detail::DenseMapPair<llvm::cl::OptionCategory*, std::vector<llvm::cl::Option*, std::allocator<llvm::cl::Option*>>>>, llvm::cl::O... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x50789
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movl %esi, %eax
shrl $0x4, %eax
movl %esi, %r9d
shrl $0x9, %r9d
xorl %eax, %r9d
decl %ecx
andl %ecx, %r9d
movq %r9, %rax
shlq $0x5, %rax
leaq (%rdi,%rax), %r8
movq (%rdi,%rax), %rbx
movb $0x1, %al
cmpq %rbx, %rsi
jne 0x5079... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<(anonymous namespace)::HelpPrinterWrapper, true, llvm::cl::parser<bool>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0xf(%rsp), %rax
movb $0x0, (%rax)
movq %rax, (%rsp)
movq %rdi, %rsi
callq 0x48ce2
movl %eax, %ebp
testb %al, %al
jne 0x50f10
cmpb $0x1, 0xf(%rsp)
je 0x50f1b
movw %r14w, 0xc(%rbx)
cmpq $0x0, 0xa8(%rbx)
je 0x50f9a
leaq 0x98(%rbx), %rd... | /llvm/Support/CommandLine.h |
llvm::SmallVectorTemplateBase<std::pair<char const*, llvm::cl::Option*>, true>::push_back(std::pair<char const*, llvm::cl::Option*>) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x518b0
movq (%r14), %rax
movl %edx, %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %rsi
movl... | /llvm/ADT/SmallVector.h |
void llvm::SmallVectorImpl<char const*>::append<char const**, void>(char const**, char const**) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x3, %r13
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %ecx
movq %rax, %rdx
addq %r13, %rdx
cmpq %rcx, %rdx
jbe 0x51d72
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %r... | /llvm/ADT/SmallVector.h |
llvm::DebugCounter::printChunks(llvm::raw_ostream&, llvm::ArrayRef<llvm::DebugCounter::Chunk>) | void DebugCounter::printChunks(raw_ostream &OS, ArrayRef<Chunk> Chunks) {
if (Chunks.empty()) {
OS << "empty";
} else {
bool IsFirst = true;
for (auto E : Chunks) {
if (!IsFirst)
OS << ':';
else
IsFirst = false;
E.print(OS);
}
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x522d2
movq %rdx, %r14
movq %rsi, %r15
shlq $0x4, %r14
movb $0x1, %al
xorl %r13d, %r13d
movq %rsp, %r12
movups (%r15,%r13), %xmm0
movaps %xmm0, (%rsp)
testb $0x1, %al
jne 0x522ae
movq 0x20(%rbx), %rax
cmpq 0x18(... | /Support/DebugCounter.cpp |
llvm::DenseMap<unsigned int, llvm::DebugCounter::CounterInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DebugCounter::CounterInfo>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::formatv_object_base::splitLiteralAndReplacement(llvm::StringRef) | std::pair<ReplacementItem, StringRef>
formatv_object_base::splitLiteralAndReplacement(StringRef Fmt) {
while (!Fmt.empty()) {
// Everything up until the first brace is a literal.
if (Fmt.front() != '{') {
std::size_t BO = Fmt.find_first_of('{');
return std::make_pair(ReplacementItem{Fmt.substr(0, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x556a8
movq %rdx, %r14
cmpb $0x7b, (%r15)
jne 0x556e6
leaq -0x1(%r14), %r13
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x555e6
leaq 0x1(%rcx), %rax
cmpb $0x7b, 0x1(%r15,%rcx)
movq %rax, %rcx
j... | /Support/FormatVariadic.cpp |
llvm::SmallVectorImpl<llvm::IntervalMapImpl::Path::Entry>::append(unsigned long, llvm::IntervalMapImpl::Path::Entry) | void append(size_type NumInputs, ValueParamT Elt) {
const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumInputs);
std::uninitialized_fill_n(this->end(), NumInputs, *EltPtr);
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %ecx
leaq (%rax,%rsi), %rdx
cmpq %rcx, %rdx
ja 0x55e12
testq %rbx, %rbx
je 0x55e00
shlq $0x4, %rax
addq (%r14), %rax
movq %rbx, %rcx
movq %r12, (%rax)
movq %r15, 0x... | /llvm/ADT/SmallVector.h |
llvm::MemoryBuffer::getFileOrSTDIN(llvm::Twine const&, bool, bool, std::optional<llvm::Align>) | ErrorOr<std::unique_ptr<MemoryBuffer>>
MemoryBuffer::getFileOrSTDIN(const Twine &Filename, bool IsText,
bool RequiresNullTerminator,
std::optional<Align> Alignment) {
SmallString<256> NameBuf;
StringRef NameRef = Filename.toStringRef(NameBuf);
if (NameRef... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %r8d, %r14d
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x18(%r13)
movq $0x0, -0x10(%r13)
movq $0x100, -0x8(%r13) # imm = 0x100
movq %rsp, %rsi
mo... | /Support/MemoryBuffer.cpp |
llvm::SmallVectorBase<unsigned int>::grow_pod(void*, unsigned long, unsigned long) | void SmallVectorBase<Size_T>::grow_pod(void *FirstEl, size_t MinSize,
size_t TSize) {
size_t NewCapacity = getNewCapacity<Size_T>(MinSize, TSize, this->capacity());
void *NewElts;
if (BeginX == FirstEl) {
NewElts = llvm::safe_malloc(NewCapacity * TSize);
if (NewElts ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movl 0xc(%rdi), %esi
movq %rdx, %rdi
callq 0x5aef0
movq %rax, %r15
movq (%rbx), %rbp
movq %rax, %r14
movq %r13, (%rsp)
imulq %r13, %r14
cmpq %r12, %rbp
je 0x5b02e
movq %rbp, %rdi
movq %r14, %rsi
... | /Support/SmallVector.cpp |
llvm::SmallVectorBase<unsigned long>::replaceAllocation(void*, unsigned long, unsigned long, unsigned long) | void *SmallVectorBase<Size_T>::replaceAllocation(void *NewElts, size_t TSize,
size_t NewCapacity,
size_t VSize) {
void *NewEltsReplace = llvm::safe_malloc(NewCapacity * TSize);
if (VSize)
memcpy(NewEltsReplace, New... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rbx
imulq %rdx, %r13
movq %r13, %rdi
callq 0x9490
testq %rax, %rax
jne 0x5b0ee
testq %r13, %r13
jne 0x5b11d
movl $0x1, %edi
callq 0x9490
testq %rax, %rax
je 0x5b11d
movq %rax, %r12
testq %r14, %r14
je 0x5b1... | /Support/SmallVector.cpp |
(anonymous namespace)::RealFile::status() | ErrorOr<Status> RealFile::status() {
assert(FD != kInvalidFile && "cannot stat closed file");
if (!S.isStatusKnown()) {
file_status RealStatus;
if (std::error_code EC = sys::fs::status(FD, RealStatus))
return EC;
S = Status::copyWithNewName(RealStatus, S.getName());
}
return S;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x58(%rsi)
je 0x61046
andb $-0x2, 0x58(%rbx)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xb3be
movb 0x60(%r14), %al
movb %al, 0x50(%rbx)
... | /Support/VirtualFileSystem.cpp |
llvm::cl::opt<llvm::cl::boolOrDefault, false, llvm::cl::parser<llvm::cl::boolOrDefault>>::opt<char [6], llvm::cl::cat, llvm::cl::desc, llvm::cl::initializer<llvm::cl::boolOrDefault>>(char const (&) [6], llvm::cl::cat const&, llvm::cl::desc const&, llvm::cl::initializer<llvm::cl::boolOrDefault> const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0xbd4e
movl $0x0, 0x80(%r14)
movq $0x0, 0x90(%r14)
leaq 0x341e0(%rip), %rax # 0x95e78
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x34bfe(%rip),... | /llvm/Support/CommandLine.h |
llvm::yaml::Scanner::scanBlockEntry() | bool Scanner::scanBlockEntry() {
rollIndent(Column, Token::TK_BlockSequenceStart, TokenQueue.end());
removeSimpleKeyCandidatesOnFlowLevel(FlowLevel);
IsSimpleKeyAllowed = true;
IsAdjacentValueAllowedInFlow = false;
Token T;
T.Kind = Token::TK_BlockEntry;
T.Range = StringRef(Current, 1);
skip(1);
Token... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl 0x3c(%rdi), %esi
leaq 0x50(%rdi), %r15
leaq 0xb0(%rdi), %r14
movl $0x9, %edx
movq %r14, %rcx
callq 0x62e7e
movl 0xe8(%rbx), %eax
testq %rax, %rax
je 0x63a04
movq 0xe0(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
movl -0x8(%rcx,%rdx,8), %ecx
cmpl ... | /Support/YAMLParser.cpp |
llvm::yaml::Scanner::scanValue() | bool Scanner::scanValue() {
// If the previous token could have been a simple key, insert the key token
// into the token queue.
if (!SimpleKeys.empty()) {
SimpleKey SK = SimpleKeys.pop_back_val();
Token T;
T.Kind = Token::TK_Key;
T.Range = SK.Tok->Range;
TokenQueueT::iterator i, e;
for (i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl 0xe8(%rdi), %ecx
testq %rcx, %rcx
je 0x63d0b
movq 0xe0(%rbx), %rdx
leaq (%rcx,%rcx,2), %rsi
movq -0x18(%rdx,%rsi,8), %rax
movl -0x10(%rdx,%rsi,8), %ebp
decl %ecx
movl %ecx, 0xe8(%rbx)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15... | /Support/YAMLParser.cpp |
llvm::yaml::Node::getVerbatimTag[abi:cxx11]() const | std::string Node::getVerbatimTag() const {
StringRef Raw = getRawTag();
if (!Raw.empty() && Raw != "!") {
std::string Ret;
if (Raw.find_last_of('!') == 0) {
Ret = std::string(Doc->getTagMap().find("!")->second);
Ret += Raw.substr(1);
return Ret;
} else if (Raw.starts_with("!!")) {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x40(%rsi), %r14
testq %r14, %r14
je 0x6512f
movq 0x38(%r12), %r15
cmpq $0x1, %r14
jne 0x65168
cmpb $0x21, (%r15)
jne 0x65168
movl 0x20(%r12), %eax
cmpq $0x5, %rax
ja 0x65348
leaq 0x100b7(%rip), %rcx # 0x751... | /Support/YAMLParser.cpp |
llvm::yaml::Document::parseBlockNode() | Node *Document::parseBlockNode() {
Token T = peekNext();
// Handle properties.
Token AnchorInfo;
Token TagInfo;
parse_property:
switch (T.Kind) {
case Token::TK_Alias:
getNext();
return new (NodeAllocator) AliasNode(stream.CurrentDoc, T.Range.substr(1));
case Token::TK_Anchor:
if (AnchorInfo.K... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rdi
callq 0x6233e
movups (%rax), %xmm0
leaq 0x58(%rsp), %rbx
movaps %xmm0, -0x18(%rbx)
movq 0x10(%rax), %rcx
movq %rcx, -0x8(%rbx)
leaq 0x68(%rsp), %rcx
movq %rcx,... | /Support/YAMLParser.cpp |
llvm::raw_ostream::~raw_ostream() | raw_ostream::~raw_ostream() {
// raw_ostream's subclasses should take care to flush the buffer
// in their destructors.
assert(OutBufCur == OutBufStart &&
"raw_ostream destructor called with non-empty buffer!");
if (BufferMode == BufferKind::InternalBuffer)
delete [] OutBufStart;
} | leaq 0x2c673(%rip), %rax # 0x96b28
addq $0x10, %rax
movq %rax, (%rdi)
cmpl $0x1, 0x2c(%rdi)
jne 0x6a4cf
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x9480
retq
| /Support/raw_ostream.cpp |
bsplib::Rdma::hpget(int, unsigned long, unsigned long, void*, unsigned long) | void Rdma::hpget( int src_pid, Memslot src_slot, size_t src_offset,
void * dst, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::HPGET );
#endif
if ( size < m_min_n_hp_msg_size ) {
get( src_pid, src_slot, src_offset, dst, size );
return;
}
assert( !( slot( m_pid, src_slot ).sta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r15
movq %r8, 0x8(%rsp)
cmpq %r9, 0x2f8(%rdi)
jbe 0xad2d
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r9
addq $0x48, %rsp
popq %rbx... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
fmt::v9::appender fmt::v9::detail::fill<fmt::v9::appender, char>(fmt::v9::appender, unsigned long, fmt::v9::detail::fill_t<char> const&) | FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n,
const fill_t<Char>& fill) -> OutputIt {
auto fill_size = fill.size();
if (fill_size == 1) return detail::fill_n(it, n, fill[0]);
auto data = fill.data();
for (size_t i = 0; i < n; ++i)
it = copy_str<Char>(data, ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x4(%rdx), %r12d
cmpq $0x1, %r12
jne 0x1e8bc
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1e8e6
testq %r14, %r14
je 0x1e8d7
addq %rbx, %r12
movq ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
char fmt::v9::detail::write_padded<(fmt::v9::align::type)1, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_bytes<(fmt::v9::align::type)1, char, fmt::v9::appender>(fmt::v9::appender, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_specs<char> const&)::'lambda'(fmt::v9::appender)&>(char, fmt::v... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x72f9b(%rip), %rcx # 0x9264d
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r13
movq %rdi, %r12
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detai... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x7210b(%rip), %rcx # 0x92648
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi,... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::float_specs fmt::v9::detail::parse_float_type_spec<fmt::v9::detail::error_handler, char>(fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::error_handler&&) | FMT_CONSTEXPR auto parse_float_type_spec(const basic_format_specs<Char>& specs,
ErrorHandler&& eh = {})
-> float_specs {
auto result = float_specs();
result.showpoint = specs.alt;
result.locale = specs.localized;
switch (specs.type) {
case presentation_type::none:
... | movzbl 0x8(%rdi), %edx
cmpq $0xe, %rdx
ja 0x21cca
movzwl 0x9(%rdi), %eax
movl %eax, %ecx
shrl $0x7, %ecx
andl $0x1, %ecx
movl %ecx, %esi
shll $0x13, %esi
shll $0x9, %eax
andl $0x20000, %eax # imm = 0x20000
orl %esi, %eax
leaq 0x6f4fe(%rip), %rsi # 0x91168
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%r... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/core.h |
int fmt::v9::detail::snprintf_float<long double>(long double, int, fmt::v9::detail::float_specs, fmt::v9::detail::buffer<char>&) | auto snprintf_float(T value, int precision, float_specs specs,
buffer<char>& buf) -> int {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
FMT_ASSERT(specs.format == float_format::hex, "");
static_assert(!s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %edi, %ebp
fldt 0x60(%rsp)
fstpt 0x1c(%rsp)
shrq $0x20, %rsi
movb $0x25, 0x15(%rsp)
btl $0x13, %esi
jb 0x21d08
leaq 0x16(%rsp), %rax
jmp 0x21d11
leaq 0x17(%rsp), %rax
movb $0x23, -0x1(%rax)
testl %ebp, %ebp
js 0x21d1... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::bigint::assign(fmt::v9::detail::bigint const&) | FMT_CONSTEXPR20 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
cmpq %r15, 0x18(%rdi)
jae 0x229d1
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
movq 0x18(%rbx), %rax
cmpq %r15, %rax
cmovaeq %r15, %rax
movq %rax, 0x10(%rbx)
jmp 0x229da
movq %r15, 0x10(%rbx)
testq %r15, %r15
je 0x... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
void fmt::v9::detail::bigint::multiply<unsigned __int128, 0>(unsigned __int128) | constexpr auto size() const noexcept -> size_t { return size_; } | movq 0x10(%rdi), %r9
testq %r9, %r9
je 0x23108
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rdi, %rbx
movq 0x8(%rdi), %r10
movq %rdx, %r11
shrq $0x20, %r11
shlq $0x20, %rcx
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%r10,%r12,4), %r8d
movq %r8, %rax... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/core.h |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, double, 0>(fmt::v9::appender, double, fmt::v9::basic_format_specs<char>, fmt::v9::detail::locale_ref) | FMT_CONSTEXPR20 auto write(OutputIt out, T value,
basic_format_specs<Char> specs, locale_ref loc = {})
-> OutputIt {
if (const_check(!is_supported_floating_point(value))) return out;
float_specs fspecs = parse_float_type_spec(specs);
fspecs.sign = specs.sign;
if (detail::signbit(v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x260, %rsp # imm = 0x260
movq %rcx, %r14
movaps %xmm0, 0x20(%rsp)
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %rsi, (%r12)
movq %rdx, 0x8(%r12)
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x21c3a
movdqa 0x20(%rsp), %xmm0
movq %rax, %rbx
movq %rax, ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
long ranges::concat_view<ranges::ref_view<std::vector<double, std::allocator<double>>>, ranges::ref_view<std::vector<double, std::allocator<double>>>, ranges::ref_view<std::vector<double, std::allocator<double>>>>::cursor<true>::distance_to_<0ul>(std::integral_constant<unsigned long, 0ul>, ranges::concat_view<ranges::r... | static difference_type distance_to_(meta::size_t<N>, cursor const & from,
cursor const & to)
{
if(from.its_.index() > N)
return cursor::distance_to_(meta::size_t<N + 1>{}, from, to);
if(from.its_.index() == N... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x29296
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x292ec
leaq 0x8(%r14), %rdi
cmpq $0x0, 0x10(%rbx)
je 0x292c8
callq 0x295ed
movq (%r14), %rcx
movq 0x18(%rcx), %rcx
movq 0x8(%rcx), %r15
subq (%rax), %r15
s... | /njoy[P]ENDFtk/build_O3/_deps/range-v3-src/include/range/v3/view/concat.hpp |
void njoy::tools::disco::Integer<3u>::write<int, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(int const&, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&) | static void write( const Representation& value, Iterator& iter ) {
// std::abs does not exist for all integer types (e.g. unsigned)
const Representation absValue = value < 0 ? -value : value;
const auto required = minimumRequiredWidth( absValue )
+ ( value < 0 ? 1 : 0 );
std::o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ebp
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
movl $0x1, %eax
cmpl $0xa, %ecx
jb 0x2ae38
movl $0xcccccccd, %edx # imm = 0xCCCCCCCD
movl %ecx, %esi
imulq %rdx, %rsi
shrq... | /njoy[P]ENDFtk/build_O3/_deps/tools-src/src/tools/disco/Integer.hpp |
Catch::MatchExpr<double, Catch::Matchers::WithinRelMatcher>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream& os ) const override {
os << Catch::Detail::stringify( m_arg )
<< ' '
<< m_matcher.toString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movsd (%rax), %xmm0
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x4b5f8
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x17700
movq %rsp, %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x... | /njoy[P]ENDFtk/build_O3/_deps/catch2-src/src/catch2/../catch2/matchers/internal/catch_matchers_impl.hpp |
spdlog::details::registry::disable_backtrace() | SPDLOG_INLINE void registry::disable_backtrace()
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
backtrace_n_messages_ = 0;
for (auto &l : loggers_)
{
l.second->disable_backtrace();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x17950
testl %eax, %eax
jne 0x301ce
movq $0x0, 0x148(%rbx)
leaq 0x88(%rbx), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x301bf
movq 0x28(%r14), %rdi
addq $0x68, %rdi
callq 0x30e3a
jmp 0x301a8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x174c0
movl %ea... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/registry-inl.h |
spdlog::details::registry::shutdown() | SPDLOG_INLINE void registry::shutdown()
{
{
std::lock_guard<std::mutex> lock(flusher_mutex_);
periodic_flusher_.reset();
}
drop_all();
{
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_.reset();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x17950
testl %eax, %eax
jne 0x30775
leaq 0x128(%rbx), %rdi
xorl %esi, %esi
callq 0x3730c
movq %r14, %rdi
callq 0x174c0
movq %rbx, %rdi
callq 0x306b2
leaq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0x17950
testl %eax, %eax
jne 0x30... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/registry-inl.h |
spdlog::details::backtracer::operator=(spdlog::details::backtracer) | SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other)
{
std::lock_guard<std::mutex> lock(mutex_);
enabled_ = other.enabled();
messages_ = std::move(other.messages_);
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17950
testl %eax, %eax
jne 0x30da9
movb 0x28(%r14), %al
andb $0x1, %al
xchgb %al, 0x28(%rbx)
addq $0x30, %r14
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x36688
movq %rbx, %rdi
callq 0x174c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
ret... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/backtracer-inl.h |
spdlog::details::backtracer::foreach_pop(std::function<void (spdlog::details::log_msg const&)>) | SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun)
{
std::lock_guard<std::mutex> lock{mutex_};
while (!messages_.empty())
{
auto &front_msg = messages_.front();
fun(front_msg);
messages_.pop_front();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17950
testl %eax, %eax
jne 0x30f43
movq 0x38(%rbx), %rdx
cmpq %rdx, 0x40(%rbx)
je 0x30f2f
cmpq $0x0, 0x10(%r14)
je 0x30f3e
leaq (%rdx,%rdx,2), %rsi
shlq $0x7, %rsi
addq 0x50(%rbx), %rsi
movq %r14, %rdi
callq *0x18(%r14)
movq 0x38(%rbx), %rax
movq ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/backtracer-inl.h |
spdlog::details::os::now() | SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT
{
#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
timespec ts;
::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
return std::chrono::time_point<log_clock, typename log_clock::duration>(
std::chrono::duration_cast<typename log_clock::... | jmp 0x17080
| /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/os-inl.h |
spdlog::details::os::is_color_terminal() | SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT
{
#ifdef _WIN32
return true;
#else
static const bool result = []() {
const char *env_colorterm_p = std::getenv("COLORTERM");
if (env_colorterm_p != nullptr)
{
return true;
}
static constexpr std::array<c... | movb 0xa1357(%rip), %al # 0xd2d78
testb %al, %al
je 0x31a2c
movb 0xa1345(%rip), %al # 0xd2d70
retq
pushq %rax
callq 0x17df7
addq $0x8, %rsp
jmp 0x31a25
| /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/os-inl.h |
spdlog::details::scoped_padder::scoped_padder(unsigned long, spdlog::details::padding_info const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | scoped_padder(size_t wrapped_size, const padding_info &padinfo, memory_buf_t &dest)
: padinfo_(padinfo)
, dest_(dest)
{
remaining_pad_ = static_cast<long>(padinfo.width_) - static_cast<long>(wrapped_size);
if (remaining_pad_ <= 0)
{
return;
}
if (... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
leaq 0x5dcc7(%rip), %rsi # 0x962cf
movq %rsi, 0x18(%rdi)
movq $0x40, 0x20(%rdi)
movq (%rdx), %r14
subq %rax, %r14
movq %r14, 0x10(%rdi)
jle 0x3865f
movq %rdi, %rbx
movl 0x8(%rdx), %eax
cmpl $0x2, %eax
je 0x38642
testl %eax, %eax... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::t_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
const auto field_size = ScopedPadder::count_digits(msg.thread_id);
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_int(msg.thread_id, dest);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq 0x20(%rsi), %rax
movq %rax, %rcx
orq $0x1, %rcx
bsrq %rcx, %rcx
leaq 0x5a115(%rip), %rdx # 0x92910
movzbl (%rdx,%rcx), %esi
leaq 0x5a14a(%rip), %rcx # 0x92950
cmpq (%rcx,%rsi,8), %rax
sbbl $0x0, %esi
leaq 0x8(%rdi), %rdx
movq %rsp, %rdi... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::F_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
auto ns = fmt_helper::time_fraction<std::chrono::nanoseconds>(msg.time);
const size_t field_size = 9;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad9(static_cast<size_t>(ns.count()),... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x18(%rsi), %r14
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
movq %r14, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
imulq $0x3b9aca00, %rdx, %rax # imm = 0x3B9ACA00
subq %rax, %r14
movq %r14, %rax
orq $0x1, %ra... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::set_color_mode(spdlog::color_mode) | SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
{
switch (mode)
{
case color_mode::always:
should_do_colors_ = true;
return;
case color_mode::automatic:
should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal()... | pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x3df35
cmpl $0x2, %esi
je 0x3df31
cmpl $0x1, %esi
jne 0x3df31
movq 0x1c0(%rbx), %rdi
callq 0x31afd
testb %al, %al
je 0x3df31
callq 0x31a1b
jmp 0x3df37
xorl %eax, %eax
jmp 0x3df37
movb $0x1, %al
movb %al, 0x1d0(%rbx)
popq %rbx
retq
nop
| /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::log(spdlog::details::log_msg const&) | SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
{
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.
std::lock_guard<mutex_t> lock(mutex_);
msg.color_range_start = 0;
msg.color_range_end = 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
leaq 0x20(%rsp), %r15
movq $0x0, -0x10(%r15)
leaq 0x8d767(%rip), %rax # 0xcc1d0
addq $0x10, %rax
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
movq $0xfa, -0x8(%r15... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::set_formatter(std::unique_ptr<spdlog::formatter, std::default_delete<spdlog::formatter>>) | SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter);
} | movq %rdi, %rax
movq (%rsi), %rcx
movq $0x0, (%rsi)
movq 0x1d8(%rdi), %rdi
movq %rcx, 0x1d8(%rax)
testq %rdi, %rdi
je 0x3ed64
movq (%rdi), %rax
jmpq *0x8(%rax)
retq
nop
| /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
fmt::v9::detail::report_error(void (*)(fmt::v9::detail::buffer<char>&, int, char const*), int, char const*) | FMT_FUNC void report_error(format_func func, int error_code,
const char* message) noexcept {
memory_buffer full_message;
func(full_message, error_code, message);
// Don't use fwrite_fully because the latter may throw.
if (std::fwrite(full_message.data(), full_message.size(), 1, stderr... | pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdi, %rax
leaq 0x20(%rsp), %rbx
movq $0x0, -0x10(%rbx)
leaq 0x88d98(%rip), %rcx # 0xcc250
addq $0x10, %rcx
movq %rcx, -0x20(%rbx)
movq %rbx, -0x18(%rbx)
movq $0x1f4, -0x8(%rbx) # imm = 0x1F4
movq %rsp, %rdi
callq *%rax
movq 0x8(%rsp), %rdi
... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h |
fmt::v9::vformat[abi:cxx11](fmt::v9::basic_string_view<char>, fmt::v9::basic_format_args<fmt::v9::basic_format_context<fmt::v9::appender, char>>) | FMT_FUNC std::string vformat(string_view fmt, format_args args) {
// Don't optimize the "{}" case to keep the binary size small and because it
// can be better optimized in fmt::format anyway.
auto buffer = memory_buffer();
detail::vformat_to(buffer, fmt, args);
return to_string(buffer);
} | pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq $0x0, -0x10(%r14)
leaq 0x88c44(%rip), %rax # 0xcc250
addq $0x10, %rax
movq %rax, -0x20(%r14)
movq %r14, -0x18(%r14)
movq $0x1f4, -0x8(%r14) # imm = 0x1F4
movq %rsp, %rdi
xorl %r9d, %r9d
callq 0x1d289
mov... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h |
fmt::v9::detail::is_printable(unsigned int) | FMT_FUNC auto is_printable(uint32_t cp) -> bool {
static constexpr singleton singletons0[] = {
{0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8},
{0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13},
{0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0... | cmpl $0xffff, %edi # imm = 0xFFFF
ja 0x43a13
movl %edi, %eax
shrl $0x8, %eax
xorl %r9d, %r9d
leaq 0x54913(%rip), %rcx # 0x98290
leaq 0x5496c(%rip), %rdx # 0x982f0
xorl %esi, %esi
movzbl (%rcx,%rsi,2), %r11d
movzbl 0x1(%rcx,%rsi,2), %r10d
leal (%r9,%r10), %r8d
cmpl %r11d, %eax
jb 0x439d2
sete %r11b
tes... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h |
fmt::v9::basic_memory_buffer<wchar_t, 500ul, std::allocator<wchar_t>>::grow(unsigned long) | FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(
size_t size) {
detail::abort_fuzzing_if(size > 5000);
const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
size_t old_capacity = this->capacity();
size_t new_capacity = old_capacity + old_capacity / 2;
if (size > ne... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
addq $0x7f0, %rdi # imm = 0x7F0
movq 0x18(%r14), %rbx
movq %rbx, %r15
shrq %r15
addq %rbx, %r15
cmpq %rsi, %r15
jae 0x44b70
movq %rsi, %r15
jmp 0x44b8a
movq %r15, %rax
shrq $0x3d, %rax
je 0x44b8a
movabsq $0x1fffffffffffffff, %r15 # imm = ... | /njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
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.