name string | code string | asm string | file string |
|---|---|---|---|
CLI::detail::split_names(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline std::vector<std::string> split_names(std::string current) {
std::vector<std::string> output;
size_t val;
while((val = current.find(",")) != std::string::npos) {
output.push_back(trim_copy(current.substr(0, val)));
current = current.substr(val + 1);
}
output.push_back(trim_copy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %r13
pushq $-0x1
popq %rbp
movq %r14, %rdi
leaq 0x217bc(%rip), %rsi # 0x3ec5a
xorl %edx, %edx
callq 0... | /SX91[P]CLI11/include/CLI/Split.hpp |
CLI::RequiresError::RequiresError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | RequiresError(std::string curname, std::string subname)
: RequiresError(curname + " requires " + subname, ExitCodes::RequiresError) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x1ed74(%rip), %rdx # 0x3f012
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1a3e5
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a3c6
movq %rsp, %rsi
pushq $0x6b
popq %rdx
movq %rbx, %rdi
callq 0x2379c
movq %rsp, %rdi
c... | /SX91[P]CLI11/include/CLI/Error.hpp |
CLI::App::_parse_positional(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | void _parse_positional(std::vector<std::string> &args) {
std::string positional = args.back();
for(const Option_p &opt : options_) {
// Eat options, one by one, until done
if(opt->get_positional() &&
(static_cast<int>(opt->count()) < opt->get_expected() || opt->ge... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
addq $-0x20, %rsi
leaq 0x8(%rsp), %rdi
callq 0xb7e0
movq 0x98(%r14), %r12
movq 0xa0(%r14), %rax
cmpq %rax, %r12
je 0x210ea
movq (%r12), %r15
cmpq $0x0, 0x60(%r15)
je 0x210e4
movl 0xfc(%r15), %ecx
testl %ecx... | /SX91[P]CLI11/include/CLI/App.hpp |
CLI::detail::split_long(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>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline bool split_long(const std::string ¤t, std::string &name, std::string &value) {
if(current.size() > 2 && current.substr(0, 2) == "--" && valid_first_char(current[2])) {
auto loc = current.find("=");
if(loc != std::string::npos) {
name = current.substr(2, loc - 2);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x3, 0x8(%rdi)
jb 0x213b2
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
pushq $0x2
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb540
leaq 0x21a2f(%rip), %rsi # 0x42d38
movq %r12, %rdi... | /SX91[P]CLI11/include/CLI/Split.hpp |
TApp_IniNotRequiredNotDefault_Test::TApp_IniNotRequiredNotDefault_Test() | TEST_F(TApp, IniNotRequiredNotDefault) {
TempFile tmpini{"TestIniTmp.ini"};
TempFile tmpini2{"TestIniTmp2.ini"};
app.set_config("--config", tmpini);
{
std::ofstream out{tmpini};
out << "[default]" << std::endl;
out << "two=99" << std::endl;
out << "three=3" << std::end... | pushq %rbx
movq %rdi, %rbx
callq 0x1b864
leaq 0x3bf0a(%rip), %rax # 0x5fc40
movq %rax, (%rbx)
popq %rbx
retq
nop
| /SX91[P]CLI11/tests/IniTest.cpp |
TApp_IniRequired_Test::TApp_IniRequired_Test() | TEST_F(TApp, IniRequired) {
TempFile tmpini{"TestIniTmp.ini"};
app.set_config("--config", tmpini, "", true);
{
std::ofstream out{tmpini};
out << "[default]" << std::endl;
out << "two=99" << std::endl;
out << "three=3" << std::endl;
}
int one = 0, two = 0, three = ... | pushq %rbx
movq %rdi, %rbx
callq 0x1b864
leaq 0x3bf1a(%rip), %rax # 0x5fda0
movq %rax, (%rbx)
popq %rbx
retq
nop
| /SX91[P]CLI11/tests/IniTest.cpp |
testing::internal::NotMatcher<testing::PolymorphicMatcher<testing::internal::HasSubstrMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::operator testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&><std::__cxx11::basic_string<cha... | operator Matcher<T>() const {
return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0xb510
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x265c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x26ad6
movq %rbx, 0x8(%r14)
leaq 0x10(%r14), %rax
movq %rax, 0x10(%r14)
leaq 0x3a807(%rip), ... | /SX91[P]CLI11/build_O2/googletest-src/googlemock/include/gmock/gmock-matchers.h |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&> const&) | class GTEST_API_ Matcher<const internal::string&>
: public internal::MatcherBase<const internal::string&> {
public:
Matcher() {}
explicit Matcher(const MatcherInterface<const internal::string&>* impl)
: internal::MatcherBase<const internal::string&>(impl) {}
// Allows the user to write str instead of... | pushq %rbx
movq %rdi, %rbx
callq 0x26b52
leaq 0x3a7a6(%rip), %rax # 0x612a0
movq %rax, (%rbx)
popq %rbx
retq
nop
| /SX91[P]CLI11/build_O2/googletest-src/googlemock/include/gmock/gmock-matchers.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> CLI::detail::join<std::set<int, std::less<int>, std::allocator<int>>>(std::set<int, std::less<int>, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | std::string join(const T &v, std::string delim = ",") {
std::ostringstream s;
size_t start = 0;
for(const auto &i : v) {
if(start++ > 0)
s << delim;
s << i;
}
return s.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0xb7b0
movq 0x18(%r15), %r13
addq $0x8, %r15
xorl %ebp, %ebp
cmpq %r15, %r13
je 0x26cd0
subq $0x1, %rbp
jb 0x26cb7
movq %r12,... | /SX91[P]CLI11/include/CLI/StringTools.hpp |
CLI::ConversionError::ConversionError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | ConversionError(std::string member, std::string name)
: ConversionError("The value " + member + "is not an allowed value for " + name) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x184a4(%rip), %rsi # 0x3f5f5
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x1bee2
leaq 0x1849b(%rip), %rdx # 0x3f600
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1bdb2
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r1... | /SX91[P]CLI11/include/CLI/Error.hpp |
testing::internal::StringFromGTestEnv[abi:cxx11](char const*, char const*) | std::string StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#endif // defined(GTEST_GET_STRING_FROM_ENV_)
const std::string env_var = FlagToEnvVar(flag);
const char* value = posix::GetEnv(env_var.c_s... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x35a33
movq (%r12), %rdi
callq 0xb6a0
testq %rax, %rax
je 0x27a4d
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb200
jmp 0x27ab6
leaq 0x1961a(%rip), %r... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest-port.cc |
testing::internal::AssertHelper::operator=(testing::Message const&) const | void AssertHelper::operator=(const Message& message) const {
UnitTest::GetInstance()->
AddTestPartResult(data_->type, data_->file, data_->line,
AppendUserMessage(data_->message, message),
UnitTest::GetInstance()->impl()
->CurrentOsStackTraceExceptT... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x27e74
movq (%rbx), %rsi
movl (%rsi), %ebx
movq 0x8(%rsi), %r14
movl 0x10(%rsi), %ebp
addq $0x18, %rsi
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x281cd
callq 0x27e74
movq 0x3aad2(%rip), %rsi # 0x628d8
leaq 0x8(%rs... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::UnitTest::GetInstance() | UnitTest* UnitTest::GetInstance() {
// When compiled with MSVC 7.1 in optimized mode, destroying the
// UnitTest object upon exiting the program messes up the exit code,
// causing successful tests to appear failed. We have to use a
// different implementation in this case to bypass the compiler bug.
// This... | pushq %rbx
movb 0x3aa65(%rip), %al # 0x628e0
testb %al, %al
je 0x27e88
leaq 0x3aa12(%rip), %rax # 0x62898
popq %rbx
retq
leaq 0x3aa51(%rip), %rdi # 0x628e0
callq 0xbaa0
testl %eax, %eax
je 0x27e7f
leaq 0x3a9f9(%rip), %rdi # 0x62898
callq 0x3102a
leaq 0x91df(%rip), %rdi # 0x3108a
leaq 0x3a9e6(%rip)... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.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;
}
return gtest_msg + "\n" + user_m... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x2969c
cmpq $0x0, 0x8(%r15)
je 0x2821f
leaq 0x1a5f1(%rip), %rdx # 0x427eb
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1a3e5
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::FilePath::RemoveDirectoryName() const | FilePath FilePath::RemoveDirectoryName() const {
const char* const last_sep = FindLastPathSeparator();
return last_sep ? FilePath(last_sep + 1) : *this;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x35216
testq %rax, %rax
je 0x28363
incq %rax
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xb200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36acc
leaq 0x8(%rsp), %rdi
callq 0xbbd8
jmp 0x2836e
mo... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest-filepath.cc |
testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11]() | std::string UnitTestOptions::GetOutputFormat() {
const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
if (gtest_output_flag == NULL) return std::string("");
const char* const colon = strchr(gtest_output_flag, ':');
return (colon == NULL) ?
std::string(gtest_output_flag) :
std::string(g... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3a414(%rip), %r14 # 0x627b0
testq %r14, %r14
je 0x283c8
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0xb1e0
testq %rax, %rax
je 0x283d9
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3b4c2
jmp 0x283e9
leaq 0x1a41... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
const FilePath& base_name,
const char* extension) {
FilePath full_pathname;
int number = 0;
do {
full_pathname.Set(MakeFileName(directory, base_name, number+... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x36ab8
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
callq 0x35222
movq %rbx, %rdi
movq %r13, %r... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest-filepath.cc |
testing::internal::UnitTestOptions::FilterMatchesTest(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&) | bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,
const std::string &test_name) {
const std::string& full_name = test_case_name + "." + test_name.c_str();
// Split --gtest_filter at '-', if there is one, to separate into
// positive filter and nega... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x19625(%rip), %rdx # 0x41fc0
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1a3e5
movq (%rbx), %rdx
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
callq 0x1bdb2
leaq 0x10(%rsp), %rdi
callq 0xbbd8
movq 0x39dbf(%rip), %rbx # 0x62788
pus... | /SX91[P]CLI11/build_O2/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 0x36afb
movq %rax, %r14
cmpl $0x1, 0x8(%rbx)
jne 0x28b6f
movq %r14, %rdi
callq 0x28bac
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28bda
movq %r14, %rdi
callq 0x28c10
movq %rax, 0x10(%rbx)
addq $0x90, %r14
movq %r... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::HasOneFailure(char const*, char const*, char const*, testing::TestPartResultArray const&, testing::TestPartResult::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult HasOneFailure(const char* /* results_expr */,
const char* /* type_expr */,
const char* /* substr_expr */,
const TestPartResultArray& results,
TestPartResult::Type type,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %r9d, %ebp
movq %r8, %r14
movq %rdi, %rbx
cmpl $0x2, %r9d
leaq 0x1937d(%rip), %rax # 0x42044
leaq 0x19386(%rip), %rsi # 0x42054
cmoveq %rax, %rsi
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xb200
leaq 0x8(%rsp), %rdi
callq 0x294... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::TestPartResultArray::GetTestPartResult(int) const | const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
if (index < 0 || index >= size()) {
printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
internal::posix::Abort();
}
return array_[index];
} | testl %esi, %esi
js 0x28fb7
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
pushq $0x70
popq %rdi
cqto
idivq %rdi
cmpl %esi, %eax
jle 0x28fb7
movl %esi, %eax
imulq $0x70, %rax, %rax
addq %rax, %rcx
movq %rcx, %rax
retq
pushq %rax
leaq 0x1a39c(%rip), %rdi # 0x4335b
xorl %eax, %eax
callq 0xb070
callq 0xb300
| /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest-test-part.cc |
testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult(testing::TestPartResult const&) | void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
const TestPartResult& result) {
unit_test_->current_test_result()->AddTestPartResult(result);
unit_test_->listeners()->repeater()->OnTestPartResult(result);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x110(%rdi), %rax
leaq 0x90(%rax), %rcx
addq $0x118, %rdi # imm = 0x118
testq %rax, %rax
cmovneq %rcx, %rdi
addq $0x38, %rdi
callq 0x37aca
movq 0x8(%r14), %rax
movq 0x190(%rax), %rdi
movq (%rdi), %rax
movq 0x40(%rax), ... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::os_stack_trace_getter() | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == NULL) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
os_stack_trace_getter_ = new OsStackTraceGetter;
#endif // GTEST_OS_STACK_TRACE_GETTER_
}
return... | movq 0x1a8(%rdi), %rax
testq %rax, %rax
je 0x29359
retq
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %rdi
callq 0xb510
leaq 0x3833c(%rip), %rcx # 0x616a8
movq %rcx, (%rax)
movq %rax, 0x1a8(%rbx)
popq %rbx
retq
| /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::GetTimeInMillis() | TimeInMillis GetTimeInMillis() {
#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
// Difference between 1970-01-01 and 1601-01-01 in milliseconds.
// http://analogous.blogspot.com/2005/04/epoch.html
const TimeInMillis kJavaEpochToWinFileTimeDelta =
static_cast<TimeInMillis>(116444736UL) * 100000UL;
cons... | pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb9c0
imulq $0x3e8, (%rbx), %rcx # imm = 0x3E8
movq 0x8(%rbx), %rax
movl $0x3e8, %esi # imm = 0x3E8
cqto
idivq %rsi
addq %rcx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /SX91[P]CLI11/build_O2/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
nop
| /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | Message& Message::operator <<(const ::std::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
xorl %r13d, %r13d
movq %rsp, %r14
cmpq %r13, %r12
je 0x29678
cmpl $0x0, (%r15,%r13,4)
je 0x2965f
leaq (%r15,%r13,4), %rsi
movl %r12d, %edx
subl %r13d, %edx
movq %r14, %rdi
callq 0x2bc12
movq %r... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*) | std::string StringStreamToString(::std::stringstream* ss) {
const ::std::string& str = ss->str();
const char* const start = str.c_str();
const char* const end = start + str.length();
std::string result;
result.reserve(2 * (end - start));
for (const char* ch = start; ch != end; ++ch) {
if (*ch == '\0') ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x18, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xb970
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movq (%r14), %r15
movq 0x8(%r14), %r12
movb $0x0, 0x10(%rbx)
leaq (%r12,%r12), %rsi
movq %rbx, %rdi
callq 0xb... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::AssertionResult::AssertionResult(testing::AssertionResult const&) | AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_),
message_(other.message_.get() != NULL ?
new ::std::string(*other.message_) :
static_cast< ::std::string*>(NULL)) {
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rsi), %al
movb %al, (%rdi)
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x29787
pushq $0x20
popq %rdi
callq 0xb510
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb7e0
jmp 0x2978a
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::AssertionResult::operator!() const | AssertionResult AssertionResult::operator!() const {
AssertionResult negation(!success_);
if (message_.get() != NULL)
negation << *message_;
return negation;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %al
xorb $0x1, %al
movb %al, (%rdi)
andq $0x0, 0x8(%rdi)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x297e9
leaq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x26534
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b3b... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::InternalStrings::GetId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | size_t GetId(const std::string& str) {
IdMap::iterator it = ids_.find(str);
if (it != ids_.end()) return it->second;
size_t id = ids_.size();
return ids_[str] = id;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x39d00
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x29d3b
movq 0x40(%rax), %r15
jmp 0x29d4d
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39c9a
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::String::FormatIntWidth2[abi:cxx11](int) | std::string String::FormatIntWidth2(int value) {
std::stringstream ss;
ss << std::setfill('0') << std::setw(2) << value;
return ss.str();
} | pushq %rbp
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xb3a0
leaq 0x10(%rsp), %rdi
pushq $0x30
popq %rsi
callq 0xb950
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movq %rax, %rdi
movl %ebp, %esi
callq 0xba30
leaq 0x18(%rsp), %rsi
mo... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::String::FormatByte[abi:cxx11](unsigned char) | std::string String::FormatByte(unsigned char value) {
std::stringstream ss;
ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
<< static_cast<unsigned int>(value);
return ss.str();
} | pushq %rbp
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xb3a0
leaq 0x10(%rsp), %rdi
pushq $0x30
popq %rsi
callq 0xb950
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movq $0x2, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl $-0x4b, %esi
o... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::TestResult::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&) | void TestResult::RecordProperty(const std::string& xml_element,
const TestProperty& test_property) {
if (!ValidateTestProperty(xml_element, test_property)) {
return;
}
internal::MutexLock lock(&test_properites_mutex_);
const std::vector<TestProperty>::iterator property_with_m... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2c21c
testb %al, %al
je 0x2c1d6
movq %r14, 0x10(%rsp)
movq %r14, %rdi
callq 0x267b6
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
movq (%rbx), %rsi
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rd... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::ValidateTestPropertyName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | bool ValidateTestPropertyName(const std::string& property_name,
const std::vector<std::string>& reserved_names) {
if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
reserved_names.end()) {
ADD_FAILURE() << "Reserved key used in RecordProperty(): "... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
movq %r15, %rdx
callq 0x1e350
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x2c490
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq ... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::TestCase::Run() | void TestCase::Run() {
if (!should_run_) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_case(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
repeater->OnTestCaseStart(*this);
impl->os_stack_trace_getter()->UponLeaving... | cmpb $0x1, 0x70(%rdi)
jne 0x2d6f9
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x36afb
movq %rax, %r14
movq %rbx, 0x108(%rax)
callq 0x27e74
movq 0x352a1(%rip), %rax # 0x628d8
movq 0x190(%rax), %r15
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq %r14, %rdi
ca... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationStart(
const UnitTest& unit_test, int iteration) {
if (GTEST_FLAG(repeat) != 1)
printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
const char* const filter = GTEST_FLAG(filter).c_str();
// Prints the filter if it's not *. This remin... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
cmpl $0x1, 0x34d24(%rip) # 0x627d8
je 0x2dac8
incl %edx
leaq 0x14bf1(%rip), %rdi # 0x426b0
movl %edx, %esi
xorl %eax, %eax
callq 0xb070
movq 0x34cb9(%rip), %r14 # 0x62788
leaq 0x1363a(%rip), %rsi # 0x41110
movq %r14, %rdi
callq 0x293a8
te... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::Int32FromEnvOrDie(char const*, int) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
const char* str_val = posix::GetEnv(var);
if (str_val == NULL) {
return default_val;
}
Int32 result;
if (!ParseInt32(Message() << "The value of environment variable " << var,
str_val, &result)) {
exit(EXIT_FAILURE);
}
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, 0x18(%rsp)
callq 0xb6a0
testq %rax, %rax
je 0x2dff9
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x294dc
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x14d28(%rip), %rsi # 0x42ce9
callq 0xb4f0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp),... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestCase const&) | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(COLOR_GREEN, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_param() == ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x2932a
leaq 0x14f40(%rip), %rdx # 0x43001
leaq 0x146b4(%rip), %rcx # 0x4277c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x2e14e
leaq 0x14690(%rip), %rsi # 0x4276e
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x2d8d3
... | /SX91[P]CLI11/build_O2/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 0x38501
leaq 0x14e49(%rip), %rdx # 0x42fc9
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1bdb2
cmpl $0x1, 0x4... | /SX91[P]CLI11/build_O2/googletest-src/googletest/src/gtest.cc |
Kandinsky::PowerExpression Kandinsky::pow<int, Kandinsky::Variable, (void*)0>(int const&, Kandinsky::Variable const&) | PowerExpression
pow(const Arg1T& arg1, const Arg2T& arg2)
{
return PowerExpression(BaseExpression::makePtr(arg1), BaseExpression::makePtr(arg2));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
callq 0x15f3b
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x162b2
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x15f22
leaq 0x10(%rsp), %rdi
callq 0x15bd6
leaq 0x20(%rsp), %rdi
callq 0x15bd6
movq %rbx, %rax
a... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/PowerExpression.hpp |
Kandinsky::VariableExpression::fillVariableSet(std::set<Kandinsky::Variable, Kandinsky::VariableLessThanComparator, std::allocator<Kandinsky::Variable>>&, std::shared_ptr<Kandinsky::BaseExpression> const&) const | void VariableExpression::fillVariableSet(std::set<Variable, VariableLessThanComparator>& variableSet, const BaseExpressionPtr& thisSharedPtr) const
{
variableSet.insert(Variable(std::dynamic_pointer_cast<VariableExpression>(thisSharedPtr)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x16726
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1677c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x167d2
leaq 0x18(%rsp), %rdi
callq 0x1577e
leaq 0x10(%rsp), %rdi
callq 0x15bd6
a... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/VariableExpression.cpp |
Kandinsky::SquareRootExpression::derivative(std::shared_ptr<Kandinsky::VariableExpression> const&) const | BaseExpressionPtr SquareRootExpression::derivative(const VariableExpressionPtr& variable) const
{
return makePtr(0.5 / sqrt(m_arg) * m_arg->derivative(variable));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
leaq 0x58(%rsp), %r12
movq %rax, (%r12)
addq $0x8, %r15
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x19be8
leaq 0x10(%rsp)... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/SquareRootExpression.cpp |
Kandinsky::SubtractionExpression::derivative(std::shared_ptr<Kandinsky::VariableExpression> const&) const | BaseExpressionPtr SubtractionExpression::derivative(const VariableExpressionPtr& variable) const
{
return makePtr(m_arg1->derivative(variable) - m_arg2->derivative(variable));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
callq *0x8(%rax)
movq 0x18(%r15), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq *0x8(%rax)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/SubtractionExpression.cpp |
arangodb::velocypack::ArrayIterator::first() const | [[nodiscard]] uint8_t const* first() const noexcept {
if (VELOCYPACK_UNLIKELY(_size == 0)) {
return nullptr;
}
auto const head = _slice.head();
VELOCYPACK_ASSERT(head != 0x01); // no empty array allowed here
if (head == 0x13) {
return _slice.start() + _slice.getStartOffsetFromCompact();... | pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0x2328
movq (%rdi), %rbx
movb (%rbx), %al
cmpb $0x13, %al
jne 0x2318
leaq 0x1(%rbx), %rdx
xorl %eax, %eax
xorl %ecx, %ecx
movzbl (%rdx), %esi
movl %esi, %edi
andl $0x7f, %edi
shlq %cl, %rdi
addq %rdi, %rax
addq $0x7, %rcx
incq %rdx
testb %sil, %sil
js 0x22d9
pushq $0x2
popq %rcx
cmpq... | /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::ArrayIterator::ArrayIterator(arangodb::velocypack::Slice) | explicit ArrayIterator(Slice slice)
: _slice{slice}, _current{nullptr}, _size{0}, _position{0} {
auto const head = slice.head();
if (VELOCYPACK_UNLIKELY(slice.type(head) != ValueType::Array)) {
throw Exception{Exception::InvalidValueType, "Expecting Array slice"};
}
_size = slice.arrayLength... | pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movzbl (%rsi), %eax
leaq 0xee1c(%rip), %rcx # 0x120c0
cmpb $0x4, (%rax,%rcx)
jne 0x32cd
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdc5c
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0... | /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::ArrayIterator::next() | [[nodiscard]] Slice value() const {
if (VELOCYPACK_UNLIKELY(!valid())) {
throw Exception{Exception::IndexOutOfBounds};
}
VELOCYPACK_ASSERT(_current != nullptr);
return Slice{_current};
} | pushq %rbx
subq $0x10, %rsp
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x341b
movq %rdi, %rbx
incq %rax
movq %rax, 0x18(%rdi)
movq 0x8(%rdi), %rsi
movq %rsi, 0x8(%rsp)
movzbl (%rsi), %eax
leaq 0xedbc(%rip), %rcx # 0x121c0
movzbl (%rax,%rcx), %eax
testq %rax, %rax
jne 0x3417
leaq 0x8(%rsp), %rdi
callq 0xe256
ad... | /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::Builder::Builder(std::shared_ptr<arangodb::velocypack::Buffer<unsigned char>>, arangodb::velocypack::Options const*) | Builder::Builder(std::shared_ptr<Buffer<uint8_t>> buffer, Options const* opts)
: Builder(std::move(buffer)) {
if (VELOCYPACK_UNLIKELY(opts == nullptr)) {
throw Exception(Exception::InternalError, "Options cannot be a nullptr");
}
options = opts;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorl %ecx, %ecx
movq %rsp, %rax
movq %rcx, 0x8(%rax)
movups (%rsi), %xmm0
movq %rcx, 0x8(%rsi)
movaps %xmm0, (%rax)
movq %rcx, (%rsi)
movq %rax, %rsi
callq 0x3674
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x37b0
callq 0x3486
testq %r14, %r14
je 0x37c... | /arangodb[P]velocypack/src/Builder.cpp |
arangodb::velocypack::Builder::sortObjectIndexLong(unsigned char*, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>) const | void Builder::sortObjectIndexLong(
uint8_t* objBase, std::vector<ValueLength>::iterator indexStart,
std::vector<ValueLength>::iterator indexEnd) const {
#ifndef VELOCYPACK_NO_THREADLOCALS
std::unique_ptr<std::vector<SortEntry>>& tmp = ::sortEntries;
// start with clean sheet in case the previous run left s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
callq 0x6de8
movq %fs:0x0, %rax
leaq -0x18(%rax), %rbx
callq 0x6de8
cmpq $0x0, (%rbx)
movq %r14, (%rsp)
je 0x3f49
callq 0x6de8
movq (%rbx), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x... | /arangodb[P]velocypack/src/Builder.cpp |
arangodb::velocypack::Builder::set(arangodb::velocypack::Slice const&) | uint8_t* Builder::set(Slice const& item) {
checkKeyHasValidType(item);
if (VELOCYPACK_UNLIKELY(options->disallowCustom && item.isCustom())) {
// Custom values explicitly disallowed as a security precaution
throw Exception(Exception::BuilderCustomDisallowed);
}
ValueLength const l = item.byteSize();
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x80(%rdi), %rax
cmpq %rax, 0x78(%rdi)
je 0x589d
movq -0x10(%rax), %rax
movq 0x18(%rbx), %rcx
movzbl (%rcx,%rax), %eax
cmpl $0x14, %eax
je 0x5867
cmpl $0xb, %eax
jne 0x589d
movb 0xa8(%rbx), %al
testb %al, %al
jne 0x5895
movzbl (%rsi... | /arangodb[P]velocypack/src/Builder.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::internal::FormatForComparisonFailureMessage<int, int>(int const&, int const&) | inline ::std::string FormatForComparisonFailureMessage(const T1& value, const T2& /*other_operand*/)
{
return PrintToString(value);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x18c18
leaq 0x10(%rsp), %rdi
movl (%r14), %esi
callq 0x12510
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x12490
leaq 0xbbf1(%rip), %rsi # 0x30430
movq %rsp, %rdi
callq 0x12240
leaq 0x80(%rsp), %... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
yaml_string_write_handler | static int
yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
{
yaml_emitter_t *emitter = (yaml_emitter_t *)data;
if (emitter->output.string.size - *emitter->output.string.size_written
< size) {
memcpy(emitter->output.string.buffer
+ *emitter->output.str... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x30(%rcx), %rcx
subq (%rcx), %rax
cmpq -0x20(%rbp), %rax
jae 0x40e0
movq -0x28(%rbp), %... | /dyna-dot[P]libyaml/src/api.c |
yaml_alias_event_initialize | YAML_DECLARE(int)
yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
{
yaml_mark_t mark = { 0, 0, 0 };
yaml_char_t *anchor_copy = NULL;
assert(event); /* Non-NULL event object is expected. */
assert(anchor); /* Non-NULL anchor is expected. */
if (!yaml_check_utf8(anchor... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20a0
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4dc1
jmp 0x4de0
leaq 0x14885(%rip), %rdi # 0x1964d
leaq 0x143a2(%rip), %rsi # 0x19171
movl $0x322, %ed... | /dyna-dot[P]libyaml/src/api.c |
yaml_document_initialize | YAML_DECLARE(int)
yaml_document_initialize(yaml_document_t *document,
yaml_version_directive_t *version_directive,
yaml_tag_directive_t *tag_directives_start,
yaml_tag_directive_t *tag_directives_end,
int start_implicit, int end_implicit)
{
struct {
yaml_error_type_t error;
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20a0
movq $0x0, -0x58(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0... | /dyna-dot[P]libyaml/src/api.c |
yaml_document_add_sequence | YAML_DECLARE(int)
yaml_document_add_sequence(yaml_document_t *document,
yaml_char_t *tag, yaml_sequence_style_t style)
{
struct {
yaml_error_type_t error;
} context;
yaml_mark_t mark = { 0, 0, 0 };
yaml_char_t *tag_copy = NULL;
struct {
yaml_node_item_t *start;
yaml_n... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20a0
movq $0x0, -0x40(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20a0
cmpq $0x0, -0x10(%rbp)
je 0x6067
jmp 0x6086
le... | /dyna-dot[P]libyaml/src/api.c |
yaml_parser_scan_to_next_token | static int
yaml_parser_scan_to_next_token(yaml_parser_t *parser)
{
/* Until the next token is not found. */
while (1)
{
/* Allow the BOM mark to start a line. */
if (!CACHE(parser, 1)) return 0;
if (parser->mark.column == 0 && IS_BOM(parser->buffer))
SKIP(parser);
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0xa8(%rax)
jb 0x7d82
movb $0x1, %al
testb $0x1, %al
jne 0x7da1
jmp 0x7d95
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x17c80
cmpl $0x0, %eax
jne 0x7da1
movl $0x0, -0x4(%rbp)
jmp 0x871c
movq -0x10(%rbp), %rax
cmpq $0x0... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_unroll_indent | static int
yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column)
{
yaml_token_t token;
/* In the flow context, do nothing. */
if (parser->flow_level)
return 1;
/* Loop through the indentation levels in the stack. */
while (parser->indent > column)
{
/* Create a t... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x100(%rax)
je 0x8759
movl $0x1, -0x4(%rbp)
jmp 0x88a5
jmp 0x875b
movq -0x10(%rbp), %rax
movslq 0x150(%rax), %rax
cmpq -0x18(%rbp), %rax
jle 0x889e
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x5... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_fetch_stream_end | static int
yaml_parser_fetch_stream_end(yaml_parser_t *parser)
{
yaml_token_t token;
/* Force new line. */
if (parser->mark.column != 0) {
parser->mark.column = 0;
parser->mark.line ++;
}
/* Reset the indentation level. */
if (!yaml_parser_unroll_indent(parser, -1))
r... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x88ef
movq -0x10(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
callq 0x8730
cmpl $0x0, %eax
j... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_fetch_flow_collection_end | static int
yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
yaml_token_type_t type)
{
yaml_mark_t start_mark, end_mark;
yaml_token_t token;
/* Reset any potential simple key on the current flow level. */
if (!yaml_parser_remove_simple_key(parser))
return 0;
/* Decrease... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xab20
cmpl $0x0, %eax
jne 0x936c
movl $0x0, -0x4(%rbp)
jmp 0x95ee
movq -0x10(%rbp), %rdi
callq 0xe9f0
cmpl $0x0, %eax
jne 0x9386
movl $0x0, -0x4(%rbp)
jmp 0x95ee
movq -0x10(%rbp), %rax
movl $0x0, 0x15... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_fetch_value | static int
yaml_parser_fetch_value(yaml_parser_t *parser)
{
yaml_mark_t start_mark, end_mark;
yaml_token_t token;
yaml_simple_key_t *simple_key = parser->simple_keys.top-1;
/* Have we found a simple key? */
if (simple_key->possible)
{
/* Create the KEY token and insert it into the que... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rax
addq $-0x28, %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa1e3
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x20a0
movl $0x10, -0x90(%rbp)
movq -0x98(%rbp), %rax... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_fetch_tag | static int
yaml_parser_fetch_tag(yaml_parser_t *parser)
{
yaml_token_t token;
/* A tag could be a simple key. */
if (!yaml_parser_save_simple_key(parser))
return 0;
/* A simple key cannot follow a tag. */
parser->simple_key_allowed = 0;
/* Create the TAG token and append it to the q... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe7e0
cmpl $0x0, %eax
jne 0xa666
movl $0x0, -0x4(%rbp)
jmp 0xa744
movq -0x10(%rbp), %rax
movl $0x0, 0x154(%rax)
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xf6e0
cmpl $0x0, %eax
jne 0xa692
movl $0x0, -0x4(%rbp)
jmp... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_fetch_block_scalar | static int
yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal)
{
yaml_token_t token;
/* Remove any potential simple keys. */
if (!yaml_parser_remove_simple_key(parser))
return 0;
/* A simple key may follow a block scalar. */
parser->simple_key_allowed = 1;
/* Create t... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xab20
cmpl $0x0, %eax
jne 0xa779
movl $0x0, -0x4(%rbp)
jmp 0xa85a
movq -0x10(%rbp), %rax
movl $0x1, 0x154(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x68(%rbp), %rsi
callq 0xfeb0
cmpl $... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_remove_simple_key | static int
yaml_parser_remove_simple_key(yaml_parser_t *parser)
{
yaml_simple_key_t *simple_key = parser->simple_keys.top-1;
if (simple_key->possible)
{
/* If the key is required, it is an error. */
if (simple_key->required) {
return yaml_parser_set_scanner_error(parser,
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rax
addq $-0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xab91
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xab8f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x10, %ra... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_scan_directive_name | static int
yaml_parser_scan_directive_name(yaml_parser_t *parser,
yaml_mark_t start_mark, yaml_char_t **name)
{
yaml_string_t string = NULL_STRING;
if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
/* Consume the directive name. */
if (!CACHE(parser, 1)) goto error;
whil... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20a0
movl $0x10, %edi
callq 0x24b0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xb928
movq -0x30(%rbp), %rax
movq %rax, -0x... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_scan_tag_handle | static int
yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
yaml_mark_t start_mark, yaml_char_t **handle)
{
yaml_string_t string = NULL_STRING;
if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
/* Check the initial '!' character. */
if (!CACHE(parser, 1)) got... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20a0
movl $0x10, %edi
callq 0x24b0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xcbde
movq -0x38(%rb... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_increase_flow_level | static int
yaml_parser_increase_flow_level(yaml_parser_t *parser)
{
yaml_simple_key_t empty_simple_key = { 0, 0, 0, { 0, 0, 0 } };
/* Reset the simple key on the next level. */
if (!PUSH(parser, parser->simple_keys, empty_simple_key))
return 0;
/* Increase the flow level. */
if (parser->... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20a0
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x160(%rcx), %rax
jne 0xe957
movq -0x10(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
movq -0x10(%rbp... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_roll_indent | static int
yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
ptrdiff_t number, yaml_token_type_t type, yaml_mark_t mark)
{
yaml_token_t token;
/* In the flow context, do nothing. */
if (parser->flow_level)
return 1;
if (parser->indent < column)
{
/*
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x100(%rax)
je 0xea7b
movl $0x1, -0x4(%rbp)
jmp 0xeda4
movq -0x10(%rbp), %rax
movslq 0x150(%rax), %rax
cm... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_scan_tag | static int
yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)
{
yaml_char_t *handle = NULL;
yaml_char_t *suffix = NULL;
yaml_mark_t start_mark, end_mark;
start_mark = parser->mark;
/* Check if the tag is in the canonical form. */
if (!CACHE(parser, 2)) goto error;
if (CHECK... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmp... | /dyna-dot[P]libyaml/src/scanner.c |
yaml_parser_scan_plain_scalar | static int
yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token)
{
yaml_mark_t start_mark;
yaml_mark_t end_mark;
yaml_string_t string = NULL_STRING;
yaml_string_t leading_break = NULL_STRING;
yaml_string_t trailing_breaks = NULL_STRING;
yaml_string_t whitespaces = NULL_STRING... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20a0
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20a0
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20... | /dyna-dot[P]libyaml/src/scanner.c |
AvlTree::insert(AvlTree::Node*, int) | AvlTree::Node *AvlTree::insert(Node *node, int value) {
/* 1. Perform the normal BST insertion */
if (node == nullptr) {
return (newNode(value));
}
if (value < node->value) {
node->leftChild = insert(node->leftChild, value);
} else if (value > node->value) {
node->rightChil... | pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
testq %rsi, %rsi
je 0x5518
movq %rsi, %rbx
cmpl %ebp, (%rsi)
jle 0x553a
movq 0x8(%rbx), %rsi
movl %ebp, %edx
callq 0x54f6
movq %rax, 0x8(%rbx)
jmp 0x5553
movl $0x20, %edi
callq 0x5180
movq %rax, %rbx
movl %ebp, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x1,... | /spyridon97[P]DataStructuresComparison/Source/AvlTree.cpp |
AvlTree::containsElement(int, AvlTree::Node*) | AvlTree::Node *AvlTree::containsElement(int value, Node *node) {
if (node == nullptr) { // Element not found
return nullptr;
} else if (value < node->value) { // Searching for element
return containsElement(value, node->leftChild);
} else if (value > node->value) {
return containsEle... | testq %rdx, %rdx
je 0x57c7
movq %rdx, %rax
movl $0x8, %ecx
cmpl %esi, (%rax)
jg 0x57be
movl $0x10, %ecx
jge 0x57c9
movq (%rax,%rcx), %rax
testq %rax, %rax
jne 0x57ae
xorl %eax, %eax
retq
| /spyridon97[P]DataStructuresComparison/Source/AvlTree.cpp |
AvlTree::findMax(AvlTree::Node*) | AvlTree::Node *AvlTree::findMax(Node *node) {
if (node == nullptr) {
return nullptr;
} else if (node->rightChild == nullptr) {
return node;
} else {
return findMax(node->rightChild);
}
} | movq %rsi, %rax
testq %rsi, %rsi
je 0x5829
movq 0x10(%rax), %rsi
testq %rsi, %rsi
jne 0x5818
retq
| /spyridon97[P]DataStructuresComparison/Source/AvlTree.cpp |
BinarySearchTree::insert(BinarySearchTree::Node*, BinarySearchTree::Node*) | bool BinarySearchTree::insert(Node *node, Node *newNode) {
if (root == nullptr) {
root = new Node;
root->value = newNode->value;
root->leftChild = nullptr;
root->rightChild = nullptr;
// std::cout << "Root Node is Added" << std::endl;
return true;
}
if (node-... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpq $0x0, (%rdi)
je 0x5a0c
movl (%rbx), %edx
movl (%rsi), %edi
cmpl %edx, %edi
setne %al
je 0x5a08
xorl %ecx, %ecx
cmpl %edx, %edi
jle 0x59f3
movq 0x8(%rsi), %r8
testq %r8, %r8
jne 0x59fc
jmp 0x5a3a
movq 0x10(%rsi), %r8
testq %r8, %r8
je 0x5a2d
movl (%r8), %edi
movb $0x... | /spyridon97[P]DataStructuresComparison/Source/BinarySearchTree.cpp |
BinarySearchTree::removeElement(int) | bool BinarySearchTree::removeElement(int value) {
Node *parent, *location;
if (root == nullptr) {
return false;
}
find(value, &parent, &location);
if (location == nullptr) {
return false;
}
if (location->leftChild == nullptr && location->rightChild == nullptr) {
caseA... | movl %esi, %eax
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x5aa8
pushq %rbx
cmpl %eax, (%rsi)
jne 0x5aab
movq %rsi, %rbx
xorl %esi, %esi
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x5ad2
cmpq $0x0, 0x10(%rbx)
jne 0x5b04
movq %rdi, %rcx
testq %rsi, %rsi
je 0x5a9c
leaq 0x8(%rsi), %rdx
leaq 0x10(%rsi), %rcx
cmpq %rbx, 0x8(%rsi)... | /spyridon97[P]DataStructuresComparison/Source/BinarySearchTree.cpp |
BinarySearchTree::caseA(BinarySearchTree::Node*, BinarySearchTree::Node*) | void BinarySearchTree::caseA(Node *par, Node *loc) {
if (par == nullptr) {
root = nullptr;
} else {
if (loc == par->leftChild) {
par->leftChild = nullptr;
} else {
par->rightChild = nullptr;
}
}
} | testq %rsi, %rsi
je 0x5bb3
leaq 0x8(%rsi), %rax
leaq 0x10(%rsi), %rdi
cmpq %rdx, 0x8(%rsi)
cmoveq %rax, %rdi
movq $0x0, (%rdi)
retq
nop
| /spyridon97[P]DataStructuresComparison/Source/BinarySearchTree.cpp |
BinarySearchTree::caseB(BinarySearchTree::Node*, BinarySearchTree::Node*) | void BinarySearchTree::caseB(Node *par, Node *loc) {
Node *child;
if (loc->leftChild != nullptr) {
child = loc->leftChild;
} else {
child = loc->rightChild;
}
if (par == nullptr) {
root = child;
} else {
if (loc == par->leftChild) {
par->leftChild = ch... | movq 0x8(%rdx), %rax
testq %rax, %rax
jne 0x5bc9
movq 0x10(%rdx), %rax
testq %rsi, %rsi
je 0x5bde
leaq 0x8(%rsi), %rcx
leaq 0x10(%rsi), %rdi
cmpq %rdx, 0x8(%rsi)
cmoveq %rcx, %rdi
movq %rax, (%rdi)
retq
| /spyridon97[P]DataStructuresComparison/Source/BinarySearchTree.cpp |
BinarySearchTree::findMin(BinarySearchTree::Node*) | BinarySearchTree::Node *BinarySearchTree::findMin(Node *node) {
if (node == nullptr) {
return nullptr;
} else if (node->leftChild == nullptr) {
return node;
} else {
return findMin(node->leftChild);
}
} | movq %rsi, %rax
testq %rsi, %rsi
je 0x5c93
movq 0x8(%rax), %rsi
testq %rsi, %rsi
jne 0x5c82
retq
| /spyridon97[P]DataStructuresComparison/Source/BinarySearchTree.cpp |
RedBlackTree::containsElement(int) | int RedBlackTree::find(Node *&root, int value) {
if (root == nullptr) {
return -1;
}
if (value == root->value) {
return value;
} else if (value < root->value) {
find(root->left, value);
} else if (value > root->value) {
find(root->right, value);
}
return -1;
} | movq (%rdi), %rax
testq %rax, %rax
je 0x5d53
cmpl %esi, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovel %esi, %eax
retq
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
nop
| /spyridon97[P]DataStructuresComparison/Source/RedBlackTree.cpp |
RedBlackTree::insertElement(int) | void RedBlackTree::insertElement(int value) {
auto *node = new Node(value);
root = insert(root, node);
fixInsert(node);
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x20, %edi
callq 0x5180
movl %ebx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
movups %xmm0, 0x10(%rax)
movq %rsp, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5dbe
movq %rax, (%r14)
movq %r14, %rdi
movq %rbx,... | /spyridon97[P]DataStructuresComparison/Source/RedBlackTree.cpp |
RedBlackTree::rotateRight(RedBlackTree::Node*&) | void RedBlackTree::rotateRight(Node *&ptr) {
Node *left_child = ptr->left;
ptr->left = left_child->right;
if (ptr->left != nullptr) {
ptr->left->parent = ptr;
}
left_child->parent = ptr->parent;
if (ptr->parent == nullptr) {
root = left_child;
} else if (ptr == ptr->parent-... | movq (%rsi), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq (%rsi), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x60ae
movq %rcx, 0x18(%rdx)
movq (%rsi), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq (%rsi), %rcx
movq 0x18(%rcx), %rdx
testq %rdx, %rdx
je 0x60d2
leaq 0x8(%rdx), %r8
l... | /spyridon97[P]DataStructuresComparison/Source/RedBlackTree.cpp |
RedBlackTree::fixDelete(RedBlackTree::Node*&) | void RedBlackTree::fixDelete(Node *&node) {
if (node == nullptr) {
return;
}
if (node == root) {
root = nullptr;
return;
}
if (getColor(node) == RED || getColor(node->left) == RED || getColor(node->right) == RED) {
Node *child = node->left != nullptr ? node->left : n... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %r13
testq %r13, %r13
je 0x63a7
movq %rdi, %r14
cmpq (%rdi), %r13
je 0x6240
movq %rsi, %rbx
cmpl $0x0, 0x4(%r13)
movq 0x8(%r13), %rax
je 0x624c
testq %rax, %rax
je 0x6128
cmpl $0x0, 0x4(%rax)
je 0x6255
movq 0x10(%r13), %rcx
testq %rcx,... | /spyridon97[P]DataStructuresComparison/Source/RedBlackTree.cpp |
RedBlackTree::deleteBST(RedBlackTree::Node*&, int) | RedBlackTree::Node *RedBlackTree::deleteBST(Node *&root, int data) {
if (root == nullptr) {
return root;
}
if (data < root->value) {
return deleteBST(root->left, data);
}
if (data > root->value) {
return deleteBST(root->right, data);
}
if (root->left == nullptr || ... | movq (%rsi), %rcx
testq %rcx, %rcx
je 0x6401
movq %rcx, %rax
movl $0x8, %ecx
cmpl %edx, (%rax)
jg 0x63d1
movl $0x10, %ecx
jge 0x63dc
movq (%rax,%rcx), %rax
testq %rax, %rax
jne 0x63c1
jmp 0x6401
cmpq $0x0, 0x8(%rax)
je 0x6403
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x6403
movq %rcx, %rsi
movq %rsi, %rdx
movq 0x8(%rsi... | /spyridon97[P]DataStructuresComparison/Source/RedBlackTree.cpp |
RedBlackTree::merge(RedBlackTree) | void RedBlackTree::merge(RedBlackTree RedBlackTree2) {
int temp;
Node *c, *temp_ptr;
Node *root1 = root;
Node *root2 = RedBlackTree2.root;
int initialblackheight1 = getBlackHeight(root1);
int initialblackheight2 = getBlackHeight(root2);
if (initialblackheight1 > initialblackheight2) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r12
movq (%rsi), %r15
xorl %eax, %eax
movl $0x0, %ebp
testq %r12, %r12
je 0x6485
xorl %ebp, %ebp
movq %r12, %rcx
xorl %edx, %edx
cmpl $0x1, 0x4(%rcx)
sete %dl
addl %edx, %ebp
movq 0x8(%rcx), ... | /spyridon97[P]DataStructuresComparison/Source/RedBlackTree.cpp |
ScapeGoatTree::insertElement(int) | bool ScapeGoatTree::insertElement(int value) {
/* first do basic insertion keeping track of depth */
auto *u = new Node(value);
int d = addWithDepth(u);
if (d > log32(q)) {
/* depth exceeded, find scapegoat */
Node *w = u->parent;
while (3 * size(w) <= 2 * size(w->parent)) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x20, %edi
callq 0x5180
movq %rax, %r14
movl %ebp, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6826
movl %eax, %ebp
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rbx), %x... | /spyridon97[P]DataStructuresComparison/Source/ScapeGoatTree.cpp |
ScapeGoatTree::addWithDepth(ScapeGoatTree::Node*) | int ScapeGoatTree::addWithDepth(Node *node) {
Node *w = root;
if (w == nullptr) {
root = node;
n++;
q++;
return 0;
}
bool done = false;
int d = 0;
do {
if (node->value < w->value) {
if (w->leftChild == nullptr) {
w->leftChild = ... | movq (%rdi), %rcx
testq %rcx, %rcx
je 0x6857
movl 0x18(%rsi), %edx
movl $0x1, %eax
cmpl 0x18(%rcx), %edx
jge 0x6846
movq 0x8(%rcx), %r8
testq %r8, %r8
jne 0x6850
jmp 0x685e
jle 0x6864
movq (%rcx), %r8
testq %r8, %r8
je 0x686a
incl %eax
movq %r8, %rcx
jmp 0x6836
movq %rsi, (%rdi)
xorl %eax, %eax
jmp 0x6874
leaq 0x8(%rcx... | /spyridon97[P]DataStructuresComparison/Source/ScapeGoatTree.cpp |
ScapeGoatTree::rebuild(ScapeGoatTree::Node*) | void ScapeGoatTree::rebuild(Node *node) {
int ns = size(node);
Node *p = node->parent;
auto **a = new Node *[ns];
packIntoArray(node, a, 0);
if (p == nullptr) {
root = buildBalanced(a, 0, ns);
root->parent = nullptr;
} else if (p->rightChild == node) {
p->rightChild = bui... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x68a6
movl %eax, %ebp
movq 0x10(%r14), %r12
movl %eax, %eax
shlq $0x3, %rax
testl %ebp, %ebp
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x5030
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rd... | /spyridon97[P]DataStructuresComparison/Source/ScapeGoatTree.cpp |
ScapeGoatTree::findMin(ScapeGoatTree::Node*) | ScapeGoatTree::Node *ScapeGoatTree::findMin(Node *node) {
if (node == nullptr) {
return nullptr;
} else if (node->leftChild == nullptr) {
return node;
} else {
return findMin(node->leftChild);
}
} | movq %rsi, %rax
testq %rsi, %rsi
je 0x6b1d
movq 0x8(%rax), %rsi
testq %rsi, %rsi
jne 0x6b0c
retq
| /spyridon97[P]DataStructuresComparison/Source/ScapeGoatTree.cpp |
ScapeGoatTree::findMax(ScapeGoatTree::Node*) | ScapeGoatTree::Node *ScapeGoatTree::findMax(Node *node) {
if (node == nullptr) {
return nullptr;
} else if (node->rightChild == nullptr) {
return node;
} else {
return findMax(node->rightChild);
}
} | movq %rsi, %rax
testq %rsi, %rsi
je 0x6b4c
movq (%rax), %rsi
testq %rsi, %rsi
jne 0x6b3c
retq
nop
| /spyridon97[P]DataStructuresComparison/Source/ScapeGoatTree.cpp |
ScapeGoatTree::find(int, ScapeGoatTree::Node**, ScapeGoatTree::Node**) | void ScapeGoatTree::find(int value, Node **par, Node **loc) {
Node *ptr, *ptrSave;
if (root == nullptr) {
*loc = nullptr;
*par = nullptr;
return;
}
if (value == root->value) {
*loc = root;
*par = nullptr;
return;
}
if (value < root->value) {
... | movq (%rdi), %rax
testq %rax, %rax
je 0x6cb8
cmpl %esi, 0x18(%rax)
jne 0x6cc3
movq %rax, %rdi
jmp 0x6cba
xorl %edi, %edi
xorl %eax, %eax
movq %rdi, (%rcx)
movq %rax, (%rdx)
retq
setg %dil
movzbl %dil, %edi
movq (%rax,%rdi,8), %rdi
testq %rdi, %rdi
je 0x6ceb
movl 0x18(%rdi), %r8d
cmpl %esi, %r8d
je 0x6cbc
movq %rdi, %ra... | /spyridon97[P]DataStructuresComparison/Source/ScapeGoatTree.cpp |
ScapeGoatTree::caseA(ScapeGoatTree::Node*, ScapeGoatTree::Node*) | void ScapeGoatTree::caseA(Node *par, Node *loc) {
if (par == nullptr) {
root = nullptr;
} else {
if (loc == par->leftChild) {
par->leftChild = nullptr;
} else {
par->rightChild = nullptr;
}
}
} | testq %rsi, %rsi
je 0x6d01
leaq 0x8(%rsi), %rdi
cmpq %rdx, 0x8(%rsi)
cmovneq %rsi, %rdi
movq $0x0, (%rdi)
retq
nop
| /spyridon97[P]DataStructuresComparison/Source/ScapeGoatTree.cpp |
ScapeGoatTree::caseB(ScapeGoatTree::Node*, ScapeGoatTree::Node*) | void ScapeGoatTree::caseB(Node *par, Node *loc) {
Node *child;
if (loc->leftChild != nullptr) {
child = loc->leftChild;
} else {
child = loc->rightChild;
}
if (par == nullptr) {
root = child;
} else {
if (loc == par->leftChild) {
par->leftChild = child... | movq 0x8(%rdx), %rax
testq %rax, %rax
jne 0x6d16
movq (%rdx), %rax
testq %rsi, %rsi
je 0x6d27
leaq 0x8(%rsi), %rdi
cmpq %rdx, 0x8(%rsi)
cmovneq %rsi, %rdi
movq %rax, (%rdi)
retq
nop
| /spyridon97[P]DataStructuresComparison/Source/ScapeGoatTree.cpp |
ScapeGoatTree::caseC(ScapeGoatTree::Node*, ScapeGoatTree::Node*) | void ScapeGoatTree::caseC(Node *par, Node *loc) {
Node *ptr, *ptrSave, *suc, *parSuc;
ptrSave = loc;
ptr = loc->rightChild;
while (ptr->leftChild != nullptr) {
ptrSave = ptr;
ptr = ptr->leftChild;
}
suc = ptr;
parSuc = ptrSave;
if (suc->leftChild == nullptr && suc->rightC... | movq (%rdx), %r8
movq %rdx, %r9
movq %r8, %rax
movq %r9, %rcx
movq 0x8(%r8), %r8
movq %rax, %r9
testq %r8, %r8
jne 0x6d32
movq (%rax), %r8
leaq 0x8(%rcx), %r9
cmpq %rax, 0x8(%rcx)
cmovneq %rcx, %r9
movq %r8, (%r9)
testq %rsi, %rsi
je 0x6d67
leaq 0x8(%rsi), %rdi
cmpq %rdx, 0x8(%rsi)
cmovneq %rsi, %rdi
movq %rax, (%rdi)
... | /spyridon97[P]DataStructuresComparison/Source/ScapeGoatTree.cpp |
SkipList::SkipList() | SkipList::SkipList() : head(0, MAX_HEIGHT), tail(INF, 0), height(0) {
for (auto &i : head.next) {
i = &tail;
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movabsq $0x7fffffff00000010, %rax # imm = 0x7FFFFFFF00000010
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
leaq 0x10(%rdi), %r14
leaq 0xf(%rsp), %rdx
movl $0x11, %esi
movq %r14, %rdi
callq 0x7332
movl 0x4(%rbx), %eax
movl %eax, 0x28(%rbx)
pxor %xmm0, %xmm0
movd... | /spyridon97[P]DataStructuresComparison/Source/SkipList.cpp |
SkipList::insertElement(int) | bool SkipList::insertElement(int value) {
std::vector<Element *> update((unsigned long long) (MAX_HEIGHT + 1));
Element *p = &head;
for (int i = height; i >= 0; --i) {
while (p->next[i]->value < value) {
p = p->next[i];
}
update[i] = p;
}
p = p->next[0];
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movslq (%rdi), %rsi
incq %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7332
leaq 0x8(%r14), %r13
movslq 0x48(%r14), %rax
movq %r13, %rcx
testq %rax, %rax
js 0x6f58
movq %r13, %rcx
movq %rcx, %rdx... | /spyridon97[P]DataStructuresComparison/Source/SkipList.cpp |
SkipList::randomHeight() | int SkipList::randomHeight() {
int rand_height = 0;
std::srand(10000);
while (std::experimental::randint(0, 10000) < 5000 && rand_height < MAX_HEIGHT) {
++rand_height;
}
return rand_height;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1398, %rsp # imm = 0x1398
movq %rdi, %rbx
movl $0x2710, %edi # imm = 0x2710
callq 0x5160
movq %fs:0x0, %rax
leaq -0x10(%rax), %r14
xorl %ebp, %ebp
movabsq $0x271000000000, %r13 # imm = 0x271000000000
leaq 0x10(%rsp), %r15
le... | /spyridon97[P]DataStructuresComparison/Source/SkipList.cpp |
SkipList::containsElement(int) | bool SkipList::containsElement(int value) {
Element *p = &head;
for (int i = height; i >= 0; --i) {
while (p->next[i]->value < value) {
p = p->next[i];
}
}
// now either p == &head and x <= p->next[0]->key
// or p != &head and p->key < x <= p->next[0]->key
p = p->nex... | movslq 0x48(%rdi), %rax
testq %rax, %rax
js 0x728d
addq $0x8, %rdi
movq %rdi, %rdx
movq %rdx, %rdi
movq 0x8(%rdx), %rcx
movq (%rcx,%rax,8), %rdx
cmpl %esi, (%rdx)
jl 0x7270
leaq -0x1(%rax), %rdx
testq %rax, %rax
movq %rdx, %rax
jg 0x726d
jmp 0x7291
movq 0x10(%rdi), %rcx
movq (%rcx), %rax
cmpl %esi, (%rax)
sete %al
retq... | /spyridon97[P]DataStructuresComparison/Source/SkipList.cpp |
SplayTree::insert(int, SplayTree::Node*) | SplayTree::Node *SplayTree::insert(int value, Node *root) {
static Node *p_node = nullptr;
if (!p_node) {
p_node = newNode(value);
} else {// could take advantage of the node remains because of there was duplicate key before.
p_node->value = value;
}
if (!root) {
root = p_nod... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq 0x6aae(%rip), %rcx # 0xe160
testq %rcx, %rcx
je 0x76bb
movl %ebx, (%rcx)
jmp 0x76d8
movl $0x18, %edi
callq 0x5180
movq %rax, %rcx
movl %ebx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x6a88(%rip) # 0xe160
testq %r14, %r14... | /spyridon97[P]DataStructuresComparison/Source/SplayTree.cpp |
SplayTree::remove(int, SplayTree::Node*) | SplayTree::Node *SplayTree::remove(int value, Node *root) {
Node *temp;
if (!root) {
return nullptr;
}
root = splay(value, root);
if (value != root->value) { // No such node in splay tree
return root;
} else {
if (!root->leftChild) {
temp = root;
r... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0x777a
movl %esi, %ebp
callq 0x78a2
movq %rax, %rbx
cmpl %ebp, (%rax)
jne 0x778d
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x777e
movl %ebp, %esi
callq 0x78a2
movq %rax, %r14
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
jmp 0x7782
xorl %ebx, %ebx
jmp 0x778d
movq 0x10(%... | /spyridon97[P]DataStructuresComparison/Source/SplayTree.cpp |
SplayTree::findMin(SplayTree::Node*) | SplayTree::Node *SplayTree::findMin(Node *node) {
if (node == nullptr) {
return nullptr;
} else if (node->leftChild == nullptr) {
return node;
} else {
return findMin(node->leftChild);
}
} | movq %rsi, %rax
testq %rsi, %rsi
je 0x77ed
movq 0x8(%rax), %rsi
testq %rsi, %rsi
jne 0x77dc
retq
| /spyridon97[P]DataStructuresComparison/Source/SplayTree.cpp |
SplayTree::findMax(SplayTree::Node*) | SplayTree::Node *SplayTree::findMax(Node *node) {
if (node == nullptr) {
return nullptr;
} else if (node->rightChild == nullptr) {
return node;
} else {
return findMax(node->rightChild);
}
} | movq %rsi, %rax
testq %rsi, %rsi
je 0x781d
movq 0x10(%rax), %rsi
testq %rsi, %rsi
jne 0x780c
retq
| /spyridon97[P]DataStructuresComparison/Source/SplayTree.cpp |
SplayTree::splay(int, SplayTree::Node*) | SplayTree::Node *SplayTree::splay(int value, Node *root) {
if (!root) {
return nullptr;
}
Node header{};
/* header.rChild points to L tree; header.lChild points to R Tree */
header.leftChild = header.rightChild = nullptr;
Node *LeftTreeMax = &header;
Node *RightTreeMin = &header;
... | testq %rdx, %rdx
je 0x795b
xorps %xmm0, %xmm0
leaq -0x18(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq %rcx, %rdi
cmpl %esi, (%rdx)
jle 0x78e7
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x7935
cmpl %esi, (%rax)
jle 0x790b
movq 0x10(%rax), %r8
movq %r8, 0x8(%rdx)
movq %rdx, 0x10(%rax)
cmpq $0x0, 0x8(%rax)
jn... | /spyridon97[P]DataStructuresComparison/Source/SplayTree.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.