name string | code string | asm string | file string |
|---|---|---|---|
Catch::listTests(Catch::Config const&) | std::size_t listTests( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
if( config.hasTestFilters() )
Catch::cout() << "Matching test cases:\n";
else {
Catch::cout() << "All available test cases:\n";
}
auto matchedTestCases = filterT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, 0x30(%rsp)
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x6b5ce(%rip), %rdi # 0x86f98
testb %al, %al
je 0x1b9dc
leaq 0x4454c(%rip), %rsi #... | /diatomic[P]diy/tests/catch.hpp |
Catch::filterTests(std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&, Catch::TestSpec const&, Catch::IConfig const&) | std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
std::vector<TestCase> filtered;
filtered.reserve( testCases.size() );
for (auto const& testCase : testCases) {
if ((!testSpec.hasFilters() && !testCase.isHid... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movq %rdx, %r15
sarq $0x3, %rax
movabsq $-0x2c8590b21642c859, %rsi # imm = 0xD37A6F4DE9BD37A7
imulq %rax, %rsi
callq... | /diatomic[P]diy/tests/catch.hpp |
Catch::TestCaseInfo::tagsAsString[abi:cxx11]() const | std::string TestCaseInfo::tagsAsString() const {
std::string ret;
// '[' and ']' per tag
std::size_t full_size = 2 * tags.size();
for (const auto& tag : tags) {
full_size += tag.size();
}
ret.reserve(full_size);
for (const auto& tag : tags) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x60(%rsi), %rax
movq 0x68(%rsi), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
cmpq %rax, %rcx
je 0x1c063
addq 0x8(%rax), %rsi
addq $0x20... | /diatomic[P]diy/tests/catch.hpp |
Catch::operator<<(std::ostream&, Catch::pluralise const&) | std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
os << pluraliser.m_count << ' ' << pluraliser.m_label;
if( pluraliser.m_count != 1 )
os << 's';
return os;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x11370
leaq 0x6(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x11630
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rax, %rdi
callq 0x11630
cmpq $0x1, (%r14)
je 0x1c12a
leaq 0x7(%rsp), %rsi
movb $0x73, (%... | /diatomic[P]diy/tests/catch.hpp |
Catch::listTestsNamesOnly(Catch::Config const&) | std::size_t listTestsNamesOnly( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
std::size_t matchedTests = 0;
std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
for( auto const& testCaseInfo : matchedTestCases... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
callq 0x34948
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x18(%rcx)
leaq 0x10(%rsp), %r15
movq %r15, %r... | /diatomic[P]diy/tests/catch.hpp |
Catch::listTags(Catch::Config const&) | std::size_t listTags( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
if( config.hasTestFilters() )
Catch::cout() << "Tags for matching test cases:\n";
else {
Catch::cout() << "All available tags:\n";
}
std::map<std::string, TagInfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x6abf6(%rip), %rdi # 0x86f98
testb %al, %al
je 0x1c3b4
leaq 0x43bcc(%rip), %rsi ... | /diatomic[P]diy/tests/catch.hpp |
Catch::RedirectedStdOut::RedirectedStdOut() | RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x23fa6
movq 0x10(%rbx), %rax
movq 0x67cf7(%rip), %rdi # 0x86f98
movq %rdi, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq (%rdi), %rcx
movq -0x18(%rcx), %rdx
movq 0xe8(%rdi,%rdx), %rdx
movq %rdx, 0x28(%rbx)
addq -0x18(%rcx), %rdi
movq (%rax), %rcx
movq -0x18(%rcx), %rc... | /diatomic[P]diy/tests/catch.hpp |
Catch::SimplePcg32::operator()() | SimplePcg32::result_type SimplePcg32::operator()() {
// prepare the output value
const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
const auto output = rotate_right(xorshifted, m_state >> 59u);
// advance state
m_state = m_state * 63641362238... | movq (%rdi), %rax
movq %rax, %rdx
movq %rax, %rcx
movabsq $0x5851f42d4c957f2d, %rsi # imm = 0x5851F42D4C957F2D
imulq %rax, %rsi
shrq $0x2d, %rax
shrq $0x1b, %rdx
xorl %edx, %eax
shrq $0x3b, %rcx
rorl %cl, %eax
movabsq $0x27da198a7f2728ed, %rcx # imm = 0x27DA198A7F2728ED
addq %rsi, %rcx
movq %rcx, (%rdi)
retq
| /diatomic[P]diy/tests/catch.hpp |
Catch::cleanupSingletons() | static auto getSingletons() -> std::vector<ISingleton*>*& {
static std::vector<ISingleton*>* g_singletons = nullptr;
if( !g_singletons )
g_singletons = new std::vector<ISingleton*>();
return g_singletons;
} | pushq %r15
pushq %r14
pushq %rbx
movq 0x6887a(%rip), %rbx # 0x87e50
testq %rbx, %rbx
je 0x1f5e0
movq (%rbx), %r14
jmp 0x1f605
movl $0x18, %edi
callq 0x11530
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x6884e(%rip) # 0x87e50
xorl %r14d, %r14d
movq 0x8(%rbx), %r15
cmp... | /diatomic[P]diy/tests/catch.hpp |
Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<Catch::IConfig const> const&) const | IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
auto it = m_factories.find( name );
if( it == m_factories.end() )
return nullptr;
return it->second->create( ReporterConfig( config ) );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x426e2
addq $0x10, %r14
cmpq %r14, %rax
je 0x1f71a
movq 0x40(%rax), %r14
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, 0x8(%rsp)
movq (%r15), %rax
movq %rax, 0... | /diatomic[P]diy/tests/catch.hpp |
Catch::Totals::operator+=(Catch::Totals const&) | Totals& Totals::operator += ( Totals const& other ) {
assertions += other.assertions;
testCases += other.testCases;
return *this;
} | movq %rdi, %rax
movdqu 0x8(%rsi), %xmm0
movdqu 0x8(%rdi), %xmm1
paddq %xmm0, %xmm1
movdqu 0x18(%rdi), %xmm0
movdqu 0x28(%rdi), %xmm2
movdqu %xmm1, 0x8(%rdi)
movdqu 0x18(%rsi), %xmm1
paddq %xmm0, %xmm1
movdqu %xmm1, 0x18(%rdi)
movdqu 0x28(%rsi), %xmm0
paddq %xmm2, %xmm0
movdqu %xmm0, 0x28(%rdi)
retq
nop
| /diatomic[P]diy/tests/catch.hpp |
Catch::XmlReporter::testRunStarting(Catch::TestRunInfo const&) | void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
StreamingReporterBase::testRunStarting( testInfo );
std::string stylesheetRef = getStylesheetRef();
if( !stylesheetRef.empty() )
m_xml.writeStylesheetRef( stylesheetRef );
m_xml.startElement( "Catch" );
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x41be0
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x42364
movq %r15, 0x20(%rbx)
movb $0x0, 0x48(%rbx)
m... | /diatomic[P]diy/tests/catch.hpp |
Catch::XmlReporter::testCaseStarting(Catch::TestCaseInfo const&) | void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
StreamingReporterBase::testCaseStarting(testInfo);
m_xml.startElement( "TestCase" )
.writeAttribute( "name", trim( testInfo.name ) )
.writeAttribute( "description", testInfo.description )
.writeAttri... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x41b3c
leaq 0x98(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x36c2e
movq %r14, 0x90(%rbx)
movb $0x0, 0x140(%rbx)
leaq 0x170(%rbx), %r14
leaq 0xb8(%rsp), %r13
movq %r13, -0x10... | /diatomic[P]diy/tests/catch.hpp |
non-virtual thunk to Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::~Singleton() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq -0x10(%rdi), %rbx
leaq 0x5032d(%rip), %rax # 0x852a8
movq %rax, -0x10(%rdi)
leaq 0x50312(%rip), %rax # 0x85298
movl $0x90, %r15d
addq %r15, %rax
movq %rax, -0x8(%rdi)
leaq 0x503e6(%rip), %rax # 0x85380
movq %rax, (%rdi)
leaq 0x4eeec(%rip), %rax # 0x8... | /diatomic[P]diy/tests/catch.hpp |
Catch::clara::detail::TokenStream::operator++() | auto operator++() -> TokenStream & {
if( m_tokenBuffer.size() >= 2 ) {
m_tokenBuffer.erase( m_tokenBuffer.begin() );
} else {
if( it != itEnd )
++it;
loadBuffer();
}
return *this;
} | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
cmpq $0x2, %rcx
jb 0x3c35a
leaq 0x10(%rbx), %rdi
callq 0x3c62e
jmp 0x3c372
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x3c36a
addq $0x20, %... | /diatomic[P]diy/tests/catch.hpp |
Catch::clara::detail::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::clara::detail::TokenStream const&) const | auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
struct ParserInfo {
ParserBase const* parser = nullptr;
size_t count = 0;
};
const size_t totalParsers = m_options.size() + m_args.size();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2148, %rsp # imm = 0x2148
movq %rcx, 0x10(%rsp)
movq %rdx, 0x78(%rsp)
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq 0x30(%rsi), %rbx
movq 0x38(%rsi), %r13
movq 0x50(%rsi), %rax
movq %rax, (%rsp)
movq 0x48(%rsi), %r15
leaq 0x140(%rsp), %r12
... | /diatomic[P]diy/tests/catch.hpp |
Catch::clara::detail::Parser Catch::clara::detail::Parser::operator|<Catch::clara::detail::Help>(Catch::clara::detail::Help const&) const | auto operator|( T const &other ) const -> Parser {
return Parser( *this ) |= other;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x4326a(%rip), %rbp # 0x85bf0
movq %rbp, 0x8(%rsp)
leaq 0x42b6e(%rip), %rax # 0x85500
movq %rax, 0x10(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsi), %rax
mo... | /diatomic[P]diy/tests/catch.hpp |
Catch::clara::detail::ParserRefImpl<Catch::clara::detail::Opt>::ParserRefImpl<double>(double&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ParserRefImpl( T &ref, std::string const &hint )
: m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint )
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4253b(%rip), %rax # 0x859c0
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movl $0x20, %edi
callq 0x11530
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x42b8a(%rip), %rcx # 0x86038
movq %rcx, (%rax)
... | /diatomic[P]diy/tests/catch.hpp |
backward::TraceResolverLinuxBase::~TraceResolverLinuxBase() | TraceResolverLinuxBase()
: argv0_(get_argv0()), exec_path_(read_symlink("/proc/self/exe")) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x2b79d(%rip), %rax # 0x86bd8
movq %rax, (%rdi)
movq 0x40(%rdi), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x5b450
callq 0x114f0
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x5b462
callq 0x114f0
leaq 0x2b79f(%rip), %rax # 0x86c08
movq %rax, (%rbx)
cmpb $0x0... | /diatomic[P]diy/tests/backward/backward.hpp |
backward::Printer::print_trace(std::ostream&, backward::ResolvedTrace const&, backward::Colorize&) | void print_trace(std::ostream &os, const ResolvedTrace &trace,
Colorize &colorize) {
os << "#" << std::left << std::setw(2) << trace.idx << std::right;
bool already_indented = true;
if (!trace.source.filename.size() || object) {
os << " Object \"" << trace.object_filename << "\",... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x3fca(%rip), %rsi # 0x5fa81
movl $0x1, %edx
movq %r15, %rdi
callq 0x11630
movq (%r15), %rax
movq -0x18(%rax), %rcx
movl $0xffffff4f, %ebx # imm = 0xFF... | /diatomic[P]diy/tests/backward/backward.hpp |
main | int main()
{
struct test {
const char* name;
void (*test_func)();
};
test tests[] = {
{
"== any_of",
[]{
REQUIRE(zero == any_of(0,1,2));
REQUIRE(zero == any_of(1,0,3));
REQUIRE(zero == any_of(1,2,0));
REQUIRE(!(zero == any_of(1,2,3)));
... | pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
movl $0x0, -0x4(%rbp)
leaq -0x270(%rbp), %rdi
leaq 0x2b760(%rip), %rsi # 0x2da80
movl $0x260, %edx # imm = 0x260
callq 0x20c0
movl $0x0, -0x274(%rbp)
leaq -0x270(%rbp), %rax
movq %rax, -0x280(%rbp)
movq -0x280(%rbp), %rax
movq %rax, -0... | /rollbear[P]dry-comparisons/self_test.cpp |
std::basic_ostream<char, std::char_traits<char>>& rollbear::internal::logical_tuple<int, int, int>::print<char, std::char_traits<char>>(char const*, std::basic_ostream<char, std::char_traits<char>>&) const | std::basic_ostream<Char, Traits>& print(const Char* label, std::basic_ostream<Char, Traits>& os) const
{
os << label << '{';
std::apply([&os](const auto& ... v) {
int first = 1;
((os << &","[std::exchange(first, 0)] << v),...);
}, self());
return os << '}';
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20e0
movq %rax, %rdi
movl $0x7b, %esi
callq 0x2130
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -... | /rollbear[P]dry-comparisons/dry-comparisons.hpp |
flexfloat_exp | int_fast16_t flexfloat_exp(const flexfloat_t *a)
{
int_fast16_t a_exp = EXPONENT(CAST_TO_INT(a->value));
int_fast16_t bias = flexfloat_bias(a->desc);
if(a_exp == 0 || a_exp == INF_EXP)
return a_exp;
else
return (a_exp - BIAS) + bias;
} | movq (%rdi), %rax
shrq $0x34, %rax
andq $0x7ff, %rax # imm = 0x7FF
je 0x2315
cmpl $0x7ff, %eax # imm = 0x7FF
je 0x2315
movb 0x8(%rdi), %cl
decb %cl
movq $-0x1, %rdx
shlq %cl, %rdx
notq %rdx
addq %rdx, %rax
addq $-0x3ff, %rax # imm = 0xFC01
retq
| /oprecomp[P]flexfloat/src/flexfloat.c |
flexfloat_pack_bits | uint_t flexfloat_pack_bits(flexfloat_desc_t desc, uint_t bits)
{
bool sign = (bits >> (desc.exp_bits + desc.frac_bits)) & 0x1;
int_fast16_t exp = (bits >> desc.frac_bits) & ((0x1<<desc.exp_bits) - 1);
uint_t frac = bits & ((UINT_C(1)<<desc.frac_bits) - 1);
if(exp == 0 && frac == 0)
{
return... | pushq %rbx
movl %edi, %eax
shrl $0x8, %eax
movl $0xff, %ebx
movl %eax, %edx
andl %ebx, %edx
leal (%rdi,%rdx), %ecx
movl $0x1, %r9d
shlq %cl, %r9
movq %rsi, %r8
movl %eax, %ecx
shrq %cl, %r8
movl $0xffffffff, %r10d # imm = 0xFFFFFFFF
movl %edi, %ecx
shll %cl, %r10d
movl $0x1, %r11d
notl %r10d
andl %r10d, %r8d
movl ... | /oprecomp[P]flexfloat/src/flexfloat.c |
flexfloat_get_bits | uint_t flexfloat_get_bits(flexfloat_t *a)
{
int_fast16_t exp = flexfloat_exp(a);
uint_t frac = flexfloat_frac(a);
if(exp == INF_EXP)
exp = flexfloat_inf_exp(a->desc);
else if(exp <= 0) {
frac = flexfloat_denorm_frac(a, exp);
exp = 0;
}
return ((uint_t)flexfloat_sign(a) ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x22e4
movq (%rbx), %r15
movabsq $0xfffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFF
andq %r15, %rdx
movzbl 0x9(%rbx), %r14d
movb $0x34, %cl
subb %r14b, %cl
shrq %cl, %rdx
cmpq $0x7ff, %rax # imm = 0x7FF
jne 0x2588
movb 0x8(%rbx), %cl
movq $-0x1, %rax
shlq %... | /oprecomp[P]flexfloat/src/flexfloat.c |
flexfloat_sticky_bit | bool flexfloat_sticky_bit(const flexfloat_t *a, int_fast16_t exp)
{
if(exp <= 0 && EXPONENT(CAST_TO_INT(a->value)) != 0)
{
int shift = (- exp + 1);
uint_t denorm = 0;
if(shift < NUM_BITS)
denorm = ((CAST_TO_INT(a->value) & MASK_FRAC) | MASK_FRAC_MSB) >> shift;
return ... | movabsq $0x7ffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFF
testq %rsi, %rsi
jle 0x262a
movb 0x9(%rdi), %cl
shrq %cl, %rdx
testq %rdx, (%rdi)
setne %al
retq
movq (%rdi), %r8
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
testq %rax, %r8
je 0x261d
movabsq $0xfffffffffffff, %r9 # imm = 0xFFFFFFFFFFFFF
movl $0... | /oprecomp[P]flexfloat/src/flexfloat.c |
flexfloat_rounding_value | int_t flexfloat_rounding_value(const flexfloat_t *a, int_fast16_t exp, bool sign)
{
if(EXPONENT(CAST_TO_INT(a->value)) == 0) // Denorm backend format
{
return flexfloat_denorm_pack(a->desc, sign, 0x1);
}
else if(exp <= 0) // Denorm target format
{
return flexfloat_pack(a->desc, sign,... | movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movzwl 0x6(%rdi), %eax
testl $0x7ff0, %eax # imm = 0x7FF0
je 0x278e
movb 0x8(%rdi), %al
leal -0x1(%rax), %ecx
movq $-0x1, %r9
movq $-0x1, %r10
shlq %cl, %r10
movl %eax, %ecx
shlq %cl, %r9
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
... | /oprecomp[P]flexfloat/src/flexfloat.c |
flexfloat_sanitize | void flexfloat_sanitize(flexfloat_t *a)
{
bool sign;
int_fast16_t exp;
int_fast16_t inf_exp;
uint_t frac;
// Sign
sign = flexfloat_sign(a);
// Exponent
exp = flexfloat_exp(a);
// This case does not require to be sanitized (except for NaNs)
if(a->desc.exp_bits == NUM_BITS_EXP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
callq 0x22e4
movq %rax, %r14
cmpb $0xb, 0x8(%rbx)
jne 0x2803
cmpb $0x34, 0x9(%rbx)
je 0x2a31
movl $0x7ff, %r15d # imm = 0x7FF
cmpq $0x7ff, %r14 # imm = 0x7FF
je 0x28f4
cmpb $0x34, 0x9(%rbx... | /oprecomp[P]flexfloat/src/flexfloat.c |
ff_init | INLINE void ff_init(flexfloat_t *obj, flexfloat_desc_t desc) {
obj->value = 0.0;
#ifdef FLEXFLOAT_TRACKING
obj->exact_value = 0.0;
obj->tracking_fn = 0;
obj->tracking_arg = 0;
#endif
obj->desc = desc;
} | movq $0x0, (%rdi)
movw %si, 0x8(%rdi)
retq
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_init_float | INLINE void ff_init_float(flexfloat_t *obj, float value, flexfloat_desc_t desc) {
obj->value = (fp_t)value;
#ifdef FLEXFLOAT_TRACKING
obj->exact_value = (fp_t)value;
obj->tracking_fn = 0;
obj->tracking_arg = 0;
#endif
obj->desc = desc;
flexfloat_sanitize(obj);
} | cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rdi)
movw %si, 0x8(%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_init_double | INLINE void ff_init_double(flexfloat_t *obj, double value, flexfloat_desc_t desc) {
obj->value = (fp_t)value;
#ifdef FLEXFLOAT_TRACKING
obj->exact_value = (fp_t)value;
obj->tracking_fn = 0;
obj->tracking_arg = 0;
#endif
obj->desc = desc;
flexfloat_sanitize(obj);
} | movsd %xmm0, (%rdi)
movw %si, 0x8(%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_init_float128 | INLINE void ff_init_float128(flexfloat_t *obj, __float128 value, flexfloat_desc_t desc) {
obj->value = (fp_t)value;
#ifdef FLEXFLOAT_TRACKING
obj->exact_value = (fp_t)value;;
obj->tracking_fn = 0;
obj->tracking_arg = 0;
#endif
obj->desc = desc;
flexfloat_sanitize(obj);
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x3120
movsd %xmm0, (%r14)
movw %bx, 0x8(%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_init_int | INLINE void ff_init_int(flexfloat_t *obj, int value, flexfloat_desc_t desc) {
obj->value = (fp_t)value;
#ifdef FLEXFLOAT_TRACKING
obj->exact_value = (fp_t)value;
obj->tracking_fn = 0;
obj->tracking_arg = 0;
#endif
obj->desc = desc;
flexfloat_sanitize(obj);
} | cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rdi)
movw %dx, 0x8(%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_init_long | INLINE void ff_init_long(flexfloat_t *obj, long value, flexfloat_desc_t desc) {
obj->value = (fp_t)value;
#ifdef FLEXFLOAT_TRACKING
obj->exact_value = (fp_t)value;
obj->tracking_fn = 0;
obj->tracking_arg = 0;
#endif
obj->desc = desc;
flexfloat_sanitize(obj);
} | cvtsi2sd %rsi, %xmm0
movsd %xmm0, (%rdi)
movw %dx, 0x8(%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_cast | INLINE void ff_cast(flexfloat_t *obj, const flexfloat_t *source, flexfloat_desc_t desc ) {
obj->value = source->value;
#ifdef FLEXFLOAT_TRACKING
obj->exact_value = source->exact_value;
obj->tracking_fn = 0;
obj->tracking_arg = 0;
#endif
obj->desc = desc;
if(desc.exp_bits != source->desc... | movzbl %dh, %eax
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
movb %dl, 0x8(%rdi)
movb %al, 0x9(%rdi)
cmpb %dl, 0x8(%rsi)
jne 0x27da
movzbl 0x9(%rsi), %ecx
cmpw %cx, %ax
jne 0x27da
retq
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_inverse | INLINE void ff_inverse(flexfloat_t *dest, const flexfloat_t *a) {
assert((dest->desc.exp_bits == a->desc.exp_bits) && (dest->desc.frac_bits == a->desc.frac_bits));
dest->value = - a->value;
#ifdef FLEXFLOAT_TRACKING
dest->exact_value = - a->exact_value;
if(dest->tracking_fn) (dest->tracking_fn)(dest... | movsd (%rsi), %xmm0
xorps 0x1587(%rip), %xmm0 # 0x40b0
movlps %xmm0, (%rdi)
retq
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_add_any | INLINE void ff_add_any(flexfloat_t *dest, const flexfloat_t *a, const flexfloat_t *b) {
dest->value = a->value + b->value;
#ifdef FLEXFLOAT_TRACKING
dest->exact_value = a->exact_value + b->exact_value;
if(dest->tracking_fn) (dest->tracking_fn)(dest, dest->tracking_arg);
#endif
flexfloat_sanitize... | movsd (%rsi), %xmm0
addsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_sub | INLINE void ff_sub(flexfloat_t *dest, const flexfloat_t *a, const flexfloat_t *b) {
assert((dest->desc.exp_bits == a->desc.exp_bits) && (dest->desc.frac_bits == a->desc.frac_bits) &&
(a->desc.exp_bits == b->desc.exp_bits) && (a->desc.frac_bits == b->desc.frac_bits));
dest->value = a->value - b->value... | movsd (%rsi), %xmm0
subsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_sub_any | INLINE void ff_sub_any(flexfloat_t *dest, const flexfloat_t *a, const flexfloat_t *b) {
dest->value = a->value - b->value;
#ifdef FLEXFLOAT_TRACKING
dest->exact_value = a->exact_value - b->exact_value;
if(dest->tracking_fn) (dest->tracking_fn)(dest, dest->tracking_arg);
#endif
flexfloat_sanitize... | movsd (%rsi), %xmm0
subsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_mul | INLINE void ff_mul(flexfloat_t *dest, const flexfloat_t *a, const flexfloat_t *b) {
assert((dest->desc.exp_bits == a->desc.exp_bits) && (dest->desc.frac_bits == a->desc.frac_bits) &&
(a->desc.exp_bits == b->desc.exp_bits) && (a->desc.frac_bits == b->desc.frac_bits));
dest->value = a->value * b->value... | movsd (%rsi), %xmm0
mulsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_mul_any | INLINE void ff_mul_any(flexfloat_t *dest, const flexfloat_t *a, const flexfloat_t *b) {
dest->value = a->value * b->value;
#ifdef FLEXFLOAT_TRACKING
dest->exact_value = a->exact_value * b->exact_value;
if(dest->tracking_fn) (dest->tracking_fn)(dest, dest->tracking_arg);
#endif
flexfloat_sanitize... | movsd (%rsi), %xmm0
mulsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_div | INLINE void ff_div(flexfloat_t *dest, const flexfloat_t *a, const flexfloat_t *b) {
assert((dest->desc.exp_bits == a->desc.exp_bits) && (dest->desc.frac_bits == a->desc.frac_bits) &&
(a->desc.exp_bits == b->desc.exp_bits) && (a->desc.frac_bits == b->desc.frac_bits));
dest->value = a->value / b->value... | movsd (%rsi), %xmm0
divsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_div_any | INLINE void ff_div_any(flexfloat_t *dest, const flexfloat_t *a, const flexfloat_t *b) {
dest->value = a->value / b->value;
#ifdef FLEXFLOAT_TRACKING
dest->exact_value = a->exact_value / b->exact_value;
if(dest->tracking_fn) (dest->tracking_fn)(dest, dest->tracking_arg);
#endif
flexfloat_sanitize... | movsd (%rsi), %xmm0
divsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_sqrt | INLINE void ff_sqrt(flexfloat_t *dest, const flexfloat_t *a) {
assert((dest->desc.exp_bits == a->desc.exp_bits) && (dest->desc.frac_bits == a->desc.frac_bits));
dest->value = sqrt(a->value);
#ifdef FLEXFLOAT_TRACKING
dest->exact_value = sqrt(a->value);
if(dest->tracking_fn) (dest->tracking_fn)(dest,... | pushq %rbx
movq %rdi, %rbx
movsd (%rsi), %xmm0
callq 0x20b0
movsd %xmm0, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_sqrt_any | INLINE void ff_sqrt_any(flexfloat_t *dest, const flexfloat_t *a) {
dest->value = sqrt(a->value);
#ifdef FLEXFLOAT_TRACKING
dest->exact_value = sqrt(a->exact_value);
if(dest->tracking_fn) (dest->tracking_fn)(dest, dest->tracking_arg);
#endif
flexfloat_sanitize(dest);
#ifdef FLEXFLOAT_STATS
... | pushq %rbx
movq %rdi, %rbx
movsd (%rsi), %xmm0
callq 0x20b0
movsd %xmm0, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_acc | INLINE void ff_acc(flexfloat_t *dest, const flexfloat_t *a) {
assert((dest->desc.exp_bits == a->desc.exp_bits) && (dest->desc.frac_bits == a->desc.frac_bits));
dest->value += a->value;
#ifdef FLEXFLOAT_TRACKING
dest->exact_value += a->exact_value;
if(dest->tracking_fn) (dest->tracking_fn)(dest, dest... | movsd (%rdi), %xmm0
addsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_acc_any | INLINE void ff_acc_any(flexfloat_t *dest, const flexfloat_t *a) {
dest->value += a->value;
#ifdef FLEXFLOAT_TRACKING
dest->exact_value += a->exact_value;
if(dest->tracking_fn) (dest->tracking_fn)(dest, dest->tracking_arg);
#endif
flexfloat_sanitize(dest);
#ifdef FLEXFLOAT_STATS
// TODO S... | movsd (%rdi), %xmm0
addsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
jmp 0x27da
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_min | INLINE void ff_min(flexfloat_t *dest, const flexfloat_t *a, const flexfloat_t *b) {
assert((dest->desc.exp_bits == a->desc.exp_bits) && (dest->desc.frac_bits == a->desc.frac_bits) &&
(a->desc.exp_bits == b->desc.exp_bits) && (a->desc.frac_bits == b->desc.frac_bits));
dest->value = fmin(a->value,b->va... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movsd (%rsi), %xmm0
movsd (%rdx), %xmm1
callq 0x2090
movsd %xmm0, (%rbx)
movsd (%r15), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
ucomisd %xmm0, %xmm1
setp %al
setne %cl
orb %al, %cl
jne 0x2c62
ucomisd (%r14), %xmm0
setp... | /oprecomp[P]flexfloat/src/flexfloat.c |
ff_max | INLINE void ff_max(flexfloat_t *dest, const flexfloat_t *a, const flexfloat_t *b) {
assert((dest->desc.exp_bits == a->desc.exp_bits) && (dest->desc.frac_bits == a->desc.frac_bits) &&
(a->desc.exp_bits == b->desc.exp_bits) && (a->desc.frac_bits == b->desc.frac_bits));
dest->value = fmax(a->value,b->va... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movsd (%rsi), %xmm0
movsd (%rdx), %xmm1
callq 0x2060
movsd %xmm0, (%rbx)
movsd (%r15), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
ucomisd %xmm0, %xmm1
setp %al
setne %cl
orb %al, %cl
jne 0x2cc0
ucomisd (%r14), %xmm0
setp... | /oprecomp[P]flexfloat/src/flexfloat.c |
ff_fma | INLINE void ff_fma(flexfloat_t *dest, const flexfloat_t *a, const flexfloat_t *b, const flexfloat_t *c) {
assert((dest->desc.exp_bits == a->desc.exp_bits) && (dest->desc.frac_bits == a->desc.frac_bits) &&
(a->desc.exp_bits == b->desc.exp_bits) && (a->desc.frac_bits == b->desc.frac_bits) &&
(b-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2080
movl %eax, %ebp
cmpb $0x34, 0x9(%r14)
setb %al
testl %ebp, %ebp
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2d6c
movq (%r12), %rax
xorq (%r15), %rax
xorq (%r14), %rax... | /oprecomp[P]flexfloat/src/flexfloat.c |
ff_le | INLINE bool ff_le(const flexfloat_t *a, const flexfloat_t *b) {
assert((a->desc.exp_bits == b->desc.exp_bits) && (a->desc.frac_bits == b->desc.frac_bits));
#if defined(FLEXFLOAT_FLAGS) && !defined(FLEXFLOAT_CORRECT_CMP_FLAGS)
if (isnan(a->value) || isnan(b->value))
feraiseexcept(FE_INVALID);
#en... | movsd (%rsi), %xmm0
comisd (%rdi), %xmm0
setae %al
retq
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_lt | INLINE bool ff_lt(const flexfloat_t *a, const flexfloat_t *b) {
assert((a->desc.exp_bits == b->desc.exp_bits) && (a->desc.frac_bits == b->desc.frac_bits));
#if defined(FLEXFLOAT_FLAGS) && !defined(FLEXFLOAT_CORRECT_CMP_FLAGS)
if (isnan(a->value) || isnan(b->value))
feraiseexcept(FE_INVALID);
#en... | movsd (%rsi), %xmm0
comisd (%rdi), %xmm0
seta %al
retq
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_ge | INLINE bool ff_ge(const flexfloat_t *a, const flexfloat_t *b) {
assert((a->desc.exp_bits == b->desc.exp_bits) && (a->desc.frac_bits == b->desc.frac_bits));
#if defined(FLEXFLOAT_FLAGS) && !defined(FLEXFLOAT_CORRECT_CMP_FLAGS)
if (isnan(a->value) || isnan(b->value))
feraiseexcept(FE_INVALID);
#en... | movsd (%rdi), %xmm0
comisd (%rsi), %xmm0
setae %al
retq
| /oprecomp[P]flexfloat/src/flexfloat.c |
ff_gt | INLINE bool ff_gt(const flexfloat_t *a, const flexfloat_t *b) {
assert((a->desc.exp_bits == b->desc.exp_bits) && (a->desc.frac_bits == b->desc.frac_bits));
#if defined(FLEXFLOAT_FLAGS) && !defined(FLEXFLOAT_CORRECT_CMP_FLAGS)
if (isnan(a->value) || isnan(b->value))
feraiseexcept(FE_INVALID);
#en... | movsd (%rdi), %xmm0
comisd (%rsi), %xmm0
seta %al
retq
nop
| /oprecomp[P]flexfloat/src/flexfloat.c |
calc_uuid[abi:cxx11](RenX::PlayerInfo&) | std::string calc_uuid(RenX::PlayerInfo &player)
{
return player.name;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x7060
movq %rbx, %rax
popq %rbx
retq
nop
| /JAJames[P]Jupiter-Bot/src/Plugins/RenX/RenX.NicknameUUID/RenX_NicknameUUID.cpp |
Process::close(unsigned int) | void Process::close(uint streams)
{
#ifdef _WIN32
if(streams & stdinStream && hStdInWrite != INVALID_HANDLE_VALUE)
{
CloseHandle(hStdInWrite);
hStdInWrite = INVALID_HANDLE_VALUE;
}
if(streams & stdoutStream && hStdOutRead != INVALID_HANDLE_VALUE)
{
CloseHandle(hStdOutRead);
hStdOutRead = INVAL... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testb $0x4, %bpl
je 0x3de7
movl 0x8(%rbx), %edi
testl %edi, %edi
je 0x3de7
callq 0x2410
movl $0x0, 0x8(%rbx)
testb $0x1, %bpl
je 0x3dfe
movl (%rbx), %edi
testl %edi, %edi
je 0x3dfe
callq 0x2410
movl $0x0, (%rbx)
testb $0x2, %bpl
je 0x3e17
movl 0x4(%rbx), ... | /craflin[P]libnstd/src/Process.cpp |
Process::read(void*, unsigned long) | ssize Process::read(void* buffer, usize len)
{
#ifdef _WIN32
DWORD i;
#ifdef _AMD64
byte* bufferStart = (byte*)buffer;
while(len > (usize)INT_MAX)
{
if(!ReadFile(hStdOutRead, buffer, INT_MAX, &i, NULL))
{
if(GetLastError() == ERROR_BROKEN_PIPE)
return (byte*)buffer - bufferStart;
ret... | movl (%rdi), %edi
jmp 0x2300
nop
| /craflin[P]libnstd/src/Process.cpp |
String::fromHex(unsigned char const*, unsigned long) | String String::fromHex(const byte* data, usize size)
{
String result;
result.resize(size * 2);
char* dest = result;
const char* hex = "0123456789ABCDEF";
for(const byte* src = data, * end = data + size; src < end; ++src)
{
dest[0] = hex[*src >> 4];
dest[1] = hex[*src & 0xf];
dest += 2;
}
re... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4b93(%rip), %rax # 0xb4b8
movq %rax, (%rdi)
addq %rdx, %rdx
movq %rdx, %rsi
callq 0x30aa
movq (%rbx), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x30aa
testq %r14, %r14
jle 0x697f
addq %r15, %r14
movq (%rbx... | /craflin[P]libnstd/src/String.cpp |
CCEXP::CCEXPMat<unsigned char>::StoreData(_IO_FILE*) | int CCEXPMat<T>::StoreData(FILE* fp) {
if (IgnoreM) return 0;
CECS_ERRI(CCEXPECS,fp == NULL,"CCEXPMat::StoreData():: File pointer is NULL! (!%u!)");
uint64_t N = (uint64_t)data.size();
uint64_t typeSize = (uint64_t)sizeof(T);
uint64_t _maxRows64 = (uint64_t)_maxRows;
fwrite(name,sizeof(char),64,fp); /// Table, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
xorl %ebp, %ebp
cmpb $0x0, 0x8a(%rdi)
jne 0x14245
testq %rsi, %rsi
je 0x140af
movq %rdi, %r14
movq 0x98(%rdi), %rax
subq 0x90(%rdi), %rax
sarq $0x6, %rax
leaq 0x20(%rsp), %r13
movq %rax, (%r13)
leaq 0x10(%rsp), %rbp
movq $0x1, (%rbp)
mov... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
CCEXP::CCEXPMat<int>::AppendRow(unsigned long, int*, unsigned long) | int CCEXPMat<T>::AppendRow(size_t row, T* ptr, size_t n) {
if (IgnoreM) return 0;
MVECTOR<T>* it = getDataRowPtr(row); CECS_ERRI(CCEXPECS, it == nullptr, "CCEXPMat::AppendRow():: 'it' is nullptr");
const size_t currentData = (*it).size();
(*it).resize(currentData + n);
T* Dptr = (*it).data();
memcpy(&Dptr[current... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %ebx, %ebx
cmpb $0x0, 0x8a(%rdi)
jne 0x18bbd
movq %rcx, %r14
movq %rdx, %r15
callq 0x16854
testq %rax, %rax
je 0x18b8c
movq %rax, %r12
movq 0x10(%rax), %r13
leaq (%r14,%r13), %rsi
movq %rax, %rdi
callq 0x168f4
shlq $0x2, %r13
addq 0x8(%r12), %r13
shlq $0x2, %r... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
void CCEXP::AddTable<short>(CCEXP::CCEXP&, char const*, char const*, unsigned long) | inline void AddTable (
CCEXP &obj,
const char* matname,
const char* typeName,
size_t MaxRows = 0
) {
obj.ErrorId = 0;
if (!obj.isActive) return;
CECS_ERR(CCEXPECS,obj.Status != CCEXPORTMAT_READY,"[%s]: AddTable():: CCEXP object has wrong status." , obj.SavingFile );
obj.Status = CCEXPORTMAT_ACTIVE;
size_t rd =... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl $0x0, 0x14(%rdi)
cmpb $0x1, 0x10(%rdi)
jne 0x1b4a2
movq %rdi, %rbx
cmpl $0x1, 0x8(%rdi)
jne 0x1b46e
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movl $0x2, 0x8(%rbx)
movq %rbx, %rdi
callq 0xcba0
testq %rax, %rax
je 0x1b4b0
addq $0x70, %rbx
... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
void CCEXP::AddVal<short>(CCEXP::CCEXP&, char const*, short) | void AddVal(
CCEXP &obj, const char* matname, T val
) {
obj.ErrorId = 0;
size_t sel = obj.getTableIndexByName(matname);
CECS_ERR(CCEXPECS,sel == MAXSIZE_T,"[%s]: AddVal():: Failed to find table with name [%s]!", obj.SavingFile, matname);
AddVal(obj, sel, val);
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0x14(%rdi)
callq 0xcb48
cmpq $-0x1, %rax
je 0x1b8d4
movl $0x0, 0x14(%rbx)
cmpb $0x1, 0x10(%rbx)
jne 0x1b972
cmpl $0x1, 0x8(%rbx)
jne 0x1b903
movq %rax, %r10
movl $0x2, 0x8(%rbx)
cmpq %rax, 0x40(%rbx)
jbe 0x1b934
movq 0x38(%rbx),... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x2271a
movb $0x0, 0x18(%rbx)
jmp 0x22725
movq %rbx, %rdi
callq 0x7968e
movl %eax, 0x14(%rbx)
movl 0x14(%rbx), %eax
cmpl $-0x1, %eax
je 0x2273d
leaq 0x38(%rbx),... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vecto... | char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x2277a
movb $0x0, 0x18(%rbx)
jmp 0x2278f
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x227be
movzbl (%rcx), %eax
incq %rcx
movq %rcx, (%rbx)
movl %eax, 0x14(%rbx... | /ggerganov[P]llama/common/json.hpp |
sigint_handler(int) | static void sigint_handler(int signo) {
if (signo == SIGINT) {
if (!is_interacting && g_params->interactive) {
is_interacting = true;
need_insert_eot = true;
} else {
console::cleanup();
LOG("\n");
common_perf_print(*g_ctx, *g_smpl);
... | cmpl $0x2, %edi
jne 0x2a863
cmpb $0x0, 0x13f795(%rip) # 0x169fd8
jne 0x2a864
movq 0x13f774(%rip), %rax # 0x169fc0
cmpb $0x1, 0x101d(%rax)
jne 0x2a864
movb $0x1, %al
movb %al, 0x13f77b(%rip) # 0x169fd8
movb %al, 0x13f776(%rip) # 0x169fd9
retq
pushq %rbx
callq 0x101919
leaq 0x1401af(%rip), %rbx # 0x16aa2... | /ggerganov[P]llama/examples/main/main.cpp |
common_arg::to_string[abi:cxx11]() | std::string common_arg::to_string() {
// params for printing to console
const static int n_leading_spaces = 40;
const static int n_char_per_line_help = 70; // TODO: detect this based on current console
std::string leading_spaces(n_leading_spaces, ' ');
std::ostringstream ss;
for (const auto arg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x558, %rsp # imm = 0x558
movq %rsi, %r14
movq %rdi, 0xd8(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x18(%rsp), %rdi
movl $0x28, %esi
movl $0x20, %edx
callq 0x21a60
leaq 0x3e0(%rsp), %rdi
callq 0x22140
movq 0x60(%r14), %r12... | /ggerganov[P]llama/common/arg.cpp |
get_all_kv_cache_types[abi:cxx11]() | static std::string get_all_kv_cache_types() {
std::ostringstream msg;
for (const auto & type : kv_cache_types) {
msg << ggml_type_name(type) << (&type == &kv_cache_types.back() ? "" : ", ");
}
return msg.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x22140
movq 0x10ba40(%rip), %r12 # 0x169fe0
movq 0x10ba41(%rip), %r13 # 0x169fe8
cmpq %r13, %r12
je 0x5e635
leaq 0xb8b8c(%rip), %rbp # 0x117143
leaq 0x... | /ggerganov[P]llama/common/arg.cpp |
list_builtin_chat_templates[abi:cxx11]() | static std::string list_builtin_chat_templates() {
std::vector<const char *> supported_tmpl;
int32_t res = llama_chat_builtin_templates(nullptr, 0);
supported_tmpl.resize(res);
res = llama_chat_builtin_templates(supported_tmpl.data(), supported_tmpl.size());
std::ostringstream msg;
for (auto & t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
xorl %edi, %edi
xorl %esi, %esi
callq 0x21da0
movslq %eax, %rsi
movq %rsp, %rdi
callq 0x940e8
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
... | /ggerganov[P]llama/common/arg.cpp |
curl_perform_with_retry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void*, int, int) | static bool curl_perform_with_retry(const std::string & url, CURL * curl, int max_attempts, int retry_delay_seconds) {
int remaining_attempts = max_attempts;
while (remaining_attempts > 0) {
LOG_INF("%s: Trying to download from %s (attempt %d of %d)...\n", __func__ , url.c_str(), max_attempts - remaini... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movl $0x3, %r12d
leaq 0x18(%rsp), %rbp
movl %r12d, %r14d
leaq 0x109048(%rip), %rax # 0x16aa20
movl (%rax), %eax
testl %r12d, %r12d
jle 0x61af4
testl %eax, %eax
js 0x61a21
callq 0x112a5f
movq 0x10(... | /ggerganov[P]llama/common/arg.cpp |
common_arg::common_arg(std::initializer_list<char const*> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&)) | common_arg(
const std::initializer_list<const char *> & args,
const std::string & help,
void (*handler)(common_params & params)
) : args(args), help(help), handler_void(handler) {} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
leaq 0xb(%rsp), %rcx
leaq 0xa(%rsp), %r8
movl $0x1, %edx
callq 0x887f6
leaq 0x38(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %... | /ggerganov[P]llama/common/arg.h |
nlohmann::json_abi_v3_11_3::detail::input_stream_adapter::get_character() | std::char_traits<char>::int_type get_character()
{
auto res = sb->sbumpc();
// set eof manually, as we don't use the istream interface.
if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
{
is->clear(is->rdstate() | std::ios::eofbit);
}
return ... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x796ba
movzbl (%rax), %ebp
incq %rax
movq %rax, 0x10(%rdi)
cmpl $-0x1, %ebp
je 0x796c4
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rdi), %rax
callq *0x50(%rax)
movl %eax, %ebp
jmp 0... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x6, %rdx
ja 0x797ec
movq %rdx, %r12
movl $0x54, %eax
btq %rdx, %rax
jae 0x797ec
movq %rsi, %r14
movq %rdi, %rbx
movsbl 0x14(%rdi), %esi
leaq 0x50(%rdi), %r15
movq %r15, %rdi
callq 0x224f0
testq %r12, %r12
sete %bpl
je 0x797dd
leaq (%r14,%r12,4), %r12
movq %r... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsign... | json_sax_dom_callback_parser(BasicJsonType& r,
const parser_callback_t cb,
const bool allow_exceptions_ = true)
: root(r), callback(cb), allow_exceptions(allow_exceptions_)
{
keep_stack.push_back(true);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x20(%rdi), %r14
leaq 0x80(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups... | /ggerganov[P]llama/common/json.hpp |
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> ... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x7cee6
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
leaq ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::alloc... | pointer operator->() const
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
return &(m_it.object_iterator->secon... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x7d8ac
movq %rdi, %r14
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x7d80f
cmpl $0x1, %ecx
jne 0x7d83c
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%r14), %rax
cmpq %rcx, %rax
je 0x7d8c8
addq $0x40, %rax
jmp 0x7d843
movq 0x8... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::alloc... | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
... | pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x7dbce
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x7dbbe
cmpl $0x1, %eax
jne 0x7dbc5
movq 0x8(%rbx), %rdi
callq 0x22180
movq %rax, 0x8(%rbx)
jmp 0x7dbc9
addq $0x10, 0x10(%rbx)
jmp 0x7dbc9
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xa2181(%rip), %r... | /ggerganov[P]llama/common/json.hpp |
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> ... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x7f926
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](nlohmann::json_abi_v3_11_3::detail::position_t const&) | static std::string position_string(const position_t& pos)
{
return concat(" at line ", std::to_string(pos.lines_read + 1),
", column ", std::to_string(pos.chars_read_current_line));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
incq %r15
movl $0x1, %ebp
movabsq $0x346dc5d63886594b, %r13 # imm = 0x346DC5D63886594B
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x8094a
movl $0x4, %esi
movq %r15, %rcx
cmpq $0x63, %rcx
jbe ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allo... | serializer(output_adapter_t<char> s, const char ichar,
error_handler_t error_handler_ = error_handler_t::strict)
: o(std::move(s))
, loc(std::localeconv())
, thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r15, 0x8(%rdi)
movups (%rsi), %xmm0
movq %r15, 0x8(%rsi)
movups %xmm0, (%rdi)
movq %r15, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
mo... | /ggerganov[P]llama/common/json.hpp |
void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std:... | void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}... | pushq %rbx
testq %rsi, %rsi
je 0x8312a
movq %rsi, %rcx
leaq 0x10(%rdi), %rsi
testq %rcx, %rcx
js 0x8313b
movl $0x1, %r9d
cmpq $0xa, %rcx
jb 0x831af
movl $0x4, %r9d
movabsq $0x346dc5d63886594b, %r10 # imm = 0x346DC5D63886594B
movq %rcx, %r8
cmpq $0x63, %r8
jbe 0x83198
cmpq $0x3e7, %r8 # imm = 0x3E7
jbe 0x831... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(char*, int, int, int, int) | inline char* format_buffer(char* buf, int len, int decimal_exponent,
int min_exp, int max_exp)
{
JSON_ASSERT(min_exp < 0);
JSON_ASSERT(max_exp > 0);
const int k = len;
const int n = len + decimal_exponent;
// v = buf * 10^(n-k)
// k is the length of the buffer (numbe... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %ecx, %ecx
jns 0x83aaa
testl %r8d, %r8d
jle 0x83ac6
movq %rdi, %rbx
leal (%rdx,%rsi), %r14d
testl %edx, %edx
sets %al
cmpl %r8d, %r14d
setg %dil
orb %al, %dil
je 0x83964
cmpl %r8d, %r14d
setg %al
testl %r14d, %r14d
setle %dil
orb %al, %dil
je 0x83992
cmpl %ec... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [6], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [12... | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rbp
movq %rbp, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x216d0
movq %rax, %r13
addq 0x8(%r15), %r13
movq %r14, %rdi
callq 0x216d0... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::cbegin() const | const_iterator cbegin() const noexcept
{
const_iterator result(this);
result.set_begin();
return result;
} | pushq %rbx
movq %rdi, %rbx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rax, 0x18(%rdi)
movzbl (%rsi), %ecx
cmpl $0x2, %ecx
je 0x8562a
cmpl $0x1, %ecx
jne 0x85634
leaq 0x8(%rbx), %rax
movq $0x0, (%rax)
jmp 0x85638
movq $0x0, 0x10(%rbx)
... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false)
{
basic_json result;
parser(deta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, %esi
callq 0x898e8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x898e8
movq (%r12), %r15
movq 0x8(%r12), %r12
mo... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vecto... | token_type scan_number() // lgtm [cpp/use-of-goto]
{
// reset token_buffer to store the number's bytes
reset();
// the type of the parsed number; initially set to unsigned; will be
// changed if minus sign, decimal point or exponent is read
token_type number_type = token_ty... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8a742
movl 0x14(%rbx), %eax
leal -0x31(%rax), %ecx
cmpl $0x9, %ecx
jae 0x8a4d2
leaq 0x50(%rbx), %r14
movl $0x5, %ebp
movsbl %al, %esi
movq %r14, %rdi
callq 0x224f0
leaq 0x50(%rbx), %r14
movq %rbx, %rdi
callq 0x22754
leal -0x30(%rax), %ecx
cm... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vecto... | std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if (static_cast<unsigned char>(c) <= '\x1F')
{
// escape control characters
std::array<char, 9> cs{{}};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %rbp
cmpq %rbp, %r13
je 0x8b92d
leaq 0x955f4(%rip), %r14 # 0x120ed2
leaq 0x8(%rsp), %r15
movzbl... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl... | ~json_sax_dom_callback_parser() = default; | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x898e8
movq %r14, %rdi
callq 0x8e276
movq 0x90(%rbx), %rax
testq %rax, %rax
je 0x8bcdd
leaq 0x80(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x48(%rbx), %rdi
callq 0x7bfee
leaq 0x20(%rbx), %rdi... | /ggerganov[P]llama/common/json.hpp |
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allo... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x8d704
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
leaq ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | size_type size() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return 0;
}
case value_t::array:
{
// delegate call to array_t::size()
... | movzbl (%rdi), %eax
testl %eax, %eax
je 0x8dd14
cmpl $0x1, %eax
je 0x8dcf1
cmpl $0x2, %eax
jne 0x8dd0f
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x4, %rax
retq
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAA... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x8e956
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::invalid_iterator nlohmann::json_abi_v3_11_3::detail::invalid_iterator::create<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double... | static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x91ffa(%rip), %rsi # 0x120d9f
leaq 0x92003(%rip), %rdx # 0x120daf
leaq 0x28(%rsp), %rdi
callq 0x2d5b8
leaq 0x48(%rsp), %rdi
leaq 0... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned c... | JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
... | movzbl (%rdi), %eax
cmpq $0x9, %rax
ja 0x8f197
leaq 0xd7a66(%rip), %rcx # 0x166bf8
movq (%rcx,%rax,8), %rax
retq
leaq 0x91d16(%rip), %rax # 0x120eb4
retq
nop
| /ggerganov[P]llama/common/json.hpp |
void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long,... | static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
{
j.m_data.m_value.destroy(j.m_data.m_type);
j.m_data.m_type = value_t::number_float;
j.m_data.m_value = val;
j.assert_invariant();
} | pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
addq $0x8, %rdi
movzbl (%rbx), %esi
callq 0x8e6c8
movb $0x7, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
addq $0x10, %rsp
popq %rbx
jmp 0x898e8
movq %rax, %rdi
callq 0x2c73f
| /ggerganov[P]llama/common/json.hpp |
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allo... | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x907c4
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializ... | bool end_object()
{
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(ref_stack.back()->is_object());
ref_stack.back()->set_parents();
ref_stack.pop_back();
return true;
} | pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x90f6c
movq -0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x90f88
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rcx
retq
leaq 0x8ede3(%rip), %rdi # 0x11fd56
leaq 0x866f1(%rip), %rdx # 0x11766b
leaq 0x8fdca(%rip), %rcx # 0x120d4b
movl $0x1aeb, ... | /ggerganov[P]llama/common/json.hpp |
std::vector<common_chat_tool, std::allocator<common_chat_tool>> common_chat_tools_parse_oaicompat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::vector<common_chat_tool> common_chat_tools_parse_oaicompat(const std::string & tools) {
return common_chat_tools_parse_oaicompat(json::parse(tools));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rsp, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x890e6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x96983
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x898e8
movq %r1... | /ggerganov[P]llama/common/chat.cpp |
common_chat_templates_apply(common_chat_templates const*, common_chat_templates_inputs const&) | common_chat_params common_chat_templates_apply(
const struct common_chat_templates * tmpls,
const struct common_chat_templates_inputs & inputs)
{
GGML_ASSERT(tmpls != nullptr);
return inputs.use_jinja
? common_chat_templates_apply_jinja(tmpls, inputs)
: common_chat_templates_apply_legacy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
testq %rsi, %rsi
je 0x988c2
movq %rdi, %rbx
cmpb $0x1, 0x59(%rdx)
jne 0x98481
movq %rbx, %rdi
callq 0x99439
movq %rbx, %rax
jmp 0x988b0
movq %rsi, 0x80(%rsp)
movq %rbx, 0x70(%rsp)
xorl %eax, %eax
movq %rax, 0x30(%rsp)
xorpd %xmm0, %xmm0
... | /ggerganov[P]llama/common/chat.cpp |
common_chat_templates_source(common_chat_templates const*, char const*) | const char * common_chat_templates_source(const struct common_chat_templates * tmpls, const char * variant) {
if (variant != nullptr) {
if (strcmp(variant, "tool_use") == 0) {
if (tmpls->template_tool_use) {
return tmpls->template_tool_use->source().c_str();
}
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x99187
movq %rsi, %r14
leaq 0x8bc33(%rip), %rsi # 0x124d7d
movq %r14, %rdi
callq 0x21f60
testl %eax, %eax
je 0x99197
leaq 0xd18c3(%rip), %rax # 0x16aa20
cmpl $0x0, (%rax)
jle 0x99187
callq 0x112a5f
leaq 0x8bc18(%rip), %rdx # 0x124d86
leaq... | /ggerganov[P]llama/common/chat.cpp |
common_chat_params_init_generic(minja::chat_template const&, templates_params const&) | static common_chat_params common_chat_params_init_generic(const common_chat_template & tmpl, const struct templates_params & inputs) {
common_chat_params data;
auto tool_call_schemas = json::array();
foreach_function(inputs.tools, [&](const json & tool) {
const auto & function = tool.at("function")... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x588, %rsp # imm = 0x588
movq %rdx, %r15
movq %rsi, %rbx
movl $0x0, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x30... | /ggerganov[P]llama/common/chat.cpp |
common_chat_params_init_mistral_nemo(minja::chat_template const&, templates_params const&) | static common_chat_params common_chat_params_init_mistral_nemo(const common_chat_template & tmpl, const struct templates_params & inputs) {
common_chat_params data;
data.grammar_lazy = inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_REQUIRED;
data.grammar = build_grammar([&](const common_grammar_builder & bui... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movl $0x0, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi... | /ggerganov[P]llama/common/chat.cpp |
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.