name string | code string | asm string | file string |
|---|---|---|---|
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3d05e(%rip), %r14 # 0x507b8
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::basic_string_view<char, std::char_traits<char>>) | Matcher<internal::StringView>::Matcher(internal::StringView s) {
*this = Eq(std::string(s));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3cd5e(%rip), %r14 # 0x507b8
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq (%rsi,%rdx), %rax
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xacba
leaq 0x1... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::internal::PrintTo(char32_t const*, std::ostream*) | void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x15647
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8370
leaq 0x28cc5(%rip), %rsi # 0x3e2da
movl $0xd, %edx
movq %rax, %rdi
callq 0x8560
movq $-0x1, %rsi
cmpl $0x0, 0x4(%r14,%rsi,4)
leaq 0x1(%rsi), %rsi
jne 0x15629
movq %r14, %rdi
movq... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(wchar_t const*, std::ostream*) | void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x156ad
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8370
leaq 0x28c57(%rip), %rsi # 0x3e2da
movl $0xd, %edx
movq %rax, %rdi
callq 0x8560
movq %r14, %rdi
callq 0x83c0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq ... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::PrintStringTo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::ostream*) | void PrintStringTo(const ::std::string& s, ostream* os) {
if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
if (GTEST_FLAG_GET(print_utf8)) {
ConditionalPrintAsText(s.data(), s.size(), os);
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x15908
testl %eax, %eax
je 0x158c0
cmpb $0x1, 0x3bec9(%rip) # 0x515c0
jne 0x158c0
movq %rbx, (%rsp)
movq (%r15), %r14
movq 0x8(%r15), %r15
testq ... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::TestPartResult::ExtractSummary[abi:cxx11](char const*) | std::string TestPartResult::ExtractSummary(const char* message) {
const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
return stack_trace == nullptr ? message : std::string(message, stack_trace);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x24bad(%rip), %rsi # 0x3a955
movq %r15, %rdi
callq 0x80e0
movq %rax, %rbx
testq %rax, %rax
je 0x15dcf
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xacba
jmp 0x15ddf
leaq 0xf(%rsp... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-test-part.cc |
testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&) | std::string AppendUserMessage(const std::string& gtest_msg,
const Message& user_msg) {
// Appends the user message if it's non-empty.
const std::string user_msg_string = user_msg.GetString();
if (user_msg_string.empty()) {
return gtest_msg;
}
if (gtest_msg.empty()) {
retu... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1a4e7
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x16d79
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x16d94
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
addq %r... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool) | void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
bool has_test_p) {
const auto& ignored = *GetIgnoredParameterizedTestSuites();
if (ignored.find(name) != ignored.end()) return;
const char kMissingInstantiation[] = //
" is defined via TEST_P, but nev... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x168d6
movq 0x3a78c(%rip), %r15 # 0x516f0
leaq 0x130(%r15), %rdi
movq %r14, %rsi
callq 0x37586
addq $0x138, %r15 # imm = 0x138
cmpq %r15, %ra... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::TypeParameterizedTestSuiteRegistry::RegisterTestSuite(char const*, testing::internal::CodeLocation) | void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
const char* test_suite_name, CodeLocation code_location) {
suites_.emplace(std::string(test_suite_name),
TypeParameterizedTestSuiteInfo(code_location));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9bba
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x9e50
movl 0x20(%r14), %eax
movl %eax, 0x28(%rsp)
leaq... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations() | void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
const auto& ignored = *GetIgnoredParameterizedTestSuites();
for (const auto& testcase : suites_) {
if (testcase.second.instantiated) continue;
if (ignored.find(testcase.first) != ignored.end()) continue;
std::string message =
"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %rbx
callq 0x168d6
movq 0x18(%rbx), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x17f7f
movq 0x39d09(%rip), %rax # 0x516f0
leaq 0x130(%rax), %rcx
movq %rcx, 0x128(%rsp)
addq $0x138, %rax # ... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::GetCurrentExecutableName() | FilePath GetCurrentExecutableName() {
FilePath result;
#if GTEST_OS_WINDOWS || GTEST_OS_OS2
result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
result.Set(FilePath(GetArgvs()[0]));
#endif // GTEST_OS_WINDOWS
return result.RemoveDirectoryName();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x394c2(%rip), %rsi # 0x51690
leaq 0x48(%rsp), %rdi
callq 0x2ed72
movq 0x48(%rsp), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestOptions::MatchesFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | bool UnitTestOptions::MatchesFilter(const std::string& name_str,
const char* filter) {
return UnitTestFilter(filter).MatchesName(name_str);
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x9bba
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x18d2a
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x18e38
movl %eax, %ebx
leaq 0x40(%rsp), %rdi
callq 0x33dc0
leaq 0x28(%rsp), %rdi
callq 0x2eac2
le... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::PositiveAndNegativeUnitTestFilter::MatchesTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool MatchesTest(const std::string& test_suite_name,
const std::string& test_name) const {
return MatchesName(test_suite_name + "." + test_name);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x9e50
leaq 0x23da5(%rip), %rsi # 0x3d265
movq %r15, %rdi
callq ... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::ScopedFakeTestPartResultReporter::Init() | void ScopedFakeTestPartResultReporter::Init() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
old_reporter_ = impl->GetGlobalTestPartResultReporter();
impl->SetGlobalTestPartResultReporter(this);
} else {
old_reporter_ = impl->GetTest... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x168d6
movq 0x380c9(%rip), %r14 # 0x516f0
cmpl $0x1, 0x8(%rbx)
jne 0x1964b
movq %r14, %rdi
callq 0x1968a
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x196bc
addq $0x90, %r14
movq %r14, %rdi
callq 0x37b82
movq (... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::AlwaysTrue() | bool AlwaysTrue() {
#if GTEST_HAS_EXCEPTIONS
// This condition is always false so AlwaysTrue() never actually throws,
// but it makes the compiler think that it may throw.
if (IsTrue(false)) throw ClassUniqueToAlwaysTrue();
#endif // GTEST_HAS_EXCEPTIONS
return true;
} | movb $0x1, %al
retq
| /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::CalculateOptimalEdits(std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
const std::vector<size_t>& right) {
std::vector<std::vector<double> > costs(
left.size() + 1, std::vector<double>(right.size() + 1));
std::vector<std::vector<EditType> > best_move(
le... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r12
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x3, %rsi
incq %rsi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x2f518
subq %r14, %r12
sarq $0x3, %... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::Test::IsSkipped() | bool Test::IsSkipped() {
return internal::GetUnitTestImpl()->current_test_result()->Skipped();
} | pushq %rax
callq 0x168d6
movq 0x333ef(%rip), %rax # 0x516f0
movq 0x170(%rax), %rdi
testq %rdi, %rdi
je 0x1e316
addq $0x90, %rdi
jmp 0x1e334
movq 0x168(%rax), %rdi
testq %rdi, %rdi
je 0x1e32b
addq $0x88, %rdi
jmp 0x1e334
addq $0x178, %rax # imm = 0x178
movq %rax, %rdi
popq %rax
jmp 0x1d804
| /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestInfo::~TestInfo() | TestInfo::~TestInfo() { delete factory_; } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0x1e5dd
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x90(%rbx), %r14
leaq 0xe0(%rbx), %rdi
callq 0x30820
leaq 0xc8(%rbx), %rdi
callq 0x30850
movq %r14, %rdi
callq 0x30880
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestSuite::~TestSuite() | TestSuite::~TestSuite() {
// Deletes every Test in the collection.
ForEach(test_info_list_, internal::Delete<TestInfo>);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30fd8(%rip), %rax # 0x4fed8
movq %rax, (%rdi)
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %r12
cmpq %r12, %r15
je 0x1ef33
movq (%r15), %r14
testq %r14, %r14
je 0x1ef2d
movq %r14, %rdi
callq 0x1e5c4
movl $0x110, %esi # imm = 0x110
mo... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestSuite::ClearResult() | void TestSuite::ClearResult() {
ad_hoc_test_result_.Clear();
ForEach(test_info_list_, TestInfo::ClearTestResult);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0xc0, %rdi
movq 0xc0(%rbx), %rsi
callq 0x3863c
leaq 0xd8(%rbx), %rdi
movq 0xd8(%rbx), %rsi
callq 0x38946
movl $0x0, 0xf0(%rbx)
movq $0x0, 0x100(%rbx)
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rbx
cmpq %rbx, %r14
je 0x1f4ed
movq (%r14), %r15
leaq 0xc8(%r15), %rdi
movq... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ShouldShard(char const*, char const*, bool) | bool ShouldShard(const char* total_shards_env, const char* shard_index_env,
bool in_subprocess_for_death_test) {
if (in_subprocess_for_death_test) {
return false;
}
const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
const int32_t shard_index = Int32FromEnvOrDie(shard_ind... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
testl %edx, %edx
jne 0x1fbef
movq %rsi, %r14
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x20015
movl %eax, %ebx
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x20015
movl %eax, %ebp
andl %ebx, %eax
cmpl $-0x1, %eax
je 0x1fbef
cmpl $-0x... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::FormatCountableNoun[abi:cxx11](int, char const*, char const*) | static std::string FormatCountableNoun(int count, const char* singular_form,
const char* plural_form) {
return internal::StreamableToString(count) + " " +
(count == 1 ? singular_form : plural_form);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x2e937
leaq 0x1c46a(%rip), %rsi # 0x3c6e8
movq %r12, %rdi
callq 0xae26
leaq 0x18(%rsp), %r12
movq %r12, -0x... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::UnitTest::GetTestSuite(int) const | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x209c9
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x209c9
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x209c9
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
retq
xorl %eax, %eax
retq
| /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::PrettyUnitTestResultPrinter::PrintSkippedTests(testing::UnitTest const&) | void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
const int skipped_test_count = unit_test.skipped_test_count();
if (skipped_test_count == 0) {
return;
}
for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
const TestSuite& test_suite = *unit_test.GetTestSuite(i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x19e06
testl %eax, %eax
je 0x20c54
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x20c54
leaq 0x1c3b1(%rip), %r15 # 0x3ce... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void BriefUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this ... | cmpl $0x0, (%rsi)
je 0x20f6e
pushq %rax
movq %rsi, %rdi
callq 0x20451
movq 0x3002b(%rip), %rax # 0x50f90
movq (%rax), %rdi
popq %rax
jmp 0x85a0
retq
nop
| /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::~TestEventRepeater() | TestEventRepeater::~TestEventRepeater() {
ForEach(listeners_, Delete<TestEventListener>);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2ec29(%rip), %rax # 0x4fef8
movq %rax, (%rdi)
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x212f3
movq (%r14), %rdi
testq %rdi, %rdi
je 0x212ed
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x212da
movq 0x10(%rbx), %rdi
testq %rdi, ... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::OnTestIterationEnd(testing::UnitTest const&, int) | void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
int iteration) {
if (forwarding_enabled_) {
for (size_t i = listeners_.size(); i > 0; i--) {
listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
}
}
} | cmpb $0x1, 0x8(%rdi)
jne 0x21819
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x18(%rdi), %r12
subq 0x10(%rdi), %r12
je 0x2180e
movl %edx, %ebx
movq %rsi, %r14
sarq $0x3, %r12
movq 0x10(%r15), %rax
movq -0x8(%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x80(... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::CapturedStream::GetCapturedString[abi:cxx11]() | std::string GetCapturedString() {
if (uncaptured_fd_ != -1) {
// Restores the original stream.
fflush(nullptr);
dup2(uncaptured_fd_, fd_);
close(uncaptured_fd_);
uncaptured_fd_ = -1;
}
FILE* const file = posix::FOpen(filename_.c_str(), "r");
if (file == nullptr) {
GT... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rsi)
je 0x33415
xorl %edi, %edi
callq 0x85a0
movl (%r15), %esi
movl 0x4(%r15), %edi
callq 0x8430
movl 0x4(%r15), %edi
callq 0x8990
movl $0xffffffff, 0x4(%r15) # imm = 0xFFFFFFFF
movq 0x8(%r15), %rdi
leaq 0x9e1a(%rip), %r... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc |
find_real() | void find_real()
{
variable data(3.0);
{
auto result = std::equal_range(data.begin(), data.end(), null);
TRIAL_PROTOCOL_TEST_EQUAL(std::distance(data.begin(), result.first), 0);
TRIAL_PROTOCOL_TEST_EQUAL(std::distance(data.begin(), result.second), 0);
}
{
auto result = st... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x508, %rsp # imm = 0x508
leaq 0x50(%rsp), %rsi
movb $0xd, 0x20(%rsi)
movabsq $0x4008000000000000, %r12 # imm = 0x4008000000000000
movq %r12, (%rsi)
leaq 0x370(%rsp), %rdi
movl $0x1, %edx
callq 0x1382c
leaq 0x358(%rsp), %rdi
leaq 0x50(%rsp), %rsi
xorl %edx, %... | /breese[P]trial/test/dynamic/std/equal_range_suite.cpp |
find_u32string() | void find_u32string()
{
variable data(U"delta");
{
auto result = std::equal_range(data.begin(), data.end(), null);
TRIAL_PROTOCOL_TEST_EQUAL(std::distance(data.begin(), result.first), 0);
TRIAL_PROTOCOL_TEST_EQUAL(std::distance(data.begin(), result.second), 0);
}
{
auto r... | pushq %r15
pushq %r14
pushq %rbx
subq $0x500, %rsp # imm = 0x500
leaq 0x17c18(%rip), %rsi # 0x22f84
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x12fc4
leaq 0x368(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x1382c
leaq 0x350(%rsp), %rdi
leaq 0x50(%rsp), %rsi
xorl %edx, %edx
callq 0x1382c
leaq 0x18... | /breese[P]trial/test/dynamic/std/equal_range_suite.cpp |
bool sptk::ReadStream<sptk::int24_t>(bool, int, int, int, std::vector<sptk::int24_t, std::allocator<sptk::int24_t>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x709d
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
gs_parse_expr_assignment | static gs_expr_t *gs_parse_expr_assignment(gs_parser_t *parser) {
gs_token_t token = gs_peek(parser);
gs_expr_t *expr = gs_parse_expr_comparison(parser);
if (parser->error) goto cleanup;
while (true) {
if (gs_eat_char(parser, '=')) {
gs_expr_t *right = gs_parse_expr_assignment(parse... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0x18(%rdi), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x10(%rax,%rcx,8), %rdx
movq %rdx, 0x10(%rsp)
movups (%rax,%rcx,8), %xmm0
movaps %xmm0, (%rsp)
callq 0x3881d
movq %rax, %r14
cmpb $0x0, 0x1c(%rbx)
je 0x3879e
movq %r14, %rax
addq $0x... | /mgerdes[P]Open-Golf/src/common/script.c |
json_object_deinit | static void json_object_deinit(JSON_Object *object, parson_bool_t free_keys, parson_bool_t free_values) {
unsigned int i = 0;
for (i = 0; i < object->count; i++) {
if (free_keys) {
parson_free(object->names[i]);
}
if (free_values) {
json_value_free(object->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
cmpq $0x0, 0x30(%rdi)
je 0x53c15
movl %edx, %ebp
movl %esi, %r14d
movl $0x1, %r12d
xorl %r13d, %r13d
testl %r14d, %r14d
je 0x53bf9
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rdi
callq *0x10bfbf(%rip) ... | /mgerdes[P]Open-Golf/src/3rd_party/parson/parson.c |
SetClipboardTextFn_DefaultImpl(void*, char const*) | static void SetClipboardTextFn_DefaultImpl(void*, const char* text)
{
ImGuiContext& g = *GImGui;
g.ClipboardHandlerData.clear();
const char* text_end = text + strlen(text);
g.ClipboardHandlerData.resize((int)(text_end - text) + 1);
memcpy(&g.ClipboardHandlerData[0], text, (size_t)(text_end - text));... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0xf522a(%rip), %r12 # 0x172d90
movq 0x31e8(%r12), %rdi
testq %rdi, %rdi
je 0x7db9b
xorl %r14d, %r14d
movq %r14, 0x31e0(%r12)
decl 0x3ac(%r12)
movq 0xf5213(%rip), %rsi # 0x172da0
callq *0xe2085(%rip) # 0x15... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp |
ImGuiStorage::GetFloatRef(unsigned int, float) | float* ImGuiStorage::GetFloatRef(ImGuiID key, float default_val)
{
ImGuiStoragePair* it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
it = Data.insert(it, ImGuiStoragePair(key, default_val));
return &it->val_f;
} | subq $0x18, %rsp
movslq (%rdi), %rdx
movq 0x8(%rdi), %rcx
testq %rdx, %rdx
je 0x7fcca
movq %rcx, %rax
movq %rdx, %r9
movq %rdx, %r8
shrq %r8
movq %r8, %r10
shlq $0x4, %r10
cmpl %esi, (%rax,%r10)
jae 0x7fcc0
notq %r8
addq %r9, %r8
addq %r10, %rax
addq $0x10, %rax
movq %r8, %r9
testq %r8, %r8
jne 0x7fca3
jmp 0x7fccf
xorl... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp |
ImGuiStorage::SetInt(unsigned int, int) | void ImGuiStorage::SetInt(ImGuiID key, int val)
{
ImGuiStoragePair* it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
{
Data.insert(it, ImGuiStoragePair(key, val));
return;
}
it->val_i = val;
} | subq $0x18, %rsp
movslq (%rdi), %r8
movq 0x8(%rdi), %rcx
testq %r8, %r8
je 0x7fdb2
movq %rcx, %rax
movq %r8, %r10
movq %r8, %r9
shrq %r9
movq %r9, %r11
shlq $0x4, %r11
cmpl %esi, (%rax,%r11)
jae 0x7fda8
notq %r9
addq %r10, %r9
addq %r11, %rax
addq $0x10, %rax
movq %r9, %r10
testq %r9, %r9
jne 0x7fd8b
jmp 0x7fdb8
xorl %... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp |
ImGui::CalcListClipping(int, float, int*, int*) | void ImGui::CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (g.LogEnabled)
{
// If logging is active, do not perform any clipping
*out_items_display_star... | movq 0xf258d(%rip), %rax # 0x172d90
cmpb $0x1, 0x32b4(%rax)
jne 0x80817
movl $0x0, (%rsi)
jmp 0x8092e
movq 0x1d18(%rax), %rcx
movq 0x21a0(%rax), %r8
leaq 0x207(%r8), %r9
leaq 0xcc(%rcx), %r10
testq %r8, %r8
cmoveq %r10, %r9
cmpb $0x1, (%r9)
jne 0x80847
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rsi)
retq
movss ... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp |
ImGui::DockNodeRemoveWindow(ImGuiDockNode*, ImGuiWindow*, unsigned int) | static void ImGui::DockNodeRemoveWindow(ImGuiDockNode* node, ImGuiWindow* window, ImGuiID save_dock_id)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(window->DockNode == node);
//IM_ASSERT(window->RootWindowDockTree == node->HostWindow);
//IM_ASSERT(window->LastFrameActive < g.FrameCount); // We may call th... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq %rdi, 0x400(%rsi)
jne 0xa043b
movq %rsi, %r14
movq %rdi, %rbx
movq 0xd2b81(%rip), %r15 # 0x172d90
testl %edx, %edx
je 0xa021b
cmpl %edx, (%rbx)
jne 0xa045a
movq $0x0, 0x400(%r14)
andb $-0xa, 0x3e1(%r14)
movl %edx, 0x410(%r14)
movl $0xfeffffff, %esi #... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp |
ImGui::DockBuilderSplitNode(unsigned int, int, float, unsigned int*, unsigned int*) | ImGuiID ImGui::DockBuilderSplitNode(ImGuiID id, ImGuiDir split_dir, float size_ratio_for_node_at_dir, ImGuiID* out_id_at_dir, ImGuiID* out_id_at_opposite_dir)
{
ImGuiContext* ctx = GImGui;
IM_ASSERT(split_dir != ImGuiDir_None);
IMGUI_DEBUG_LOG_DOCKING("DockBuilderSplitNode node 0x%08X, split_dir %d\n", id, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movaps %xmm0, 0x10(%rsp)
movl %esi, %ebp
cmpl $-0x1, %esi
je 0xa120b
movq %rcx, %rbx
movq %rdx, %r14
movl %edi, %esi
movq 0xd1c62(%rip), %r12 # 0x172d90
leaq 0x3220(%r12), %rdi
callq 0x7fbb6
testq %rax, %rax
je 0xa122a
movq %rax, %r1... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp |
ImGui::DockNodeTreeFindFallbackLeafNode(ImGuiDockNode*) | ImGuiDockNode* ImGui::DockNodeTreeFindFallbackLeafNode(ImGuiDockNode* node)
{
if (node->IsLeafNode())
return node;
if (ImGuiDockNode* leaf_node = DockNodeTreeFindFallbackLeafNode(node->ChildNodes[0]))
return leaf_node;
if (ImGuiDockNode* leaf_node = DockNodeTreeFindFallbackLeafNode(node->Chi... | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xa1b99
callq 0xa1b75
testq %rax, %rax
jne 0xa1b96
movq 0x28(%rbx), %rbx
movq 0x20(%rbx), %rdi
jmp 0xa1b7d
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
| /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp |
ImGui::DebugRenderViewportThumbnail(ImDrawList*, ImGuiViewportP*, ImRect const&) | void ImGui::DebugRenderViewportThumbnail(ImDrawList* draw_list, ImGuiViewportP* viewport, const ImRect& bb)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImVec2 scale = bb.GetSize() / viewport->Size;
ImVec2 off = bb.Min - viewport->Pos * scale;
float alpha_mul = (viewport->Fla... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x90(%rsp)
movq 0xd0834(%rip), %r15 # 0x172d90
movq 0x1d18(%r15), %rdx
movsd (%r12), %xmm0
movaps %xmm0, 0x70(%rsp)
movsd 0x8(%r12), %xmm0
movaps %xmm0, 0x60(%rsp)
movsd 0x8(%rsi), %xmm0
mov... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp |
ImGui::DebugNodeStorage(ImGuiStorage*, char const*) | void ImGui::DebugNodeStorage(ImGuiStorage* storage, const char* label)
{
if (!TreeNode(label, "%s: %d entries, %d bytes", label, storage->Data.Size, storage->Data.size_in_bytes()))
return;
for (int n = 0; n < storage->Data.Size; n++)
{
const ImGuiStorage::ImGuiStoragePair& p = storage->Data[... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rdi), %ecx
movl %ecx, %r8d
shll $0x4, %r8d
leaq 0x6d56f(%rip), %rsi # 0x114efd
movq %rdx, %rdi
xorl %eax, %eax
callq 0xede49
testb %al, %al
je 0xa79e7
cmpl $0x0, (%rbx)
jle 0xa79d7
movl $0x8, %r15d
leaq 0x6d568(%rip), %r14... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp |
ImGui::NavScoreItem(ImGuiNavItemData*) | static bool ImGui::NavScoreItem(ImGuiNavItemData* result)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (g.NavLayer != window->DC.NavLayerCurrent)
return false;
// FIXME: Those are not good variables names
ImRect cand = g.LastItemData.NavRect; // Current item nav ... | subq $0x18, %rsp
movq 0xcad77(%rip), %rax # 0x172d90
movq 0x1d18(%rax), %rsi
movl 0x1fc8(%rax), %ecx
cmpl 0x15c(%rsi), %ecx
jne 0xa81bd
movsd 0x1df4(%rax), %xmm4
movsd %xmm4, 0x10(%rsp)
movsd 0x1dfc(%rax), %xmm1
movsd %xmm1, 0x8(%rsp)
movss 0x2008(%rax), %xmm3
movss 0x200c(%rax), %xmm0
movss 0x2010(%rax), %xmm5
mov... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui.cpp |
ImGui::ShowFontSelector(char const*) | void ImGui::ShowFontSelector(const char* label)
{
ImGuiIO& io = ImGui::GetIO();
ImFont* font_current = ImGui::GetFont();
if (ImGui::BeginCombo(label, font_current->GetDebugName()))
{
for (int n = 0; n < io.Fonts->Fonts.Size; n++)
{
ImFont* font = io.Fonts->Fonts[n];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0x84987
movq %rax, %rbx
callq 0x9611a
movq %rax, %r14
movq 0x48(%rax), %rax
leaq 0x56(%rax), %rsi
testq %rax, %rax
leaq 0x42e5f(%rip), %r13 # 0x101985
cmoveq %r13, %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0xe1222
te... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_demo.cpp |
ShowDemoWindowWidgets()::Funcs::MyCallback(ImGuiInputTextCallbackData*) | static int MyCallback(ImGuiInputTextCallbackData* data)
{
if (data->EventFlag == ImGuiInputTextFlags_CallbackCompletion)
{
data->InsertChars(data->CursorPos, "..");
}
else if (data->EventFlag == ImGui... | pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x80000, %eax # imm = 0x80000
je 0xbecc2
cmpl $0x80, %eax
je 0xbec9f
cmpl $0x40, %eax
jne 0xbed13
movl 0x2c(%rbx), %esi
leaq 0x648c9(%rip), %rdx # 0x12355c
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xe9f04
jmp 0xbed13
movl 0x14(%rbx), %eax
cmpl $0x4, %eax
je 0... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_demo.cpp |
ImDrawListSharedData::SetCircleTessellationMaxError(float) | void ImDrawListSharedData::SetCircleTessellationMaxError(float max_error)
{
if (CircleSegmentMaxError == max_error)
return;
IM_ASSERT(max_error > 0.0f);
CircleSegmentMaxError = max_error;
for (int i = 0; i < IM_ARRAYSIZE(CircleSegmentCounts); i++)
{
const float radius = (float)i;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movss 0x18(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jne 0xc1beb
jnp 0xc1c94
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc1c9f
movq %rdi, %rbx
movss %xmm0, 0x18(%rdi)
xorl %r14d, %r14d
movl $0x200, %ebp # imm = 0x200
movl $0x4, %r15d
testq %r14, %r14
je 0xc1c6... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_draw.cpp |
ImDrawList::PushTextureID(void*) | void ImDrawList::PushTextureID(ImTextureID texture_id)
{
_TextureIdStack.push_back(texture_id);
_CmdHeader.TextureId = texture_id;
_OnChangedTextureID();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x68(%rdi), %eax
cmpl 0x6c(%rdi), %eax
jne 0xc292d
leal 0x1(%rax), %ebp
testl %eax, %eax
je 0xc2933
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0xc2938
movq 0x70(%rbx), %r15
jmp 0xc2978
movl $0... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_draw.cpp |
ImDrawList::PrimQuadUV(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int) | void ImDrawList::PrimQuadUV(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a, const ImVec2& uv_b, const ImVec2& uv_c, const ImVec2& uv_d, ImU32 col)
{
ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
_IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %r11
movq 0x28(%rsp), %rbx
movl 0x40(%rsp), %r10d
movl 0x34(%rdi), %r14d
movq 0x50(%rdi), %r15
movw %r14w, (%r15)
leal 0x1(%r14), %ebp
movw %bp, 0x2(%r15)
leal 0x2(%r14), %ebp
movw %bp, 0x4(%r15)
movw %r14w, 0x6(%r15)
movw %bp, 0x8(%r15)... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_draw.cpp |
ImDrawList::PathArcToFast(ImVec2 const&, float, int, int) | void ImDrawList::PathArcToFast(const ImVec2& center, float radius, int a_min_of_12, int a_max_of_12)
{
if (radius <= 0.0f)
{
_Path.push_back(center);
return;
}
_PathArcToFastEx(center, radius, a_min_of_12 * IM_DRAWLIST_ARCFAST_SAMPLE_MAX / 12, a_max_of_12 * IM_DRAWLIST_ARCFAST_SAMPLE_MAX... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0xc3f3f
shll $0x2, %edx
shll $0x2, %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc39b4
movl 0x78(%rbx), %eax
cmpl 0x7c(%... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_draw.cpp |
ImDrawList::AddRectFilled(ImVec2 const&, ImVec2 const&, unsigned int, float, int) | void ImDrawList::AddRectFilled(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding, ImDrawFlags flags)
{
if ((col & IM_COL32_A_MASK) == 0)
return;
if (rounding <= 0.0f || (flags & ImDrawFlags_RoundCornersMask_) == ImDrawFlags_RoundCornersNone)
{
PrimReserve(6, 4);
Pri... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1000000, %ecx # imm = 0x1000000
jb 0xc55f5
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
setb %al
movl %r8d, %ecx
andl $0x1f0, %ecx # imm = 0x1F0
cmpl $0x100, %ecx # imm ... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_draw.cpp |
ImFontAtlas::~ImFontAtlas() | ImFontAtlas::~ImFontAtlas()
{
IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
Clear();
} | pushq %rbx
cmpb $0x1, 0x18(%rdi)
je 0xc7c97
movq %rdi, %rbx
callq 0xc7cde
movq %rbx, %rdi
callq 0xc7e36
movq %rbx, %rdi
callq 0xc7e96
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0xc7c79
callq 0x7ef53
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xc7c87
callq 0x7ef53
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xc7c95
callq 0x... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_draw.cpp |
ImFontAtlas::ClearTexData() | void ImFontAtlas::ClearTexData()
{
IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
if (TexPixelsAlpha8)
IM_FREE(TexPixelsAlpha8);
if (TexPixelsRGBA32)
IM_FREE(TexPixelsRGBA32);
TexPixelsAlpha8 = NULL;
TexPixelsRGBA32 = NULL;
... | pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x18(%rdi)
je 0xc7e76
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xc7e51
callq 0x7ef53
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xc7e63
callq 0x7ef53
movb $0x0, 0x1a(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_draw.cpp |
ImFontGlyphRangesBuilder::AddRanges(unsigned short const*) | void ImFontGlyphRangesBuilder::AddRanges(const ImWchar* ranges)
{
for (; ranges[0]; ranges += 2)
for (ImWchar c = ranges[0]; c <= ranges[1]; c++)
AddChar(c);
} | pushq %rax
movzwl (%rsi), %ecx
testw %cx, %cx
je 0xce705
movzwl 0x2(%rsi), %eax
cmpw %ax, %cx
ja 0xce6fb
movq 0x8(%rdi), %rdx
movzwl %cx, %r8d
shrl $0x5, %r8d
cmpl %r8d, (%rdi)
jle 0xce707
movl $0x1, %r9d
shll %cl, %r9d
movzwl %r8w, %r8d
orl %r9d, (%rdx,%r8,4)
incl %ecx
cmpw %ax, %cx
jbe 0xce6d6
movzwl 0x4(%rsi), %ecx
... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_draw.cpp |
stbtt_GetGlyphShape(stbtt_fontinfo const*, int, stbtt_vertex**) | STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
{
if (!info->cff.size)
return stbtt__GetGlyphShapeTT(info, glyph_index, pvertices);
else
return stbtt__GetGlyphShapeT2(info, glyph_index, pvertices);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r12
cmpl $0x0, 0x4c(%rdi)
je 0xd2403
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
xorl %ebp, %ebp
movq %rbp, 0x30(%rdx)
movl $... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imstb_truetype.h |
rect_height_compare(void const*, void const*) | static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
{
const stbrp_rect *p = (const stbrp_rect *) a;
const stbrp_rect *q = (const stbrp_rect *) b;
if (p->h > q->h)
return -1;
if (p->h < q->h)
return 1;
return (p->w > q->w) ? -1 : (p->w < q->w);
} | movzwl 0x6(%rsi), %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpw %cx, 0x6(%rdi)
ja 0xd34c0
movl $0x1, %eax
jb 0xd34c0
movzwl 0x4(%rdi), %eax
xorl %ecx, %ecx
cmpw 0x4(%rsi), %ax
setb %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovbel %ecx, %eax
retq
| /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imstb_rectpack.h |
ImGui::TableDrawBorders(ImGuiTable*) | void ImGui::TableDrawBorders(ImGuiTable* table)
{
ImGuiWindow* inner_window = table->InnerWindow;
if (!table->OuterWindow->ClipRect.Overlaps(table->OuterRect))
return;
ImDrawList* inner_drawlist = inner_window->DrawList;
table->DrawSplitter->SetCurrentChannel(inner_drawlist, TABLE_DRAW_CHANNEL_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x188(%rdi), %rax
movss 0x24c(%rax), %xmm0
ucomiss 0xf8(%rdi), %xmm0
jbe 0xd7d5f
movq %rdi, %rbx
movss 0x100(%rdi), %xmm0
ucomiss 0x244(%rax), %xmm0
jbe 0xd7d5f
leaq 0xf4(%rbx), %r13
movss 0x248(%rax), %xmm0
ucomiss (%r13), %xmm0
jb... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_tables.cpp |
ImGui::TableSetColumnIndex(int) | bool ImGui::TableSetColumnIndex(int column_n)
{
ImGuiContext& g = *GImGui;
ImGuiTable* table = g.CurrentTable;
if (!table)
return false;
if (table->CurrentColumn != column_n)
{
if (table->CurrentColumn != -1)
TableEndCell(table);
IM_ASSERT(column_n >= 0 && table-... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x99ade(%rip), %rax # 0x172d90
movq (%rax), %rax
movq 0x21a0(%rax), %r14
testq %r14, %r14
je 0xd92fa
movl %edi, %ebx
movl 0x7c(%r14), %eax
cmpl %edi, %eax
je 0xd92ed
cmpl $-0x1, %eax
je 0xd92d8
movq %r14, %rdi
callq 0xd9165
testl %ebx, %ebx
js 0xd9304
cmpl $0x0, 0x74(%r14)
je 0... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_tables.cpp |
TableSettingsHandler_ClearAll(ImGuiContext*, ImGuiSettingsHandler*) | static void TableSettingsHandler_ClearAll(ImGuiContext* ctx, ImGuiSettingsHandler*)
{
ImGuiContext& g = *ctx;
for (int i = 0; i != g.Tables.GetMapSize(); i++)
if (ImGuiTable* table = g.Tables.TryGetMapData(i))
table->SettingsOffset = -1;
g.SettingsTables.clear();
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x21c0(%rdi)
je 0xdaa44
leaq 0x21b0(%rbx), %r14
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0xaa788
testq %rax, %rax
je 0xdaa3a
movl $0xffffffff, 0x6c(%rax) # imm = 0xFFFFFFFF
incl %ebp
cmpl 0x21c0(%rbx), %ebp
jne 0xdaa24
movq 0x3298(%rbx), %rdi
test... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_tables.cpp |
ImGui::SliderBehavior(ImRect const&, unsigned int, int, void*, void const*, void const*, char const*, int, ImRect*) | bool ImGui::SliderBehavior(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, void* p_v, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
// Read imgui.cpp "API BREAKING CHANGES" section for 1.78 if you hit this assert.
IM_ASSERT((flags == 1 || (flags ... | pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl 0x28(%rsp), %eax
cmpl $0x1, %eax
setne %cl
testl $0x7000000f, %eax # imm = 0x7000000F
setne %r10b
testb %r10b, %cl
jne 0xe44bb
leaq 0x8eb4a(%rip), %rcx # 0x172d90
movq (%rcx), %rcx
movl $0x80, %r10d
andl 0x1ddc(%rcx), %r10d
movl %eax, %ecx
andl $0x200000, %ecx ... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_widgets.cpp |
ImGui::TabBarQueueReorder(ImGuiTabBar*, ImGuiTabItem const*, int) | void ImGui::TabBarQueueReorder(ImGuiTabBar* tab_bar, const ImGuiTabItem* tab, int offset)
{
IM_ASSERT(offset != 0);
IM_ASSERT(tab_bar->ReorderRequestTabId == 0);
tab_bar->ReorderRequestTabId = tab->ID;
tab_bar->ReorderRequestOffset = (ImS16)offset;
} | pushq %rax
testl %edx, %edx
je 0xf2c1d
cmpl $0x0, 0x64(%rdi)
jne 0xf2c3c
movl (%rsi), %eax
movl %eax, 0x64(%rdi)
movw %dx, 0x68(%rdi)
popq %rax
retq
leaq 0x3f01c(%rip), %rdi # 0x131c40
leaq 0x3d2f8(%rip), %rsi # 0x12ff23
leaq 0x3f01a(%rip), %rcx # 0x131c4c
movl $0x1e01, %edx # imm = 0x1E01
callq 0... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_widgets.cpp |
ImGui::TabItemEx(ImGuiTabBar*, char const*, bool*, int, ImGuiWindow*) | bool ImGui::TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags, ImGuiWindow* docked_window)
{
// Layout whole tab bar if not already done
if (tab_bar->WantLayout)
TabBarLayout(tab_bar);
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, 0x20(%rsp)
movl %ecx, %r14d
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x1, 0x6b(%rdi)
jne 0xf302f
movq %rbx, %rdi
callq 0xf1961
leaq 0x7fd5a(%rip), %rax # 0x172d90
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_widgets.cpp |
ImStb::stb_textedit_discard_undo(ImStb::StbUndoState*) | static void stb_textedit_discard_undo(StbUndoState *state)
{
if (state->undo_point > 0) {
// if the 0th undo state has characters, clean those up
if (state->undo_rec[0].char_storage >= 0) {
int n = state->undo_rec[0].insert_length, i;
// delete n characters from all other records
... | movzwl 0xdfe(%rdi), %eax
testw %ax, %ax
jle 0xf4f3e
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
js 0xf4f1a
movslq 0x4(%rbx), %r14
movslq 0xe04(%rbx), %rdx
subq %r14, %rdx
movl %edx, 0xe04(%rbx)
leaq 0x630(%rbx), %rdi
leaq (%rbx,%r14,2), %rsi
addq $0x630, %rsi # imm = 0x630
addq %rdx... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imstb_textedit.h |
bool ImGui::SliderBehaviorT<unsigned int, int, float>(ImRect const&, unsigned int, int, unsigned int*, unsigned int, unsigned int, char const*, int, ImRect*) | bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_V... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x48(%rsp)
movl %edx, %ebx
movl %esi, %r12d
movl %r8d, %eax
subl %r9d, %eax
negl %eax
movl %r8d, 0x28(%rsp)
movl %r8d, %r14d
movl %r9d, 0x2c(%rsp)
subl %r9d, %r14d
movl 0xd8(%rsp), %r13d
leaq 0x7b5d9(%rip), %rcx # 0x172d90... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_widgets.cpp |
int ImGui::ScaleValueFromRatioT<int, int, float>(int, float, int, int, bool, float, float) | TYPE ImGui::ScaleValueFromRatioT(ImGuiDataType data_type, float t, TYPE v_min, TYPE v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)
{
if (v_min == v_max)
return v_min;
const bool is_floating_point = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataTy... | subq $0x18, %rsp
movl %esi, %eax
movl %edx, %esi
subl %eax, %esi
jne 0xfa3b2
addq $0x18, %rsp
retq
movaps %xmm0, %xmm3
testb %cl, %cl
je 0xfa3ef
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
jae 0xfa3ad
ucomiss 0x2c68(%rip), %xmm3 # 0xfd030
jae 0xfa449
movaps %xmm1, %xmm7
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movaps 0x... | /mgerdes[P]Open-Golf/src/3rd_party/cimgui/imgui/imgui_widgets.cpp |
mau::GetTimeUsec() | uint64_t GetTimeUsec()
{
#ifdef _WIN32
LARGE_INTEGER timeStamp = {};
if (!::QueryPerformanceCounter(&timeStamp))
return 0;
if (PerfFrequencyInverse == 0.)
InitPerfFrequencyInverse();
return (uint64_t)(PerfFrequencyInverse * timeStamp.QuadPart);
#elif __MACH__
if (!m_clock_serv_init)
... | pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6610
imulq $0xf4240, (%rbx), %rax # imm = 0xF4240
addq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
| /catid[P]mau/MauTools.cpp |
logger::OutputWorker::GetInstance() | OutputWorker& OutputWorker::GetInstance()
{
// Fix crash on shutdown due to MSVCRT bug prior to version 2015
static std::once_flag m_singletonFlag;
static std::unique_ptr<OutputWorker> instance;
std::call_once(m_singletonFlag, []()
{
instance.reset(new OutputWorker);
});
return *in... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movb 0xdb5b(%rip), %al # 0x25680
testb %al, %al
je 0x17b83
leaq 0xf(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq 0xd42b(%rip), %rbx # 0x24f68
movq %rcx, %fs:(%rbx)
movq 0xd448(%rip), %r14 # 0x24f90
leaq 0xa83(%rip), %rax # 0x185d2
movq %rax, %fs:(... | /catid[P]mau/Logger.cpp |
logger::OutputWorker::OutputWorker() | OutputWorker::OutputWorker()
{
Start();
#if !defined(LOGGER_DISABLE_ATEXIT)
// Register an atexit() callback so we do not need manual shutdown in app code
// Application code can still manually shutdown by calling OutputWorker::Stop()
std::atexit(AtExitWrapper);
#endif // LOGGER_DISABLE_ATEXIT
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x50(%rdi), %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x10(%rdi)
vmovups %zmm0, (%rdi)
movq %rbx, %rdi
vzeroupper
callq 0x6570
leaq 0x80(%r12), %r14
movq %r14, 0x88(%r12)
movq %r14, 0x80(%r12)
xorl %eax, %eax
movq %ra... | /catid[P]mau/Logger.cpp |
logger::OutputWorker::Start() | void OutputWorker::Start()
{
std::lock_guard<std::mutex> locker(StartStopLock);
// If thread is already spinning:
if (Thread)
return;
#if defined(_WIN32)
CachedIsDebuggerPresent = (::IsDebuggerPresent() != FALSE);
#endif // _WIN32
QueuePublic.clear();
QueuePrivate.clear();
#if !defin... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x65c0
testl %eax, %eax
jne 0x17db9
cmpq $0x0, 0xe8(%rbx)
jne 0x17da7
leaq 0x80(%rbx), %r14
movq %r14, %rdi
callq 0x18660
movq %r14, 0x88(%rbx)
movq %r14, 0x80(%rbx)
xorl %r15d, %r15d
movq %r15, 0x90(%rbx)
leaq 0x98(%rbx), %r14
movq %r14, %rdi
call... | /catid[P]mau/Logger.cpp |
logger::OutputWorker::Flush() | void OutputWorker::Flush()
{
// unique_lock used since FlushCondition.wait requires it
std::unique_lock<std::mutex> locker(QueueLock);
if (!Terminated)
{
FlushRequested = true;
QueueCondition.notify_all();
FlushCondition.wait(locker);
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x18892
movb $0x1, 0x8(%r14)
movb 0xf8(%rbx), %al
testb $0x1, %al
jne 0x18287
movb $0x1, %al
xchgb %al, 0xb4(%rbx)
leaq 0x50(%rbx), %rdi
callq 0x6670
addq $0xb8,... | /catid[P]mau/Logger.cpp |
logger::OutputWorker::Write(logger::LogStringBuffer&) | void OutputWorker::Write(LogStringBuffer& buffer)
{
std::string str = buffer.LogStream.str();
#if defined(_WIN32)
// If a debugger is present:
if (CachedIsDebuggerPresent)
{
// Log all messages immediately to the Visual Studio Output Window
// to allow logging while single-stepping in a... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x8(%rsp), %rdi
callq 0x6600
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x65c0
testl %eax, %eax
jne 0x1833f
cmpq $0x400, 0x90(%rbx) # imm = 0x400
jb 0x182df
lock
incl 0xb0(%rbx)
jmp 0x1830c
leaq 0x80(%rbx... | /catid[P]mau/Logger.cpp |
pktalloc::Allocator::Allocate(unsigned int) | uint8_t* Allocator::Allocate(unsigned bytes)
{
if (bytes <= 0) {
return nullptr;
}
ALLOC_DEBUG_INTEGRITY_CHECK();
// Calculate number of units required by this allocation
// Note: +1 for the AllocationHeader
const unsigned units = (bytes + kUnitSize - 1) / kUnitSize + 1;
if (units... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
testl %esi, %esi
je 0x18e37
leal 0x1f(%rsi), %ebx
cmpl $0x4000, %ebx # imm = 0x4000
jb 0x18e3e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18ff6
xorl %eax, %eax
jmp 0x... | /catid[P]mau/PacketAllocator.cpp |
pktalloc::Allocator::fallbackAllocate(unsigned int) | uint8_t* Allocator::fallbackAllocate(unsigned bytes)
{
// Calculate number of units required by this allocation
// Note: +1 for the AllocationHeader
const unsigned units = (bytes + kUnitSize - 1) / kUnitSize + 1;
uint8_t* ptr = SIMDSafeAllocate(kUnitSize * units);
if (!ptr) {
return nullptr... | pushq %rbx
movl %esi, %ebx
addl $0x1f, %ebx
shrl $0x5, %ebx
incl %ebx
movl %ebx, %esi
shll $0x5, %esi
addq $0x20, %rsi
movl $0x1, %edi
callq 0x6260
testq %rax, %rax
je 0x1902a
movl %eax, %ecx
andl $0x1f, %ecx
subq %rcx, %rax
movb %cl, 0x1f(%rax)
addq $0x20, %rax
jmp 0x1902c
xorl %eax, %eax
testq %rax, %rax
je 0x19041
m... | /catid[P]mau/PacketAllocator.cpp |
pktalloc::Allocator::Shrink(unsigned char*, unsigned int) | void Allocator::Shrink(uint8_t* ptr, unsigned bytes)
{
ALLOC_DEBUG_INTEGRITY_CHECK();
if (!ptr) {
return;
}
PKTALLOC_DEBUG_ASSERT((uintptr_t)ptr % kUnitSize == 0);
AllocationHeader* regionHeader = (AllocationHeader*)(ptr - kUnitSize);
#ifdef PKTALLOC_DEBUG
if (regionHeader->Canary != A... | testq %rsi, %rsi
je 0x193be
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpl $0x0, -0x18(%rsi)
je 0x193b6
movl %edx, %r14d
addl $0x1f, %r14d
shrl $0x5, %r14d
leal 0x1(%r14), %r12d
movl -0x18(%rbx), %ebp
cmpl %ebp, %r12d
jae 0x193b6
leaq -0x20(%rbx), %rdx
movq (%rdx), %r15
testq %r15, %r15
je ... | /catid[P]mau/PacketAllocator.cpp |
pktalloc::Allocator::fallbackFree(unsigned char*) | static inline void SIMDSafeFree(void* ptr)
{
if (!ptr) {
return;
}
uint8_t* data = (uint8_t*)ptr;
unsigned offset = data[-1];
if (offset >= kAlignmentBytes) {
PKTALLOC_DEBUG_BREAK(); // Should never happen
return;
}
data -= kAlignmentBytes - offset;
free(data);
} | movzbl -0x21(%rsi), %eax
cmpq $0x1f, %rax
jbe 0x193cb
retq
leaq -0x40(%rax,%rsi), %rdi
jmp 0x6450
nop
| /catid[P]mau/PacketAllocator.cpp |
pktalloc::LightVector<pktalloc::Allocator::WindowHeader*>::SetSize_NoCopy(unsigned int) | bool SetSize_NoCopy(unsigned elements)
{
PKTALLOC_DEBUG_ASSERT(Size <= Allocated);
// If it is actually expanding, and it needs to grow:
if (elements > Allocated)
{
const unsigned newAllocated = (elements * 3) / 2;
T* newData = new(std::nothrow) T[newAllocate... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, 0xd8(%rdi)
jae 0x1943d
leal (%rbx,%rbx,2), %r12d
shrl %r12d
leaq (,%r12,8), %rdi
movq 0xbb37(%rip), %rsi # 0x24f38
callq 0x6640
testq %rax, %rax
je 0x19448
movq %rax, %r15
movq 0xd0(%r14), %rdi
movl %r12d, 0xd8(%r14)
... | /catid[P]mau/PacketAllocator.h |
nlohmann::json_abi_v3_11_3::detail::out_of_range nlohmann::json_abi_v3_11_3::detail::out_of_range::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t) | static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | subq $0xd8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x7cb00
movq 0x18(%rsp), %rdx
leaq 0x1cfac9(%rip), %rsi # 0x342e77
leaq 0x58(%rsp), %rdi
callq 0xb2e30
... | /ggerganov[P]llama/common/./json.hpp |
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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, u... | size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return 1;
}
}
return 0;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x10a150
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x10a180
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10a4c0
testb $0x1, %al
jne 0x1916b6
jmp 0x1916fd
movq 0x8(%rsp), %rax... | /ggerganov[P]llama/common/./json.hpp |
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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, u... | size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return 1;
}
}
return 0;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x10a150
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x10a180
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10a4c0
testb $0x1, %al
jne 0x191756
jmp 0x19179d
movq 0x8(%rsp), %rax... | /ggerganov[P]llama/common/./json.hpp |
base64::encode[abi:cxx11](char const*, unsigned long, base64::alphabet) | static std::string encode(const char* buffer, std::size_t size, alphabet alphabet = alphabet::standard)
{
std::string result;
result.reserve(required_encode_size(size) + 1);
encode(buffer, buffer + size, std::back_inserter(result), alphabet);
return result;
} | subq $0x78, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movb $0x0, 0x5b(%rsp)
callq 0x7d370
movq 0x60(%rsp), %rdi
callq 0x1931b0
movq 0x30(%rsp), %rdi
movq %rax, %rsi
incq %rsi
callq 0x7d950
jmp 0x19186a
movq 0x... | /ggerganov[P]llama/common/./base64.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 push_back(const basic_json& val)
{
// push_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
}
// transfo... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x10c400
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x1919a8
movq 0x10(%rsp), %rdi
callq 0xc08b0
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1,... | /ggerganov[P]llama/common/./json.hpp |
decltype(from_json_array_impl(fp, fp0, nlohmann::json_abi_v3_11_3::detail::priority_tag<3u>{}), fp.get<std::vector<float, std::allocator<float>>::value_type>(), (void)()) nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx... | auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, concat("type must be ar... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc08b0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x191c97
jmp 0x191d49
movb $0x1, 0x13(%rsp)
movl $0x20, %edi
callq 0x7d3d0
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x10c680
movq %rax, 0x20(%rsp)
... | /ggerganov[P]llama/common/./json.hpp |
decltype(fp0.reserve(std::declval<std::vector<float, std::allocator<float>>::size_type>()), fp.get<std::vector<float, std::allocator<float>>::value_type>(), (void)()) nlohmann::json_abi_v3_11_3::detail::from_json_array_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std... | auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
-> decltype(
arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
using std::end;
ConstructibleArra... | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x191bb0
movq 0xd8(%rsp), %rdi
callq 0x115ed0
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x191ec0
jmp 0x191db5
movq 0xd8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x15a050
movq 0xd8(%rsp), %rsi
leaq 0x68(%rsp),... | /ggerganov[P]llama/common/./json.hpp |
std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> base64::encode<char const*, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(char const*, char const*, std::back_insert_iterator<std::__cxx11::basic_string<... | static Output_iterator encode(Input_iterator in_begin, Input_iterator in_end, Output_iterator out,
alphabet alphabet = alphabet::standard)
{
constexpr auto pad = '=';
const char* alpha = alphabet == alphabet::url_filename_safe
? "ABC... | subq $0x78, %rsp
movq %rdx, 0x68(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movb $0x3d, 0x53(%rsp)
cmpl $0x2, 0x54(%rsp)
jne 0x193231
leaq 0x1b22e4(%rip), %rax # 0x34550e
movq %rax, 0x38(%rsp)
jmp 0x19323f
leaq 0x1ad700(%rip), %rax # 0x340938
movq %rax, 0x38(%rsp)
jmp 0x19323f
movq 0x... | /ggerganov[P]llama/common/./base64.hpp |
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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, u... | size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return 1;
}
}
return 0;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x10a150
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x10a180
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10a4c0
testb $0x1, %al
jne 0x193b46
jmp 0x193b8d
movq 0x8(%rsp), %rax... | /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... | const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xc08f0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x193c88
jmp 0x193d64
movb $0x1, 0x83(%rsp)
movl $0x20, %edi
callq 0x7d3d0
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x10c680... | /ggerganov[P]llama/common/./json.hpp |
server_context::can_be_detokenized(llama_context const*, std::vector<int, std::allocator<int>> const&) | bool can_be_detokenized(const struct llama_context * ctx, const std::vector<llama_token> & tokens) {
const llama_model * model = llama_get_model(ctx);
const llama_vocab * vocab = llama_model_get_vocab(model);
const int32_t n_vocab = llama_vocab_n_tokens(vocab);
for (const auto & token : ... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x7d820
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7dba0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7d360
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %r... | /ggerganov[P]llama/examples/server/server.cpp |
server_task_result_metrics::to_json[abi:cxx11]() | virtual json to_json() override {
return json {
{ "idle", n_idle_slots },
{ "processing", n_processing_slots },
{ "deferred", n_tasks_deferred },
{ "t_start", t_start },... | subq $0xbb8, %rsp # imm = 0xBB8
movq %rdi, 0x500(%rsp)
movq %rdi, %rax
movq %rax, 0x508(%rsp)
movq %rdi, 0xbb0(%rsp)
movq %rsi, 0xba8(%rsp)
movq 0xba8(%rsp), %rax
movq %rax, 0x510(%rsp)
movb $0x1, 0x51f(%rsp)
leaq 0xa00(%rsp), %rax
movq %rax, 0x9f8(%rsp)
leaq 0x9b8(%rsp), %rdi
movq %rdi, 0x9b0(%rsp)
leaq 0x1... | /ggerganov[P]llama/examples/server/server.cpp |
server_context::send_error(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, error_type) | void send_error(const int id_task, const std::string & error, const enum error_type type = ERROR_TYPE_SERVER) {
SRV_ERR("task id = %d, error: %s\n", id_task, error.c_str());
auto res = std::make_unique<server_task_result_error>();
res->id = id_task;
res->err_type = type;
r... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
xorl %eax, %eax
leaq 0x3cc3de(%rip), %rcx # 0x568740
cmpl (%rcx), %eax
jg 0x19c3af
callq 0x330010
movq %rax, 0x30(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq... | /ggerganov[P]llama/examples/server/server.cpp |
server_task_result_slot_save_load::to_json[abi:cxx11]() | virtual json to_json() override {
if (is_save) {
return json {
{ "id_slot", id_slot },
{ "filename", filename },
{ "n_saved", n_tokens },
{ "n_written", n_bytes },
{ "timings", {
{ "save_ms", t_m... | subq $0x978, %rsp # imm = 0x978
movq %rdi, 0x450(%rsp)
movq %rdi, %rax
movq %rax, 0x458(%rsp)
movq %rdi, 0x970(%rsp)
movq %rsi, 0x968(%rsp)
movq 0x968(%rsp), %rax
movq %rax, 0x460(%rsp)
testb $0x1, 0x30(%rax)
je 0x19d978
movb $0x1, 0x6e5(%rsp)
leaq 0x8e0(%rsp), %rax
movq %rax, 0x8d8(%rsp)
leaq 0x898(%rsp), %... | /ggerganov[P]llama/examples/server/server.cpp |
server_task_result_slot_erase::to_json[abi:cxx11]() | virtual json to_json() override {
return json {
{ "id_slot", id_slot },
{ "n_erased", n_erased },
};
} | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0xd0(%rsp)
movq %rdi, %rax
movq %rax, 0xd8(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1d8(%rsp), %rax
movq %rax, 0xe0(%rsp)
movb $0x1, 0xef(%rsp)
leaq 0x198(%rsp), %rax
movq %rax, 0x190(%rsp)
leaq 0x150(%rsp), %rdi
movq %rdi, 0x148(%rsp)
leaq 0x1a1ef... | /ggerganov[P]llama/examples/server/server.cpp |
server_task_result_apply_lora::to_json[abi:cxx11]() | virtual json to_json() override {
return json {{ "success", true }};
} | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x80(%rsp)
movq %rdi, %rax
movq %rax, 0x88(%rsp)
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movb $0x1, 0x92(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0xe8(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0xa0(%rsp)
leaq 0x1a410f(%rip), %rsi # 0x3436e8
callq 0xff050
jmp 0x1... | /ggerganov[P]llama/examples/server/server.cpp |
server_slot::print_timings() const | void print_timings() const {
const double t_prompt = t_prompt_processing / n_prompt_tokens_processed;
const double n_prompt_second = 1e3 / t_prompt_processing * n_prompt_tokens_processed;
const double t_gen = t_token_generation / n_decoded;
const double n_gen_s... | pushq %rbx
subq $0x60, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movsd 0x858(%rax), %xmm0
cvtsi2sdl 0x76c(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x19b352(%rip), %xmm0 # 0x33ec18
divsd 0x858(%rax), %xmm0
cvtsi2sdl 0x76c(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x... | /ggerganov[P]llama/examples/server/server.cpp |
server_context::send_rerank(server_slot const&, llama_batch const&) | void send_rerank(const server_slot & slot, const llama_batch & batch) {
auto res = std::make_unique<server_task_result_rerank>();
res->id = slot.id_task;
res->index = slot.index;
res->n_tokens = slot.n_prompt_tokens;
for (int i = 0; i < batch.n_tokens; ++i) {
if (... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x1bc420
movq 0xa8(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x64(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x1bc480
movl 0x64(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0xa8(%... | /ggerganov[P]llama/examples/server/server.cpp |
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... | int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x75, 0x14(%rax)
je 0x20345a
leaq 0x14dfef(%rip), %rdi # 0x35142f
movl $0x1d79, %esi # imm = 0x1D79
leaq 0x13d9b9(%rip), %rdx # 0x340e05
leaq 0x140e48(%rip), %rcx # 0x34429b
movb $0x0, %al
callq 0x7c9b0
movl $0x0,... | /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};
... | subq $0x148, %rsp # imm = 0x148
movb %dl, %al
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
andb $0x1, %al
movb %al, 0x127(%rsp)
movq 0x130(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x20, %rdi
callq 0x173770
testb $0x1, %al
jne 0x21109e
jmp 0x2110bf
leaq 0x14038a(%rip), %rdi # 0x35142f
movl $0x1c28, %esi ... | /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};
... | subq $0x148, %rsp # imm = 0x148
movb %dl, %al
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
andb $0x1, %al
movb %al, 0x127(%rsp)
movq 0x130(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x20, %rdi
callq 0x173770
testb $0x1, %al
jne 0x21175e
jmp 0x21177f
leaq 0x13fcca(%rip), %rdi # 0x35142f
movl $0x1c28, %esi ... | /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};
... | subq $0x148, %rsp # imm = 0x148
movb %dl, %al
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
andb $0x1, %al
movb %al, 0x127(%rsp)
movq 0x130(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x20, %rdi
callq 0x173770
testb $0x1, %al
jne 0x211e1e
jmp 0x211e3f
leaq 0x13f60a(%rip), %rdi # 0x35142f
movl $0x1c28, %esi ... | /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};
... | subq $0x148, %rsp # imm = 0x148
movb %dl, %al
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
andb $0x1, %al
movb %al, 0x127(%rsp)
movq 0x130(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x20, %rdi
callq 0x173770
testb $0x1, %al
jne 0x21237e
jmp 0x21239f
leaq 0x13f0aa(%rip), %rdi # 0x35142f
movl $0x1c28, %esi ... | /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... | void dump(const BasicJsonType& val,
const bool pretty_print,
const bool ensure_ascii,
const unsigned int indent_step,
const unsigned int current_indent = 0)
{
switch (val.m_data.m_type)
{
case value_t::object:
{
... | subq $0x178, %rsp # imm = 0x178
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
andb $0x1, %cl
movb %cl, 0x167(%rsp)
andb $0x1, %al
movb %al, 0x166(%rsp)
movl %r8d, 0x160(%rsp)
movl %r9d, 0x15c(%rsp)
movq 0x170(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x168(%rsp), %rax
movzbl (%rax), ... | /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'}... | subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
movb %al, 0x3f(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movzbl 0x3f(%rsp), %eax
cmpl $0x0, %eax
jne 0x2184e0
movq 0x10(%rsp), %rdi
callq 0x151c70
movq %rax, %rdi
movq (%rdi), %rax
movl $0x30, %esi
callq *(%rax)
jmp 0x21872c
movq 0x10(%rsp), %rdi
addq $0x10,... | /ggerganov[P]llama/common/json.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.