name string | code string | asm string | file string |
|---|---|---|---|
unsigned long pstore::sparse_array<int, unsigned long>::bitmap<pstore::details::pair_field_iterator<std::pair<unsigned long, int> const*, decltype(auto) pstore::details::get_accessor<0ul, std::pair<unsigned long, int> const*>()::'lambda'(std::pair<unsigned long, int> const*) const>, void>(pstore::details::pair_field_it... | BitmapType sparse_array<ValueType, BitmapType>::bitmap (InputIterator first,
InputIterator last) {
return std::accumulate (
first, last, BitmapType{0U},
[] (BitmapType const mm, typename std::iterator_traits<InputIterator>::valu... | pushq %rax
xorl %eax, %eax
cmpq %rsi, %rdi
je 0x9090e
movq (%rdi), %rcx
cmpq $0x40, %rcx
jae 0x90928
movl $0x1, %edx
shlq %cl, %rdx
btq %rcx, %rax
jb 0x90910
orq %rdx, %rax
addq $0x10, %rdi
jmp 0x908e9
popq %rcx
retq
leaq 0x7046d(%rip), %rdi # 0x100d84
leaq 0x703fd(%rip), %rsi # 0x100d1b
movl $0x25d, %edx ... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
testing::internal::SuiteApiResolver<SparseArray_Equal_Test<pstore::uint128>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xc9a82
testb %al, %al
jne 0x90a17
leaq 0x6bdcf(%rip), %rdx # 0xfc736
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x211, %ecx # imm = 0x211
callq 0xe85c4
movq 0xc266e(%rip), %rdi # 0x152ff0
leaq 0x6... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::SuiteApiResolver<SparseArray_Equal_Test<pstore::uint128>>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xc9a82
testb %al, %al
jne 0x90b0f
leaq 0x6bcd7(%rip), %rdx # 0xfc736
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x226, %ecx # imm = 0x226
callq 0xe85c4
movq 0xc2576(%rip), %rdi # 0x152ff0
leaq 0x6... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
pstore::sparse_array<int, pstore::uint128>::sparse_array<pstore::details::pair_field_iterator<std::pair<unsigned long, int> const*, decltype(auto) pstore::details::get_accessor<0ul, std::pair<unsigned long, int> const*>()::'lambda'(std::pair<unsigned long, int> const*) const>, pstore::details::pair_field_iterator<std::... | sparse_array<ValueType, BitmapType>::sparse_array (IteratorIdx first_index,
IteratorIdx last_index,
IteratorV first_value, IteratorV last_value)
: bitmap_{bitmap (first_index, last_index)} {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x90f14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
cmpq %rbx, %r15
je 0x90ea4
cmpq %r12, %r13
je 0x90ea0
movl 0x8(%r13), %eax
addq $0x10, %r13
movl %eax... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
pstore::uint128 pstore::sparse_array<int, pstore::uint128>::bitmap<pstore::details::pair_field_iterator<std::pair<unsigned long, int> const*, decltype(auto) pstore::details::get_accessor<0ul, std::pair<unsigned long, int> const*>()::'lambda'(std::pair<unsigned long, int> const*) const>, void>(pstore::details::pair_fiel... | bool operator== (pair_field_iterator const & other) const {
return it_ == other.it_ && acc_ == other.acc_;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq %rsi, %rdi
je 0x90f7c
movq %rsi, %r14
movq %rdi, %r12
xorl %ebx, %ebx
movq %rsp, %r13
xorl %r15d, %r15d
movq (%r12), %rsi
cmpq $0x80, %rsi
jae 0x90fad
movq $0x0, 0x8(%rsp)
movq $0x1, (%rsp)
movq %r13, %rdi
callq 0x74dfc
movq %rdx, %rcx
andq %r... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
testing::internal::SuiteApiResolver<SparseArray_Equal2_Test<unsigned short>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xc9a82
testb %al, %al
jne 0x9109d
leaq 0x6b749(%rip), %rdx # 0xfc736
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x211, %ecx # imm = 0x211
callq 0xe85c4
movq 0xc1fe8(%rip), %rdi # 0x152ff0
leaq 0x6... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::SuiteApiResolver<SparseArray_Equal2_Test<unsigned short>>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xc9a82
testb %al, %al
jne 0x91195
leaq 0x6b651(%rip), %rdx # 0xfc736
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x226, %ecx # imm = 0x226
callq 0xe85c4
movq 0xc1ef0(%rip), %rdi # 0x152ff0
leaq 0x6... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
SparseArray_Equal2_Test<unsigned short>::TestBody() | TYPED_TEST (SparseArray, Equal2) {
auto arr1 = sparse_array<int, TypeParam>::make_unique ({{0, 0}, {2, 2}, {4, 5}});
auto arr2 = sparse_array<int, TypeParam>::make_unique ({{0, 0}, {2, 2}, {4, 4}});
EXPECT_FALSE (*arr1 == *arr2);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
xorl %r14d, %r14d
leaq 0x60(%rsp), %rdx
movq %r14, -0x30(%rdx)
movl %r14d, -0x28(%rdx)
movl $0x2, %r15d
movq %r15, -0x20(%rdx)
movl $0x2, %ebp
movl %ebp, -0x18(%rdx)
movl $0x4, %r12d
movq %r12, -0x10(%rdx)
movl $0x5, -0x8(%rdx)
leaq 0x18(%rsp), %rd... | /SNSystems[P]pstore/unittests/adt/test_sparse_array.cpp |
SparseArray_Equal2_Test<unsigned long>::TestBody() | TYPED_TEST (SparseArray, Equal2) {
auto arr1 = sparse_array<int, TypeParam>::make_unique ({{0, 0}, {2, 2}, {4, 5}});
auto arr2 = sparse_array<int, TypeParam>::make_unique ({{0, 0}, {2, 2}, {4, 4}});
EXPECT_FALSE (*arr1 == *arr2);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
xorl %r14d, %r14d
leaq 0x60(%rsp), %rdx
movq %r14, -0x30(%rdx)
movl %r14d, -0x28(%rdx)
movl $0x2, %r15d
movq %r15, -0x20(%rdx)
movl $0x2, %ebp
movl %ebp, -0x18(%rdx)
movl $0x4, %r12d
movq %r12, -0x10(%rdx)
movl $0x5, -0x8(%rdx)
leaq 0x18(%rsp), %rd... | /SNSystems[P]pstore/unittests/adt/test_sparse_array.cpp |
testing::internal::SuiteApiResolver<SparseArray_Equal3_Test<unsigned short>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xc9a82
testb %al, %al
jne 0x922bd
leaq 0x6a529(%rip), %rdx # 0xfc736
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x211, %ecx # imm = 0x211
callq 0xe85c4
movq 0xc0dc8(%rip), %rdi # 0x152ff0
leaq 0x6... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
pstore::sparse_array<int, unsigned int>::sparse_array<std::_Rb_tree_const_iterator<unsigned long>, int const*>(std::_Rb_tree_const_iterator<unsigned long>, std::_Rb_tree_const_iterator<unsigned long>, int const*, int const*) | sparse_array<ValueType, BitmapType>::sparse_array (IteratorIdx first_index,
IteratorIdx last_index,
IteratorV first_value, IteratorV last_value)
: bitmap_{bitmap (first_index, last_index)} {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x94f3a
movl %eax, (%r14)
cmpq %rbx, %r15
je 0x94ecd
cmpq %r12, %r13
je 0x94ec2
movl (%r13), %eax
addq $0x4, %r13
movl %eax, 0x4(%r14)
movq %r15, %r... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
unsigned long pstore::sparse_array<unsigned int, unsigned long>::bitmap<unsigned long const*, void>(unsigned long const*, unsigned long const*) | BitmapType sparse_array<ValueType, BitmapType>::bitmap (InputIterator first,
InputIterator last) {
return std::accumulate (
first, last, BitmapType{0U},
[] (BitmapType const mm, typename std::iterator_traits<InputIterator>::valu... | pushq %rax
xorl %eax, %eax
cmpq %rsi, %rdi
je 0x9af5e
movq (%rdi), %rcx
cmpq $0x40, %rcx
jae 0x9af78
movl $0x1, %edx
shlq %cl, %rdx
btq %rcx, %rax
jb 0x9af60
orq %rdx, %rax
addq $0x8, %rdi
jmp 0x9af39
popq %rcx
retq
leaq 0x65e1d(%rip), %rdi # 0x100d84
leaq 0x65dad(%rip), %rsi # 0x100d1b
movl $0x25d, %edx ... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
std::unique_ptr<pstore::sparse_array<unsigned int, pstore::uint128>, std::default_delete<pstore::sparse_array<unsigned int, pstore::uint128>>> pstore::sparse_array<unsigned int, pstore::uint128>::make_unique<__gnu_cxx::__normal_iterator<std::pair<unsigned int, unsigned int>*, std::vector<std::pair<unsigned int, unsigne... | auto sparse_array<ValueType, BitmapType>::make_unique (Iterator begin, Iterator end)
-> std::unique_ptr<sparse_array> {
using details::get_accessor;
using details::pair_field_iterator;
auto const accessor0 = get_accessor<0U, Iterator> ();
auto const accessor1 = get_accessor<1U,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9b7fa
popcntq %rdx, %rcx
popcntq %rax, %rax
leal (%rcx,%rax), %edx
cmpl $0x1, %edx
adcl %eax, %ecx
leal 0x1c(,%rcx,4), %edi
callq 0x1f540
movq %rax, %r12
movq %rax, %rdi
movq %r... | /SNSystems[P]pstore/include/pstore/adt/sparse_array.hpp |
testing::internal::Mutex::Mutex() | Mutex() {
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
has_owner_ = false;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x1f940
testl %eax, %eax
je 0xec750
movl %eax, %ebp
leaq 0x1d5c2(%rip), %rdx # 0x109cb6
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x6ae, %ecx # imm = 0x6AE
callq 0xe85c4
movq 0x668e1(%rip), %rdi # 0x152ff0
leaq 0x1d681(%rip), %rs... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::~ThreadLocal() | ~ThreadLocal() {
// Destroys the managed object for the current thread, if any.
DeleteThreadLocalValue(pthread_getspecific(key_));
// Releases resources associated with the key. This will *not*
// delete managed objects for other threads.
GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x1f960
testq %rax, %rax
je 0xed94b
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0x1f6d0
testl %eax, %eax
je 0xed9bb
movl %eax, %ebp
leaq 0x1c357(%rip), %rdx # 0x109cb6
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-port.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int*, char**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseBoolFlag;
using internal::ParseInt32Flag;
using internal::ParseStringFlag;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x2, (%rdi)
jl 0xee0ca
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %rax
movq %rax, (%rsp)
movl $0x1, %r13d
leaq 0x8(%rsp), %r15
movslq %r13d, %r12
leaq (%rbx,%r12,8), %rsi
movq %r15, %rdi
callq 0xf483f
movq 0x8(%rsp), %rbp
movq... | /SNSystems[P]pstore/3rd_party/googletest/googletest/src/gtest.cc |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<wchar_t>(int*, wchar_t**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseBoolFlag;
using internal::ParseInt32Flag;
using internal::ParseStringFlag;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x2, (%rdi)
jl 0xee232
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %rax
movq %rax, (%rsp)
movl $0x1, %r13d
leaq 0x8(%rsp), %r15
movslq %r13d, %r12
leaq (%rbx,%r12,8), %rsi
movq %r15, %rdi
callq 0xf48d2
movq 0x8(%rsp), %rbp
movq... | /SNSystems[P]pstore/3rd_party/googletest/googletest/src/gtest.cc |
void testing::internal::InitGoogleTestImpl<wchar_t>(int*, wchar_t**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
// We don't want to run the initialization code twice.
if (GTestIsInitialized()) return;
if (*argc <= 0) return;
g_argvs.clear();
for (int i = 0; i != *argc; i++) {
g_argvs.push_back(StreamableToString(argv[i]));
}
#if GTEST_HAS_ABSL
absl::Initi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x6569f(%rip), %rsi # 0x153a38
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x89544
movq 0x8(%r15), %rbx
movq (%r15), %r12
movq %r15, %rdi
callq 0x54a06
cmpq %r12, %rbx
jne 0xee455
cmpl $0x0, (%r14)... | /SNSystems[P]pstore/3rd_party/googletest/googletest/src/gtest.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::~Matcher() | class GTEST_API_ Matcher<const std::string&>
: public internal::MatcherBase<const std::string&> {
public:
Matcher() {}
explicit Matcher(const MatcherInterface<const std::string&>* impl)
: internal::MatcherBase<const std::string&>(impl) {}
template <typename M, typename = typename std::remove_referenc... | pushq %rbx
movq %rdi, %rbx
callq 0xee486
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1f570
nop
| /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/gtest-matchers.h |
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 0xcda52
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0xe95d8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x58192
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xef674
movq (%rdi), %rax
call... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/gtest.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 0xcda52
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x1f220
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1f660
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x58192
movq 0x8(... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/gtest.h |
testing::Cardinality::DescribeActualCallCountTo(int, std::ostream*) | void Cardinality::DescribeActualCallCountTo(int actual_call_count,
::std::ostream* os) {
if (actual_call_count > 0) {
*os << "called " << FormatTimes(actual_call_count);
} else {
*os << "never called";
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
testl %edi, %edi
jle 0xf4ded
movl %edi, %ebp
leaq 0x164d9(%rip), %rsi # 0x10b279
movl $0x7, %edx
movq %rbx, %rdi
callq 0x1f660
movq %rsp, %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0xf4e2f
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq ... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/src/gmock-cardinalities.cc |
testing::internal::UntypedFunctionMockerBase::Name() const | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
const char* name;
{
// We protect name_ under g_gmock_mutex in case this mock
// function is called from two threads concurrently.
MutexLock l(&g_gmock_mutex);
Assert(name_ != nullptr, __FILE__, __LINE__,
"Name() must not be called before SetOwnerAndN... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x5c539(%rip), %rdi # 0x153bc0
callq 0xef71a
movq 0x10(%rbx), %r15
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x14377(%rip), %rsi # 0x10ba17
leaq 0x143b3(%rip), %rdx # 0x10ba5a
movq %rsp, %rdi
callq 0x7318e
testq %r15, %r15
jne 0x... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/src/gmock-spec-builders.cc |
testing::internal::UntypedFunctionMockerBase::GetHandleOf(testing::internal::ExpectationBase*) | Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
// See the definition of untyped_expectations_ for why access to it
// is unprotected here.
for (UntypedExpectations::const_iterator it =
untyped_expectations_.begin();
it != untyped_expectations_.end(); ++it) {
if (i... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rsi), %rcx
movq 0x38(%rsi), %rsi
cmpq %rsi, %rcx
sete %al
je 0xf818b
movq (%rcx), %rdi
cmpq %rdx, %rdi
je 0xf8162
addq $0x10, %rcx
cmpq %rsi, %rcx
sete %al
je 0xf818b
movq (%rcx), %rdi
addq $0x10, %rcx
cmpq %rdx, %rdi
jne 0xf814a
addq $-0x10, %rcx
movq %... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/src/gmock-spec-builders.cc |
testing::Mock::VerifyAndClear(void*) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
internal::MutexLock l(&internal::g_gmock_mutex);
ClearDefaultActionsLocked(mock_obj);
return VerifyAndClearExpectationsLocked(mock_obj);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x5b0e5(%rip), %rdi # 0x153bc0
callq 0xef71a
movq %rbx, %rdi
callq 0xf8b24
movq %rbx, %rdi
callq 0xf8a26
movl %eax, %ebx
leaq 0x5b0c7(%rip), %rdi # 0x153bc0
callq 0xef7b8
movl %ebx, %eax
popq %rbx
retq
jmp 0xf8b1b
movq %rax, %rbx
leaq 0x5b0b2(%rip), %rdi # 0x153bc0
callq 0xef... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/src/gmock-spec-builders.cc |
testing::Mock::ClearDefaultActionsLocked(void*) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
internal::g_gmock_mutex.AssertHeld();
if (g_mock_object_registry.states().count(mock_obj) == 0) {
// No ON_CALL() was set on the given mock object.
return;
}
// Clears the default actions for each mock method in the given mock
// object.
Fu... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, (%rsp)
leaq 0x5b08a(%rip), %rdi # 0x153bc0
callq 0xf99c4
movq 0x5b0d6(%rip), %rdx # 0x153c18
leaq 0x5b0c7(%rip), %rcx # 0x153c10
movq %rcx, %rax
testq %rdx, %rdx
je 0xf8b70
leaq 0x5b0b8(%rip), %rax # 0x153c10
xorl %esi, %esi
cmpq %rbx, 0x20(%rd... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/src/gmock-spec-builders.cc |
testing::(anonymous namespace)::BetweenCardinalityImpl::DescribeTo(std::ostream*) const | void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const {
if (min_ == 0) {
if (max_ == 0) {
*os << "never called";
} else if (max_ == INT_MAX) {
*os << "called any number of times";
} else {
*os << "called at most " << FormatTimes(max_);
}
} else if (min_ == max_) {
*... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
testl %ecx, %ecx
je 0xf8f74
cmpl %eax, %ecx
jne 0xf8f98
leaq 0x12337(%rip), %rsi # 0x10b279
movl $0x7, %edx
movq %rbx, %rdi
callq 0x1f660
movl 0x8(%r14), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/src/gmock-cardinalities.cc |
bool testing::internal::ParseGoogleMockStringFlag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
String* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
// Aborts if the parsing failed.
if (value_str == nullptr) return ... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x12d62(%rip), %rsi # 0x10bf60
xorl %edx, %edx
callq 0xf92e6
movq %rax, %rbx
testq %rax, %rax
je 0xf9236
movq 0x5a95c(%rip), %r14 # 0x153b70
leaq 0x5a94d(%rip), %r15 # 0x153b68
movq %rbx, %rdi
callq 0x1f220
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/src/gmock.cc |
testing::internal::MaxBipartiteMatchState::~MaxBipartiteMatchState() | explicit MaxBipartiteMatchState(const MatchMatrix& graph)
: graph_(&graph),
left_(graph_->LhsSize(), kUnused),
right_(graph_->RhsSize(), kUnused) {} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xf96a3
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x1f570
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xf96b9
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x1f570
popq %rbx
retq
nop
| /SNSystems[P]pstore/3rd_party/googletest/googlemock/src/gmock-matchers.cc |
testing::internal::ThreadLocal<testing::Sequence*>::~ThreadLocal() | ~ThreadLocal() {
// Destroys the managed object for the current thread, if any.
DeleteThreadLocalValue(pthread_getspecific(key_));
// Releases resources associated with the key. This will *not*
// delete managed objects for other threads.
GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x1f960
testq %rax, %rax
je 0xf9b63
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0x1f6d0
testl %eax, %eax
je 0xf9bd3
movl %eax, %ebp
leaq 0x1013f(%rip), %rdx # 0x109cb6
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0... | /SNSystems[P]pstore/3rd_party/googletest/googletest/include/gtest/internal/gtest-port.h |
void testing::internal::InitGoogleMockImpl<wchar_t>(int*, wchar_t**) | void InitGoogleMockImpl(int* argc, CharType** argv) {
// Makes sure Google Test is initialized. InitGoogleTest() is
// idempotent, so it's fine if the user has already called it.
InitGoogleTest(argc, argv);
if (*argc <= 0) return;
for (int i = 1; i != *argc; i++) {
const std::string arg_string = Streama... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xe062a
cmpl $0x0, (%r14)
jle 0xf9e74
cmpl $0x1, (%r14)
je 0xf9e74
leaq 0x8(%rbx), %rax
movq %rax, (%rsp)
movl $0x1, %ebp
leaq 0x8(%rsp), %r15
movslq %ebp, %r13
leaq (%rbx,%r13,8), %rsi
movq %r15, %r... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/src/gmock.cc |
testing::internal::GoogleTestFailureReporter::ReportFailure(testing::internal::FailureReporterInterface::FailureType, char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ReportFailure(FailureType type, const char* file, int line,
const std::string& message) override {
AssertHelper(type == kFatal ?
TestPartResult::kFatalFailure :
TestPartResult::kNonFatalFailure,
file,
line,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
leaq 0x10(%rsp), %rdi
callq 0xcda52
xorl %esi, %esi
cmpl $0x1, %ebx
sete %sil
incl %esi
movq (%r14), %r8
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xc9a86
leaq 0x8(%rsp), %rdi
lea... | /SNSystems[P]pstore/3rd_party/googletest/googlemock/src/gmock-internal-utils.cc |
cmSystemTools::SplitProgramFromArgs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool cmSystemTools::SplitProgramFromArgs(std::string const& command,
std::string& program,
std::string& args)
{
const char* c = command.c_str();
// Skip leading whitespace.
while (cmIsSpace(*c)) {
++c;
}
// Parse one comma... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12250
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x2abb0
testb $0x1, %al
jne 0x1b643
jmp 0x1b651
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::RunSingleCommand(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx1... | bool cmSystemTools::RunSingleCommand(std::vector<std::string> const& command,
std::string* captureStdOut,
std::string* captureStdErr, int* retVal,
const char* dir, OutputOption outputflag,
... | pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp # imm = 0x320
movl 0x10(%rbp), %eax
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0x416d0
movq -... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::GetRealPathResolvingWindowsSubst(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | std::string cmSystemTools::GetRealPathResolvingWindowsSubst(
const std::string& path, std::string* errorMessage)
{
#ifdef _WIN32
// uv_fs_realpath uses Windows Vista API so fallback to kwsys if not found
std::string resolved_path;
uv_fs_t req;
int err = uv_fs_realpath(nullptr, &req, path.c_str(), nullptr);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6c7f0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::MakeTempDirectory(char*, unsigned int const*) | cmsys::Status cmSystemTools::MakeTempDirectory(char* path, const mode_t* mode)
{
if (!path) {
return cmsys::Status::POSIX(EINVAL);
}
// verify that path ends with "XXXXXX"
const auto l = std::strlen(path);
if (!cmHasLiteralSuffix(cm::string_view{ path, l }, "XXXXXX")) {
return cmsys::Status::POSIX(EI... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1caaa
movl $0x16, %edi
callq 0x2b700
movq %rax, -0x8(%rbp)
jmp 0x1cb77
movq -0x10(%rbp), %rdi
callq 0x129f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
c... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::RenameFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmSystemTools::Replace, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | cmSystemTools::RenameResult cmSystemTools::RenameFile(
std::string const& oldname, std::string const& newname, Replace replace,
std::string* err)
{
#ifdef _WIN32
# ifndef INVALID_FILE_ATTRIBUTES
# define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
# endif
std::wstring const oldname_wstr =
SystemTools::ConvertToW... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x1cf59
movq -0x10(%rbp), %rdi
callq 0x12250
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12250
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x13790... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::GlobDirs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | void cmSystemTools::GlobDirs(const std::string& path,
std::vector<std::string>& files)
{
std::string::size_type pos = path.find("/*");
if (pos == std::string::npos) {
files.push_back(path);
return;
}
std::string startPath = path.substr(0, pos);
std::string finishPath = pat... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x364f40(%rip), %rsi # 0x3821de
xorl %eax, %eax
movl %eax, %edx
callq 0x12060
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x1d2c4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp)... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::ConvertToOutputPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmSystemTools::ConvertToOutputPath(std::string const& path)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
if (s_ForceUnixPaths) {
return cmSystemTools::ConvertToUnixOutputPath(path);
}
return cmSystemTools::ConvertToWindowsOutputPath(path);
#else
return cmSystemTools::ConvertToUnixOutputPath(pat... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x692a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::ConvertToLongPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void cmSystemTools::ConvertToLongPath(std::string& path)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
// Try to convert path to a long path only if the path contains character '~'
if (path.find('~') == std::string::npos) {
return;
}
std::wstring wPath = cmsys::Encoding::ToWide(path);
DWORD ret = GetLong... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::ForceToRelativePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cmSystemTools::ForceToRelativePath(std::string const& local_path,
std::string const& remote_path)
{
// The paths should never be quoted.
assert(local_path.front() != '\"');
assert(remote_path.front() != '\"');
// The local path should never have a trai... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12330
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x1decb
jmp 0x1deea
leaq 0x364379(%rip), %r... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::GetEnvVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | cm::optional<std::string> cmSystemTools::GetEnvVar(std::string const& var)
{
cm::optional<std::string> result;
{
std::string value;
if (cmSystemTools::GetEnv(var, value)) {
result = std::move(value);
}
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2be10
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x128c0
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x66cd0
movb %al, -0... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::UnsetEnv(char const*) | bool cmSystemTools::UnsetEnv(const char* value)
{
# if !defined(HAVE_UNSETENV)
return cmSystemTools::UnPutEnv(value);
# else
unsetenv(value);
return true;
# endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12a70
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
| /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::EnvDiff::PutEnv(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void cmSystemTools::EnvDiff::PutEnv(const std::string& env)
{
auto const eq_loc = env.find('=');
if (eq_loc != std::string::npos) {
std::string name = env.substr(0, eq_loc);
diff[name] = env.substr(eq_loc + 1);
} else {
this->UnPutEnv(env);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x13bc0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x1eb80
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::EnvDiff::ApplyToCurrentEnv(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>*) | void cmSystemTools::EnvDiff::ApplyToCurrentEnv(std::ostringstream* measurement)
{
for (auto const& env_apply : diff) {
if (env_apply.second) {
auto const env_update =
cmStrCat(env_apply.first, '=', *env_apply.second);
cmSystemTools::PutEnv(env_update);
if (measurement) {
*measure... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2c4d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2c2e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2c2b0
testb ... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::CreateTar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, cmSystemTool... | bool cmSystemTools::CreateTar(const std::string& outFileName,
const std::vector<std::string>& files,
cmTarCompression compressType, bool verbose,
std::string const& mtime,
std::string const& format, i... | pushq %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp # imm = 0x4B0
movb %cl, %al
movl 0x10(%rbp), %ecx
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x206b0
movq -0x10(%rbp), %rdi
call... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
(anonymous namespace)::extract_tar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, bo... | bool extract_tar(const std::string& outFileName,
const std::vector<std::string>& files, bool verbose,
cmSystemTools::cmTarExtractTimestamps extractTimestamps,
bool extract)
{
cmLocaleRAII localeRAII;
static_cast<void>(localeRAII);
struct archive* a = archive_read... | pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp # imm = 0x320
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %dl
movb %dl, -0x19(%rbp)
movl %ecx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x30b10
callq 0x7cb20
movq %rax, -0x290(%rbp)
jmp 0x2079b
movq ... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::DoNotInheritStdPipes() | void cmSystemTools::DoNotInheritStdPipes()
{
#ifdef _WIN32
// Check to see if we are attached to a console
// if so, then do not stop the inherited pipes
// or stdout and stderr will not show up in dos
// shell windows
CONSOLE_SCREEN_BUFFER_INFO hOutInfo;
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
if ... | pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::FindCMakeResources(char const*) | void cmSystemTools::FindCMakeResources(const char* argv0)
{
std::string exe_dir;
#if defined(_WIN32) && !defined(__CYGWIN__)
(void)argv0; // ignore this on windows
wchar_t modulepath[_MAX_PATH];
::GetModuleFileNameW(nullptr, modulepath, sizeof(modulepath));
std::string path = cmsys::Encoding::ToNarrow(modulep... | pushq %rbp
movq %rsp, %rbp
subq $0x890, %rsp # imm = 0x890
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x128c0
leaq -0x48(%rbp), %rdi
movq %rdi, -0x788(%rbp)
callq 0x128c0
leaq -0x68(%rbp), %rdi
movq %rdi, -0x790(%rbp)
callq 0x128c0
movq -0x790(%rbp), %rsi
movq -0x788(%rbp), %rdx
movq -0x8(%rbp), %rdi... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
ChangeRPathXCOFF(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, std::__cxx11::basic_string<char, std... | static cm::optional<bool> ChangeRPathXCOFF(std::string const& file,
std::string const& oldRPath,
std::string const& newRPath,
bool removeEnvironmentRPath,
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x23261
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
leaq -0x2(%rbp), %rdi
callq 0x30ed0
m... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
(anonymous namespace)::VersionCompare(cmSystemTools::CompareOp, char const*, char const*) | bool VersionCompare(cmSystemTools::CompareOp op, const char* lhss,
const char* rhss)
{
const char* endl = lhss;
const char* endr = rhss;
while (((*endl >= '0') && (*endl <= '9')) ||
((*endr >= '0') && (*endr <= '9'))) {
// Do component-wise comparison, ignoring leading zeros
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x23520
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
mo... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::RemoveRPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) | bool cmSystemTools::RemoveRPath(std::string const& file, std::string* emsg,
bool* removed)
{
if (cm::optional<bool> result = RemoveRPathELF(file, emsg, removed)) {
return result.value();
}
if (cm::optional<bool> result = RemoveRPathXCOFF(file, emsg, removed)) {
return resul... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x239e0
movw %ax, -0x22(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x2d580
testb $0x1, %al
jne 0x23988
jmp 0x2399a
leaq -0x22(%rbp), %rdi
ca... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
RemoveRPathXCOFF(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) | static cm::optional<bool> RemoveRPathXCOFF(std::string const& file,
std::string* emsg, bool* removed)
{
if (removed) {
*removed = false;
}
#if !defined(CMake_USE_XCOFF_PARSER)
(void)file;
(void)emsg;
return cm::nullopt; // Cannot handle XCOFF files.
#else
cmXCO... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x24342
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
leaq -0x2(%rbp), %rdi
callq 0x30ed0
movw -0x2(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemToolsFindRPath(std::basic_string_view<char, std::char_traits<char>> const&, std::basic_string_view<char, std::char_traits<char>> const&) | static std::string::size_type cmSystemToolsFindRPath(
cm::string_view const& have, cm::string_view const& want)
{
std::string::size_type pos = 0;
while (pos < have.size()) {
// Look for an occurrence of the string.
std::string::size_type const beg = have.find(want, pos);
if (beg == std::string::npos) ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2db10
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x24606
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax)... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::EncodeURL(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string cmSystemTools::EncodeURL(std::string const& in, bool escapeSlashes)
{
std::string out;
for (char c : in) {
char hexCh[4] = { 0, 0, 0, 0 };
hexCh[0] = c;
switch (c) {
case '+':
case '?':
case '\\':
case '&':
case ' ':
case '=':
case '%':
snpri... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x128c0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1255... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmSystemTools::CreateSymlinkQuietly(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | cmsys::Status cmSystemTools::CreateSymlinkQuietly(std::string const& origName,
std::string const& newName)
{
uv_fs_t req;
int flags = 0;
#if defined(_WIN32)
if (cmsys::SystemTools::FileIsDirectory(origName)) {
flags |= UV_FS_SYMLINK_DIR;
}
#endif
int err =... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1d4(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12250
movq %rax, -0x1e8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12250
movq -0x1e8(%rbp), %rdx
movq %rax, %rcx
movl -0x1d4(%rbp), %r8d
xorl %eax, %eax
mo... | /JeremieA[P]CMake/Source/cmSystemTools.cxx |
cmsys::SystemTools::RemoveCharsButUpperHex(char const*) | char* SystemTools::RemoveCharsButUpperHex(const char* str)
{
if (!str) {
return nullptr;
}
char* clean_str = new char[strlen(str) + 1];
char* ptr = clean_str;
while (*str) {
if ((*str >= '0' && *str <= '9') || (*str >= 'A' && *str <= 'F')) {
*ptr++ = *str;
}
++str;
}
*ptr = '\0';
r... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x68720
movq $0x0, -0x8(%rbp)
jmp 0x687ae
movq -0x10(%rbp), %rdi
callq 0x129f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x12bb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0... | /JeremieA[P]CMake/Source/kwsys/SystemTools.cxx |
tree_dup | static int
tree_dup(int fd)
{
int new_fd;
#ifdef F_DUPFD_CLOEXEC
static volatile int can_dupfd_cloexec = 1;
if (can_dupfd_cloexec) {
new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 0);
if (new_fd != -1)
return (new_fd);
/* Linux 2.6.18 - 2.6.23 declare F_DUPFD_CLOEXEC,
* but it cannot be used. So we have to try dup... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl 0x397e57(%rip), %eax # 0x41c1a8
cmpl $0x0, %eax
je 0x84382
movl -0x8(%rbp), %edi
movl $0x406, %esi # imm = 0x406
xorl %edx, %edx
movb $0x0, %al
callq 0x12350
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x84378
movl -0xc(%rbp), %eax... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c |
setup_current_filesystem | static int
setup_current_filesystem(struct archive_read_disk *a)
{
struct tree *t = a->tree;
struct statfs sfs;
#if defined(HAVE_GETVFSBYNAME) && defined(VFCF_SYNTHETIC)
/* TODO: configure should set GETVFSBYNAME_ARG_TYPE to make
* this accurate; some platforms have both and we need the one that's
* used by getvfsb... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x108(%rbp)
movl $0x0, -0x10c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x84740
cmpl $0x0, %eax
je 0x844cd
movq -0x18(%rbp), %rdi
callq 0x81270
movl %eax,... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c |
compress_bidder_bid | static int
compress_bidder_bid(struct archive_read_filter_bidder *self,
struct archive_read_filter *filter)
{
const unsigned char *buffer;
ssize_t avail;
int bits_checked;
(void)self; /* UNUSED */
/* Shortest valid compress file is 3 bytes. */
buffer = __archive_read_filter_ahead(filter, 3, &avail);
if (b... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3, %esi
leaq -0x28(%rbp), %rdx
callq 0x7e630
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x868a6
movl $0x0, -0x4(%rbp)
jmp 0x86912
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_compress.c |
getbits | static int
getbits(struct archive_read_filter *self, int n)
{
struct private_data *state = (struct private_data *)self->data;
int code;
ssize_t ret;
static const int mask[] = {
0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff,
0x1ff, 0x3ff, 0x7ff, 0xfff, 0x1fff, 0x3fff, 0x7fff, 0xffff
};
while (state->bi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x86c65
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
ja 0x86c0a
movq -0x20(%rbp), %rax
cmpq... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_compress.c |
next_code | static int
next_code(struct archive_read_filter *self)
{
struct private_data *state = (struct private_data *)self->data;
int code, newcode;
static int debug_buff[1024];
static unsigned debug_index;
code = newcode = getbits(self, state->bits);
if (code < 0)
return (code);
debug_buff[debug_index++] = code;
i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4c(%rax), %esi
callq 0x86b40
movl %eax, -0x20(%rbp)
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x86cef
movl -0x1c(%rbp), %eax... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_compress.c |
compress_filter_read | static ssize_t
compress_filter_read(struct archive_read_filter *self, const void **pblock)
{
struct private_data *state;
unsigned char *p, *start, *end;
int ret;
state = (struct private_data *)self->data;
if (state->end_of_stream) {
*pblock = NULL;
return (0);
}
p = start = (unsigned char *)state->out_block... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
je 0x8702e
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x87114
movq -0x20(%rbp), %rax
movq 0x3... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_compress.c |
archive_read_support_filter_gzip | int
archive_read_support_filter_gzip(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
if (__archive_read_register_bidder(a, NULL, "gzip",
&gzip_bidder_vtable) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
/* Signal the extent of gzip support with the return value here. */
#if HAVE_ZLIB_H
r... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x30b9ed(%rip), %rdx # 0x392b90
leaq 0x39169e(%rip), %rcx # 0x418848
callq 0x7e490
cmpl $0x0, %eax
je 0x871bd
movl $0xffffffe2, -0x4(%rbp) # ... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_gzip.c |
gzip_bidder_init | static int
gzip_bidder_init(struct archive_read_filter *self)
{
struct private_data *state;
static const size_t out_block_size = 64 * 1024;
void *out_block;
self->code = ARCHIVE_FILTER_GZIP;
self->name = "gzip";
state = (struct private_data *)calloc(sizeof(*state), 1);
out_block = (unsigned char *)malloc(out_b... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x10(%rbp), %rax
leaq 0x30b95e(%rip), %rcx # 0x392b90
movq %rcx, 0x30(%rax)
movl $0xb0, %edi
movl $0x1, %esi
callq 0x13630
movq %rax, -0x18(%rbp)
movl $0x10000, %edi # imm = 0x10000
callq 0x... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_gzip.c |
consume_trailer | static int
consume_trailer(struct archive_read_filter *self)
{
struct private_data *state;
const unsigned char *p;
ssize_t avail;
state = (struct private_data *)self->data;
state->in_stream = 0;
switch (inflateEnd(&(state->stream))) {
case Z_OK:
break;
default:
archive_set_error(&self->archive->archive,
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0x70(%rax)
movq -0x18(%rbp), %rdi
callq 0x37b160
testl %eax, %eax
jne 0x87ae1
jmp 0x87adf
jmp 0x87b05
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_gzip.c |
parse_file_info | static struct file_info *
parse_file_info(struct archive_read *a, struct file_info *parent,
const unsigned char *isodirrec, size_t reclen)
{
struct iso9660 *iso9660;
struct file_info *file, *filep;
size_t name_len;
const unsigned char *rr_start, *rr_end;
const unsigned char *p;
size_t dr_len = 0;
uint64_t fs... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x979c7
movq -0x20(%rbp), %rax
movzbl (%rax), %e... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
parse_rockridge | static int
parse_rockridge(struct archive_read *a, struct file_info *file,
const unsigned char *p, const unsigned char *end)
{
struct iso9660 *iso9660;
int entry_seen = 0;
iso9660 = (struct iso9660 *)(a->format->data);
while (p + 4 <= end /* Enough space for another entry. */
&& p[0] >= 'A' && p[0] <= '... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
addq $0x4, %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
heap_get_entry | static struct file_info *
heap_get_entry(struct heap_queue *heap)
{
uint64_t a_key, b_key, c_key;
int a, b, c;
struct file_info *r, *tmp;
if (heap->used < 1)
return (NULL);
/*
* The first file in the list is the earliest; we'll return this.
*/
r = heap->files[0];
/*
* Move the last item in the heap to... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jge 0x99b1f
movq $0x0, -0x8(%rbp)
jmp 0x99c55
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0xc(%rdx), %ecx
addl $-0x1, %... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
lha_check_header_format | static size_t
lha_check_header_format(const void *h)
{
const unsigned char *p = h;
size_t next_skip_bytes;
switch (p[H_METHOD_OFFSET+3]) {
/*
* "-lh0-" ... "-lh7-" "-lhd-"
* "-lzs-" "-lz5-"
*/
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
case 'd':
case 's':
next_skip_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %eax
addl $-0x2d, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x4d, %eax
ja 0x9c05e
movq -0x28(%rbp), %rax
leaq 0x2ec2eb(%rip), %rcx # 0x388220
movslq (%rcx,%rax,4), %rax
add... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_dos_time | static time_t
lha_dos_time(const unsigned char *p)
{
int msTime, msDate;
struct tm ts;
msTime = archive_le16dec(p);
msDate = archive_le16dec(p+2);
memset(&ts, 0, sizeof(ts));
ts.tm_year = ((msDate >> 9) & 0x7f) + 80; /* Years since 1900. */
ts.tm_mon = ((msDate >> 5) & 0x0f) - 1; /* Month number. */
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9cf10
movzwl %ax, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
callq 0x9cf10
movzwl %ax, %eax
movl %eax, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x12820
movl -0x10(%rbp),... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_calcsum | static unsigned char
lha_calcsum(unsigned char sum, const void *pp, int offset, size_t size)
{
unsigned char const *p = (unsigned char const *)pp;
p += offset;
for (;size > 0; --size)
sum += *p++;
return (sum);
} | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x9cf9e
movq... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_read_file_extended_header | static int
lha_read_file_extended_header(struct archive_read *a, struct lha *lha,
uint16_t *crc, int sizefield_length, size_t limitsize, size_t *total_size)
{
const void *h;
const unsigned char *extdheader;
size_t extdsize;
size_t datasize;
unsigned int i;
unsigned char extdtype;
#define EXT_HEADER_CRC 0x00... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movslq -0x24(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
xorl %eax, %eax
movl %eax,... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_crc16 | static uint16_t
lha_crc16(uint16_t crc, const void *pp, size_t len)
{
const unsigned char *p = (const unsigned char *)pp;
const uint16_t *buff;
const union {
uint32_t i;
char c[4];
} u = { 0x01020304 };
if (len == 0)
return crc;
/* Process unaligned address. */
if (((uintptr_t)p) & (uintptr_t)0x1) {
cr... | pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x2eaf8b(%rip), %eax # 0x388a4c
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9dad8
movw -0x4(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x9ddbb
movq -0x20(%rb... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_win_time | static time_t
lha_win_time(uint64_t wintime, long *ns)
{
#define EPOC_TIME ARCHIVE_LITERAL_ULL(116444736000000000)
if (wintime >= EPOC_TIME) {
wintime -= EPOC_TIME; /* 1970-01-01 00:00:00 (UTC) */
if (ns != NULL)
*ns = (long)(wintime % 10000000) * 100;
return (wintime / 10000000);
} else {
if (ns != NULL)... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movabsq $0x19db1ded53e8000, %rax # imm = 0x19DB1DED53E8000
cmpq %rax, -0x10(%rbp)
jb 0x9de65
movq -0x10(%rbp), %rax
movabsq $0x19db1ded53e8000, %rcx # imm = 0x19DB1DED53E8000
subq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9de51... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_end_of_entry | static int
lha_end_of_entry(struct archive_read *a)
{
struct lha *lha = (struct lha *)(a->format->data);
int r = ARCHIVE_EOF;
if (!lha->end_of_entry_cleanup) {
if ((lha->setflag & CRC_IS_SET) &&
lha->crc != lha->entry_crc_calculated) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"LHa data C... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x12d(%rax)
jne 0x9df61
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x9df56... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_read_data_lzh | static int
lha_read_data_lzh(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct lha *lha = (struct lha *)(a->format->data);
ssize_t bytes_avail;
int r;
/* If we haven't yet read any data, initialize the decompressor. */
if (!lha->decompress_init) {
r = lzh_decode_init(&(lha->... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, 0x12b(%rax)
jne 0x9e092
movq -0x30(%rbp), %rsi
movq %rsi, %rdi
... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_read_blocks | static int
lzh_read_blocks(struct lzh_stream *strm, int last)
{
struct lzh_dec *ds = strm->ds;
struct lzh_br *br = &(ds->br);
int c = 0, i;
unsigned rbits;
for (;;) {
switch (ds->state) {
case ST_RD_BLOCK:
/*
* Read a block number indicates how many blocks
* we will handle. The block is composed of... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x40(%rbp)
subq $0x9, %... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_decode_blocks | static int
lzh_decode_blocks(struct lzh_stream *strm, int last)
{
struct lzh_dec *ds = strm->ds;
struct lzh_br bre = ds->br;
struct huffman *lt = &(ds->lt);
struct huffman *pt = &(ds->pt);
unsigned char *w_buff = ds->w_buff;
unsigned char *lt_bitlen = lt->bitlen;
unsigned char *pt_bitlen = pt->bitlen;
int block... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_decode_huffman_tree | static int
lzh_decode_huffman_tree(struct huffman *hf, unsigned rbits, int c)
{
struct htree_t *ht;
int extlen;
ht = hf->tree;
extlen = hf->shift_bits;
while (c >= hf->len_avail) {
c -= hf->len_avail;
if (extlen-- <= 0 || c >= hf->tree_used)
return (0);
if (rbits & (1U << extlen))
c = ht[c].left;
el... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0xa08ed
movq -0x10... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
cleanup | static int
cleanup(struct archive_read *a)
{
struct mtree *mtree;
struct mtree_entry *p, *q;
mtree = (struct mtree *)(a->format->data);
p = mtree->entries;
while (p != NULL) {
q = p->next;
free(p->name);
free_options(p->options);
free(p);
p = q;
}
archive_string_free(&mtree->line);
archive_string_fr... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa112a
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
detect_form | static int
detect_form(struct archive_read *a, int *is_form_d)
{
const char *p;
ssize_t avail, ravail;
ssize_t len, nl;
int entry_cnt = 0, multiline = 0;
int form_D = 0;/* The archive is generated by `NetBSD mtree -D'
* (In this source we call it `form D') . */
if (is_form_d != NULL)
*is_form_d = 0;
p = __... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa1216
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
callq 0x7e5f0
movq %rax,... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
next_line | static ssize_t
next_line(struct archive_read *a,
const char **b, ssize_t *avail, ssize_t *ravail, ssize_t *nl)
{
ssize_t len;
int quit;
quit = 0;
if (*avail == 0) {
*nl = 0;
len = 0;
} else
len = get_line_size(*b, *avail, nl);
/*
* Read bytes more while it does not reach the end of line.
*/
while... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xa15e2
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x38(%rbp)
jmp 0xa15fd
movq -0x18... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
get_num_opt | static int
get_num_opt(struct archive_write *a, int *num, int high, int low,
const char *key, const char *value)
{
const char *p = value;
int data = 0;
int neg = 0;
if (p == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Invalid value(empty) for option ``%s''", key);
return (ARCHIVE_FATA... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xdb452
movq -0x10(%r... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
write_directory_descriptors | static int
write_directory_descriptors(struct archive_write *a, struct vdd *vdd)
{
struct isoent *np;
int depth, r;
depth = 0;
np = vdd->rootent;
do {
struct extr_rec *extr;
r = _write_directory_descriptors(a, vdd, np, depth);
if (r < 0)
return (r);
if (vdd->vdd_type != VDD_JOLIET) {
/*
* This ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0xe78d0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
extra_next_record | static unsigned char *
extra_next_record(struct ctl_extr_rec *ctl, int length)
{
int cur_len = ctl->cur_len;/* save cur_len */
/* Close the current extra record or Directory Record. */
extra_close_record(ctl, RR_CE_SIZE);
/* Get a next extra record. */
ctl->use_extr = 1;
if (ctl->bp != NULL) {
/* Storing data... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1c, %esi
callq 0xe6450
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe6372
movq -0x8(%rbp), %... | /JeremieA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
uv__read_proc_meminfo | static uint64_t uv__read_proc_meminfo(const char* what) {
uint64_t rc;
char* p;
char buf[4096]; /* Large enough to hold all of /proc/meminfo. */
if (uv__slurp("/proc/meminfo", buf, sizeof(buf)))
return 0;
p = strstr(buf, what);
if (p == NULL)
return 0;
p += strlen(what);
rc = 0;
sscanf(p... | pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp # imm = 0x1020
movq %rdi, -0x10(%rbp)
leaq -0x1020(%rbp), %rsi
leaq 0x4a23c(%rip), %rdi # 0x3b7239
movl $0x1000, %edx # imm = 0x1000
callq 0x356650
cmpl $0x0, %eax
je 0x36d016
movq $0x0, -0x8(%rbp)
jmp 0x36d076
leaq -0x1020(%rbp), %rdi
movq -0x10(%rb... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv_get_total_memory | uint64_t uv_get_total_memory(void) {
struct sysinfo info;
uint64_t rc;
rc = uv__read_proc_meminfo("MemTotal:");
if (rc != 0)
return rc;
if (0 == sysinfo(&info))
return (uint64_t) info.totalram * info.mem_unit;
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x4a014(%rip), %rdi # 0x3b70b6
callq 0x36cfe0
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
je 0x36d0bc
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x36d0e6
leaq -0x78(%rbp), %rdi
callq 0x13c40
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x36d0de
movq -0... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv__read_cgroups_uint64 | static uint64_t uv__read_cgroups_uint64(const char* cgroup, const char* param) {
char filename[256];
char buf[32]; /* Large enough to hold an encoded uint64_t. */
uint64_t rc;
rc = 0;
snprintf(filename, sizeof(filename), "/sys/fs/cgroup/%s/%s", cgroup, param);
if (0 == uv__slurp(filename, buf, sizeof(buf)... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x138(%rbp)
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x100, %esi # imm = 0x100
leaq 0x4a0f5(%rip), %rdx # 0x3b724e
movb $0x0, %al
callq 0x12d20
l... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv_loadavg | void uv_loadavg(double avg[3]) {
struct sysinfo info;
char buf[128]; /* Large enough to hold all of /proc/loadavg. */
if (0 == uv__slurp("/proc/loadavg", buf, sizeof(buf)))
if (3 == sscanf(buf, "%lf %lf %lf", &avg[0], &avg[1], &avg[2]))
return;
if (sysinfo(&info) < 0)
return;
avg[0] = (doubl... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
leaq -0x100(%rbp), %rsi
leaq 0x49f09(%rip), %rdi # 0x3b70d6
movl $0x80, %edx
callq 0x356650
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x36d21a
leaq -0x100(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rcx
add... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv_fs_event_stop | int uv_fs_event_stop(uv_fs_event_t* handle) {
struct watcher_list* w;
if (!uv__is_active(handle))
return 0;
w = find_watcher(handle->loop, handle->wd);
assert(w != NULL);
handle->wd = -1;
handle->path = NULL;
uv__handle_stop(handle);
QUEUE_REMOVE(&handle->watchers);
maybe_free_watcher_list(w, ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x36d917
movl $0x0, -0x4(%rbp)
jmp 0x36d9f9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x80(%rax), %esi
callq 0x36ddd0
movq %rax, -0x18(%rbp)
c... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
maybe_free_watcher_list | static void maybe_free_watcher_list(struct watcher_list* w, uv_loop_t* loop) {
/* if the watcher_list->watchers is being iterated over, we can't free it. */
if ((!w->iterating) && QUEUE_EMPTY(&w->watchers)) {
/* No watchers left for this path. Clean up. */
RB_REMOVE(watcher_root, CAST(&loop->inotify_watcher... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x36da6f
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x36da6f
movq -0x10(%rbp), %rdi
addq $0x340, %rdi # imm = 0x340
movq -0x8(%r... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
uv_fs_event_start | int uv_fs_event_start(uv_fs_event_t* handle,
uv_fs_event_cb cb,
const char* path,
unsigned int flags) {
struct watcher_list* w;
size_t len;
int events;
int err;
int wd;
if (uv__is_active(handle))
return UV_EINVAL;
err = init_inotify(h... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x36dab2
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x36dc93
movq -0x10(%rbp), %rax
movq 0x8(%r... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
init_inotify | static int init_inotify(uv_loop_t* loop) {
int fd;
if (loop->inotify_fd != -1)
return 0;
fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
if (fd < 0)
return UV__ERR(errno);
loop->inotify_fd = fd;
uv__io_init(&loop->inotify_read_watcher, uv__inotify_read, loop->inotify_fd);
uv__io_start(loop, &loop... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x348(%rax)
je 0x36dd52
movl $0x0, -0x4(%rbp)
jmp 0x36ddc4
movl $0x80800, %edi # imm = 0x80800
callq 0x131a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x36dd76
callq 0x13a10
movq %rax, %rcx
xorl %eax, ... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
uv__inotify_read | static void uv__inotify_read(uv_loop_t* loop,
uv__io_t* dummy,
unsigned int events) {
const struct inotify_event* e;
struct watcher_list* w;
uv_fs_event_t* h;
QUEUE queue;
QUEUE* q;
const char* path;
ssize_t size;
const char *p;
/* needs to be ... | pushq %rbp
movq %rsp, %rbp
subq $0x1080, %rsp # imm = 0x1080
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
jmp 0x36e8a8
movq -0x8(%rbp), %rax
movl 0x348(%rax), %edi
leaq -0x1060(%rbp), %rsi
movl $0x1000, %edx # imm = 0x1000
callq 0x13390
movq %rax, -0x58(%rbp)
xorl %eax, %eax
c... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
uv__sendmmsg | int uv__sendmmsg(int fd, struct uv__mmsghdr* mmsg, unsigned int vlen) {
#if defined(__i386__)
unsigned long args[4];
int rc;
args[0] = (unsigned long) fd;
args[1] = (unsigned long) mmsg;
args[2] = (unsigned long) vlen;
args[3] = /* flags */ 0;
/* socketcall() raises EINVAL when SYS_SENDMMSG is not suppo... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl $0x133, %edi # imm = 0x133
xorl %r8d, %r8d
movb $0x0, %al
callq 0x12520
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-syscalls.c |
uv__recvmmsg | int uv__recvmmsg(int fd, struct uv__mmsghdr* mmsg, unsigned int vlen) {
#if defined(__i386__)
unsigned long args[5];
int rc;
args[0] = (unsigned long) fd;
args[1] = (unsigned long) mmsg;
args[2] = (unsigned long) vlen;
args[3] = /* flags */ 0;
args[4] = /* timeout */ 0;
/* socketcall() raises EINVAL w... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl $0x12b, %edi # imm = 0x12B
xorl %r9d, %r9d
movl %r9d, %r8d
movb $0x0, %al
callq 0x12520
addq $0x20, %rsp
popq %rbp
retq
nopw... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-syscalls.c |
uv__fs_copy_file_range | ssize_t
uv__fs_copy_file_range(int fd_in,
off_t* off_in,
int fd_out,
off_t* off_out,
size_t len,
unsigned int flags)
{
#ifdef __NR_copy_file_range
return syscall(__NR_copy_file_range,
fd... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movl -0x2c(%rbp), %eax
movl ... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/linux-syscalls.c |
uv_setup_args | char** uv_setup_args(int argc, char** argv) {
struct uv__process_title pt;
char** new_argv;
size_t size;
char* s;
int i;
if (argc <= 0)
return argv;
pt.str = argv[0];
pt.len = strlen(argv[0]);
pt.cap = pt.len + 1;
/* Calculate how much memory we need for the argv strings. */
size = pt.cap;
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x36f342
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x36f4ce
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x129f0
movq %rax, -0x28(%rb... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/proctitle.c |
uv_set_process_title | int uv_set_process_title(const char* title) {
struct uv__process_title* pt;
size_t len;
/* If uv_setup_args wasn't called or failed, we can't continue. */
if (args_mem == NULL)
return UV_ENOBUFS;
pt = &process_title;
len = strlen(title);
uv_once(&process_title_mutex_once, init_process_title_mutex_o... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0xaf9d4(%rip) # 0x41eec8
jne 0x36f502
movl $0xffffff97, -0x4(%rbp) # imm = 0xFFFFFF97
jmp 0x36f5c9
leaq 0xaf9c7(%rip), %rax # 0x41eed0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x129f0
movq %rax, -0x20(%rbp)
leaq 0xaf9c7(%ri... | /JeremieA[P]CMake/Utilities/cmlibuv/src/unix/proctitle.c |
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.