name string | code string | asm string | file string |
|---|---|---|---|
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 %... | /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 absolut... | 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), ... | /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 ... | 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 0... | /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.
lis... | 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
ca... | /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);
... | 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... | /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, ar... | 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, 0... | /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 # 0x5270... | /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 ... | /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 whic... | 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 ... | /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 # 0x... | /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(%r... | /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(%r... | /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(%r... | /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... | /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... | /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 <= ... | 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 $... | /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... | /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, 0x... | /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_... | 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(%r... | /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
call... | /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(%r... | /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
... | /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 ... | /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... | /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 0x3... | /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 s... | 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, 0... | /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(%r... | /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),
... | 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, %... | /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),
... | 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 ... | /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 ... | /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("[\"令狐冲\", \"是\", \"云计算\", \"方面\"... | 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 0x3... | /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 0x3... | /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 0x3... | /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),
... | 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 ... | /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),
... | 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, %... | /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... | /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), %... | /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 ... | 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,... | /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 __IN... | 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 war... | 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);
#i... | 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 (uns... | 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(po... | 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... | 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_CO... | 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, QP... | 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;... | 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 #... | /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... | 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
pus... | /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... | 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 %... | /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)
... | 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 # ... | /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 setApplicationFallbackFontFamili... | 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 = 0x10... | /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,
famil... | 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... | /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);
... | 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, %... | /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;... | 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 %r... | /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(... | 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 ... | /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);
... | 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, (%... | /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 0... | /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 %... | /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... | 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,... | /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... | /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
... | /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 << bgBrus... | 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... | /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(), f... | 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
... | /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->... | 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
cal... | /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()) {
... | 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
... | /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, &... | 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, ... | /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;
}
... | 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 ... | /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() >= ... | 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
... | /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... | /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 bel... | 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 %ra... | /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,
... | 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... | /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
... | /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(... | 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 ... | /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 wa... | 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, (%... | /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() >= ... | 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
... | /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 &... | 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
... | /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 bel... | 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 %ra... | /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_ASSE... | 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... | /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;
... | 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 (... | /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:... | 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... | /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();
... | 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(%r... | /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, %rd... | /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... | /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, %x... | /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 0x225... | /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>... | 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) {
... | 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 %ra... | /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 stac... | 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... | /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);
ou... | 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), ... | /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, %... | /qt[P]qtbase/src/gui/painting/qcolorspace.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.