name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
testing::UnitTest::total_test_count() const | const internal::UnitTestImpl* impl() const { return impl_; } | movq 0x40(%rdi), %rax
movq 0xb8(%rax), %rcx
movq 0xc0(%rax), %rdx
subq %rcx, %rdx
je 0x2bed5
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rcx,%rsi,8), %rdi
movq 0x38(%rdi), %r8
subq 0x30(%rdi), %r8
shrq $0x3, %r8
addl %r8d, %eax
incq %rsi
cmpq %rsi, %rdx
jne 0x2beb9
retq
xorl %eax, %eax
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::UnitTest::GetTestCase(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 0x2bf33
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x2bf33
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x2bf33
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
retq
xorl %eax, %eax
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::UnitTest::Run() | int UnitTest::Run() {
const bool in_death_test_child_process =
GTEST_FLAG_GET(internal_run_death_test).length() > 0;
// Google Test implements this protocol for catching that a test
// program exits before returning control to Google Test:
//
// 1. Upon start, Google Test creates a file whose absolute path
// is specified by the environment variable
// TEST_PREMATURE_EXIT_FILE.
// 2. When Google Test has finished its work, it deletes the file.
//
// This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
// running a Google-Test-based test program and check the existence
// of the file at the end of the test execution to see if it has
// exited prematurely.
// If we are in the child process of a death test, don't
// create/delete the premature exit file, as doing so is unnecessary
// and will confuse the parent process. Otherwise, create/delete
// the file upon entering/leaving this function. If the program
// somehow exits before this function has a chance to return, the
// premature-exit file will be left undeleted, causing a test runner
// that understands the premature-exit-file protocol to report the
// test as having failed.
const internal::ScopedPrematureExitFile premature_exit_file(
in_death_test_child_process
? nullptr
: internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
// Captures the value of GTEST_FLAG(catch_exceptions). This value will be
// used for the duration of the program.
impl()->set_catch_exceptions(GTEST_FLAG_GET(catch_exceptions));
#if GTEST_OS_WINDOWS
// Either the user wants Google Test to catch exceptions thrown by the
// tests or this is executing in the context of death test child
// process. In either case the user does not want to see pop-up dialogs
// about crashes - they are expected.
if (impl()->catch_exceptions() || in_death_test_child_process) {
#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
// SetErrorMode doesn't exist on CE.
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
#endif // !GTEST_OS_WINDOWS_MOBILE
#if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
// Death test children can be terminated with _abort(). On Windows,
// _abort() can show a dialog with a warning message. This forces the
// abort message to go to stderr instead.
_set_error_mode(_OUT_TO_STDERR);
#endif
#if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
// In the debug version, Visual Studio pops up a separate dialog
// offering a choice to debug the aborted program. We need to suppress
// this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
// executed. Google Test will notify the user of any unexpected
// failure via stderr.
if (!GTEST_FLAG_GET(break_on_failure))
_set_abort_behavior(
0x0, // Clear the following flags:
_WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump.
// In debug mode, the Windows CRT can crash with an assertion over invalid
// input (e.g. passing an invalid file descriptor). The default handling
// for these assertions is to pop up a dialog and wait for user input.
// Instead ask the CRT to dump such assertions to stderr non-interactively.
if (!IsDebuggerPresent()) {
(void)_CrtSetReportMode(_CRT_ASSERT,
_CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
(void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
}
#endif
}
#endif // GTEST_OS_WINDOWS
return internal::HandleExceptionsInMethodIfSupported(
impl(), &internal::UnitTestImpl::RunAllTests,
"auxiliary test code (environments or event listeners)")
? 0
: 1;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x275a4(%rip) # 0x53668
je 0x2c0ca
xorl %esi, %esi
jmp 0x2c0d9
leaq 0x123c8(%rip), %rdi # 0x3e499
callq 0x96b0
movq %rax, %rsi
movq %rsp, %rdi
callq 0x32ee2
movq 0x40(%rbx), %rdi
movb 0x275da(%rip), %al # 0x536c5
movb %al, 0x258(%rdi)
leaq 0x36(%rip), %rsi # 0x2c12e
leaq 0x123b3(%rip), %rcx # 0x3e4b2
xorl %edx, %edx
callq 0x32f55
xorb $0x1, %al
movzbl %al, %ebx
movq %rsp, %rdi
callq 0x330ce
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x330ce
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RunAllTests() | bool UnitTestImpl::RunAllTests() {
// True if and only if Google Test is initialized before RUN_ALL_TESTS() is
// called.
const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
// Do not run any test if the --help flag was specified.
if (g_help_flag) return true;
// Repeats the call to the post-flag parsing initialization in case the
// user didn't call InitGoogleTest.
PostFlagParsingInit();
// Even if sharding is not on, test runners may want to use the
// GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
// protocol.
internal::WriteToShardStatusFileIfNeeded();
// True if and only if we are in a subprocess for running a thread-safe-style
// death test.
bool in_subprocess_for_death_test = false;
#if GTEST_HAS_DEATH_TEST
in_subprocess_for_death_test =
(internal_run_death_test_flag_.get() != nullptr);
#if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
if (in_subprocess_for_death_test) {
GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
}
#endif // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
#endif // GTEST_HAS_DEATH_TEST
const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
in_subprocess_for_death_test);
// Compares the full test names with the filter to decide which
// tests to run.
const bool has_tests_to_run =
FilterTests(should_shard ? HONOR_SHARDING_PROTOCOL
: IGNORE_SHARDING_PROTOCOL) > 0;
// Lists the tests and exits if the --gtest_list_tests flag was specified.
if (GTEST_FLAG_GET(list_tests)) {
// This must be called *after* FilterTests() has been called.
ListTestsMatchingFilter();
return true;
}
random_seed_ = GetRandomSeedFromFlag(GTEST_FLAG_GET(random_seed));
// True if and only if at least one test has failed.
bool failed = false;
TestEventListener* repeater = listeners()->repeater();
start_timestamp_ = GetTimeInMillis();
repeater->OnTestProgramStart(*parent_);
// How many times to repeat the tests? We don't want to repeat them
// when we are inside the subprocess of a death test.
const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG_GET(repeat);
// Repeats forever if the repeat count is negative.
const bool gtest_repeat_forever = repeat < 0;
// Should test environments be set up and torn down for each repeat, or only
// set up on the first and torn down on the last iteration? If there is no
// "last" iteration because the tests will repeat forever, always recreate the
// environments to avoid leaks in case one of the environments is using
// resources that are external to this process. Without this check there would
// be no way to clean up those external resources automatically.
const bool recreate_environments_when_repeating =
GTEST_FLAG_GET(recreate_environments_when_repeating) ||
gtest_repeat_forever;
for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
// We want to preserve failures generated by ad-hoc test
// assertions executed before RUN_ALL_TESTS().
ClearNonAdHocTestResult();
Timer timer;
// Shuffles test suites and tests if requested.
if (has_tests_to_run && GTEST_FLAG_GET(shuffle)) {
random()->Reseed(static_cast<uint32_t>(random_seed_));
// This should be done before calling OnTestIterationStart(),
// such that a test event listener can see the actual test order
// in the event.
ShuffleTests();
}
// Tells the unit test event listeners that the tests are about to start.
repeater->OnTestIterationStart(*parent_, i);
// Runs each test suite if there is at least one test to run.
if (has_tests_to_run) {
// Sets up all environments beforehand. If test environments aren't
// recreated for each iteration, only do so on the first iteration.
if (i == 0 || recreate_environments_when_repeating) {
repeater->OnEnvironmentsSetUpStart(*parent_);
ForEach(environments_, SetUpEnvironment);
repeater->OnEnvironmentsSetUpEnd(*parent_);
}
// Runs the tests only if there was no fatal failure or skip triggered
// during global set-up.
if (Test::IsSkipped()) {
// Emit diagnostics when global set-up calls skip, as it will not be
// emitted by default.
TestResult& test_result =
*internal::GetUnitTestImpl()->current_test_result();
for (int j = 0; j < test_result.total_part_count(); ++j) {
const TestPartResult& test_part_result =
test_result.GetTestPartResult(j);
if (test_part_result.type() == TestPartResult::kSkip) {
const std::string& result = test_part_result.message();
printf("%s\n", result.c_str());
}
}
fflush(stdout);
} else if (!Test::HasFatalFailure()) {
for (int test_index = 0; test_index < total_test_suite_count();
test_index++) {
GetMutableSuiteCase(test_index)->Run();
if (GTEST_FLAG_GET(fail_fast) &&
GetMutableSuiteCase(test_index)->Failed()) {
for (int j = test_index + 1; j < total_test_suite_count(); j++) {
GetMutableSuiteCase(j)->Skip();
}
break;
}
}
} else if (Test::HasFatalFailure()) {
// If there was a fatal failure during the global setup then we know we
// aren't going to run any tests. Explicitly mark all of the tests as
// skipped to make this obvious in the output.
for (int test_index = 0; test_index < total_test_suite_count();
test_index++) {
GetMutableSuiteCase(test_index)->Skip();
}
}
// Tears down all environments in reverse order afterwards. If test
// environments aren't recreated for each iteration, only do so on the
// last iteration.
if (i == repeat - 1 || recreate_environments_when_repeating) {
repeater->OnEnvironmentsTearDownStart(*parent_);
std::for_each(environments_.rbegin(), environments_.rend(),
TearDownEnvironment);
repeater->OnEnvironmentsTearDownEnd(*parent_);
}
}
elapsed_time_ = timer.Elapsed();
// Tells the unit test event listener that the tests have just finished.
repeater->OnTestIterationEnd(*parent_, i);
// Gets the result and clears it.
if (!Passed()) {
failed = true;
}
// Restores the original test order after the iteration. This
// allows the user to quickly repro a failure that happens in the
// N-th iteration without repeating the first (N - 1) iterations.
// This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
// case the user somehow changes the value of the flag somewhere
// (it's always safe to unshuffle the tests).
UnshuffleTests();
if (GTEST_FLAG_GET(shuffle)) {
// Picks a new random seed for each iteration.
random_seed_ = GetNextRandomSeed(random_seed_);
}
}
repeater->OnTestProgramEnd(*parent_);
if (!gtest_is_initialized_before_run_all_tests) {
ColoredPrintf(
GTestColor::kRed,
"\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
"This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
"() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
" will start to enforce the valid usage. "
"Please fix it ASAP, or IT WILL START TO FAIL.\n"); // NOLINT
#if GTEST_FOR_GOOGLE_
ColoredPrintf(GTestColor::kRed,
"For more details, see http://wiki/Main/ValidGUnitMain.\n");
#endif // GTEST_FOR_GOOGLE_
}
return !failed;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x2764a(%rip), %rsi # 0x53790
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x30742
movq (%r14), %r13
movq 0x8(%r14), %rbp
movq %r14, %rdi
callq 0x30492
movb $0x1, %r14b
cmpb $0x0, 0x27555(%rip) # 0x536c1
jne 0x2c6fd
movq %rbx, %rdi
callq 0x2d236
callq 0x2d5c2
movq 0x238(%rbx), %r12
xorl %edx, %edx
testq %r12, %r12
setne %dl
leaq 0xf8bb(%rip), %rdi # 0x3ba50
leaq 0xf8d4(%rip), %rsi # 0x3ba70
callq 0x2158a
xorb $0x1, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x2d62c
movl %eax, 0x14(%rsp)
cmpb $0x1, 0x27550(%rip) # 0x53709
jne 0x2c1c8
movq %rbx, %rdi
callq 0x2d97e
jmp 0x2c6fd
movl 0x27566(%rip), %edx # 0x53734
movabsq $0x431bde82d7b634db, %r14 # imm = 0x431BDE82D7B634DB
testl %edx, %edx
jne 0x2c1f1
callq 0x90b0
imulq %r14
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x12, %rdx
addl %eax, %edx
decl %edx
movl $0xa7c61a3b, %eax # imm = 0xA7C61A3B
imulq %rdx, %rax
shrq $0x30, %rax
imull $0x1869f, %eax, %eax # imm = 0x1869F
subl %eax, %edx
incl %edx
movl %edx, 0x21c(%rbx)
movq 0x1f8(%rbx), %r15
callq 0x90b0
imulq %r14
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
movq %rdx, 0x228(%rbx)
movq 0x8(%rbx), %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movl $0x1, %edx
testq %r12, %r12
jne 0x2c251
movl 0x274e7(%rip), %edx # 0x53738
testl %edx, %edx
sets %al
je 0x2c6d2
movq %rbp, 0x18(%rsp)
movq %r13, 0x20(%rsp)
orb 0x274d0(%rip), %al # 0x5373c
movb %al, 0xe(%rsp)
leal -0x1(%rdx), %eax
movl %eax, 0x10(%rsp)
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %rdx, 0x28(%rsp)
movq 0xb8(%rbx), %r12
movq 0xc0(%rbx), %r13
cmpq %r13, %r12
je 0x2c2a3
movq (%r12), %rdi
callq 0x20e60
addq $0x8, %r12
jmp 0x2c28f
callq 0x9790
movq %rax, 0x30(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x2c31d
cmpb $0x1, 0x27483(%rip) # 0x5373e
jne 0x2c2d1
movl 0x21c(%rbx), %eax
movl %eax, 0x220(%rbx)
movq %rbx, %rdi
callq 0x2ddce
movq 0x8(%rbx), %rsi
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %edx
callq *0x18(%rax)
testl %ebp, %ebp
sete %al
orb 0xe(%rsp), %al
testb $0x1, %al
je 0x2c33e
movq 0x8(%rbx), %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
movq 0xa0(%rbx), %r12
movq 0xa8(%rbx), %r13
cmpq %r13, %r12
je 0x2c331
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r12
jmp 0x2c308
movq 0x8(%rbx), %rsi
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %edx
callq *0x18(%rax)
jmp 0x2c632
movq 0x8(%rbx), %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
callq 0x1fcfc
testb %al, %al
je 0x2c36f
callq 0x1832e
movq 0x2749d(%rip), %rax # 0x537f0
movq 0x170(%rax), %r13
testq %r13, %r13
je 0x2c53d
addq $0x90, %r13
jmp 0x2c55b
callq 0x1fc92
testb %al, %al
je 0x2c3ff
callq 0x1fc92
testb %al, %al
je 0x2c5e6
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x2c5e6
xorl %r12d, %r12d
movq 0xd0(%rbx), %rcx
movq 0xd8(%rbx), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %r12
jge 0x2c3cf
movl (%rcx,%r12,4), %edx
movl %edx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x20d82
incq %r12
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jl 0x2c3a9
jmp 0x2c5e6
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x2c5e6
movl $0x1, %r13d
leaq -0x1(%r13), %r12
movq 0xd0(%rbx), %rcx
movq 0xd8(%rbx), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %r12
jge 0x2c44d
movl -0x4(%rcx,%r13,4), %edx
movl %edx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x20ac4
cmpb $0x1, 0x27263(%rip) # 0x536c2
jne 0x2c4bd
movq 0xd0(%rbx), %rax
movq 0xd8(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rdx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rdx, %r12
jge 0x2c488
movl -0x4(%rax,%r13,4), %ecx
testl %ecx, %ecx
js 0x2c49b
movl %ecx, %eax
movq 0xb8(%rbx), %rcx
movq (%rcx,%rax,8), %r12
jmp 0x2c49e
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x1b94c
testl %eax, %eax
jg 0x2c51e
addq $0x88, %r12
movq %r12, %rdi
callq 0x1f248
testb %al, %al
jne 0x2c51e
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
leaq 0x1(%r13), %rdx
cmpq %rcx, %r13
movq %rdx, %r13
jl 0x2c422
jmp 0x2c5e6
movq 0xd0(%rbx), %rcx
movq 0xd8(%rbx), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rsi, %r13
jge 0x2c510
movl (%rcx,%r13,4), %edx
movl %edx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x20d82
incq %r13
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ecx, %r13d
jl 0x2c4ea
jmp 0x2c5e6
movq 0x168(%rax), %r13
testq %r13, %r13
je 0x2c552
addq $0x88, %r13
jmp 0x2c55b
addq $0x178, %rax # imm = 0x178
movq %rax, %r13
movq 0x40(%r13), %rax
subq 0x38(%r13), %rax
shrq $0x4, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
testl %eax, %eax
jle 0x2c5d7
xorl %r12d, %r12d
movq %r13, %rdi
movl %r12d, %esi
callq 0x1eb1c
cmpl $0x3, (%rax)
jne 0x2c5bd
movq 0x50(%rax), %rsi
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30290
movq 0x38(%rsp), %rdi
callq 0x98e0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x2c5bd
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x40(%r13), %rax
subq 0x38(%r13), %rax
incl %r12d
shrq $0x4, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
cmpl %eax, %r12d
jl 0x2c574
movq 0x269b2(%rip), %rax # 0x52f90
movq (%rax), %rdi
callq 0x9640
cmpl 0x10(%rsp), %ebp
sete %al
orb 0xe(%rsp), %al
testb $0x1, %al
je 0x2c632
movq 0x8(%rbx), %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x70(%rax)
movq 0xa0(%rbx), %r12
movq 0xa8(%rbx), %r13
cmpq %r12, %r13
je 0x2c625
movq -0x8(%r13), %rdi
addq $-0x8, %r13
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x2c610
movq 0x8(%rbx), %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x78(%rax)
callq 0x9790
subq 0x30(%rsp), %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
movq %rdx, 0x230(%rbx)
movq 0x8(%rbx), %rsi
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %edx
callq *0x80(%rax)
movq %rbx, %rdi
callq 0x32e24
movzbl %r14b, %r14d
testb %al, %al
movl $0x1, %eax
cmovel %eax, %r14d
movq %rbx, %rdi
callq 0x2de5c
cmpb $0x1, 0x270a8(%rip) # 0x5373e
jne 0x2c6a9
movl 0x21c(%rbx), %edi
callq 0x33654
movl %eax, 0x21c(%rbx)
movq 0x28(%rsp), %rdx
testl %edx, %edx
sets %al
incl %ebp
cmpl %edx, %ebp
setne %cl
orb %al, %cl
jne 0x2c281
xorb $0x1, %r14b
movq 0x20(%rsp), %r13
movq 0x18(%rsp), %rbp
jmp 0x2c6d5
movb $0x1, %r14b
movq 0x8(%rbx), %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x88(%rax)
cmpq %r13, %rbp
jne 0x2c6fd
leaq 0x11e4d(%rip), %rsi # 0x3e53e
movl $0x1, %edi
xorl %eax, %eax
callq 0x21426
andb $0x1, %r14b
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::PostFlagParsingInit() | void UnitTestImpl::PostFlagParsingInit() {
// Ensures that this function does not execute more than once.
if (!post_flag_parse_init_performed_) {
post_flag_parse_init_performed_ = true;
#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
// Register to send notifications about key process state changes.
listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
#endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
#if GTEST_HAS_DEATH_TEST
InitDeathTestSubprocessControlInfo();
SuppressTestEventsIfInSubprocess();
#endif // GTEST_HAS_DEATH_TEST
// Registers parameterized tests. This makes parameterized tests
// available to the UnitTest reflection API without running
// RUN_ALL_TESTS.
RegisterParameterizedTests();
// Configures listeners for XML output. This makes it possible for users
// to shut down the default XML output before invoking RUN_ALL_TESTS.
ConfigureXmlOutput();
if (GTEST_FLAG_GET(brief)) {
listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
}
#if GTEST_CAN_STREAM_RESULTS_
// Configures listeners for streaming test results to the specified server.
ConfigureStreamingOutput();
#endif // GTEST_CAN_STREAM_RESULTS_
#if GTEST_HAS_ABSL
if (GTEST_FLAG_GET(install_failure_signal_handler)) {
absl::FailureSignalHandlerOptions options;
absl::InstallFailureSignalHandler(options);
}
#endif // GTEST_HAS_ABSL
}
} | cmpb $0x0, 0x218(%rdi)
je 0x2d240
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x218(%rdi)
leaq 0x238(%rdi), %r14
callq 0x13670
movq %r14, %rdi
movq %rax, %rsi
callq 0x37bf2
cmpq $0x0, 0x238(%rbx)
je 0x2d27a
movq 0x1f8(%rbx), %rax
movb $0x0, 0x8(%rax)
movq %rbx, %rdi
callq 0x204be
movq %rbx, %rdi
callq 0x2ce86
cmpb $0x1, 0x2649f(%rip) # 0x53730
jne 0x2d2b9
leaq 0x1f8(%rbx), %r14
movl $0x8, %edi
callq 0x94d0
leaq 0x2514d(%rip), %rcx # 0x523f8
movq %rcx, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x2bd64
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d074
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrintOnOneLine(char const*, int) | static void PrintOnOneLine(const char* str, int max_length) {
if (str != nullptr) {
for (int i = 0; *str != '\0'; ++str) {
if (i >= max_length) {
printf("...");
break;
}
if (*str == '\n') {
printf("\\n");
i += 2;
} else {
printf("%c", *str);
++i;
}
}
}
} | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2df1a
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x2df1a
incq %rbx
leaq 0x10431(%rip), %r14 # 0x3e314
xorl %ebp, %ebp
cmpl $0xfa, %ebp
jae 0x2df1f
cmpb $0xa, %al
jne 0x2df02
movq %r14, %rdi
xorl %eax, %eax
callq 0x90a0
movl $0x2, %eax
jmp 0x2df0f
movsbl %al, %edi
callq 0x97e0
movl $0x1, %eax
addl %eax, %ebp
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x2dee5
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10567(%rip), %rdi # 0x3e48d
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x90a0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::InitGoogleTest() | void InitGoogleTest() {
// Since Arduino doesn't have a command line, fake out the argc/argv arguments
int argc = 1;
const auto arg0 = "dummy";
char* argv0 = const_cast<char*>(arg0);
char** argv = &argv0;
#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
internal::InitGoogleTestImpl(&argc, argv);
#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
} | subq $0x18, %rsp
leaq 0xc(%rsp), %rdi
movl $0x1, (%rdi)
leaq 0x104e7(%rip), %rax # 0x3e764
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
callq 0x33d60
addq $0x18, %rsp
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::FailureTest::FailureTest(testing::internal::CodeLocation const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) | explicit FailureTest(const CodeLocation& loc, std::string error_message,
bool as_error)
: loc_(loc),
error_message_(std::move(error_message)),
as_error_(as_error) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1f30c
leaq 0x232c0(%rip), %rax # 0x52670
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0xc86c
movl 0x20(%r15), %eax
movl %eax, 0x30(%rbx)
leaq 0x48(%rbx), %rcx
movq %rcx, 0x38(%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x2f3f6
movq %rdx, 0x38(%rbx)
movq (%rax), %rcx
movq %rcx, 0x48(%rbx)
jmp 0x2f3fc
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movb $0x1, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x22a50(%rip), %rax # 0x51e78
movq %rax, (%rbx)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x32686
movq %r14, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ExecDeathTest::ExecDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int) | ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
const char* file, int line)
: ForkingDeathTest(a_statement, std::move(matcher)),
file_(file),
line_(line) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdi, %r15
leaq 0x22433(%rip), %rcx # 0x52980
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x8(%rdx)
leaq 0x22194(%rip), %rcx # 0x52708
movq %rcx, (%rax)
movq %rax, %rdx
callq 0xe926
leaq 0x8(%rsp), %rdi
callq 0x302ce
leaq 0x21c90(%rip), %rax # 0x52220
movq %rax, (%r15)
movq %r14, 0x40(%r15)
movl %ebx, 0x48(%r15)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x302ce
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::NoExecDeathTest::NoExecDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>) | NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher)
: ForkingDeathTest(a_statement, std::move(matcher)) {} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x223b7(%rip), %rcx # 0x52980
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x8(%rdx)
leaq 0x22118(%rip), %rcx # 0x52708
movq %rcx, (%rax)
movq %rax, %rdx
callq 0xe926
leaq 0x8(%rsp), %rdi
callq 0x302ce
leaq 0x21bb4(%rip), %rax # 0x521c0
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x302ce
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-death-test.cc |
void testing::internal::PrintCharAndCodeTo<unsigned char>(unsigned char, std::ostream*) | void PrintCharAndCodeTo(Char c, ostream* os) {
// First, print c as a literal in the most readable form we can find.
*os << GetCharWidthPrefix(c) << "'";
const CharFormat format = PrintAsCharLiteralTo(c, os);
*os << "'";
// To aid user debugging, we also print c's code in decimal, unless
// it's 0 (in which case c was printed as '\\0', making the code
// obvious).
if (c == 0) return;
*os << " (" << static_cast<int>(c);
// For more convenience, we print c's code again in hexadecimal,
// unless c was already printed in the form '\x##' or the code is in
// [1, 9].
if (format == kHexEscape || (1 <= c && c <= 9)) {
// Do nothing.
} else {
*os << ", 0x" << String::FormatHexInt(static_cast<int>(c));
}
*os << ")";
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xd788(%rip), %rsi # 0x3dfa9
movq %rbx, %rdi
xorl %edx, %edx
callq 0x95f0
leaq 0xcd1f(%rip), %rsi # 0x3d551
movl $0x1, %edx
movq %rbx, %rdi
callq 0x95f0
cmpl $0xd, %ebp
ja 0x3085f
movl %ebp, %eax
leaq 0xc263(%rip), %rcx # 0x3cab0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xd157(%rip), %rsi # 0x3d9b4
jmp 0x308d3
cmpl $0x27, %ebp
je 0x308cc
cmpl $0x5c, %ebp
jne 0x30872
leaq 0xeafc(%rip), %rsi # 0x3f36c
jmp 0x308d3
movl %ebp, %eax
addl $-0x20, %eax
cmpl $0x5e, %eax
ja 0x30992
movq %rsp, %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
jmp 0x308d8
leaq 0xeade(%rip), %rsi # 0x3f372
jmp 0x308d3
leaq 0xda7a(%rip), %rsi # 0x3e317
jmp 0x308d3
leaq 0xda74(%rip), %rsi # 0x3e31a
jmp 0x308d3
leaq 0xeac0(%rip), %rsi # 0x3f36f
jmp 0x308d3
leaq 0xda5c(%rip), %rsi # 0x3e314
jmp 0x308d3
leaq 0xda4d(%rip), %rsi # 0x3e30e
jmp 0x308d3
leaq 0xda47(%rip), %rsi # 0x3e311
jmp 0x308d3
leaq 0xea96(%rip), %rsi # 0x3f369
movl $0x2, %edx
movq %rbx, %rdi
callq 0x95f0
xorl %r14d, %r14d
leaq 0xcc67(%rip), %rsi # 0x3d551
movl $0x1, %edx
movq %rbx, %rdi
callq 0x95f0
testb %bpl, %bpl
je 0x30989
leaq 0xd053(%rip), %rsi # 0x3d95a
movl $0x2, %edx
movq %rbx, %rdi
callq 0x95f0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x99a0
cmpb $0xa, %bpl
setb %al
orb %r14b, %al
jne 0x30975
leaq 0xea33(%rip), %rsi # 0x3f364
movl $0x4, %edx
movq %rbx, %rdi
callq 0x95f0
movq %rsp, %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x1e3ee
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x95f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30975
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0xd449(%rip), %rsi # 0x3ddc5
movl $0x1, %edx
movq %rbx, %rdi
callq 0x95f0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %r14d
leaq 0xe9d0(%rip), %rsi # 0x3f375
movl $0x2, %edx
movq %rbx, %rdi
callq 0x95f0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
orl $0x4000, 0x18(%rbx,%rax) # imm = 0x4000
movq %rbx, %rdi
movl %ebp, %esi
callq 0x99a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %r14d, 0x18(%rbx,%rax)
movb $0x1, %r14b
jmp 0x308e3
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30a0f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char const*>(char const* const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x1bce0
movq (%r14), %r15
movq (%r12), %r14
addq $0x10, %r14
testq %r15, %r15
je 0x31280
movq %r15, %rdi
callq 0x9230
movq %rax, %rdx
jmp 0x3128c
movl $0x6, %edx
leaq 0xc710(%rip), %r15 # 0x3d99c
movq %r14, %rdi
movq %r15, %rsi
callq 0x95f0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x35892
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x312b1
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x312d2
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [5]>(char const (&) [5]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1bce0
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x9230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x95f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x35892
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x313ae
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x313ce
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [27]>(char const (&) [27]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1bce0
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x9230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x95f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x35892
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x31618
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x31638
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [17]>(char const (&) [17]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1bce0
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x9230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x95f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x35892
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x31792
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x317b2
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::TestPartResult::TestPartResult(testing::TestPartResult::Type, char const*, int, char const*) | TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdi, %r14
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
testq %rdx, %rdx
leaq 0xb49e(%rip), %r12 # 0x3dfa9
cmovneq %rdx, %r12
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq %r12, %rdi
callq 0x9230
leaq (%rax,%r12), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x37c48
movl %ebp, 0x28(%r14)
leaq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x17820
leaq 0x50(%r14), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0x30290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x30(%r14), %rdi
addq $0x40, %r14
cmpq %r14, %rdi
je 0x32b7e
movq (%r14), %rsi
incq %rsi
callq 0x9500
jmp 0x32b7e
movq %rax, %r15
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x32b92
movq (%r13), %rsi
incq %rsi
callq 0x9500
movq %r15, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-test-part.h |
testing::internal::UnitTestImpl::Passed() const | bool Passed() const { return !Failed(); } | pushq %rbx
movq %rdi, %rbx
callq 0x1b734
testl %eax, %eax
jle 0x32e35
xorl %eax, %eax
jmp 0x32e46
addq $0x178, %rbx # imm = 0x178
movq %rbx, %rdi
callq 0x1f248
xorb $0x1, %al
popq %rbx
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::Message::Message(testing::Message const&) | Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
*ss_ << msg.GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x188, %edi # imm = 0x188
callq 0x94d0
movq %rax, %r15
movq %rax, %rdi
callq 0x9370
movq %r15, (%rbx)
movq (%r14), %rsi
movq %rsp, %rdi
callq 0x1bf43
addq $0x10, %r15
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x95f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33794
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x337c1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x337c1
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x337cf
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
jmp 0x337e8
movq %rax, %r14
movl $0x188, %esi # imm = 0x188
movq %r15, %rdi
callq 0x9500
movq %r14, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
void testing::internal::ShuffleRange<int>(testing::internal::Random*, int, int, std::vector<int, std::allocator<int>>*) | void ShuffleRange(internal::Random* random, int begin, int end,
std::vector<E>* v) {
const int size = static_cast<int>(v->size());
GTEST_CHECK_(0 <= begin && begin <= size)
<< "Invalid shuffle range start " << begin << ": must be in range [0, "
<< size << "].";
GTEST_CHECK_(begin <= end && end <= size)
<< "Invalid shuffle range finish " << end << ": must be in range ["
<< begin << ", " << size << "].";
// Fisher-Yates shuffle, from
// http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
for (int range_width = end - begin; range_width >= 2; range_width--) {
const int last_in_range = begin + range_width - 1;
const int selected =
begin +
static_cast<int>(random->Generate(static_cast<uint32_t>(range_width)));
std::swap((*v)[static_cast<size_t>(selected)],
(*v)[static_cast<size_t>(last_in_range)]);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rcx), %r15
subq (%rcx), %r15
shrq $0x2, %r15
testl %esi, %esi
js 0x3386a
cmpl %ebp, %r15d
jge 0x33903
leaq 0xb5bf(%rip), %rdx # 0x3ee30
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x131, %ecx # imm = 0x131
callq 0x161ce
movq 0x1f764(%rip), %rdi # 0x52ff0
leaq 0xbc0a(%rip), %rsi # 0x3f49d
movl $0x2e, %edx
callq 0x95f0
movq 0x1f74c(%rip), %rdi # 0x52ff0
leaq 0xbc21(%rip), %rsi # 0x3f4cc
movl $0x1c, %edx
callq 0x95f0
movq 0x1f734(%rip), %rdi # 0x52ff0
movl %ebp, %esi
callq 0x99a0
movq %rax, %r13
leaq 0xbc1c(%rip), %rsi # 0x3f4e9
movl $0x17, %edx
movq %rax, %rdi
callq 0x95f0
movq %r13, %rdi
movl %r15d, %esi
callq 0x99a0
leaq 0xb98f(%rip), %rsi # 0x3f27b
movl $0x2, %edx
movq %rax, %rdi
callq 0x95f0
leaq 0x4(%rsp), %rdi
callq 0x16310
movl %r12d, %r13d
subl %ebp, %r13d
jl 0x33914
cmpl %r12d, %r15d
jge 0x339cb
leaq 0xb515(%rip), %rdx # 0x3ee30
movq %rsp, %rdi
movl $0x3, %esi
movl $0x134, %ecx # imm = 0x134
callq 0x161ce
movq 0x1f6bc(%rip), %rdi # 0x52ff0
leaq 0xbbc6(%rip), %rsi # 0x3f501
movl $0x2e, %edx
callq 0x95f0
movq 0x1f6a4(%rip), %rdi # 0x52ff0
leaq 0xbbdd(%rip), %rsi # 0x3f530
movl $0x1d, %edx
callq 0x95f0
movq 0x1f68c(%rip), %rdi # 0x52ff0
movl %r12d, %esi
callq 0x99a0
movq %rax, %r12
leaq 0xbbd8(%rip), %rsi # 0x3f54e
movl $0x14, %edx
movq %rax, %rdi
callq 0x95f0
movq %r12, %rdi
movl %ebp, %esi
callq 0x99a0
movq %rax, %r12
leaq 0xbb67(%rip), %rsi # 0x3f4fe
movl $0x2, %edx
movq %rax, %rdi
callq 0x95f0
movq %r12, %rdi
movl %r15d, %esi
callq 0x99a0
leaq 0xb8c5(%rip), %rsi # 0x3f27b
movl $0x2, %edx
movq %rax, %rdi
callq 0x95f0
movq %rsp, %rdi
callq 0x16310
cmpl $0x2, %r13d
jl 0x33a10
movl %r13d, %r15d
movslq %ebp, %rax
leaq -0x4(,%rax,4), %r12
movq %r14, %rdi
movl %r15d, %esi
callq 0x1812a
addl %ebp, %eax
cltq
movq (%rbx), %rcx
leaq (%rcx,%r12), %rdx
movl (%rcx,%rax,4), %esi
movl (%rdx,%r15,4), %edi
movl %edi, (%rcx,%rax,4)
movl %esi, (%rdx,%r15,4)
leaq -0x1(%r15), %rax
cmpq $0x2, %r15
movq %rax, %r15
jg 0x339df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
jmp 0x33a2f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x16310
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::DeathTestImpl::~DeathTestImpl() | ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } | pushq %rbx
subq $0xf0, %rsp
leaq 0x1e1a5(%rip), %rax # 0x52148
movq %rax, (%rdi)
cmpl $-0x1, 0x34(%rdi)
jne 0x33fbd
addq $0x10, %rdi
addq $0xf0, %rsp
popq %rbx
jmp 0x302ce
leaq 0xe0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8d00(%rip), %rsi # 0x3ccd0
leaq 0x8d0c(%rip), %rdx # 0x3cce3
leaq 0xd0(%rsp), %rdi
callq 0x37c48
leaq 0x8bf3(%rip), %rsi # 0x3cbde
leaq 0xd0(%rsp), %rdi
callq 0x9ac0
leaq 0x80(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
jne 0x3401b
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x3402b
movq %rsi, 0x70(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x80(%rsp)
movq 0x8(%rax), %rdx
leaq 0x70(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x8c96(%rip), %rsi # 0x3cce4
callq 0x9ac0
leaq 0x38(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x34073
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
jmp 0x34080
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x4c(%rsp), %rsi
movl $0x19c, (%rsi) # imm = 0x19C
leaq 0x50(%rsp), %rdi
callq 0x30307
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x58(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %rbx, %rcx
je 0x340cf
movq 0x38(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x340ee
leaq 0x60(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x340e9
movq 0x60(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x340ff
movq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x91a0
jmp 0x3410d
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x95d0
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x3412a
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x34137
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xa1ee(%rip), %rsi # 0x3e349
leaq 0x8(%rsp), %rdi
callq 0x9ac0
leaq 0xa0(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
jne 0x34188
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x3419b
movq %rsi, 0x90(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xa0(%rsp)
movq 0x8(%rax), %rdx
leaq 0x90(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xb0bd(%rip), %rsi # 0x3f27e
callq 0x9ac0
leaq 0xc0(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
jne 0x341e9
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x341fc
movq %rsi, 0xb0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xc0(%rsp)
movq 0x8(%rax), %rdx
leaq 0xb0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0xd3ad
movq %rax, %rdi
callq 0x30730
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>&&) | MatcherBase& operator=(MatcherBase&& other) {
if (this == &other) return *this;
Destroy();
vtable_ = other.vtable_;
buffer_ = other.buffer_;
other.vtable_ = nullptr;
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x34969
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x34951
cmpq $0x0, 0x18(%rax)
je 0x34951
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x34951
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
callq *0x18(%rax)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h |
testing::internal::CapturedStream::CapturedStream(int) | explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
#if GTEST_OS_WINDOWS
char temp_dir_path[MAX_PATH + 1] = {'\0'}; // NOLINT
char temp_file_path[MAX_PATH + 1] = {'\0'}; // NOLINT
::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
const UINT success = ::GetTempFileNameA(temp_dir_path, "gtest_redir",
0, // Generate unique file name.
temp_file_path);
GTEST_CHECK_(success != 0)
<< "Unable to create a temporary file in " << temp_dir_path;
const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
GTEST_CHECK_(captured_fd != -1)
<< "Unable to open temporary file " << temp_file_path;
filename_ = temp_file_path;
#else
// There's no guarantee that a test has write access to the current
// directory, so we create the temporary file in a temporary directory.
std::string name_template;
#if GTEST_OS_LINUX_ANDROID
// Note: Android applications are expected to call the framework's
// Context.getExternalStorageDirectory() method through JNI to get
// the location of the world-writable SD Card directory. However,
// this requires a Context handle, which cannot be retrieved
// globally from native code. Doing so also precludes running the
// code as part of a regular standalone executable, which doesn't
// run in a Dalvik process (e.g. when running it through 'adb shell').
//
// The location /data/local/tmp is directly accessible from native code.
// '/sdcard' and other variants cannot be relied on, as they are not
// guaranteed to be mounted, or may have a delay in mounting.
name_template = "/data/local/tmp/";
#elif GTEST_OS_IOS
char user_temp_dir[PATH_MAX + 1];
// Documented alternative to NSTemporaryDirectory() (for obtaining creating
// a temporary directory) at
// https://developer.apple.com/library/archive/documentation/Security/Conceptual/SecureCodingGuide/Articles/RaceConditions.html#//apple_ref/doc/uid/TP40002585-SW10
//
// _CS_DARWIN_USER_TEMP_DIR (as well as _CS_DARWIN_USER_CACHE_DIR) is not
// documented in the confstr() man page at
// https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/confstr.3.html#//apple_ref/doc/man/3/confstr
// but are still available, according to the WebKit patches at
// https://trac.webkit.org/changeset/262004/webkit
// https://trac.webkit.org/changeset/263705/webkit
//
// The confstr() implementation falls back to getenv("TMPDIR"). See
// https://opensource.apple.com/source/Libc/Libc-1439.100.3/gen/confstr.c.auto.html
::confstr(_CS_DARWIN_USER_TEMP_DIR, user_temp_dir, sizeof(user_temp_dir));
name_template = user_temp_dir;
if (name_template.back() != GTEST_PATH_SEP_[0])
name_template.push_back(GTEST_PATH_SEP_[0]);
#else
name_template = "/tmp/";
#endif
name_template.append("gtest_captured_stream.XXXXXX");
// mkstemp() modifies the string bytes in place, and does not go beyond the
// string's length. This results in well-defined behavior in C++17.
//
// The const_cast is needed below C++17. The constraints on std::string
// implementations in C++11 and above make assumption behind the const_cast
// fairly safe.
const int captured_fd = ::mkstemp(const_cast<char*>(name_template.data()));
if (captured_fd == -1) {
GTEST_LOG_(WARNING)
<< "Failed to create tmp file " << name_template
<< " for test; does the test have access to the /tmp directory?";
}
filename_ = std::move(name_template);
#endif // GTEST_OS_WINDOWS
fflush(nullptr);
dup2(captured_fd, fd_);
close(captured_fd);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movl %esi, (%rdi)
movl %esi, %edi
callq 0x98c0
movl %eax, 0x4(%r14)
leaq 0x8(%r14), %rbx
leaq 0x18(%r14), %r15
movq %r15, 0x8(%r14)
xorl %eax, %eax
movq %rax, 0x10(%r14)
movb %al, 0x18(%r14)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x9cb4(%rip), %rcx # 0x3e776
leaq 0x10(%rsp), %rdi
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x98f0
leaq 0xa01e(%rip), %rsi # 0x3eafb
leaq 0x10(%rsp), %rdi
callq 0x9ac0
movq 0x10(%rsp), %rdi
callq 0x91b0
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x34b5f
leaq 0x851d(%rip), %rdx # 0x3d01c
leaq 0xc(%rsp), %rdi
movl $0x1, %esi
movl $0x450, %ecx # imm = 0x450
callq 0x161ce
movq 0x1e4d6(%rip), %rdi # 0x52ff0
leaq 0x9ff7(%rip), %rsi # 0x3eb18
movl $0x1a, %edx
callq 0x95f0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x1e4b4(%rip), %rdi # 0x52ff0
callq 0x95f0
leaq 0x9feb(%rip), %rsi # 0x3eb33
movl $0x3b, %edx
movq %rax, %rdi
callq 0x95f0
leaq 0xc(%rsp), %rdi
callq 0x16310
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x96c0
xorl %edi, %edi
callq 0x9640
movl (%r14), %esi
movl %ebp, %edi
callq 0x9490
movl %ebp, %edi
callq 0x9ae0
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x34b9b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x34bbb
movq %rax, %r14
leaq 0xc(%rsp), %rdi
callq 0x16310
jmp 0x34bbe
jmp 0x34bbb
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x34bd5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9500
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x34be8
movq (%r15), %rsi
incq %rsi
callq 0x9500
movq %r14, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<testing::TestPartResult>(testing::TestPartResult const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1bce0
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x1788a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x35892
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x357ec
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3580c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [14]>(char const (&) [14]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1bce0
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x9230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x95f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x35892
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3586a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3588a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::internal::StreamingListener::Start() | void Start() { SendLn("gtest_streaming_protocol_version=1.0"); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8d78(%rip), %rsi # 0x3f0e2
leaq 0x8d95(%rip), %rdx # 0x3f106
movq %rsp, %r14
movq %r14, %rdi
callq 0x37c48
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x37b66
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3639e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x363c1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&) | void OnTestEnd(const TestInfo& test_info) override {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) + "&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsi), %r15
movq %r15, %rdi
callq 0x1f20c
testb %al, %al
je 0x36cf7
xorl %eax, %eax
jmp 0x36d01
movq %r15, %rdi
callq 0x1f248
xorb $0x1, %al
leaq 0x61fe(%rip), %rcx # 0x3cf06
leaq 0x7d32(%rip), %rsi # 0x3ea41
testb %al, %al
cmovneq %rcx, %rsi
leaq 0xb8(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x61de(%rip), %rax # 0x3cf07
leaq 0x7d12(%rip), %rdx # 0x3ea42
cmovneq %rax, %rdx
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
callq 0x37c48
leaq 0x8453(%rip), %rcx # 0x3f19e
movl $0x15, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x95d0
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x36d84
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x36d8b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x8406(%rip), %rsi # 0x3f1b4
callq 0x9ac0
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x36dda
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x36de2
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x108(%r14), %rax
leaq 0xc8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x48(%rsp), %rdi
callq 0x32dba
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r13, %rcx
je 0x36e38
movq 0x38(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x36e57
leaq 0x58(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x36e52
movq 0x58(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x36e68
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x91a0
jmp 0x36e76
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x95d0
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x36e9a
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x36ea0
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x82ff(%rip), %rsi # 0x3f1c3
leaq 0x8(%rsp), %rdi
callq 0x9ac0
leaq 0x98(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x36efe
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
jmp 0x36f05
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rbx), %rdi
callq 0x37b66
movq 0x88(%rsp), %rdi
cmpq %r14, %rdi
je 0x36f4a
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36f65
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36f80
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x36f97
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x36fae
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0xa8(%rsp), %rdi
cmpq %r12, %rdi
je 0x36fcb
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r14, %rdi
je 0x37001
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x37001
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37021
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x37021
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37041
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x37041
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x3705d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x3705d
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x37079
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x37079
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
cmpq %r12, %rdi
je 0x37096
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestIterationEnd(testing::UnitTest const&, int) | void OnTestIterationEnd(const UnitTest& unit_test,
int /* iteration */) override {
SendLn("event=TestIterationEnd&passed=" + FormatBool(unit_test.Passed()) +
"&elapsed_time=" + StreamableToString(unit_test.elapsed_time()) +
"ms");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x32e24
leaq 0x5a86(%rip), %rcx # 0x3cf06
leaq 0x75ba(%rip), %rsi # 0x3ea41
testb %al, %al
cmovneq %rcx, %rsi
leaq 0xb8(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x5a66(%rip), %rax # 0x3cf07
leaq 0x759a(%rip), %rdx # 0x3ea42
cmovneq %rax, %rdx
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
callq 0x37c48
leaq 0x7d1d(%rip), %rcx # 0x3f1e0
movl $0x1e, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x95d0
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x374fc
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x37503
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x7c8e(%rip), %rsi # 0x3f1b4
callq 0x9ac0
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x37552
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x3755a
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x40(%r14), %rax
movq 0x230(%rax), %rax
leaq 0xc8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x48(%rsp), %rdi
callq 0x32dba
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r13, %rcx
je 0x375b4
movq 0x38(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x375d3
leaq 0x58(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x375ce
movq 0x58(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x375e4
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x91a0
jmp 0x375f2
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x95d0
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x37616
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x3761c
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x7b83(%rip), %rsi # 0x3f1c3
leaq 0x8(%rsp), %rdi
callq 0x9ac0
leaq 0x98(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3767a
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
jmp 0x37681
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rbx), %rdi
callq 0x37b66
movq 0x88(%rsp), %rdi
cmpq %r14, %rdi
je 0x376c6
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x376e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x376fc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x37713
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x3772a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9500
movq 0xa8(%rsp), %rdi
cmpq %r12, %rdi
je 0x37747
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x9500
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r14, %rdi
je 0x3777d
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x3777d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3779d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x3779d
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x377bd
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x377bd
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x377d9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x377d9
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x377f5
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9500
jmp 0x377f5
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
cmpq %r12, %rdi
je 0x37812
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x9500
movq %rbx, %rdi
callq 0x99e0
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::~SocketWriter() | ~SocketWriter() override {
if (sockfd_ != -1) CloseConnection();
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1b133(%rip), %rax # 0x52a90
movq %rax, (%rdi)
cmpl $-0x1, 0x8(%rdi)
je 0x3796e
movq %rbx, %rdi
callq 0x37ad8
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x37986
movq (%rax), %rsi
incq %rsi
callq 0x9500
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x3799f
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x9500
popq %rbx
retq
movq %rax, %rdi
callq 0x30730
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
void __gnu_cxx::new_allocator<testing::TestPartResult>::construct<testing::TestPartResult, testing::TestPartResult>(testing::TestPartResult*, testing::TestPartResult&&) | class GTEST_API_ TestPartResult {
public:
// The possible outcomes of a test part (i.e. an assertion or an
// explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
enum Type {
kSuccess, // Succeeded.
kNonFatalFailure, // Failed but the test can continue.
kFatalFailure, // Failed and the test should be terminated.
kSkip // Skipped.
};
// C'tor. TestPartResult does NOT have a default constructor.
// Always use this constructor (with parameters) to create a
// TestPartResult object.
TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {}
// Gets the outcome of the test part.
Type type() const { return type_; }
// Gets the name of the source file where the test part took place, or
// NULL if it's unknown.
const char* file_name() const {
return file_name_.empty() ? nullptr : file_name_.c_str();
}
// Gets the line in the source file where the test part took place,
// or -1 if it's unknown.
int line_number() const { return line_number_; }
// Gets the summary of the failure message.
const char* summary() const { return summary_.c_str(); }
// Gets the message associated with the test part.
const char* message() const { return message_.c_str(); }
// Returns true if and only if the test part was skipped.
bool skipped() const { return type_ == kSkip; }
// Returns true if and only if the test part passed.
bool passed() const { return type_ == kSuccess; }
// Returns true if and only if the test part non-fatally failed.
bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
// Returns true if and only if the test part fatally failed.
bool fatally_failed() const { return type_ == kFatalFailure; }
// Returns true if and only if the test part failed.
bool failed() const { return fatally_failed() || nonfatally_failed(); }
private:
Type type_;
// Gets the summary of the failure message by omitting the stack
// trace in it.
static std::string ExtractSummary(const char* message);
// The name of the source file where the test part took place, or
// "" if the source file is unknown.
std::string file_name_;
// The line in the source file where the test part took place, or -1
// if the line number is unknown.
int line_number_;
std::string summary_; // The test failure summary.
std::string message_; // The test failure message.
} | movl (%rdx), %eax
movl %eax, (%rsi)
leaq 0x18(%rsi), %rcx
movq %rcx, 0x8(%rsi)
movq 0x8(%rdx), %rdi
leaq 0x18(%rdx), %rax
cmpq %rax, %rdi
je 0x38700
movq %rdi, 0x8(%rsi)
movq (%rax), %rcx
movq %rcx, 0x18(%rsi)
jmp 0x38706
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rsi)
movq %rax, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
movb $0x0, 0x18(%rdx)
movl 0x28(%rdx), %eax
movl %eax, 0x28(%rsi)
leaq 0x40(%rsi), %rcx
movq %rcx, 0x30(%rsi)
movq 0x30(%rdx), %rdi
leaq 0x40(%rdx), %rax
cmpq %rax, %rdi
je 0x38746
movq %rdi, 0x30(%rsi)
movq (%rax), %rcx
movq %rcx, 0x40(%rsi)
jmp 0x3874c
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x38(%rdx), %rcx
movq %rcx, 0x38(%rsi)
movq %rax, 0x30(%rdx)
movq $0x0, 0x38(%rdx)
movb $0x0, 0x40(%rdx)
leaq 0x60(%rsi), %rcx
movq %rcx, 0x50(%rsi)
movq 0x50(%rdx), %rdi
leaq 0x60(%rdx), %rax
cmpq %rax, %rdi
je 0x38786
movq %rdi, 0x50(%rsi)
movq (%rax), %rcx
movq %rcx, 0x60(%rsi)
jmp 0x3878c
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x58(%rdx), %rcx
movq %rcx, 0x58(%rsi)
movq %rax, 0x50(%rdx)
movq $0x0, 0x58(%rdx)
movb $0x0, 0x60(%rdx)
retq
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-test-part.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [3]>(char const (&) [3]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3f684
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0xb240
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb650
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x204c8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x203ae
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x203ce
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xbaa0
| /yanyiwu[P]cppjieba/build_O1/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression, const T1& lhs,
const T2& rhs) {
return EqFailure(lhs_expression, rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs), false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x1b835
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1b7b2
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x405ff
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20976
callq 0xb500
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20989
callq 0xb500
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x209b3
callq 0xb500
jmp 0x209b3
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x209c6
callq 0xb500
movq %rbx, %rdi
callq 0xbaa0
| /yanyiwu[P]cppjieba/build_O1/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [3]>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [3]) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression, const T1& lhs,
const T2& rhs) {
return EqFailure(lhs_expression, rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs), false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rcx, %rsi
callq 0x1b7b2
leaq 0x40(%rsp), %rsi
movq %r12, (%rsi)
movq %rsp, %rdi
callq 0x1b835
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x405ff
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20ef1
callq 0xb500
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20f04
callq 0xb500
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20f2e
callq 0xb500
jmp 0x20f2e
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20f41
callq 0xb500
movq %rbx, %rdi
callq 0xbaa0
nopl (%rax)
| /yanyiwu[P]cppjieba/build_O1/_deps/googletest-src/googletest/include/gtest/gtest.h |
cppjieba::FullSegment::FullSegment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | FullSegment(const string& dictPath) {
dictTrie_ = new DictTrie(dictPath);
isNeedDestroy_ = true;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x11358
leaq 0x5e975(%rip), %rax # 0x835b8
movq %rax, (%rbx)
movl $0xd0, %edi
callq 0xb550
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3f9e2(%rip), %rdx # 0x64646
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x11f20
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0x11fce
movq %r14, 0x40(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24c99
callq 0xb500
movb $0x1, 0x48(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24cc0
callq 0xb500
jmp 0x24cc0
movq %rax, %r15
movq %r14, %rdi
callq 0xb500
jmp 0x24ccd
movq %rax, %r15
leaq 0x5dd2c(%rip), %rax # 0x82a00
movq %rax, (%rbx)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x11fb0
movq %r15, %rdi
callq 0xbaa0
nop
| /yanyiwu[P]cppjieba/include/cppjieba/FullSegment.hpp |
MixSegmentTest_UserDict_Test::~MixSegmentTest_UserDict_Test() | TEST(MixSegmentTest, UserDict) {
MixSegment segment("../test/testdata/extra_dict/jieba.dict.small.utf8", "../dict/hmm_model.utf8", "../dict/user.dict.utf8");
{
const char* str = "令狐冲是云计算方面的专家";
vector<string> words;
segment.Cut(str, words);
string res;
ASSERT_EQ("[\"令狐冲\", \"是\", \"云计算\", \"方面\", \"的\", \"专家\"]", res << words);
}
{
const char* str = "小明先就职于IBM,后在日本京都大学深造";
vector<string> words;
segment.Cut(str, words);
string res;
res << words;
ASSERT_EQ("[\"小明\", \"先\", \"就职\", \"于\", \"IBM\", \",\", \"后\", \"在\", \"日本\", \"京都大学\", \"深造\"]", res);
}
{
const char* str = "IBM,3.14";
vector<string> words;
segment.Cut(str, words);
string res;
res << words;
ASSERT_EQ("[\"IBM\", \",\", \"3.14\"]", res);
}
} | pushq %rbx
movq %rdi, %rbx
callq 0x42b30
movq %rbx, %rdi
popq %rbx
jmp 0xb500
| /yanyiwu[P]cppjieba/test/unittest/segments_test.cpp |
testing::AssertionResult testing::internal::CmpHelperEQ<char [105], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [105], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression, const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0xb190
movq %rbx, %rdi
testl %eax, %eax
je 0x25fed
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x25fff
jmp 0x25ff2
callq 0x32328
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /yanyiwu[P]cppjieba/build_O1/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<char [29], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [29], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression, const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0xb190
movq %rbx, %rdi
testl %eax, %eax
je 0x260f8
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x2610a
jmp 0x260fd
callq 0x32328
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /yanyiwu[P]cppjieba/build_O1/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<char [27], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [27], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression, const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0xb190
movq %rbx, %rdi
testl %eax, %eax
je 0x26a57
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x26a69
jmp 0x26a5c
callq 0x32328
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /yanyiwu[P]cppjieba/build_O1/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [36]>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [36]) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression, const T1& lhs,
const T2& rhs) {
return EqFailure(lhs_expression, rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs), false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rcx, %rsi
callq 0x1b7b2
leaq 0x40(%rsp), %rsi
movq %r12, (%rsi)
movq %rsp, %rdi
callq 0x1b835
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x405ff
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x270e9
callq 0xb500
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x270fc
callq 0xb500
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27126
callq 0xb500
jmp 0x27126
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27139
callq 0xb500
movq %rbx, %rdi
callq 0xbaa0
| /yanyiwu[P]cppjieba/build_O1/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [196], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [196], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression, const T1& lhs,
const T2& rhs) {
return EqFailure(lhs_expression, rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs), false);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x1b835
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1b7b2
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x405ff
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c340
callq 0xb500
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c353
callq 0xb500
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c37d
callq 0xb500
jmp 0x2c37d
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c390
callq 0xb500
movq %rbx, %rdi
callq 0xbaa0
| /yanyiwu[P]cppjieba/build_O1/_deps/googletest-src/googletest/include/gtest/gtest.h |
read_callback | static size_t read_callback(void *ptr, size_t size, size_t nmemb, void *stream)
{
size_t amount = nmemb * size; /* Total bytes curl wants */
if(amount < strlen(data)) {
return strlen(data);
}
(void)stream;
memcpy(ptr, data, strlen(data));
return strlen(data);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
imulq %rdx, %r14
leaq 0x2bdf(%rip), %rdi # 0x50b0
callq 0x2070
cmpq %rax, %r14
jae 0x24e3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2bc6(%rip), %r14 # 0x50b0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2090
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2070
nop
| /nomaster[P]curl/tests/libtest/lib1526.c |
hexdump | char *hexdump(const unsigned char *buffer, size_t len)
{
static char dump[200 * 3 + 1];
char *p = dump;
size_t i;
if(len > 200)
return NULL;
for(i = 0; i<len; i++, p += 3)
msnprintf(p, 4, "%02x ", buffer[i]);
return dump;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0xc8, %rsi
jbe 0x2587
xorl %ebx, %ebx
jmp 0x25d1
movq %rsi, %r14
testq %rsi, %rsi
je 0x25ca
movq %rdi, %r15
leaq 0x2b47(%rip), %rbx # 0x50e0
leaq 0xacf(%rip), %r12 # 0x306f
xorl %ebp, %ebp
movq %rbx, %r13
movzbl (%r15,%rbp), %ecx
movl $0x4, %esi
movq %r13, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2080
incq %rbp
addq $0x3, %r13
cmpq %rbp, %r14
jne 0x25a5
jmp 0x25d1
leaq 0x2b0f(%rip), %rbx # 0x50e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /nomaster[P]curl/tests/libtest/first.c |
tutil_tvnow | struct timeval tutil_tvnow(void)
{
/*
** clock_gettime() is granted to be increased monotonically when the
** monotonic clock is queried. Time starting point is unspecified, it
** could be the system start-up time, the Epoch, or something else,
** in any case the time starting point does not change once that the
** system has started up.
*/
struct timeval now;
struct timespec tsnow;
if(0 == clock_gettime(CLOCK_MONOTONIC, &tsnow)) {
now.tv_sec = tsnow.tv_sec;
now.tv_usec = tsnow.tv_nsec / 1000;
}
/*
** Even when the configure process has truly detected monotonic clock
** availability, it might happen that it is not actually available at
** run-time. When this occurs simply fallback to other time source.
*/
#ifdef HAVE_GETTIMEOFDAY
else
(void)gettimeofday(&now, NULL);
#else
else {
now.tv_sec = (long)time(NULL);
now.tv_usec = 0;
}
#endif
return now;
} | subq $0x28, %rsp
leaq 0x18(%rsp), %rsi
movl $0x1, %edi
callq 0x20b0
testl %eax, %eax
je 0x26a5
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2120
jmp 0x26d1
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
addq $0x28, %rsp
retq
| /nomaster[P]curl/tests/libtest/testutil.c |
curlx_ultous | unsigned short curlx_ultous(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(ulnum & (unsigned long) CURL_MASK_USHORT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_ultosi | int curlx_ultosi(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_SINT);
return (int)(ulnum & (unsigned long) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_uztosi | int curlx_uztosi(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT);
return (int)(uznum & (size_t) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_uztoui | unsigned int curlx_uztoui(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT(uznum <= (size_t) CURL_MASK_UINT);
#endif
return (unsigned int)(uznum & (size_t) CURL_MASK_UINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_sltoui | unsigned int curlx_sltoui(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT);
#endif
return (unsigned int)(slnum & (long) CURL_MASK_UINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_uztosz | ssize_t curlx_uztosz(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
btrq $0x3f, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_sztosi | int curlx_sztosi(ssize_t sznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sznum >= 0);
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
#endif
return (int)(sznum & (ssize_t) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_uitouc | unsigned char curlx_uitouc(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_UCHAR);
return (unsigned char) (uinum & (unsigned int) CURL_MASK_UCHAR);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movl %edi, %eax
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_sitouz | size_t curlx_sitouz(int sinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sinum >= 0);
return (size_t) sinum;
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movslq %edi, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
QPlatformMessageDialogHelper::~QPlatformMessageDialogHelper() | class Q_GUI_EXPORT QPlatformMessageDialogHelper : public QPlatformDialogHelper
{
Q_OBJECT
public:
const QSharedPointer<QMessageDialogOptions> &options() const;
void setOptions(const QSharedPointer<QMessageDialogOptions> &options);
Q_SIGNALS:
void clicked(QPlatformDialogHelper::StandardButton button, QPlatformDialogHelper::ButtonRole role);
void checkBoxStateChanged(Qt::CheckState state);
private:
QSharedPointer<QMessageDialogOptions> m_options;
} | endbr64
ud2
| /qt[P]qtbase/src/gui/kernel/qplatformdialoghelper.h |
QPlatformMenu::~QPlatformMenu() | class Q_GUI_EXPORT QPlatformMenu : public QObject
{
Q_OBJECT
public:
QPlatformMenu();
enum MenuType { DefaultMenu = 0, EditMenu };
Q_ENUM(MenuType)
virtual void insertMenuItem(QPlatformMenuItem *menuItem, QPlatformMenuItem *before) = 0;
virtual void removeMenuItem(QPlatformMenuItem *menuItem) = 0;
virtual void syncMenuItem(QPlatformMenuItem *menuItem) = 0;
virtual void syncSeparatorsCollapsible(bool enable) = 0;
virtual void setTag(quintptr tag);
virtual quintptr tag() const;
virtual void setText(const QString &text) = 0;
virtual void setIcon(const QIcon &icon) = 0;
virtual void setEnabled(bool enabled) = 0;
virtual bool isEnabled() const { return true; }
virtual void setVisible(bool visible) = 0;
virtual void setMinimumWidth(int width) { Q_UNUSED(width); }
virtual void setFont(const QFont &font) { Q_UNUSED(font); }
virtual void setMenuType(MenuType type) { Q_UNUSED(type); }
virtual void showPopup(const QWindow *parentWindow, const QRect &targetRect, const QPlatformMenuItem *item)
{
Q_UNUSED(parentWindow);
Q_UNUSED(targetRect);
Q_UNUSED(item);
setVisible(true);
}
virtual void dismiss() { } // Closes this and all its related menu popups
virtual QPlatformMenuItem *menuItemAt(int position) const = 0;
virtual QPlatformMenuItem *menuItemForTag(quintptr tag) const = 0;
virtual QPlatformMenuItem *createMenuItem() const;
virtual QPlatformMenu *createSubMenu() const;
Q_SIGNALS:
void aboutToShow();
void aboutToHide();
private:
quintptr m_tag;
} | endbr64
ud2
| /qt[P]qtbase/src/gui/kernel/qplatformmenu.h |
QtGuiTest::setKeyboardModifiers(QFlags<Qt::KeyboardModifier>) | void QtGuiTest::setKeyboardModifiers(Qt::KeyboardModifiers modifiers)
{
auto *idm = inputDeviceManager();
if (Q_UNLIKELY(!idm))
return;
idm->setKeyboardModifiers(modifiers);
deb << "Keyboard modifiers synthesized:" << modifiers;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %edi, %ebx
movq %fs:0x28, %rax
movq %rax, 0x58(%rsp)
callq 0x21a713
testq %rax, %rax
je 0x14e849
movq %rax, %rdi
movl %ebx, %esi
callq 0x148930
callq 0x21a808
movb 0x5b4bdc(%rip), %al # 0x703350
testb $0x1, %al
je 0x14e849
movq 0x5b4bc5(%rip), %rax # 0x703348
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
andl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x13ecf0
movq (%r14), %r14
leaq 0x43f039(%rip), %rdx # 0x58d7ed
leaq 0x40(%rsp), %r15
pushq $0x1f
popq %rsi
movq %r15, %rdi
callq 0x1457d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x14e7ec
lock
decl (%rax)
jne 0x14e7ec
movq 0x40(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x10
popq %rdx
callq 0x143f00
movq 0x28(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x14e804
pushq $0x20
popq %rsi
callq 0x13d680
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %r14
movq %rdi, (%r14)
incl 0x28(%rdi)
movl %ebx, %edx
movq 0x5a0458(%rip), %rcx # 0x6eec70
leaq 0x4335d6(%rip), %r8 # 0x581df5
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1396d0
movq %rbx, %rdi
callq 0x1391b0
movq %r14, %rdi
callq 0x1391b0
leaq 0x28(%rsp), %rdi
callq 0x1391b0
movq %fs:0x28, %rax
cmpq 0x58(%rsp), %rax
jne 0x14e863
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/kernel/qtestsupport_gui.cpp |
QFontPrivate::engineForScript(int) const | QFontEngine *QFontPrivate::engineForScript(int script) const
{
QMutexLocker locker(qt_fontdatabase_mutex());
if (script <= QChar::Script_Latin)
script = QChar::Script_Common;
if (engineData && engineData->fontCacheId != QFontCache::instance()->id()) {
// throw out engineData that came from a different thread
if (!engineData->ref.deref())
delete engineData;
engineData = nullptr;
}
if (!engineData || !QT_FONT_ENGINE_FROM_DATA(engineData, script))
QFontDatabasePrivate::load(this, script);
return QT_FONT_ENGINE_FROM_DATA(engineData, script);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %r14
callq 0x392f74
movq %rax, %rbx
testq %rax, %rax
je 0x15955d
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movabsq $0x100000000, %rdx # imm = 0x100000000
movq %rbx, %rdi
callq 0x13ed30
cmpl $0x4, %r15d
pushq $0x2
popq %rbp
cmovgel %r15d, %ebp
movq 0x70(%r14), %rax
movl %ebp, %r12d
testq %rax, %rax
je 0x1595c0
movl 0x4(%rax), %r15d
callq 0x145a00
movq 0x70(%r14), %rcx
cmpl 0x3c(%rax), %r15d
jne 0x159598
testq %rcx, %rcx
je 0x1595c0
movq 0x8(%rcx,%r12,8), %r15
testq %r15, %r15
jne 0x1595d3
jmp 0x1595c0
lock
decl (%rcx)
jne 0x1595bb
movq 0x70(%r14), %r15
testq %r15, %r15
je 0x1595ae
movq %r15, %rdi
callq 0x381334
movl $0x568, %esi # imm = 0x568
movq %r15, %rdi
callq 0x137fb0
andq $0x0, 0x70(%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x13fce0
movq 0x70(%r14), %rax
movq 0x8(%rax,%r12,8), %r15
testq %rbx, %rbx
je 0x1595e0
movq %rbx, %rdi
callq 0x1407a0
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /qt[P]qtbase/src/gui/text/qfont.cpp |
QFontDatabase::styles(QString const&) | QStringList QFontDatabase::styles(const QString &family)
{
QString familyName, foundryName;
parseFontName(family, foundryName, familyName);
QMutexLocker locker(fontDatabaseMutex());
QFontDatabasePrivate *d = QFontDatabasePrivate::ensureFontDatabase();
QStringList l;
QtFontFamily *f = d->family(familyName);
if (!f)
return l;
QtFontFoundry allStyles(foundryName);
for (int j = 0; j < f->count; j++) {
QtFontFoundry *foundry = f->foundries[j];
if (foundryName.isEmpty() || foundry->name.compare(foundryName, Qt::CaseInsensitive) == 0) {
for (int k = 0; k < foundry->count; k++) {
QtFontStyle::Key ke(foundry->styles[k]->key);
ke.stretch = 0;
allStyles.style(ke, foundry->styles[k]->styleName, true);
}
}
}
l.reserve(allStyles.count);
for (int i = 0; i < allStyles.count; i++) {
l.append(allStyles.styles[i]->styleName.isEmpty() ?
styleStringHelper(allStyles.styles[i]->key.weight,
(QFont::Style)allStyles.styles[i]->key.style) :
allStyles.styles[i]->styleName);
}
return l;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %fs:0x28, %rcx
movq %rcx, 0x90(%rsp)
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rax, %rdi
callq 0x394e4b
callq 0x392f7a
movq %rax, %rbp
testq %rax, %rax
je 0x15b0fa
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movabsq $0x100000000, %rdx # imm = 0x100000000
movq %rbp, %rdi
callq 0x13ed30
callq 0x139120
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x5b08ef(%rip), %rdi # 0x70ba00
leaq 0x60(%rsp), %rsi
pushq $0x2
popq %rdx
callq 0x13dbe0
testq %rax, %rax
je 0x15b2df
movaps 0x419552(%rip), %xmm0 # 0x574680
movups %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, 0x20(%rsp)
testq %rcx, %rcx
je 0x15b14f
lock
incl (%rcx)
andl $0x0, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
cmpl $0x0, 0x38(%rax)
jle 0x15b2cb
movq %rbp, (%rsp)
movq %rbx, 0x8(%rsp)
xorl %ebx, %ebx
leaq 0x18(%rsp), %r12
leaq 0x78(%rsp), %r13
pushq $0x1
popq %rbp
movq %rax, 0x10(%rsp)
movq 0x40(%rax), %rax
movq (%rax,%rbx,8), %r14
cmpq $0x0, 0x50(%rsp)
je 0x15b1a4
movq %r14, %rdi
leaq 0x40(%rsp), %rsi
xorl %edx, %edx
callq 0x138020
testl %eax, %eax
jne 0x15b1ed
cmpl $0x0, 0x18(%r14)
jle 0x15b1ed
xorl %r15d, %r15d
movl $0xaaaaaaaa, 0x78(%rsp) # imm = 0xAAAAAAAA
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %rdx
movzwl (%rdx), %eax
andl $0xfff, %eax # imm = 0xFFF
movw %ax, 0x78(%rsp)
movb $0x0, 0x7a(%rsp)
addq $0x10, %rdx
movq %r12, %rdi
movq %r13, %rsi
movl %ebp, %ecx
callq 0x142300
incq %r15
movslq 0x18(%r14), %rax
cmpq %rax, %r15
jl 0x15b1ae
incq %rbx
movq 0x10(%rsp), %rax
movslq 0x38(%rax), %rcx
cmpq %rcx, %rbx
jl 0x15b181
movslq 0x30(%rsp), %r14
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x195142
testq %r14, %r14
movq (%rsp), %rbp
jle 0x15b2d5
xorl %r14d, %r14d
leaq 0x78(%rsp), %r15
pushq $0x2
popq %r12
pushq $0x10
popq %r13
movq 0x38(%rsp), %rax
movq (%rax,%r14,8), %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x15b269
movq 0x10(%rax), %rdx
movq %rdx, 0x78(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x80(%rsp)
movq %rcx, 0x88(%rsp)
testq %rdx, %rdx
je 0x15b282
lock
incl (%rdx)
jmp 0x15b282
movzwl (%rax), %edx
movl %edx, %esi
shrl $0x2, %esi
andl $0x3ff, %esi # imm = 0x3FF
andl $0x3, %edx
movq %r15, %rdi
callq 0x394ae1
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x17e5f0
movq %rbx, %rdi
callq 0x17e77a
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0x15b2b8
lock
decl (%rax)
jne 0x15b2b8
movq 0x78(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x143f00
incq %r14
movslq 0x30(%rsp), %rax
cmpq %rax, %r14
jl 0x15b230
jmp 0x15b2d5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x195142
leaq 0x18(%rsp), %rdi
callq 0x397be0
testq %rbp, %rbp
je 0x15b2ec
movq %rbp, %rdi
callq 0x1407a0
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x15b30b
lock
decl (%rax)
jne 0x15b30b
movq 0x40(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x10
popq %rdx
callq 0x143f00
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x15b32a
lock
decl (%rax)
jne 0x15b32a
movq 0x60(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x10
popq %rdx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x90(%rsp), %rax
jne 0x15b352
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/text/qfontdatabase.cpp |
QFontDatabase::applicationFontFamilies(int) | QStringList QFontDatabase::applicationFontFamilies(int id)
{
QMutexLocker locker(fontDatabaseMutex());
auto *d = QFontDatabasePrivate::instance();
QStringList ret;
ret.reserve(d->applicationFonts.value(id).properties.size());
for (const auto &properties : d->applicationFonts.value(id).properties)
ret.append(properties.familyName);
return ret;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
callq 0x392f7a
movq %rax, %r14
testq %rax, %rax
je 0x15c7a4
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movabsq $0x100000000, %rdx # imm = 0x100000000
movq %r14, %rdi
callq 0x13ed30
callq 0x1491f0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movslq %ebp, %r15
leaq 0x5af2aa(%rip), %rsi # 0x70ba68
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x397c5c
leaq 0x38(%rsp), %r12
movq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x195142
movq %r12, %rdi
callq 0x399948
movq -0x18(%r12), %rax
testq %rax, %rax
je 0x15c804
lock
decl (%rax)
jne 0x15c804
movq 0x20(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
callq 0x143f00
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x15c823
lock
decl (%rax)
jne 0x15c823
movq 0x8(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x10
popq %rdx
callq 0x143f00
leaq 0x5af23e(%rip), %rsi # 0x70ba68
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x397c5c
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x397eaa
movq %rax, %r12
movq %r15, %rdi
callq 0x397ed6
cmpq %rax, %r12
je 0x15c877
movq %rax, %r13
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1809b6
movq %rbx, %rdi
callq 0x17e77a
addq $0x40, %r12
cmpq %r13, %r12
jne 0x15c857
movq %r15, %rdi
callq 0x399948
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x15c89e
lock
decl (%rax)
jne 0x15c89e
movq 0x20(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
callq 0x143f00
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x15c8bd
lock
decl (%rax)
jne 0x15c8bd
movq 0x8(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x10
popq %rdx
callq 0x143f00
testq %r14, %r14
je 0x15c8ca
movq %r14, %rdi
callq 0x1407a0
movq %fs:0x28, %rax
cmpq 0x50(%rsp), %rax
jne 0x15c8ec
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/text/qfontdatabase.cpp |
QFontDatabase::setApplicationFallbackFontFamilies(QChar::Script, QList<QString> const&) | void QFontDatabase::setApplicationFallbackFontFamilies(QChar::Script script, const QStringList &familyNames)
{
QMutexLocker locker(fontDatabaseMutex());
if (script < QChar::Script_Common || script >= QChar::ScriptCount) {
qCWarning(lcFontDb) << "Invalid script passed to setApplicationFallbackFontFamilies:" << script;
return;
}
if (script == QChar::Script_Latin)
script = QChar::Script_Common;
auto *db = QFontDatabasePrivate::instance();
db->setApplicationFallbackFontFamilies(QFontDatabasePrivate::ExtendedScript(script),
familyNames);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movl %edi, %r14d
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
callq 0x392f7a
movq %rax, %rbx
testq %rax, %rax
je 0x15ce37
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movabsq $0x100000000, %rdx # imm = 0x100000000
movq %rbx, %rdi
callq 0x13ed30
leal -0xab(%r14), %eax
cmpl $0xffffff56, %eax # imm = 0xFFFFFF56
ja 0x15cf0c
callq 0x391a9c
movb 0x5aeb7d(%rip), %al # 0x70b9d1
testb $0x1, %al
je 0x15cf2d
movq 0x5aeb65(%rip), %rax # 0x70b9c8
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
andl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x144250
movq (%r15), %r15
leaq 0x44ad53(%rip), %rdx # 0x5a7be7
leaq 0x30(%rsp), %r12
pushq $0x3c
popq %rsi
movq %r12, %rdi
callq 0x1457d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x1455b0
movq (%r12), %rax
testq %rax, %rax
je 0x15cecd
lock
decl (%rax)
jne 0x15cecd
movq 0x30(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x10
popq %rdx
callq 0x143f00
movq 0x28(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x15cee5
pushq $0x20
popq %rsi
callq 0x13d680
movq 0x28(%rsp), %rdi
movl %r14d, %esi
callq 0x147670
movq 0x28(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x15cf00
pushq $0x20
popq %rsi
callq 0x13d680
leaq 0x28(%rsp), %rdi
callq 0x1391b0
jmp 0x15cf2d
cmpl $0x3, %r14d
pushq $0x2
popq %rbp
cmovnel %r14d, %ebp
callq 0x1491f0
leaq 0x5aeadd(%rip), %rdi # 0x70ba00
movl %ebp, %esi
movq %r15, %rdx
callq 0x147b00
testq %rbx, %rbx
je 0x15cf3a
movq %rbx, %rdi
callq 0x1407a0
movq %fs:0x28, %rax
cmpq 0x48(%rsp), %rax
jne 0x15cf57
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/text/qfontdatabase.cpp |
QFontDatabase::removeApplicationEmojiFontFamily(QString const&) | bool QFontDatabase::removeApplicationEmojiFontFamily(const QString &familyName)
{
QMutexLocker locker(fontDatabaseMutex());
auto *db = QFontDatabasePrivate::instance();
return db->removeApplicationFallbackFontFamily(QFontDatabasePrivate::Script_Emoji,
familyName);
} | endbr64
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x392f7a
movq %rax, %rbx
testq %rax, %rax
je 0x15d110
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movabsq $0x100000000, %rdx # imm = 0x100000000
movq %rbx, %rdi
callq 0x13ed30
callq 0x1491f0
leaq 0x5ae8e4(%rip), %rdi # 0x70ba00
movl $0xab, %esi
movq %r14, %rdx
callq 0x145300
movl %eax, %ebp
testq %rbx, %rbx
je 0x15d138
movq %rbx, %rdi
callq 0x1407a0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
| /qt[P]qtbase/src/gui/text/qfontdatabase.cpp |
QStandardItemModel::QStandardItemModel(int, int, QObject*) | QStandardItemModel::QStandardItemModel(int rows, int columns, QObject *parent)
: QAbstractItemModel(*new QStandardItemModelPrivate, parent)
{
Q_D(QStandardItemModel);
d->init();
d->root->insertColumns(0, columns);
d->columnHeaderItems.insert(0, columns, nullptr);
d->root->insertRows(0, rows);
d->rowHeaderItems.insert(0, rows, nullptr);
d->root->d_func()->setModel(this);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movl $0x128, %edi # imm = 0x128
callq 0x1387d0
movq %rax, %r12
movq %rax, %rdi
callq 0x444a7c
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x13f8d0
movq 0x58fc8d(%rip), %rax # 0x6ef328
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x444be6
movq 0x110(%r14), %rax
movq 0x8(%rax), %rdi
movl 0x44(%rdi), %eax
movl %eax, %esi
sarl $0x1f, %esi
andl %eax, %esi
movl %r15d, %edx
subl %esi, %edx
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
callq 0x44530c
leaq 0xd8(%r14), %r12
testl %r15d, %r15d
je 0x15f6f6
movslq %r15d, %rdx
movq %r12, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x44ef9a
movq %r12, %rdi
callq 0x44a7cc
movq 0x110(%r14), %rax
movq 0x8(%rax), %rdi
movl 0x40(%rdi), %eax
movl %eax, %esi
sarl $0x1f, %esi
andl %eax, %esi
movl %ebp, %edx
subl %esi, %edx
movq %rsp, %rcx
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
callq 0x4450cc
leaq 0xf0(%r14), %r15
testl %ebp, %ebp
je 0x15f744
movslq %ebp, %rdx
movq %r15, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x44ef9a
movq %r15, %rdi
callq 0x44a7cc
movq 0x110(%r14), %rax
movq 0x8(%rax), %rdi
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x15f77b
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x44396c
callq 0x13a8c0
| /qt[P]qtbase/src/gui/itemmodels/qstandarditemmodel.cpp |
hb_qt_reference_table(hb_face_t*, unsigned int, void*) | static hb_blob_t *
_hb_qt_reference_table(hb_face_t * /*face*/, hb_tag_t tag, void *user_data)
{
QFontEngine::FaceData *data = static_cast<QFontEngine::FaceData *>(user_data);
Q_ASSERT(data);
qt_get_font_table_func_t get_font_table = data->get_font_table;
Q_ASSERT(get_font_table);
uint length = 0;
if (Q_UNLIKELY(!get_font_table(data->user_data, tag, 0, &length)))
return hb_blob_get_empty();
char *buffer = static_cast<char *>(malloc(length));
if (q_check_ptr(buffer) == nullptr)
return nullptr;
if (Q_UNLIKELY(!get_font_table(data->user_data, tag, reinterpret_cast<uchar *>(buffer), &length)))
return nullptr;
return hb_blob_create(const_cast<const char *>(buffer), length,
HB_MEMORY_MODE_WRITABLE,
buffer, free);
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdx), %r12
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
movq (%rdx), %rdi
xorl %edx, %edx
callq *%r12
testb %al, %al
je 0x1615d8
movl 0xc(%rsp), %edi
callq 0x1440f0
testq %rax, %rax
je 0x1615ba
movq %rax, %r15
movq (%r14), %rdi
leaq 0xc(%rsp), %rcx
movl %ebx, %esi
movq %rax, %rdx
callq *%r12
testb %al, %al
je 0x1615ba
movl 0xc(%rsp), %esi
movq 0x58d58e(%rip), %r8 # 0x6eeb38
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %r15, %rcx
callq 0x138a80
jmp 0x1615bc
xorl %eax, %eax
movq %fs:0x28, %rcx
cmpq 0x10(%rsp), %rcx
jne 0x1615df
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x139670
jmp 0x1615bc
callq 0x13a8c0
| /qt[P]qtbase/src/gui/text/qharfbuzzng.cpp |
QtGlobalStatic::Holder<(anonymous namespace)::Q_QGS_iceLoader>::~Holder() | ~Holder()
{
// TSAN does not support atomic_thread_fence and GCC complains:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97868
// https://github.com/google/sanitizers/issues/1352
// QTBUG-134415
QT_WARNING_PUSH
#if defined(Q_CC_GNU_ONLY) && Q_CC_GNU >= 1100
QT_WARNING_DISABLE_GCC("-Wtsan")
#endif
// import changes to *pointer() by other threads before running ~PlainType():
std::atomic_thread_fence(std::memory_order_acquire);
QT_WARNING_POP
pointer()->~PlainType();
guard.storeRelease(QtGlobalStatic::Destroyed);
} | endbr64
pushq %rax
callq 0x13b330
movb $-0x2, 0x5872cb(%rip) # 0x6fa2a0
popq %rax
retq
nop
| /qt[P]qtbase/src/corelib/global/qglobalstatic.h |
QList<QPixmapIconEngineEntry>::clear() | void clear() {
if (!size())
return;
if (d->needsDetach()) {
// must allocate memory
DataPointer detached(d.allocatedCapacity());
d.swap(detached);
} else {
d->truncate(0);
}
} | endbr64
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x17317c
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1730fa
movl (%rax), %ecx
cmpl $0x2, %ecx
jl 0x173164
movaps 0x401591(%rip), %xmm0 # 0x574680
movups %xmm0, 0x8(%rsp)
movq 0x8(%rax), %rcx
jmp 0x173108
movaps 0x40157f(%rip), %xmm0 # 0x574680
movups %xmm0, 0x8(%rsp)
xorl %ecx, %ecx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movl $0x40, %esi
movl $0x10, %edx
movq %r14, %rdi
movl $0x1, %r8d
callq 0x138b60
movq (%r14), %rcx
movq (%rbx), %rdx
movq %rcx, (%rbx)
movq %rsp, %rdi
movq %rdx, (%rdi)
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, 0x8(%rdi)
movq 0x10(%rbx), %rax
movq $0x0, 0x10(%rbx)
movq %rax, 0x10(%rdi)
callq 0x17344a
jmp 0x17317c
movq 0x8(%rbx), %rdi
shlq $0x6, %rsi
addq %rdi, %rsi
callq 0x173488
movq $0x0, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x173194
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QString QStringBuilder<QStringBuilder<QStringBuilder<QStringBuilder<QStringBuilder<QStringBuilder<QLatin1String, HexString<unsigned long long>>, HexString<unsigned char>>, HexString<unsigned long long>>, HexString<unsigned int>>, HexString<unsigned int>>, HexString<unsigned short>>::convertTo<QString>() const | T convertTo() const
{
if (isNull()) {
// appending two null strings must give back a null string,
// so we're special casing this one out, QTBUG-114206
return T();
}
const qsizetype len = Concatenable::size(*this);
T s(len, Qt::Uninitialized);
// Using data_ptr() here (private API) so we can bypass the
// isDetached() and the replacement of a null pointer with _empty in
// both QString and QByteArray's data() and constData(). The result is
// the same if len != 0.
auto d = reinterpret_cast<typename T::iterator>(s.data_ptr().data());
const auto start = d;
Concatenable::appendTo(*this, d);
if constexpr (Concatenable::ExactSize) {
Q_UNUSED(start)
} else {
if (len != d - start) {
// this resize is necessary since we allocate a bit too much
// when dealing with variable sized 8-bit encodings
s.resize(d - start);
}
}
return s;
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
movq (%rsi), %rsi
addq $0x36, %rsi
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x10(%rdi)
movaps 0x400af7(%rip), %xmm0 # 0x574680
movups %xmm0, (%rdi)
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x142b80
movq 0x8(%rbx), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x173c60
movaps 0x40107c(%rip), %xmm0 # 0x574c30
movaps %xmm0, 0x10(%rsp)
movaps 0x401080(%rip), %xmm1 # 0x574c40
movaps %xmm1, 0x20(%rsp)
movq (%r15), %rcx
movq %rcx, %rax
movzbl 0x30(%r14,%r12), %ecx
andl $0xf, %ecx
movzwl 0x10(%rsp,%rcx,2), %ecx
movw %cx, (%rax)
movzbl 0x30(%r14,%r12), %ecx
shrl $0x4, %ecx
movzwl 0x10(%rsp,%rcx,2), %ecx
movw %cx, 0x2(%rax)
incq %r12
leaq 0x4(%rax), %rcx
cmpl $0x4, %r12d
jne 0x173bc8
movaps %xmm0, 0x10(%rsp)
movaps %xmm1, 0x20(%rsp)
movb $0x1, %dl
xorl %ecx, %ecx
movzbl 0x38(%r14,%rcx), %esi
andl $0xf, %esi
movzwl 0x10(%rsp,%rsi,2), %esi
movw %si, 0x4(%rax,%rcx,4)
movzbl 0x38(%r14,%rcx), %esi
shrl $0x4, %esi
movzwl 0x10(%rsp,%rsi,2), %esi
movw %si, 0x6(%rax,%rcx,4)
incq %rcx
testb $0x1, %dl
movl $0x0, %edx
jne 0x173c09
movq %fs:0x28, %rax
cmpq 0x30(%rsp), %rax
jne 0x173c5b
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13a8c0
| /qt[P]qtbase/src/corelib/text/qstringbuilder.h |
QGlobalStatic<QtGlobalStatic::Holder<(anonymous namespace)::Q_QGS_iconLoaderInstance>>::operator()() | Type *operator()()
{
if (isDestroyed())
return nullptr;
return instance();
} | pushq %rbx
subq $0x10, %rsp
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movb 0x583713(%rip), %al # 0x6faa28
cmpb $-0x1, %al
jge 0x17731d
xorl %eax, %eax
jmp 0x17732e
movb 0x583a6d(%rip), %al # 0x6fad90
testb %al, %al
je 0x177349
leaq 0x583702(%rip), %rax # 0x6faa30
movq %fs:0x28, %rcx
cmpq 0x8(%rsp), %rcx
jne 0x177344
addq $0x10, %rsp
popq %rbx
retq
callq 0x13a8c0
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x149c36
movq (%rbx), %rax
jmp 0x17732e
nop
| /qt[P]qtbase/src/corelib/global/qglobalstatic.h |
QStringBuilder<QStringBuilder<QString, QLatin1String>, QString>::~QStringBuilder() | ~QStringBuilder() = default; | endbr64
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1a631d
lock
decl (%rax)
jne 0x1a631d
movq 0x28(%rbx), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq (%rbx), %rax
testq %rax, %rax
je 0x1a633d
lock
decl (%rax)
jne 0x1a633d
movq (%rbx), %rdi
movl $0x2, %esi
movl $0x10, %edx
popq %rbx
jmp 0x143f00
popq %rbx
retq
nop
| /qt[P]qtbase/src/corelib/text/qstringbuilder.h |
QPicturePaintEngine::writeCmdLength(int, QRectF const&, bool) | void QPicturePaintEngine::writeCmdLength(int pos, const QRectF &r, bool corr)
{
Q_D(QPicturePaintEngine);
int newpos = d->pic_d->pictb.pos(); // new position
int length = newpos - pos;
QRectF br(r);
if (length < 255) { // write 8-bit length
d->pic_d->pictb.seek(pos - 1); // position to right index
d->s << (quint8)length;
} else { // write 32-bit length
d->s << (quint32)0; // extend the buffer
d->pic_d->pictb.seek(pos - 1); // position to right index
d->s << (quint8)255; // indicate 32-bit length
char *p = d->pic_d->pictb.buffer().data();
memmove(p+pos+4, p+pos, length); // make room for 4 byte
d->s << (quint32)length;
newpos += 4;
}
d->pic_d->pictb.seek(newpos); // set to new position
if (br.width() > 0.0 || br.height() > 0.0) {
if (corr) { // widen bounding rect
int w2 = painter()->pen().width() / 2;
br.setCoords(br.left() - w2, br.top() - w2,
br.right() + w2, br.bottom() + w2);
}
br = painter()->transform().mapRect(br);
if (painter()->hasClipping()) {
QRectF cr = painter()->clipBoundingRect();
br &= cr;
}
if (br.width() > 0.0 || br.height() > 0.0) {
const auto clampToIntRange = [](qreal v)
{
return qBound(qreal((std::numeric_limits<int>::min)()),
v,
qreal((std::numeric_limits<int>::max)()));
};
int minx = qFloor(clampToIntRange(br.left()));
int miny = qFloor(clampToIntRange(br.top()));
int maxx = qCeil(clampToIntRange(br.right()));
int maxy = qCeil(clampToIntRange(br.bottom()));
if (d->pic_d->brect.width() > 0 || d->pic_d->brect.height() > 0) {
minx = qMin(minx, d->pic_d->brect.left());
miny = qMin(miny, d->pic_d->brect.top());
maxx = qMax(maxx, d->pic_d->brect.x() + d->pic_d->brect.width());
maxy = qMax(maxy, d->pic_d->brect.y() + d->pic_d->brect.height());
d->pic_d->brect.setCoords(minx, miny, maxx - 1, maxy - 1);
} else {
d->pic_d->brect.setCoords(minx, miny, maxx - 1, maxy - 1);
}
}
}
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, (%rsp)
movq %rdx, %r13
movl %esi, %r12d
movq %rdi, %rbp
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
movq 0x18(%rdi), %rbx
movq 0xc8(%rbx), %rdi
addq $0x8, %rdi
callq 0x140590
movq %rax, %r14
movl %r14d, %r15d
subl %r12d, %r15d
movupd (%r13), %xmm0
movupd 0x10(%r13), %xmm1
movapd %xmm1, 0x70(%rsp)
movapd %xmm0, 0x60(%rsp)
cmpl $0xfe, %r15d
jg 0x1a6865
movq 0xc8(%rbx), %rdi
addq $0x8, %rdi
decl %r12d
movslq %r12d, %rsi
callq 0x148c50
leaq 0xa0(%rbx), %rdi
movsbl %r15b, %esi
callq 0x13bf80
jmp 0x1a6902
movq %rbp, 0x10(%rsp)
leaq 0xa0(%rbx), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x1487b0
movq 0xc8(%rbx), %rdi
addq $0x8, %rdi
leal -0x1(%r12), %eax
movslq %eax, %rsi
callq 0x148c50
movq %r13, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x13bf80
movq 0xc8(%rbx), %rdi
addq $0x8, %rdi
callq 0x138070
movq %rax, %rbp
movq (%rax), %rax
testq %rax, %rax
je 0x1a68c2
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x1a68d3
movq 0x10(%rbp), %rsi
movq %rbp, %rdi
movl $0x1, %edx
callq 0x144b20
movq 0x8(%rbp), %rax
movslq %r12d, %rcx
leaq (%rax,%rcx), %rsi
leaq (%rax,%rcx), %rdi
addq $0x4, %rdi
movl %r15d, %edx
callq 0x138810
movq %r13, %rdi
movl %r15d, %esi
callq 0x1487b0
addq $0x4, %r14
movq 0x10(%rsp), %rbp
movq 0xc8(%rbx), %rdi
addq $0x8, %rdi
movslq %r14d, %rsi
callq 0x148c50
movapd 0x70(%rsp), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
ja 0x1a6937
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1 # xmm1 = xmm1[1],xmm2[1]
ucomisd %xmm0, %xmm1
jbe 0x1a6b95
cmpb $0x0, (%rsp)
je 0x1a6995
movq %rbp, %rdi
movapd %xmm2, (%rsp)
callq 0x143030
movq %rax, %rdi
callq 0x145860
movq %rax, %rdi
callq 0x1427a0
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movapd 0x60(%rsp), %xmm1
unpcklpd %xmm0, %xmm0 # xmm0 = xmm0[0,0]
movapd (%rsp), %xmm2
addpd %xmm1, %xmm2
subpd %xmm0, %xmm1
movapd %xmm1, 0x60(%rsp)
addpd %xmm0, %xmm2
subpd %xmm1, %xmm2
movapd %xmm2, 0x70(%rsp)
movq %rbp, %rdi
callq 0x143030
movq %rax, %rdi
callq 0x13fe50
leaq 0x80(%rsp), %r14
leaq 0x60(%rsp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x147920
movdqu (%r14), %xmm0
movupd 0x10(%r14), %xmm1
movapd %xmm1, 0x10(%r15)
movdqa %xmm0, (%r15)
movq %rbp, %rdi
callq 0x143030
movq %rax, %rdi
callq 0x146ba0
testb %al, %al
je 0x1a6a44
pcmpeqd %xmm0, %xmm0
leaq 0x40(%rsp), %r14
movdqa %xmm0, 0x10(%r14)
movdqa %xmm0, (%r14)
movq %rbp, %rdi
callq 0x143030
movq %r14, %rdi
movq %rax, %rsi
callq 0x13dab0
leaq 0x80(%rsp), %r12
leaq 0x60(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1433a0
movdqu (%r12), %xmm0
movupd 0x10(%r12), %xmm1
movapd %xmm1, 0x10(%r15)
movdqa %xmm0, (%r15)
movapd 0x70(%rsp), %xmm2
pxor %xmm0, %xmm0
ucomisd %xmm0, %xmm2
ja 0x1a6a66
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1 # xmm1 = xmm1[1],xmm2[1]
ucomisd %xmm0, %xmm1
jbe 0x1a6b95
movapd 0x60(%rsp), %xmm1
movapd %xmm1, 0x10(%rsp)
movapd 0x3cdd16(%rip), %xmm0 # 0x574790
minpd %xmm1, %xmm0
maxpd 0x3cdd1a(%rip), %xmm0 # 0x5747a0
movapd %xmm0, 0x30(%rsp)
movapd %xmm2, 0x20(%rsp)
callq 0x138490
movapd %xmm0, (%rsp)
movapd 0x30(%rsp), %xmm0
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
callq 0x138490
movapd (%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
cvttpd2dq %xmm1, %xmm0
movapd %xmm0, (%rsp)
movapd 0x20(%rsp), %xmm1
addpd 0x10(%rsp), %xmm1
movapd 0x3cdcbf(%rip), %xmm0 # 0x574790
minpd %xmm1, %xmm0
maxpd 0x3cdcc3(%rip), %xmm0 # 0x5747a0
movapd %xmm0, 0x20(%rsp)
callq 0x1470b0
movapd %xmm0, 0x10(%rsp)
movapd 0x20(%rsp), %xmm0
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
callq 0x1470b0
movapd 0x10(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
cvttpd2dq %xmm1, %xmm0
movq 0xc8(%rbx), %rax
movl 0x28(%rax), %edx
movl 0x30(%rax), %ecx
incl %ecx
movl %ecx, %esi
subl %edx, %esi
testl %esi, %esi
jle 0x1a6b2c
movl 0x2c(%rax), %edi
movl 0x34(%rax), %esi
incl %esi
jmp 0x1a6b3f
movl 0x2c(%rax), %edi
movl 0x34(%rax), %esi
incl %esi
movl %esi, %r8d
subl %edi, %r8d
testl %r8d, %r8d
jle 0x1a6bba
movd %edi, %xmm1
movd %edx, %xmm2
punpckldq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movdqa (%rsp), %xmm3
movdqa %xmm3, %xmm1
pcmpgtd %xmm2, %xmm1
pand %xmm1, %xmm2
pandn %xmm3, %xmm1
por %xmm2, %xmm1
movd %esi, %xmm2
movd %ecx, %xmm3
punpckldq %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movdqa %xmm3, %xmm2
pcmpgtd %xmm0, %xmm2
pand %xmm2, %xmm3
pandn %xmm0, %xmm2
por %xmm3, %xmm2
pcmpeqd %xmm0, %xmm0
paddd %xmm2, %xmm0
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movdqu %xmm1, 0x28(%rax)
movq %fs:0x28, %rax
cmpq 0xa0(%rsp), %rax
jne 0x1a6bc9
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pcmpeqd %xmm1, %xmm1
paddd %xmm1, %xmm0
movdqa (%rsp), %xmm1
jmp 0x1a6b8c
callq 0x13a8c0
| /qt[P]qtbase/src/gui/image/qpaintengine_pic.cpp |
QPicturePaintEngine::updateOpacity(double) | void QPicturePaintEngine::updateOpacity(qreal opacity)
{
Q_D(QPicturePaintEngine);
#ifdef QT_PICTURE_DEBUG
qDebug() << " -> updateOpacity():" << opacity;
#endif
int pos;
SERIALIZE_CMD(QPicturePrivate::PdcSetOpacity);
d->s << double(opacity);
writeCmdLength(pos, QRectF(), false);
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rdi), %r15
movq 0xc8(%r15), %rax
incl 0x18(%rax)
leaq 0xa0(%r15), %r14
movq %r14, %rdi
movl $0x42, %esi
callq 0x13bf80
movq %r14, %rdi
xorl %esi, %esi
callq 0x13bf80
movq 0xc8(%r15), %rdi
addq $0x8, %rdi
callq 0x140590
movq %rax, %r15
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x142b50
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movl %r15d, %esi
xorl %ecx, %ecx
callq 0x1a67ca
movq %fs:0x28, %rax
cmpq 0x38(%rsp), %rax
jne 0x1a6dbd
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/image/qpaintengine_pic.cpp |
QPicturePaintEngine::updateBrushOrigin(QPointF const&) | void QPicturePaintEngine::updateBrushOrigin(const QPointF &p)
{
Q_D(QPicturePaintEngine);
#ifdef QT_PICTURE_DEBUG
qDebug() << " -> updateBrushOrigin(): " << p;
#endif
int pos;
SERIALIZE_CMD(QPicturePrivate::PdcSetBrushOrigin);
d->s << p;
writeCmdLength(pos, QRect(), false);
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rdi), %r12
movq 0xc8(%r12), %rax
incl 0x18(%rax)
leaq 0xa0(%r12), %r15
movq %r15, %rdi
movl $0x2b, %esi
callq 0x13bf80
movq %r15, %rdi
xorl %esi, %esi
callq 0x13bf80
movq 0xc8(%r12), %rdi
addq $0x8, %rdi
callq 0x140590
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x1479a0
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movl %r12d, %esi
xorl %ecx, %ecx
callq 0x1a67ca
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x1a6f54
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/image/qpaintengine_pic.cpp |
QPicturePaintEngine::updateBackground(Qt::BGMode, QBrush const&) | void QPicturePaintEngine::updateBackground(Qt::BGMode bgMode, const QBrush &bgBrush)
{
Q_D(QPicturePaintEngine);
#ifdef QT_PICTURE_DEBUG
qDebug() << " -> updateBackground(): mode:" << bgMode << "style:" << bgBrush.style();
#endif
int pos;
SERIALIZE_CMD(QPicturePrivate::PdcSetBkColor);
d->s << bgBrush.color();
writeCmdLength(pos, QRect(), false);
SERIALIZE_CMD(QPicturePrivate::PdcSetBkMode);
d->s << (qint8) bgMode;
writeCmdLength(pos, QRectF(), false);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rdi), %r13
movq 0xc8(%r13), %rax
incl 0x18(%rax)
leaq 0xa0(%r13), %r14
movq %r14, %rdi
movl $0x28, %esi
callq 0x13bf80
movq %r14, %rdi
xorl %esi, %esi
callq 0x13bf80
movq 0xc8(%r13), %rdi
addq $0x8, %rdi
callq 0x140590
movq %rax, %r12
movq (%r15), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x13d770
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x1a67ca
movq 0xc8(%r13), %rax
incl 0x18(%rax)
movq %r14, %rdi
movl $0x29, %esi
callq 0x13bf80
movq %r14, %rdi
xorl %esi, %esi
callq 0x13bf80
movq 0xc8(%r13), %rdi
addq $0x8, %rdi
callq 0x140590
movq %rax, %r12
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x13bf80
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %rsp, %rdx
movq %rbx, %rdi
movl %r12d, %esi
xorl %ecx, %ecx
callq 0x1a67ca
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x1a713e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/image/qpaintengine_pic.cpp |
QPicturePaintEngine::updateRenderHints(QFlags<QPainter::RenderHint>) | void QPicturePaintEngine::updateRenderHints(QPainter::RenderHints hints)
{
Q_D(QPicturePaintEngine);
#ifdef QT_PICTURE_DEBUG
qDebug() << " -> updateRenderHints(): " << hints;
#endif
int pos;
SERIALIZE_CMD(QPicturePrivate::PdcSetRenderHint);
d->s << (quint32) hints;
writeCmdLength(pos, QRect(), false);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rdi), %r15
movq 0xc8(%r15), %rax
incl 0x18(%rax)
leaq 0xa0(%r15), %r14
movq %r14, %rdi
movl $0x3f, %esi
callq 0x13bf80
movq %r14, %rdi
xorl %esi, %esi
callq 0x13bf80
movq 0xc8(%r15), %rdi
addq $0x8, %rdi
callq 0x140590
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x1487b0
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movl %r15d, %esi
xorl %ecx, %ecx
callq 0x1a67ca
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x1a7411
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/image/qpaintengine_pic.cpp |
QPicturePaintEngine::drawPixmap(QRectF const&, QPixmap const&, QRectF const&) | void QPicturePaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
{
Q_D(QPicturePaintEngine);
#ifdef QT_PICTURE_DEBUG
qDebug() << " -> drawPixmap():" << r;
#endif
int pos;
SERIALIZE_CMD(QPicturePrivate::PdcDrawPixmap);
if (d->pic_d->in_memory_only) {
int index = d->pic_d->pixmap_list.size();
d->pic_d->pixmap_list.append(pm);
d->s << r << index << sr;
} else {
d->s << r << pm << sr;
}
writeCmdLength(pos, r, false);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq 0xc8(%r15), %rax
incl 0x18(%rax)
leaq 0xa0(%r15), %rbp
movq %rbp, %rdi
movl $0x11, %esi
callq 0x13bf80
movq %rbp, %rdi
xorl %esi, %esi
callq 0x13bf80
movq 0xc8(%r15), %rdi
addq $0x8, %rdi
callq 0x140590
movq %rax, 0x10(%rsp)
movq 0xc8(%r15), %r15
cmpb $0x1, 0x50(%r15)
jne 0x1a7770
movq %r12, 0x8(%rsp)
movq 0x80(%r15), %r12
addq $0x70, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1a9602
movq %r15, %rdi
callq 0x1a97e6
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x144f80
movq %rax, %rdi
movl %r12d, %esi
movq 0x8(%rsp), %r12
callq 0x1487b0
jmp 0x1a7786
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x144f80
movq %rax, %rdi
movq %r13, %rsi
callq 0x139ff0
movq %rax, %rdi
movq %r12, %rsi
callq 0x144f80
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a67ca
nop
| /qt[P]qtbase/src/gui/image/qpaintengine_pic.cpp |
QList<QPointF>::reserve(long long) | void QList<T>::reserve(qsizetype asize)
{
// capacity() == 0 for immutable data, so this will force a detaching below
if (asize <= capacity() - d.freeSpaceAtBegin()) {
if (d->flags() & Data::CapacityReserved)
return; // already reserved, don't shrink
if (!d->isShared()) {
// accept current allocation, don't shrink
d->setFlag(Data::CapacityReserved);
return;
}
}
DataPointer detached(qMax(asize, size()));
detached->copyAppend(d->begin(), d->end());
if (detached.d_ptr())
detached->setFlag(Data::CapacityReserved);
d.swap(detached);
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movq (%rdi), %rax
testq %rax, %rax
je 0x1a7f90
movq 0x8(%rax), %rdx
movq 0x8(%rbx), %rsi
leaq 0x1f(%rax), %rdi
andq $-0x10, %rdi
subq %rdi, %rsi
sarq $0x4, %rsi
subq %rsi, %rdx
cmpq %rcx, %rdx
jge 0x1a801b
movq 0x10(%rbx), %rax
cmpq %rcx, %rax
cmovgq %rax, %rcx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movl $0x10, %esi
movl $0x10, %edx
movq %r15, %rdi
movl $0x1, %r8d
callq 0x138b60
movq %rax, %r14
movq (%r15), %r12
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x1a7fe7
movq 0x8(%rbx), %rsi
movq %r15, %rdx
shlq $0x4, %rdx
movq %r14, %rdi
callq 0x137aa0
testq %r12, %r12
je 0x1a7ff2
orb $0x1, 0x4(%r12)
movq (%rbx), %rdi
movq %r12, (%rbx)
movq %r14, 0x8(%rbx)
movq %r15, 0x10(%rbx)
testq %rdi, %rdi
je 0x1a8034
lock
decl (%rdi)
jne 0x1a8034
movl $0x10, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x1a8034
movl 0x4(%rax), %edx
testb $0x1, %dl
jne 0x1a8034
movl (%rax), %esi
cmpl $0x1, %esi
jne 0x1a7f90
orl $0x1, %edx
movl %edx, 0x4(%rax)
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x1a8050
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QObject*>::~QList() | bool deref() noexcept { return !d || d->deref(); } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x1d9365
lock
decl (%rax)
jne 0x1d9365
movq (%rdi), %rdi
movl $0x8, %esi
movl $0x10, %edx
jmp 0x143f00
retq
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QList<QWindow*>::~QList() | bool deref() noexcept { return !d || d->deref(); } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x1d93ad
lock
decl (%rax)
jne 0x1d93ad
movq (%rdi), %rdi
movl $0x8, %esi
movl $0x10, %edx
jmp 0x143f00
retq
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QCommonArrayOps<QString>::growAppend(QString const*, QString const*) | void growAppend(const T *b, const T *e)
{
if (b == e)
return;
Q_ASSERT(b < e);
const qsizetype n = e - b;
DataPointer old;
// points into range:
if (QtPrivate::q_points_into_range(b, *this))
this->detachAndGrow(QArrayData::GrowsAtEnd, n, &b, &old);
else
this->detachAndGrow(QArrayData::GrowsAtEnd, n, nullptr, nullptr);
Q_ASSERT(this->freeSpaceAtEnd() >= n);
// b might be updated so use [b, n)
this->copyAppend(b, b + n);
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq %rdx, %rsi
je 0x1d9e34
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
subq %rsi, %rbx
movq %rbx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
ja 0x1d9e0c
movq 0x10(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
cmpq %r15, %rax
jbe 0x1d9e0c
leaq 0x20(%rsp), %r15
movq %rsp, %r8
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x17e7b2
movq (%r15), %r15
jmp 0x1d9e1b
movq %r14, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x17e7b2
addq %r15, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1d9cf0
movq %rsp, %rdi
callq 0x17ddb4
movq %fs:0x28, %rax
cmpq 0x28(%rsp), %rax
jne 0x1d9e4e
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
void QtPrivate::QPodArrayOps<QObject*>::emplace<QObject*&>(long long, QObject*&) | void emplace(qsizetype i, Args &&... args)
{
bool detach = this->needsDetach();
if (!detach) {
if (i == this->size && this->freeSpaceAtEnd()) {
new (this->end()) T(std::forward<Args>(args)...);
++this->size;
return;
}
if (i == 0 && this->freeSpaceAtBegin()) {
new (this->begin() - 1) T(std::forward<Args>(args)...);
--this->ptr;
++this->size;
return;
}
}
T tmp(std::forward<Args>(args)...);
typename QArrayData::GrowthPosition pos = QArrayData::GrowsAtEnd;
if (this->size != 0 && i == 0)
pos = QArrayData::GrowsAtBeginning;
this->detachAndGrow(pos, 1, nullptr, nullptr);
T *where = createHole(pos, i, 1);
new (where) T(std::move(tmp));
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1d9eb2
movl (%rax), %ecx
cmpl $0x1, %ecx
jg 0x1d9eb2
movq 0x10(%rbx), %rcx
cmpq %r14, %rcx
jne 0x1d9e9c
movq 0x8(%rbx), %rsi
leaq 0x1f(%rax), %rdi
andq $-0x10, %rdi
movq %rsi, %r8
subq %rdi, %r8
sarq $0x3, %r8
addq %r14, %r8
cmpq %r8, 0x8(%rax)
jne 0x1d9efc
testq %r14, %r14
jne 0x1d9eb2
movq 0x8(%rbx), %rsi
addq $0x1f, %rax
andq $-0x10, %rax
cmpq %rsi, %rax
jne 0x1d9f0c
movq (%rdx), %r15
cmpq $0x0, 0x10(%rbx)
setne %al
testq %r14, %r14
sete %cl
andb %al, %cl
movzbl %cl, %ebp
movl $0x1, %edx
movq %rbx, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1d9f56
movl $0x1, %ecx
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x1da002
movq %r15, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rdx), %rax
movq %rax, (%rsi,%r14,8)
incq %r14
movq %r14, 0x10(%rbx)
jmp 0x1d9ef1
movq (%rdx), %rax
movq %rax, -0x8(%rsi)
addq $-0x8, 0x8(%rbx)
incq %rcx
movq %rcx, 0x10(%rbx)
jmp 0x1d9ef1
nop
| /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QArrayDataPointer<QObject*>::detachAndGrow(QArrayData::GrowthPosition, long long, QObject* const**, QArrayDataPointer<QObject*>*) | void detachAndGrow(QArrayData::GrowthPosition where, qsizetype n, const T **data,
QArrayDataPointer *old)
{
const bool detach = needsDetach();
bool readjusted = false;
if (!detach) {
if (!n || (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= n)
|| (where == QArrayData::GrowsAtEnd && freeSpaceAtEnd() >= n))
return;
readjusted = tryReadjustFreeSpace(where, n, data);
Q_ASSERT(!readjusted
|| (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= n)
|| (where == QArrayData::GrowsAtEnd && freeSpaceAtEnd() >= n));
}
if (!readjusted)
reallocateAndGrow(where, n, old);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %rax
testq %rax, %rax
je 0x1d9f7b
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x1d9f95
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1da102
testq %r14, %r14
je 0x1d9ff6
testl %ebp, %ebp
je 0x1d9fc2
cmpl $0x1, %ebp
jne 0x1d9fbb
movq 0x8(%r15), %rdx
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jge 0x1d9ff6
movq %r15, %rdi
movl %ebp, %esi
jmp 0x1d9fea
movq 0x8(%rax), %rdx
movq 0x8(%r15), %rsi
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rsi
sarq $0x3, %rsi
addq 0x10(%r15), %rsi
subq %rsi, %rdx
cmpq %r14, %rdx
jge 0x1d9ff6
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1da05a
testb %al, %al
je 0x1d9f7b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QObject*>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, QObject* const**) | qsizetype constAllocatedCapacity() const noexcept { return d ? d->constAllocatedCapacity() : 0; } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x1da08c
movq 0x8(%rax), %r9
movq 0x8(%rdi), %r8
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %r8
sarq $0x3, %r8
movq 0x10(%rdi), %rax
addq %r8, %rax
movq %r9, %r10
subq %rax, %r10
jmp 0x1da095
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %esi, %esi
jne 0x1da0b1
cmpq %rdx, %r8
jl 0x1da0b1
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rdx
addq %r9, %r9
xorl %eax, %eax
cmpq %r9, %rdx
jl 0x1da0e9
retq
xorl %eax, %eax
cmpl $0x1, %esi
jne 0x1da0b0
cmpq %rdx, %r10
jl 0x1da0b0
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rsi
cmpq %r9, %rsi
jge 0x1da0ff
addq %rdx, %rax
subq %rax, %r9
movq %r9, %rsi
shrq $0x3f, %rsi
addq %r9, %rsi
sarq %rsi
xorl %eax, %eax
testq %rsi, %rsi
cmovgq %rsi, %rax
addq %rdx, %rax
pushq %rax
subq %r8, %rax
movq %rax, %rsi
movq %rcx, %rdx
callq 0x1da296
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QObject*>::allocateGrow(QArrayDataPointer<QObject*> const&, long long, QArrayData::GrowthPosition) | static QArrayDataPointer allocateGrow(const QArrayDataPointer &from, qsizetype n, QArrayData::GrowthPosition position)
{
// calculate new capacity. We keep the free capacity at the side that does not have to grow
// to avoid quadratic behavior with mixed append/prepend cases
// use qMax below, because constAllocatedCapacity() can be 0 when using fromRawData()
qsizetype minimalCapacity = qMax(from.size, from.constAllocatedCapacity()) + n;
// subtract the free space at the side we want to allocate. This ensures that the total size requested is
// the existing allocation at the other side + size + n.
minimalCapacity -= (position == QArrayData::GrowsAtEnd) ? from.freeSpaceAtEnd() : from.freeSpaceAtBegin();
qsizetype capacity = from.detachCapacity(minimalCapacity);
const bool grows = capacity > from.constAllocatedCapacity();
auto [header, dataPtr] = Data::allocate(capacity, grows ? QArrayData::Grow : QArrayData::KeepSize);
const bool valid = header != nullptr && dataPtr != nullptr;
if (!valid)
return QArrayDataPointer(header, dataPtr);
// Idea: * when growing backwards, adjust pointer to prepare free space at the beginning
// * when growing forward, adjust by the previous data pointer offset
dataPtr += (position == QArrayData::GrowsAtBeginning)
? n + qMax(0, (header->alloc - from.size - n) / 2)
: from.freeSpaceAtBegin();
header->flags = from.flags();
return QArrayDataPointer(header, dataPtr);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x1da3a1
movq 0x8(%rdx), %rax
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rsi
cmpq %rax, %rsi
movq %rax, %rdi
cmovgq %rsi, %rdi
addq %r15, %rdi
leaq 0x1f(%rdx), %r8
andq $-0x10, %r8
subq %r8, %rcx
sarq $0x3, %rcx
addq %rcx, %rsi
movq %rax, %r8
subq %rsi, %r8
testl %ebp, %ebp
cmovneq %rcx, %r8
subq %r8, %rdi
cmpq %rdi, %rax
movq %rdi, %rcx
cmovgq %rax, %rcx
testb $0x1, 0x4(%rdx)
cmoveq %rdi, %rcx
jmp 0x1da3b1
movq 0x10(%r14), %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
addq %r15, %rcx
xorl %r8d, %r8d
cmpq %rax, %rcx
setle %r8b
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r12
movq %rax, (%r12)
movl $0x8, %esi
movl $0x10, %edx
movq %r12, %rdi
callq 0x138b60
movq (%r12), %rcx
testq %rcx, %rcx
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
jne 0x1da453
cmpl $0x1, %ebp
jne 0x1da42f
movq 0x8(%rcx), %rdx
movq 0x10(%r14), %rsi
addq %r15, %rsi
subq %rsi, %rdx
movq %rdx, %rdi
shrq $0x3f, %rdi
addq %rdx, %rdi
sarq %rdi
xorl %esi, %esi
testq %rdi, %rdi
cmovleq %rsi, %rdi
movq (%r14), %rdx
leaq (%rax,%rdi,8), %rax
leaq (%rax,%r15,8), %rax
testq %rdx, %rdx
jne 0x1da449
jmp 0x1da450
movq (%r14), %rdx
testq %rdx, %rdx
je 0x1da44e
movq 0x8(%r14), %rsi
leaq 0x1f(%rdx), %rdi
andq $-0x10, %rdi
subq %rdi, %rsi
addq %rsi, %rax
movl 0x4(%rdx), %esi
jmp 0x1da450
xorl %esi, %esi
movl %esi, 0x4(%rcx)
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0x1da482
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QWindowSystemInterfacePrivate::MouseEvent::~MouseEvent() | MouseEvent(QWindow *w, ulong time, const QPointF &local, const QPointF &global,
Qt::MouseButtons state, Qt::KeyboardModifiers mods,
Qt::MouseButton b, QEvent::Type type,
Qt::MouseEventSource src = Qt::MouseEventNotSynthesized, bool frame = false,
const QPointingDevice *device = QPointingDevice::primaryPointingDevice(),
int evPtId = -1)
: PointerEvent(w, time, Mouse, mods, device), localPos(local), globalPos(global),
buttons(state), source(src), nonClientArea(frame), button(b), buttonType(type),
eventPointId(evPtId) { } | endbr64
pushq %rbx
movq %rdi, %rbx
movq 0x5154a5(%rip), %rax # 0x6efad8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x1da658
lock
decl (%rax)
jne 0x1da658
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0x1da653
xorl %edi, %edi
callq 0x13df00
movl $0x78, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x137fb0
| /qt[P]qtbase/src/gui/kernel/qwindowsysteminterface_p.h |
QWindowSystemInterfacePrivate::TouchEvent::~TouchEvent() | TouchEvent(QWindow *w, ulong time, QEvent::Type t, const QPointingDevice *device,
const QList<QEventPoint> &p, Qt::KeyboardModifiers mods)
: PointerEvent(w, time, Touch, mods, device), points(p), touchType(t) { } | endbr64
pushq %rbx
movq %rdi, %rbx
movq 0x5142fb(%rip), %rax # 0x6ee9e8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x40, %rdi
callq 0x1c8a12
movq 0x5153d4(%rip), %rax # 0x6efad8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1da729
lock
decl (%rax)
jne 0x1da729
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0x1da724
xorl %edi, %edi
callq 0x13df00
movl $0x60, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x137fb0
nop
| /qt[P]qtbase/src/gui/kernel/qwindowsysteminterface_p.h |
QMetaTypeIdQObject<QWindow*, 8>::qt_metatype_id() | static int qt_metatype_id()
{
Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0);
if (const int id = metatype_id.loadAcquire())
return id;
const char *const cName = T::staticMetaObject.className();
QByteArray typeName;
typeName.reserve(strlen(cName) + 1);
typeName.append(cName).append('*');
const int newId = qRegisterNormalizedMetaType<T *>(typeName);
metatype_id.storeRelease(newId);
return newId;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movl 0x526af9(%rip), %ebx # 0x701738
testl %ebx, %ebx
je 0x1dac63
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x1dad17
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x51464e(%rip), %rdi # 0x6ef2b8
callq 0x142490
movq %rax, %rbx
xorl %r14d, %r14d
movq %rsp, %r15
movq %r14, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq %rax, %rdi
callq 0x13c0e0
incq %rax
testq %rax, %rax
cmovgq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x144b20
movq (%r15), %rax
testq %rax, %rax
je 0x1dacb8
cmpq $0x0, 0x8(%rax)
je 0x1dacb8
orb $0x1, 0x4(%rax)
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rdx
callq 0x166032
movq %rax, %rdi
movl $0x2a, %esi
callq 0x142e90
movq %r14, %rdi
callq 0x1dad1c
movl %eax, %ebx
movl %eax, 0x526a4e(%rip) # 0x701738
movq (%r14), %rax
testq %rax, %rax
je 0x1dac43
lock
decl (%rax)
jne 0x1dac43
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x1dac43
callq 0x13a8c0
| /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
int qRegisterNormalizedMetaTypeImplementation<Qt::ApplicationState>(QByteArray const&) | int qRegisterNormalizedMetaTypeImplementation(const QT_PREPEND_NAMESPACE(QByteArray) &normalizedTypeName)
{
#ifndef QT_NO_QOBJECT
Q_ASSERT_X(normalizedTypeName == QMetaObject::normalizedType(normalizedTypeName.constData()),
"qRegisterNormalizedMetaType",
"qRegisterNormalizedMetaType was called with a not normalized type name, "
"please call qRegisterMetaType instead.");
#endif
const QMetaType metaType = QMetaType::fromType<T>();
const int id = metaType.id();
QtPrivate::SequentialContainerTransformationHelper<T>::registerConverter();
QtPrivate::SequentialContainerTransformationHelper<T>::registerMutableView();
QtPrivate::AssociativeContainerTransformationHelper<T>::registerConverter();
QtPrivate::AssociativeContainerTransformationHelper<T>::registerMutableView();
QtPrivate::MetaTypePairHelper<T>::registerConverter();
QtPrivate::MetaTypeSmartPointerHelper<T>::registerConverter();
#if QT_CONFIG(future)
QtPrivate::MetaTypeQFutureHelper<T>::registerConverter();
#endif
if (normalizedTypeName != metaType.name())
QMetaType::registerNormalizedTypedef(normalizedTypeName, metaType);
return id;
} | endbr64
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movl 0x515da2(%rip), %ebx # 0x6f0d84
testl %ebx, %ebx
jne 0x1daff4
leaq 0x515d8b(%rip), %rdi # 0x6f0d78
callq 0x139f90
movl %eax, %ebx
movq 0x515d95(%rip), %rax # 0x6f0d90
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x1660ec
testb %al, %al
je 0x1db01e
leaq 0x515d62(%rip), %rsi # 0x6f0d78
movq %r14, %rdi
callq 0x146700
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x1db038
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QArrayDataPointer<QWindow*>::detachAndGrow(QArrayData::GrowthPosition, long long, QWindow* const**, QArrayDataPointer<QWindow*>*) | void detachAndGrow(QArrayData::GrowthPosition where, qsizetype n, const T **data,
QArrayDataPointer *old)
{
const bool detach = needsDetach();
bool readjusted = false;
if (!detach) {
if (!n || (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= n)
|| (where == QArrayData::GrowsAtEnd && freeSpaceAtEnd() >= n))
return;
readjusted = tryReadjustFreeSpace(where, n, data);
Q_ASSERT(!readjusted
|| (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= n)
|| (where == QArrayData::GrowsAtEnd && freeSpaceAtEnd() >= n));
}
if (!readjusted)
reallocateAndGrow(where, n, old);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %rax
testq %rax, %rax
je 0x1db3ed
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x1db407
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1db574
testq %r14, %r14
je 0x1db468
testl %ebp, %ebp
je 0x1db434
cmpl $0x1, %ebp
jne 0x1db42d
movq 0x8(%r15), %rdx
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jge 0x1db468
movq %r15, %rdi
movl %ebp, %esi
jmp 0x1db45c
movq 0x8(%rax), %rdx
movq 0x8(%r15), %rsi
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rsi
sarq $0x3, %rsi
addq 0x10(%r15), %rsi
subq %rsi, %rdx
cmpq %r14, %rdx
jge 0x1db468
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1db4cc
testb %al, %al
je 0x1db3ed
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QWindow*>::reallocateAndGrow(QArrayData::GrowthPosition, long long, QArrayDataPointer<QWindow*>*) | Q_NEVER_INLINE void reallocateAndGrow(QArrayData::GrowthPosition where, qsizetype n,
QArrayDataPointer *old = nullptr)
{
if constexpr (QTypeInfo<T>::isRelocatable && alignof(T) <= alignof(std::max_align_t)) {
if (where == QArrayData::GrowsAtEnd && !old && !needsDetach() && n > 0) {
(*this)->reallocate(constAllocatedCapacity() - freeSpaceAtEnd() + n, QArrayData::Grow); // fast path
return;
}
}
QArrayDataPointer dp(allocateGrow(*this, n, where));
if (n > 0)
Q_CHECK_PTR(dp.data());
if (where == QArrayData::GrowsAtBeginning) {
Q_ASSERT(dp.freeSpaceAtBegin() >= n);
} else {
Q_ASSERT(dp.freeSpaceAtEnd() >= n);
}
if (size) {
qsizetype toCopy = size;
if (n < 0)
toCopy += n;
if (needsDetach() || old)
dp->copyAppend(begin(), begin() + toCopy);
else
dp->moveAppend(begin(), begin() + toCopy);
Q_ASSERT(dp.size == toCopy);
}
swap(dp);
if (old)
old->swap(dp);
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ecx
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
testl %esi, %esi
setne %al
testq %r14, %r14
setne %dl
orb %al, %dl
jne 0x1db5f8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1db5f8
movl (%rdi), %eax
testq %r15, %r15
jle 0x1db5f8
cmpl $0x1, %eax
jg 0x1db5f8
movq 0x8(%rbx), %rsi
leaq 0x1f(%rdi), %rax
andq $-0x10, %rax
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq 0x10(%rbx), %r15
addq %rcx, %r15
movl $0x8, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149770
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
jmp 0x1db6e6
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movaps 0x399070(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rdi)
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1db794
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0x1db674
movq %r15, %rax
sarq $0x3f, %rax
andq %r15, %rax
addq %rax, %r12
movq (%rbx), %rax
testq %rax, %rax
je 0x1db646
movl (%rax), %eax
testq %r14, %r14
jne 0x1db646
cmpl $0x2, %eax
movq 0x10(%rsp), %rdi
testq %r12, %r12
je 0x1db679
movq 0x8(%rbx), %rsi
shlq $0x3, %rdi
addq 0x8(%rsp), %rdi
leaq (,%r12,8), %rdx
callq 0x137aa0
addq 0x10(%rsp), %r12
movq %r12, %rdi
jmp 0x1db679
movq 0x10(%rsp), %rdi
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movaps (%rsp), %xmm0
movq %rax, (%rsp)
movups %xmm0, (%rbx)
movq %rcx, 0x8(%rsp)
movq 0x10(%rbx), %rdx
movq %rdi, 0x10(%rbx)
movq %rdx, 0x10(%rsp)
testq %r14, %r14
je 0x1db6c9
movq (%r14), %rsi
movq %rax, (%r14)
movq %rsi, (%rsp)
movq 0x8(%r14), %rax
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rsp)
movq 0x10(%r14), %rax
movq %rdx, 0x10(%r14)
movq %rax, 0x10(%rsp)
movq %rsi, %rax
testq %rax, %rax
je 0x1db6e6
lock
decl (%rax)
jne 0x1db6e6
movq (%rsp), %rdi
movl $0x8, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x1db702
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QWindow*>::allocateGrow(QArrayDataPointer<QWindow*> const&, long long, QArrayData::GrowthPosition) | static QArrayDataPointer allocateGrow(const QArrayDataPointer &from, qsizetype n, QArrayData::GrowthPosition position)
{
// calculate new capacity. We keep the free capacity at the side that does not have to grow
// to avoid quadratic behavior with mixed append/prepend cases
// use qMax below, because constAllocatedCapacity() can be 0 when using fromRawData()
qsizetype minimalCapacity = qMax(from.size, from.constAllocatedCapacity()) + n;
// subtract the free space at the side we want to allocate. This ensures that the total size requested is
// the existing allocation at the other side + size + n.
minimalCapacity -= (position == QArrayData::GrowsAtEnd) ? from.freeSpaceAtEnd() : from.freeSpaceAtBegin();
qsizetype capacity = from.detachCapacity(minimalCapacity);
const bool grows = capacity > from.constAllocatedCapacity();
auto [header, dataPtr] = Data::allocate(capacity, grows ? QArrayData::Grow : QArrayData::KeepSize);
const bool valid = header != nullptr && dataPtr != nullptr;
if (!valid)
return QArrayDataPointer(header, dataPtr);
// Idea: * when growing backwards, adjust pointer to prepare free space at the beginning
// * when growing forward, adjust by the previous data pointer offset
dataPtr += (position == QArrayData::GrowsAtBeginning)
? n + qMax(0, (header->alloc - from.size - n) / 2)
: from.freeSpaceAtBegin();
header->flags = from.flags();
return QArrayDataPointer(header, dataPtr);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x1db813
movq 0x8(%rdx), %rax
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rsi
cmpq %rax, %rsi
movq %rax, %rdi
cmovgq %rsi, %rdi
addq %r15, %rdi
leaq 0x1f(%rdx), %r8
andq $-0x10, %r8
subq %r8, %rcx
sarq $0x3, %rcx
addq %rcx, %rsi
movq %rax, %r8
subq %rsi, %r8
testl %ebp, %ebp
cmovneq %rcx, %r8
subq %r8, %rdi
cmpq %rdi, %rax
movq %rdi, %rcx
cmovgq %rax, %rcx
testb $0x1, 0x4(%rdx)
cmoveq %rdi, %rcx
jmp 0x1db823
movq 0x10(%r14), %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
addq %r15, %rcx
xorl %r8d, %r8d
cmpq %rax, %rcx
setle %r8b
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r12
movq %rax, (%r12)
movl $0x8, %esi
movl $0x10, %edx
movq %r12, %rdi
callq 0x138b60
movq (%r12), %rcx
testq %rcx, %rcx
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
jne 0x1db8c5
cmpl $0x1, %ebp
jne 0x1db8a1
movq 0x8(%rcx), %rdx
movq 0x10(%r14), %rsi
addq %r15, %rsi
subq %rsi, %rdx
movq %rdx, %rdi
shrq $0x3f, %rdi
addq %rdx, %rdi
sarq %rdi
xorl %esi, %esi
testq %rdi, %rdi
cmovleq %rsi, %rdi
movq (%r14), %rdx
leaq (%rax,%rdi,8), %rax
leaq (%rax,%r15,8), %rax
testq %rdx, %rdx
jne 0x1db8bb
jmp 0x1db8c2
movq (%r14), %rdx
testq %rdx, %rdx
je 0x1db8c0
movq 0x8(%r14), %rsi
leaq 0x1f(%rdx), %rdi
andq $-0x10, %rdi
subq %rdi, %rsi
addq %rsi, %rax
movl 0x4(%rdx), %esi
jmp 0x1db8c2
xorl %esi, %esi
movl %esi, 0x4(%rcx)
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0x1db8f4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QList<QWindow*>::erase(QList<QWindow*>::const_iterator, QList<QWindow*>::const_iterator) | typename QList<T>::iterator QList<T>::erase(const_iterator abegin, const_iterator aend)
{
Q_ASSERT_X(isValidIterator(abegin), "QList::erase", "The specified iterator argument 'abegin' is invalid");
Q_ASSERT_X(isValidIterator(aend), "QList::erase", "The specified iterator argument 'aend' is invalid");
Q_ASSERT(aend >= abegin);
qsizetype i = std::distance(constBegin(), abegin);
qsizetype n = std::distance(abegin, aend);
remove(i, n);
return begin() + i;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rax, %r15
subq %rsi, %r15
subq %rax, %r14
je 0x1db9ee
sarq $0x3, %r14
movq (%rbx), %rax
testq %rax, %rax
je 0x1db9ce
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x1db9e0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1db574
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1dbaae
movq %rbx, %rdi
callq 0x1d9896
addq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QDebug QtPrivate::printSequentialContainer<QList<QWindow*>>(QDebug, char const*, QList<QWindow*> const&) | inline QDebug printSequentialContainer(QDebug debug, const char *which, const SequentialContainer &c)
{
const QDebugStateSaver saver(debug);
debug.nospace() << which << '(';
typename SequentialContainer::const_iterator it = c.begin(), end = c.end();
if (it != end) {
debug << *it;
++it;
}
while (it != end) {
debug << ", " << *it;
++it;
}
debug << ')';
return debug;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x30(%rsp), %rdi
movq %rax, (%rdi)
callq 0x139b50
movq (%r14), %r13
movb $0x0, 0x30(%r13)
testq %r12, %r12
je 0x1dbc68
movq $-0x1, %rax
leaq 0x1(%rax), %rsi
cmpb $0x0, 0x1(%r12,%rax)
movq %rsi, %rax
jne 0x1dbc57
jmp 0x1dbc6a
xorl %esi, %esi
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rdx
callq 0x1457d0
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1455b0
movq (%rbp), %rax
testq %rax, %rax
je 0x1dbca7
lock
decl (%rax)
jne 0x1dbca7
movq 0x38(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq (%r14), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x1dbcbd
movl $0x20, %esi
callq 0x13d680
movq (%r14), %rdi
movq %r15, (%rsp)
movl $0x28, %esi
callq 0x13d680
movq (%r14), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x1dbcde
movl $0x20, %esi
callq 0x13d680
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %rax
leaq (%r15,%rax,8), %rcx
movq %rcx, 0x8(%rsp)
testq %rax, %rax
je 0x1dbd29
movq (%r14), %rax
leaq 0x20(%rsp), %rbx
movq %rax, (%rbx)
incl 0x28(%rax)
movq (%r15), %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x145830
movq %r12, %rdi
callq 0x1391b0
movq %rbx, %rdi
callq 0x1391b0
addq $0x8, %r15
cmpq 0x8(%rsp), %r15
je 0x1dbdd3
leaq 0x38(%rsp), %r12
leaq 0x18(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq (%r14), %rbx
movl $0x2, %esi
movq %r12, %rdi
leaq 0x3bf089(%rip), %rdx # 0x59adde
callq 0x1457d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1455b0
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x1dbd88
lock
decl (%rax)
jne 0x1dbd88
movq 0x38(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq (%r14), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x1dbd9e
movl $0x20, %esi
callq 0x13d680
movq (%r14), %rdi
movq %rdi, 0x10(%rsp)
incl 0x28(%rdi)
movq (%r15), %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x145830
movq %r13, %rdi
callq 0x1391b0
movq %rbp, %rdi
callq 0x1391b0
addq $0x8, %r15
cmpq 0x8(%rsp), %r15
jne 0x1dbd43
movq (%r14), %rdi
movl $0x29, %esi
callq 0x13d680
movq (%r14), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x1dbdf6
movl $0x20, %esi
callq 0x13d680
movq (%r14), %rdi
movq (%rsp), %rbx
movq $0x0, (%r14)
movq %rdi, (%rbx)
leaq 0x30(%rsp), %rdi
callq 0x1487e0
movq %fs:0x28, %rax
cmpq 0x50(%rsp), %rax
jne 0x1dbe30
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/corelib/io/qdebug.h |
QHash<QWindow*, QGuiApplicationPrivate::SynthesizedMouseData>::iterator QHash<QWindow*, QGuiApplicationPrivate::SynthesizedMouseData>::emplace<QGuiApplicationPrivate::SynthesizedMouseData const&>(QWindow*&&, QGuiApplicationPrivate::SynthesizedMouseData const&) | iterator emplace(Key &&key, Args &&... args)
{
if (isDetached()) {
if (d->shouldGrow()) // Construct the value now so that no dangling references are used
return emplace_helper(std::move(key), T(std::forward<Args>(args)...));
return emplace_helper(std::move(key), std::forward<Args>(args)...);
}
// else: we must detach
const auto copy = *this; // keep 'args' alive across the detach/growth
detach();
return emplace_helper(std::move(key), std::forward<Args>(args)...);
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x38(%rsp)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1de6df
movl (%rdi), %eax
cmpl $0x1, %eax
ja 0x1de6eb
movq 0x10(%rdi), %rax
shrq %rax
cmpq %rax, 0x8(%rdi)
jae 0x1de74c
movq %fs:0x28, %rax
cmpq 0x38(%rsp), %rax
jne 0x1de7b3
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1de892
movq $0x0, (%rsp)
xorl %edi, %edi
jmp 0x1de708
movq %rdi, (%rsp)
movl (%rdi), %eax
cmpl $-0x1, %eax
je 0x1de701
lock
incl (%rdi)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1de6e7
movl (%rdi), %eax
cmpl $0x2, %eax
jb 0x1de710
callq 0x1df664
movq %rax, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1de892
movq %rax, %rbx
movq %rdx, %r14
movq %rsp, %rdi
callq 0x1d985e
movq %fs:0x28, %rax
cmpq 0x38(%rsp), %rax
jne 0x1de7b3
movq %rbx, %rax
movq %r14, %rdx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%r15), %rcx
movq %rcx, 0x28(%rsp)
testq %rax, %rax
je 0x1de778
lock
incl (%rax)
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1de7b8
movq %rax, %rbx
movq %rdx, %r14
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x1de72c
lock
decl (%rax)
jne 0x1de72c
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
jne 0x1de7a9
xorl %edi, %edi
callq 0x13df00
jmp 0x1de72c
callq 0x13a8c0
| /qt[P]qtbase/src/corelib/tools/qhash.h |
QHashPrivate::Span<QHashPrivate::Node<QWindow*, QGuiApplicationPrivate::SynthesizedMouseData>>::insert(unsigned long) | Node *insert(size_t i)
{
Q_ASSERT(i < SpanConstants::NEntries);
Q_ASSERT(offsets[i] == SpanConstants::UnusedEntry);
if (nextFree == allocated)
addStorage();
unsigned char entry = nextFree;
Q_ASSERT(entry < allocated);
nextFree = entries[entry].nextFree();
offsets[i] = entry;
return &entries[entry].node();
} | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x89(%rdi), %al
cmpb 0x88(%rdi), %al
jne 0x1dede4
movq %rbx, %rdi
callq 0x1dee0e
movb 0x89(%rbx), %al
movq 0x80(%rbx), %rcx
movzbl %al, %edx
imulq $0x38, %rdx, %rax
movb (%rcx,%rax), %cl
movb %cl, 0x89(%rbx)
movb %dl, (%rbx,%r14)
addq 0x80(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /qt[P]qtbase/src/corelib/tools/qhash.h |
QHashPrivate::Data<QHashPrivate::Node<QWindow*, QGuiApplicationPrivate::SynthesizedMouseData>>::detached(QHashPrivate::Data<QHashPrivate::Node<QWindow*, QGuiApplicationPrivate::SynthesizedMouseData>>*) | static Data *detached(Data *d)
{
if (!d)
return new Data;
Data *dd = new Data(*d);
if (!d->ref.deref())
delete d;
return dd;
} | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x28, %edi
callq 0x1387d0
movq %rax, %rbx
testq %r14, %r14
je 0x1df6b9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1df738
movl (%r14), %eax
cmpl $-0x1, %eax
je 0x1df72c
lock
decl (%r14)
jne 0x1df72c
movq %r14, %rdi
callq 0x1db202
movl $0x28, %esi
movq %r14, %rdi
callq 0x137fb0
jmp 0x1df72c
movl $0x1, (%rbx)
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movq $0x80, 0x10(%rbx)
movl $0x98, %edi
callq 0x13cd50
movq $0x1, (%rax)
leaq 0x8(%rax), %rcx
movq %r14, 0x88(%rax)
movw $0x0, 0x90(%rax)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rax)
movdqu %xmm0, 0x18(%rax)
movdqu %xmm0, 0x28(%rax)
movdqu %xmm0, 0x38(%rax)
movdqu %xmm0, 0x48(%rax)
movdqu %xmm0, 0x58(%rax)
movdqu %xmm0, 0x68(%rax)
movdqu %xmm0, 0x78(%rax)
movq %rcx, 0x20(%rbx)
callq 0x13fbc0
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /qt[P]qtbase/src/corelib/tools/qhash.h |
QArrayDataPointer<QCursor>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, QCursor const**) | qsizetype constAllocatedCapacity() const noexcept { return d ? d->constAllocatedCapacity() : 0; } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x1dfeba
movq 0x8(%rax), %r9
movq 0x8(%rdi), %r8
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %r8
sarq $0x3, %r8
movq 0x10(%rdi), %rax
addq %r8, %rax
movq %r9, %r10
subq %rax, %r10
jmp 0x1dfec3
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %esi, %esi
jne 0x1dfedf
cmpq %rdx, %r8
jl 0x1dfedf
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rdx
addq %r9, %r9
xorl %eax, %eax
cmpq %r9, %rdx
jl 0x1dff17
retq
xorl %eax, %eax
cmpl $0x1, %esi
jne 0x1dfede
cmpq %rdx, %r10
jl 0x1dfede
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rsi
cmpq %r9, %rsi
jge 0x1dff2d
addq %rdx, %rax
subq %rax, %r9
movq %r9, %rsi
shrq $0x3f, %rsi
addq %r9, %rsi
sarq %rsi
xorl %eax, %eax
testq %rsi, %rsi
cmovgq %rsi, %rax
addq %rdx, %rax
pushq %rax
subq %r8, %rax
movq %rax, %rsi
movq %rcx, %rdx
callq 0x1dff30
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QEqualityOperatorForType<QTextLength, true>::equals(QtPrivate::QMetaTypeInterface const*, void const*, void const*) | inline bool operator==(const QTextLength &other) const
{ return lengthType == other.lengthType
&& qFuzzyCompare(fixedValueOrPercentage, other.fixedValueOrPercentage); } | endbr64
movl (%rsi), %eax
cmpl (%rdx), %eax
jne 0x1e0c37
movsd 0x8(%rsi), %xmm2
movsd 0x8(%rdx), %xmm0
movapd 0x393ba8(%rip), %xmm1 # 0x574770
movapd %xmm2, %xmm3
xorpd %xmm1, %xmm3
movapd %xmm3, %xmm4
cmpnlesd %xmm2, %xmm4
movapd %xmm2, %xmm5
subsd %xmm0, %xmm5
movapd %xmm5, %xmm6
xorpd %xmm1, %xmm6
movapd %xmm6, %xmm7
cmpnlesd %xmm5, %xmm7
andpd %xmm7, %xmm6
andnpd %xmm5, %xmm7
orpd %xmm6, %xmm7
mulsd 0x393fb2(%rip), %xmm7 # 0x574bb8
andpd %xmm4, %xmm3
andnpd %xmm2, %xmm4
orpd %xmm3, %xmm4
xorpd %xmm0, %xmm1
movapd %xmm1, %xmm2
cmpnlesd %xmm0, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
minsd %xmm2, %xmm4
ucomisd %xmm7, %xmm4
setae %al
retq
xorl %eax, %eax
retq
| /qt[P]qtbase/src/gui/text/qtextformat.h |
QWindow::framePosition() const | QPoint QWindow::framePosition() const
{
Q_D(const QWindow);
if (d->platformWindow) {
QMargins margins = frameMargins();
return QHighDpi::fromNativeWindowGeometry(d->platformWindow->geometry().topLeft(), this) - QPoint(margins.left(), margins.top());
}
return d->geometry.topLeft();
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rdi), %r15
cmpq $0x0, 0x88(%r15)
je 0x221806
movq %rdi, %rbx
callq 0x147200
movq %rax, %r14
movq 0x88(%r15), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rsp, %rdi
movq %rax, (%rdi)
movq %rbx, %rsi
callq 0x22524a
movq %rax, %rcx
movabsq $-0x100000000, %rdx # imm = 0xFFFFFFFF00000000
movq %r14, %rsi
andq %rdx, %rsi
subl %r14d, %eax
subq %rsi, %rcx
andq %rdx, %rcx
orq %rcx, %rax
jmp 0x22180d
movq 0xd8(%r15), %rax
movq %fs:0x28, %rcx
cmpq 0x8(%rsp), %rcx
jne 0x221827
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/kernel/qwindow.cpp |
void QtPrivate::q_relocate_overlap_n<QWindowSystemInterfacePrivate::WindowSystemEvent*, long long>(QWindowSystemInterfacePrivate::WindowSystemEvent**, long long, QWindowSystemInterfacePrivate::WindowSystemEvent**) | void q_relocate_overlap_n(T *first, N n, T *d_first)
{
static_assert(std::is_nothrow_destructible_v<T>,
"This algorithm requires that T has a non-throwing destructor");
if (n == N(0) || first == d_first || first == nullptr || d_first == nullptr)
return;
if constexpr (QTypeInfo<T>::isRelocatable) {
std::memmove(static_cast<void *>(d_first), static_cast<const void *>(first), n * sizeof(T));
} else { // generic version has to be used
if (d_first < first) {
q_relocate_overlap_n_left_move(first, n, d_first);
} else { // first < d_first
auto rfirst = std::make_reverse_iterator(first + n);
auto rd_first = std::make_reverse_iterator(d_first + n);
q_relocate_overlap_n_left_move(rfirst, n, rd_first);
}
}
} | endbr64
movq %rsi, %rax
testq %rsi, %rsi
je 0x22bf2b
testq %rdx, %rdx
je 0x22bf2b
movq %rdi, %rsi
testq %rdi, %rdi
je 0x22bf2b
cmpq %rdx, %rsi
je 0x22bf2b
shlq $0x3, %rax
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x138810
retq
| /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
bool QWindowSystemHelper<QWindowSystemInterface::SynchronousDelivery>::handleEvent<QWindowSystemInterfacePrivate::GeometryChangeEvent, QWindow*, QRect>(QWindow*, QRect) | bool QWindowSystemHelper<QWindowSystemInterface::SynchronousDelivery>::handleEvent(Args ...args)
{
if (QThread::isMainThread()) {
EventType event(args...);
// Process the event immediately on the Gui thread and return the accepted state
if (QWindowSystemInterfacePrivate::eventHandler) {
if (!QWindowSystemInterfacePrivate::eventHandler->sendEvent(&event))
return false;
} else {
QGuiApplicationPrivate::processWindowSystemEvent(&event);
}
return event.eventAccepted;
} else {
// Post the event on the Qt main thread queue and flush the queue.
// This will wake up the Gui thread which will process the event.
// Return the accepted state for the last event on the queue,
// which is the event posted by this function.
QWindowSystemHelper<QWindowSystemInterface::AsynchronousDelivery>::handleEvent<EventType>(args...);
return QWindowSystemInterface::flushWindowSystemEvents();
}
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x58(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
callq 0x149080
testb %al, %al
je 0x22cf9b
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %rdi
movq %rax, 0x40(%rdi)
movaps 0x347721(%rip), %xmm0 # 0x574680
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
leaq 0x48(%rsp), %rdx
movq %rbx, %rsi
callq 0x1407b0
movq 0x4c2996(%rip), %rax # 0x6ef918
movq (%rax), %rdi
testq %rdi, %rdi
je 0x22cfc9
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x10(%rax)
testb %al, %al
jne 0x22cfd1
xorl %ebx, %ebx
jmp 0x22cfd5
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x22d026
movq %fs:0x28, %rax
cmpq 0x58(%rsp), %rax
jne 0x22d020
xorl %edi, %edi
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x142c40
movq %rsp, %rdi
callq 0x13d4f0
movb 0x10(%rsp), %bl
movq 0x4c2444(%rip), %rax # 0x6ef420
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x22d004
lock
decl (%rax)
jne 0x22d004
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
jne 0x22cfff
xorl %edi, %edi
callq 0x13df00
movq %fs:0x28, %rax
cmpq 0x58(%rsp), %rax
jne 0x22d020
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /qt[P]qtbase/src/gui/kernel/qwindowsysteminterface.cpp |
QBezier::addToPolygon(QPolygonF*, double) const | void QBezier::addToPolygon(QPolygonF *polygon, qreal bezier_flattening_threshold) const
{
QBezier beziers[10];
int levels[10];
beziers[0] = *this;
levels[0] = 9;
int top = 0;
while (top >= 0) {
QBezier *b = &beziers[top];
// check if we can pop the top bezier curve from the stack
qreal y4y1 = b->y4 - b->y1;
qreal x4x1 = b->x4 - b->x1;
qreal l = qAbs(x4x1) + qAbs(y4y1);
qreal d;
if (l > 1.) {
d = qAbs( (x4x1)*(b->y1 - b->y2) - (y4y1)*(b->x1 - b->x2) )
+ qAbs( (x4x1)*(b->y1 - b->y3) - (y4y1)*(b->x1 - b->x3) );
} else {
d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +
qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
l = 1.;
}
if (d < bezier_flattening_threshold * l || levels[top] == 0) {
// good enough, we pop it off and add the endpoint
polygon->append(QPointF(b->x4, b->y4));
--top;
} else {
// split, second half of the polygon goes lower into the stack
std::tie(b[1], b[0]) = b->split();
levels[top + 1] = --levels[top];
++top;
}
}
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x2e0, %rsp # imm = 0x2E0
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x2d8(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x40(%rsp)
movaps 0x330bb3(%rip), %xmm0 # 0x574680
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0x90(%rsp), %r15
movl $0x240, %edx # imm = 0x240
movq %r15, %rdi
movl $0xff, %esi
callq 0x13ad10
movupd (%r14), %xmm0
movupd 0x10(%r14), %xmm1
movupd 0x20(%r14), %xmm2
movupd 0x30(%r14), %xmm3
movapd %xmm0, -0x40(%r15)
movapd %xmm1, -0x30(%r15)
movapd %xmm2, -0x20(%r15)
movapd %xmm3, -0x10(%r15)
movl $0x9, 0x20(%rsp)
xorl %r15d, %r15d
movapd 0x330c3c(%rip), %xmm10 # 0x574770
movsd 0x330c23(%rip), %xmm11 # 0x574760
leaq 0x10(%rsp), %r14
movl %r15d, %r15d
movq %r15, %rax
shlq $0x6, %rax
addq %rsp, %rax
addq $0x50, %rax
movapd (%rax), %xmm1
movapd 0x30(%rax), %xmm0
movapd %xmm0, %xmm6
subpd %xmm1, %xmm6
movapd %xmm6, %xmm8
xorpd %xmm10, %xmm8
movapd %xmm8, %xmm2
cmpnlepd %xmm6, %xmm2
movapd %xmm8, %xmm3
andpd %xmm2, %xmm3
andnpd %xmm6, %xmm2
orpd %xmm3, %xmm2
pshufd $0xee, %xmm2, %xmm4 # xmm4 = xmm2[2,3,2,3]
addsd %xmm2, %xmm4
ucomisd %xmm11, %xmm4
jbe 0x243c0b
movapd 0x10(%rax), %xmm2
movapd 0x20(%rax), %xmm3
movapd %xmm1, %xmm5
subpd %xmm2, %xmm5
movapd %xmm5, %xmm7
unpckhpd %xmm5, %xmm7 # xmm7 = xmm7[1],xmm5[1]
unpckhpd %xmm8, %xmm8 # xmm8 = xmm8[1,1]
mulsd %xmm8, %xmm5
mulsd %xmm6, %xmm7
addsd %xmm5, %xmm7
movapd %xmm7, %xmm9
xorpd %xmm10, %xmm9
movapd %xmm9, %xmm5
cmpnlesd %xmm7, %xmm5
andpd %xmm5, %xmm9
andnpd %xmm7, %xmm5
orpd %xmm9, %xmm5
movapd %xmm1, %xmm9
subpd %xmm3, %xmm9
movapd %xmm9, %xmm7
unpckhpd %xmm9, %xmm7 # xmm7 = xmm7[1],xmm9[1]
mulsd %xmm8, %xmm9
mulsd %xmm6, %xmm7
addsd %xmm9, %xmm7
jmp 0x243c77
movapd 0x10(%rax), %xmm2
movapd 0x20(%rax), %xmm3
movapd %xmm1, %xmm4
subpd %xmm2, %xmm4
movapd %xmm4, %xmm5
xorpd %xmm10, %xmm5
movapd %xmm5, %xmm6
cmpnlepd %xmm4, %xmm6
andpd %xmm6, %xmm5
andnpd %xmm4, %xmm6
orpd %xmm5, %xmm6
pshufd $0xee, %xmm6, %xmm4 # xmm4 = xmm6[2,3,2,3]
addsd %xmm6, %xmm4
movapd %xmm1, %xmm7
subpd %xmm3, %xmm7
movapd %xmm7, %xmm6
xorpd %xmm10, %xmm6
movapd %xmm6, %xmm5
cmpnlesd %xmm7, %xmm5
andpd %xmm5, %xmm6
andnpd %xmm7, %xmm5
orpd %xmm6, %xmm5
addsd %xmm4, %xmm5
unpckhpd %xmm7, %xmm7 # xmm7 = xmm7[1,1]
movapd %xmm11, %xmm4
movapd %xmm7, %xmm6
xorpd %xmm10, %xmm6
movapd %xmm6, %xmm8
cmpnlesd %xmm7, %xmm8
andpd %xmm8, %xmm6
andnpd %xmm7, %xmm8
orpd %xmm6, %xmm8
addsd %xmm5, %xmm8
mulsd 0x8(%rsp), %xmm4
ucomisd %xmm8, %xmm4
ja 0x243d28
movl 0x20(%rsp,%r15,4), %ecx
testl %ecx, %ecx
je 0x243d28
movapd %xmm1, 0x40(%rax)
addpd %xmm2, %xmm1
addpd %xmm3, %xmm2
movapd 0x330ab6(%rip), %xmm4 # 0x574780
mulpd %xmm4, %xmm1
mulpd %xmm4, %xmm2
addpd %xmm3, %xmm0
mulpd %xmm4, %xmm0
movapd %xmm1, %xmm3
addpd %xmm2, %xmm3
mulpd %xmm4, %xmm3
addpd %xmm0, %xmm2
mulpd %xmm4, %xmm2
movapd %xmm1, 0x50(%rax)
movapd %xmm3, 0x60(%rax)
addpd %xmm2, %xmm3
mulpd %xmm4, %xmm3
movapd %xmm3, 0x70(%rax)
movapd %xmm3, (%rax)
movapd %xmm2, 0x10(%rax)
movapd %xmm0, 0x20(%rax)
decl %ecx
movl %ecx, 0x20(%rsp,%r15,4)
movl %ecx, 0x24(%rsp,%r15,4)
leal 0x1(%r15), %eax
movl %eax, %r15d
jmp 0x243d5a
movapd %xmm0, 0x10(%rsp)
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x246270
movq %rbx, %rdi
callq 0x1a9086
movsd 0x330a12(%rip), %xmm11 # 0x574760
movapd 0x330a19(%rip), %xmm10 # 0x574770
decl %r15d
testl %r15d, %r15d
jns 0x243b42
movq %fs:0x28, %rax
cmpq 0x2d8(%rsp), %rax
jne 0x243d83
addq $0x2e0, %rsp # imm = 0x2E0
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qbezier.cpp |
QColorSpace::PrimaryPoints::fromPrimaries(QColorSpace::Primaries) | QColorSpace::PrimaryPoints QColorSpace::PrimaryPoints::fromPrimaries(Primaries primaries)
{
PrimaryPoints out;
switch (primaries) {
case Primaries::SRgb:
out.redPoint = QPointF(0.640, 0.330);
out.greenPoint = QPointF(0.300, 0.600);
out.bluePoint = QPointF(0.150, 0.060);
out.whitePoint = QColorVector::D65Chromaticity();
break;
case Primaries::DciP3D65:
out.redPoint = QPointF(0.680, 0.320);
out.greenPoint = QPointF(0.265, 0.690);
out.bluePoint = QPointF(0.150, 0.060);
out.whitePoint = QColorVector::D65Chromaticity();
break;
case Primaries::AdobeRgb:
out.redPoint = QPointF(0.640, 0.330);
out.greenPoint = QPointF(0.210, 0.710);
out.bluePoint = QPointF(0.150, 0.060);
out.whitePoint = QColorVector::D65Chromaticity();
break;
case Primaries::ProPhotoRgb:
out.redPoint = QPointF(0.7347, 0.2653);
out.greenPoint = QPointF(0.1596, 0.8404);
out.bluePoint = QPointF(0.0366, 0.0001);
out.whitePoint = QColorVector::D50Chromaticity();
break;
case Primaries::Bt2020:
out.redPoint = QPointF(0.708, 0.292);
out.greenPoint = QPointF(0.170, 0.797);
out.bluePoint = QPointF(0.131, 0.046);
out.whitePoint = QColorVector::D65Chromaticity();
break;
default:
Q_UNREACHABLE();
}
return out;
} | endbr64
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, (%rdi)
movslq %esi, %rcx
leaq 0x3383b1(%rip), %rdx # 0x599308
movsd -0x8(%rdx,%rcx,8), %xmm0
leaq 0x3383cc(%rip), %rdx # 0x599330
movsd -0x8(%rdx,%rcx,8), %xmm1
leaq 0x3383e7(%rip), %rdx # 0x599358
movsd -0x8(%rdx,%rcx,8), %xmm2
leaq 0x338402(%rip), %rdx # 0x599380
movsd -0x8(%rdx,%rcx,8), %xmm3
leaq 0x33841d(%rip), %rdx # 0x5993a8
movsd -0x8(%rdx,%rcx,8), %xmm4
leaq 0x338438(%rip), %rdx # 0x5993d0
movsd -0x8(%rdx,%rcx,8), %xmm5
leaq 0x338453(%rip), %rdx # 0x5993f8
movsd -0x8(%rdx,%rcx,8), %xmm6
leaq 0x33846e(%rip), %rdx # 0x599420
movsd -0x8(%rdx,%rcx,8), %xmm7
movsd %xmm0, 0x10(%rdi)
movsd %xmm1, 0x18(%rdi)
movsd %xmm2, 0x20(%rdi)
movsd %xmm3, 0x28(%rdi)
movsd %xmm4, 0x30(%rdi)
movsd %xmm5, 0x38(%rdi)
movsd %xmm6, (%rdi)
movsd %xmm7, 0x8(%rdi)
retq
| /qt[P]qtbase/src/gui/painting/qcolorspace.cpp |
operator>>(QDataStream&, QColorSpace&) | QDataStream &operator>>(QDataStream &s, QColorSpace &colorSpace)
{
QByteArray iccProfile;
s >> iccProfile;
colorSpace = QColorSpace::fromIccProfile(iccProfile);
return s;
} | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x38(%rsp)
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
movq %r13, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq %r15, %rsi
callq 0x147ee0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x13b750
movq (%r12), %rax
movq %r13, (%r12)
movq (%r14), %rcx
movq %rax, (%r14)
leaq 0x30(%rsp), %rdi
movq %rcx, (%rdi)
callq 0x137710
movq %r12, %rdi
callq 0x137710
movq (%r15), %rax
testq %rax, %rax
je 0x265eb0
lock
decl (%rax)
jne 0x265eb0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x38(%rsp), %rax
jne 0x265ed1
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qcolorspace.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.