name string | code string | asm string | file string |
|---|---|---|---|
google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TypeHandler::Type* google::protobuf::internal::RepeatedPtrFieldBase::Mutable<google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TypeHandler... | inline typename TypeHandler::Type* RepeatedPtrFieldBase::Mutable(int index) {
GOOGLE_DCHECK_GE(index, 0);
GOOGLE_DCHECK_LT(index, current_size_);
return cast<TypeHandler>(rep_->elements[index]);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jns 0x1c9c4a
leaq 0x456a2(%rip), %rdx # 0x20f2b1
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x36d, %ecx # imm = 0x36D
callq 0x1cb72a
leaq 0x170c9(%rip), %rsi # 0x1e0cf4
movq %r15, %... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/repeated_ptr_field.h |
google::protobuf::internal::ImplicitWeakMessage* google::protobuf::Arena::CreateMessageInternal<google::protobuf::internal::ImplicitWeakMessage>(google::protobuf::Arena*) | PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
static_assert(
InternalHelper<T>::is_arena_constructable::value,
"CreateMessage can only construct types that are ArenaConstructable");
if (arena == NULL) {
// Generated arena constructor T(Arena*) is protected. Call vi... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1cb0bb
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1cb0ee
pushq $0x30
popq %rdi
callq 0x32480
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1cb12c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x32440
movq %r... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/arena.h |
google::protobuf::internal::ImplicitWeakMessage* google::protobuf::Arena::DoCreateMessage<google::protobuf::internal::ImplicitWeakMessage>() | PROTOBUF_NDEBUG_INLINE T* DoCreateMessage(Args&&... args) {
return InternalHelper<T>::Construct(
AllocateInternal(sizeof(T), alignof(T),
internal::ObjectDestructor<
InternalHelper<T>::is_destructor_skippable::value,
T>::destr... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x13b9f4(%rip), %rdx # 0x306af0
pushq $0x30
popq %rsi
callq 0x1b6c80
movq %rax, %r14
movq %rax, (%rdx)
leaq 0x47(%rip), %rax # 0x1cb158
movq %rax, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1cb12c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/arena.h |
google::protobuf::internal::VerifyVersion(int, int, char const*) | void VerifyVersion(int headerVersion,
int minLibraryVersion,
const char* filename) {
if (GOOGLE_PROTOBUF_VERSION < minLibraryVersion) {
// Library is too old for headers.
GOOGLE_LOG(FATAL)
<< "This program requires version " << VersionString(minLibraryVersion)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movl %edi, %ebp
cmpl $0x2e10f9, %esi # imm = 0x2E10F9
jl 0x1cb239
movl %esi, %r15d
leaq 0x4463d(%rip), %rdx # 0x20f7c2
leaq 0x40(%rsp), %rdi
pushq $0x3
popq %rsi
pushq $0x48
popq %rcx
callq 0x1cb72a
leaq 0x58(%rsp), %r14
leaq 0x446... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/common.cc |
google::protobuf::internal::VersionString[abi:cxx11](int) | std::string VersionString(int version) {
int major = version / 1000000;
int minor = (version / 1000) % 1000;
int micro = version % 1000;
// 128 bytes should always be enough, but we use snprintf() anyway to be
// safe.
char buffer[128];
snprintf(buffer, sizeof(buffer), "%d.%d.%d", major, minor, micro);
... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movl $0xf4240, %ecx # imm = 0xF4240
movl %esi, %eax
cltd
idivl %ecx
movl %eax, %ecx
movl $0x3e8, %edi # imm = 0x3E8
movl %esi, %eax
cltd
idivl %edi
movl %edx, %r9d
cltd
idivl %edi
movl %edx, %r8d
leaq 0x44733(%rip), %rdx # 0x20fad8
leaq 0x10... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/common.cc |
google::protobuf::internal::LogMessage::operator<<(google::protobuf::uint128 const&) | LogMessage& LogMessage::operator<<(const uint128& value) {
std::ostringstream str;
str << value;
message_ += str.str();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x32600
movq %r15, %rdi
movq %r14, %rsi
callq 0x1cbbf0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x32740
leaq 0x18(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x32940... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/common.cc |
google::protobuf::internal::LogMessage::Finish() | void LogMessage::Finish() {
bool suppress = false;
if (level_ != LOGLEVEL_FATAL) {
suppress = log_silencer_count_ > 0;
}
if (!suppress) {
log_handler_(level_, filename_, line_, message_);
}
if (level_ == LOGLEVEL_FATAL) {
#if PROTOBUF_USE_EXCEPTIONS
throw FatalException(filename_, line_, mess... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, (%rdi)
jne 0x1cb761
pushq $0x3
popq %rdi
jmp 0x1cb76d
movl 0x142069(%rip), %eax # 0x30d7d0
testl %eax, %eax
jg 0x1cb77e
movl (%rbx), %edi
movq 0x8(%rbx), %rsi
movl 0x10(%rbx), %edx
leaq 0x18(%rbx), %rcx
callq *0x13fca2(%rip) # 0x30b420
cmpl $0x3, (%... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/common.cc |
google::protobuf::util::status_internal::Status::ToString[abi:cxx11]() const | std::string Status::ToString() const {
if (error_code_ == StatusCode::kOk) {
return "OK";
} else {
if (error_message_.empty()) {
return StatusCodeToString(error_code_);
} else {
return StatusCodeToString(error_code_) + ":" + error_message_;
}
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
testl %esi, %esi
je 0x1cc053
cmpq $0x0, 0x10(%r14)
je 0x1cc067
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1cc09e
leaq 0x3558e(%rip), %rdx # 0x2015b0
movq %rsp, %rdi
movq %r15, %rsi
callq 0x15579f
addq $0x8, %r14
m... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/status.cc |
google::protobuf::util::status_internal::(anonymous namespace)::StatusCodeToString[abi:cxx11](google::protobuf::util::status_internal::StatusCode) | inline std::string StatusCodeToString(StatusCode code) {
switch (code) {
case StatusCode::kOk:
return "OK";
case StatusCode::kCancelled:
return "CANCELLED";
case StatusCode::kUnknown:
return "UNKNOWN";
case StatusCode::kInvalidArgument:
return "INVALID_ARGUMENT";
case Statu... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x10, %esi
ja 0x1cc0c9
movl %esi, %eax
leaq 0x43bb4(%rip), %rcx # 0x20fc68
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x43be8(%rip), %rsi # 0x20fcac
jmp 0x1cc15a
leaq 0x43be9(%rip), %rsi # 0x20fcb9
jmp 0x1cc15a
leaq 0x43c33(%rip), %rsi # ... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/status.cc |
google::protobuf::stringpiece_internal::StringPiece::find(google::protobuf::stringpiece_internal::StringPiece, unsigned long) const | StringPiece::size_type StringPiece::find(StringPiece s, size_type pos) const {
if (length_ <= 0 || pos > static_cast<size_type>(length_)) {
if (length_ == 0 && pos == 0 && s.length_ == 0) return 0;
return npos;
}
const char *result = std::search(ptr_ + pos, ptr_ + length_,
... | pushq %rbx
movq %rdx, %r8
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
setne %al
cmpq %rcx, %rsi
setae %dil
testb %dil, %al
jne 0x1cc51e
orq %rcx, %rsi
xorl %eax, %eax
orq %r8, %rsi
setne %al
negq %rax
jmp 0x1cc54f
movq (%rbx), %rax
addq %rax, %rcx
addq %rax, %rsi
addq %rdx, %r8
movq %rcx, %rdi... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/stringpiece.cc |
google::protobuf::stringpiece_internal::StringPiece::rfind(google::protobuf::stringpiece_internal::StringPiece, unsigned long) const | StringPiece::size_type StringPiece::rfind(StringPiece s, size_type pos) const {
if (length_ < s.length_) return npos;
const size_t ulen = length_;
if (s.length_ == 0) return std::min(ulen, pos);
const char* last = ptr_ + std::min(ulen - s.length_, pos) + s.length_;
const char* result = std::find_end(ptr_, la... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x8(%rdi), %rax
movq %rax, %rsi
subq %rcx, %rsi
jae 0x1cc5aa
pushq $-0x1
popq %rax
jmp 0x1cc5e9
testq %rcx, %rcx
je 0x1cc5df
movq %rdi, %r14
cmpq %rbx, %rsi
cmovbq %rsi, %rbx
movq (%rdi), %rdi
addq %rdi, %rbx
addq %rcx, %rbx
addq %rdx... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/stringpiece.cc |
google::protobuf::stringpiece_internal::StringPiece::find_first_of(google::protobuf::stringpiece_internal::StringPiece, unsigned long) const | StringPiece::size_type StringPiece::find_first_of(StringPiece s,
size_type pos) const {
if (empty() || s.empty()) {
return npos;
}
// Avoid the cost of BuildLookupTable() for a single-character search.
if (s.length_ == 1) return find_first_of(s.ptr_[0], pos)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %rbx
movq 0x8(%rdi), %rbp
testq %rbp, %rbp
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x1cc659
pushq $-0x1
popq %rax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
po... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/stringpiece.cc |
google::protobuf::stringpiece_internal::StringPiece::find_last_of(google::protobuf::stringpiece_internal::StringPiece, unsigned long) const | StringPiece::size_type StringPiece::find_last_of(StringPiece s,
size_type pos) const {
if (empty() || s.empty()) return npos;
// Avoid the cost of BuildLookupTable() for a single-character search.
if (s.length_ == 1) return find_last_of(s.ptr_[0], pos);
bool loo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %rbx
movq 0x8(%rdi), %rbp
testq %rbp, %rbp
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x1cc7de
pushq $-0x1
popq %rax
jmp 0x1cc85f
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpq $0x1, %rd... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/stringpiece.cc |
google::protobuf::StripWhitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | void StripWhitespace(std::string *str) {
int str_length = str->length();
// Strip off leading whitespace.
int first = 0;
while (first < str_length && ascii_isspace(str->at(first))) {
++first;
}
// If entire string is white space.
if (first == str_length) {
str->clear();
return;
}
if (firs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
xorl %r14d, %r14d
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
movabsq $0x100003e00, %r15 # imm = 0x100003E00
cmpq %r14, %r12
je 0x1cd249
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32920
movzbl (%rax), %eax
cmpq $0x20,... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::SplitStringUsing(google::protobuf::stringpiece_internal::StringPiece, 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 SplitStringUsing(StringPiece full, const char *delim,
std::vector<std::string> *result) {
std::back_insert_iterator<std::vector<std::string> > it(*result);
SplitStringToIteratorUsing(full, delim, it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x38(%rsp)
movq %rsi, 0x40(%rsp)
movb (%rdx), %bpl
testb %bpl, %bpl
je 0x1cd3e6
cmpb $0x0, 0x1(%r14)
je 0x1cd502
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d1... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::JoinStrings(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&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | void JoinStrings(const std::vector<std::string> &components, const char *delim,
std::string *result) {
JoinStringsIterator(components.begin(), components.end(), delim, result);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r12
movq 0x8(%rdi), %r13
testq %rdx, %rdx
jne 0x1cd6e7
leaq 0x43774(%rip), %rdx # 0x210e20
leaq 0x10(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x108, %ecx # imm = ... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::CEscapeInternal(char const*, int, char*, int, bool, bool) | int CEscapeInternal(const char* src, int src_len, char* dest,
int dest_len, bool use_hex, bool utf8_safe) {
const char* src_end = src + src_len;
int used = 0;
bool last_hex_escape = false; // true if last output char was \xNN
for (; src < src_end; src++) {
if (dest_len - used < 2) // ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdi, %r15
movslq %esi, %rbx
addq %rdi, %rbx
leaq 0x433d3(%rip), %rax # 0x210ef1
leaq 0x433d3(%rip), %rcx # 0x210ef8
movl %r8d, 0x4(%rsp)
testl %r8d, %r8d
cmovneq %rax, %rcx
movq %rcx, 0x10(%rsp)
movq %rdx, ... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::strings::CHexEscape(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string CHexEscape(const std::string &src) {
const int dest_length = src.size() * 4 + 1; // Maximum possible expansion
std::unique_ptr<char[]> dest(new char[dest_length]);
const int len = CEscapeInternal(src.data(), src.size(),
dest.get(), dest_length, true, false);
GOOGLE_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %r12d
leal (,%r12,4), %eax
leal 0x1(,%r12,4), %ebp
testl %eax, %eax
pushq $-0x1
popq %rax
cmovnsl %ebp, %eax
movslq %eax, %rdi
callq 0x32030
movq %rax, %r14
movq %rax, 0x10(%rsp)
movq (%r15), %rdi
pus... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::FastInt32ToBufferLeft(int, char*) | char* FastInt32ToBufferLeft(int32 i, char* buffer) {
uint32 u = 0;
if (i < 0) {
*buffer++ = '-';
u -= i;
} else {
u = i;
}
return FastUInt32ToBufferLeft(u, buffer);
} | testl %edi, %edi
jns 0x1ce342
movb $0x2d, (%rsi)
incq %rsi
negl %edi
jmp 0x1ce342
| /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::FastUInt64ToBufferLeft(unsigned long, char*) | char* FastUInt64ToBufferLeft(uint64 u64, char* buffer) {
int digits;
const char *ASCII_digits = nullptr;
uint32 u = static_cast<uint32>(u64);
if (u == u64) return FastUInt32ToBufferLeft(u, buffer);
uint64 top_11_digits = u64 / 1000000000;
buffer = FastUInt64ToBufferLeft(top_11_digits, buffer);
u = u64 -... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq %rdi, %rax
shrq $0x20, %rax
jne 0x1ce4eb
movl %r14d, %edi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1ce342
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r15
movq... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::FastInt64ToBufferLeft(long, char*) | char* FastInt64ToBufferLeft(int64 i, char* buffer) {
uint64 u = 0;
if (i < 0) {
*buffer++ = '-';
u -= i;
} else {
u = i;
}
return FastUInt64ToBufferLeft(u, buffer);
} | testq %rdi, %rdi
jns 0x1ce4c3
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
jmp 0x1ce4c3
| /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::DoubleToBuffer(double, char*) | char* DoubleToBuffer(double value, char* buffer) {
// DBL_DIG is 15 for IEEE-754 doubles, which are used on almost all
// platforms these days. Just in case some system exists where DBL_DIG
// is significantly larger -- and risks overflowing our buffer -- we have
// this assert.
static_assert(DBL_DIG < 20, "... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
ucomisd 0x42669(%rip), %xmm0 # 0x210e00
jb 0x1ce7a4
movl $0x666e69, (%rbx) # imm = 0x666E69
jmp 0x1ce8bf
movsd 0x4265c(%rip), %xmm1 # 0x210e08
ucomisd %xmm0, %xmm1
jb 0x1ce7c1
movb $0x0, 0x4(%rbx)
movl $0x666e692d, (%rbx) # imm = 0x666E692D
jmp 0x1c... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::internal::NoLocaleStrtod(char const*, char**) | double NoLocaleStrtod(const char *str, char **endptr) {
// We cannot simply set the locale to "C" temporarily with setlocale()
// as this is not thread-safe. Instead, we try to parse in the current
// locale first. If parsing stops at a '.' character, then this is a
// pretty good hint that we're actually in ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x60(%rsp), %r15
movq %r15, %rsi
callq 0x323b0
movq (%r15), %r15
testq %rbx, %rbx
je 0x1ceb6e
movq %r15, (%rbx)
cmpb $0x2e, (%r15)
jne 0x1ced33
leaq 0x42857(%rip), %rdx # 0x2113d6
leaq 0x40(%rsp),... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::safe_strtof(char const*, float*) | bool safe_strtof(const char* str, float* value) {
char* endptr;
errno = 0; // errno only gets set on errors
#if defined(_WIN32) || defined (__hpux) // has no strtof()
*value = internal::NoLocaleStrtod(str, &endptr);
#else
*value = strtof(str, &endptr);
#endif
return *str != 0 && *endptr == 0 && errno == 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x32050
movq %rax, %rbx
andl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x325f0
movss %xmm0, (%r14)
cmpb $0x0, (%r15)
je 0x1cf031
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x1cf035
xorl %eax, %eax
jmp 0x1cf03b
cmpl $0x0... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::safe_strtod(char const*, double*) | bool safe_strtod(const char* str, double* value) {
char* endptr;
*value = internal::NoLocaleStrtod(str, &endptr);
if (endptr != str) {
while (ascii_isspace(*endptr)) ++endptr;
}
// Ignore range errors from strtod. The values it
// returns on underflow and overflow are the right
// fallback in a robus... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x1ceb42
movsd %xmm0, (%r14)
movq (%r15), %rax
cmpq %rbx, %rax
je 0x1cf091
movabsq $0x100003e00, %rcx # imm = 0x100003E00
movzbl (%rax), %edx
cmpq $0x20, %rdx
ja 0x1cf091
btq %rdx, %rcx
jae ... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::strings::AlphaNum::AlphaNum(google::protobuf::strings::Hex) | AlphaNum::AlphaNum(strings::Hex hex) {
char *const end = &digits[kFastToBufferSize];
char *writer = end;
uint64 value = hex.value;
uint64 width = hex.spec;
// We accomplish minimum width by OR'ing in 0x10000 to the user's value,
// where 0x10000 is the smallest hex number that is as wide as the user
// as... | leaq 0x30(%rdi), %rax
shll $0x2, %edx
addb $-0x4, %dl
movq %rsi, %r8
btsq %rdx, %r8
xorl %ecx, %ecx
leaq 0x4226c(%rip), %rdx # 0x211470
movq %r8, %r9
movl %esi, %r10d
andl $0xf, %r10d
movb (%r10,%rdx), %r10b
movb %r10b, 0x2f(%rdi,%rcx)
shrq $0x4, %rsi
shrq $0x4, %r9
decq %rcx
cmpq $0xf, %r8
movq %r9, %r8
ja 0x1cf20... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&) | std::string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c) {
std::string result;
result.resize(a.size() + b.size() + c.size());
char *const begin = &*result.begin();
char *out = Append2(begin, a, b);
out = Append1(out, c);
GOOGLE_DCHECK_EQ(out, begin + result.size());
return result;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r12
movq %rsi, %r13
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq 0x8(%r13), %rsi
addq 0x8(%rcx), %rsi
callq 0x32640
movq (%rbx), %r15
movq %... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::StrCat[abi:cxx11](google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&) | std::string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c,
const AlphaNum &d) {
std::string result;
result.resize(a.size() + b.size() + c.size() + d.size());
char *const begin = &*result.begin();
char *out = Append4(begin, a, b, c, d);
GOOGLE_DCHECK_EQ(out, begin + result.s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq 0x8(%r13), %rsi
addq 0x8(%rcx), %rsi
addq 0x8(%r8... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::Append4(char*, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&) | static char *Append4(char *out, const AlphaNum &x1, const AlphaNum &x2,
const AlphaNum &x3, const AlphaNum &x4) {
if (x1.size() > 0) {
memcpy(out, x1.data(), x1.size());
out += x1.size();
}
if (x2.size() > 0) {
memcpy(out, x2.data(), x2.size());
out += x2.size();
}
if (x3.... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x1cf533
movq %rsi, %r13
movq (%rsi), %rsi
movq %rbx, %rdi
callq 0x323d0
addq 0x8(%r13), %rbx
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x1cf54e
movq (%r12), %rsi... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::StrAppend(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, google::protobuf::strings::AlphaNum const&) | void StrAppend(std::string *result, const AlphaNum &a) {
GOOGLE_DCHECK_NO_OVERLAP(*result, a);
result->append(a.data(), a.size());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq %rsi, %rax
subq (%rdi), %rax
cmpq 0x8(%rdi), %rax
ja 0x1cfbbc
leaq 0x412a2(%rip), %rdx # 0x210e20
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x626, %ecx # imm = 0x626
callq 0x1cb7... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::StrAppend(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, google::protobuf::strings::AlphaNum const&, google::protobuf::strings::AlphaNum const&) | void StrAppend(std::string *result, const AlphaNum &a, const AlphaNum &b) {
GOOGLE_DCHECK_NO_OVERLAP(*result, a);
GOOGLE_DCHECK_NO_OVERLAP(*result, b);
std::string::size_type old_size = result->size();
result->resize(old_size + a.size() + b.size());
char *const begin = &*result->begin();
char *out = Append2... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rcx
movq (%rdi), %rax
movq 0x8(%rdi), %r12
subq %rax, %rcx
cmpq %r12, %rcx
ja 0x1cfc5a
leaq 0x41208(%rip), %rdx # 0x210e20
leaq 0x8(%rsp), %r12
pushq $0x3
popq %rsi
movq %r12, %rdi
m... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::internal::ExtensionSet::NumExtensions() const | int ExtensionSet::NumExtensions() const {
int result = 0;
ForEach([&result](int /* number */, const Extension& ext) {
if (!ext.is_cleared) {
++result;
}
});
return result;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpw $0x0, 0xa(%rdi)
js 0x1d2ef0
movq %rbx, %rdi
callq 0x1dce18
movq %rax, %r14
movq %rbx, %rdi
callq 0x1dce44
xorl %ebx, %ebx
cmpq %rax, %r14
je 0x1d2f18
movzbl 0x12(%r14), %ecx
notl %ecx
andl $0x1, %ecx
addl %ecx, %ebx
addq $0x20, %r14
jmp 0x1d2ed9
movq 0x10(%rbx), %r1... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::GetEnum(int, int) const | int ExtensionSet::GetEnum(int number, int default_value) const {
const Extension* extension = FindOrNull(number);
if (extension == nullptr || extension->is_cleared) {
// Not present. Return the default value.
return default_value;
} else {
GOOGLE_DCHECK_TYPE(*extension, OPTIONAL_FIELD, ENUM);
ret... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
callq 0x1d2e1e
testq %rax, %rax
je 0x1d6f89
movq %rax, %rbx
testb $0x1, 0xa(%rax)
jne 0x1d6f89
cmpb $0x0, 0x9(%rbx)
je 0x1d6f37
leaq 0x3ad0c(%rip), %rdx # 0x211c08
leaq 0x8(%rsp), %r14
pushq $0x3
popq %rsi
movq %r14, %rdi
movl $0x1e8, %ecx ... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::SetEnum(int, unsigned char, int, google::protobuf::FieldDescriptor const*) | void ExtensionSet::SetEnum(int number, FieldType type, int value,
const FieldDescriptor* descriptor) {
Extension* extension;
if (MaybeNewExtension(number, descriptor, &extension)) {
extension->type = type;
GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movl %ecx, %ebx
movl %edx, %ebp
callq 0x1d9f38
movq %rax, %r14
movq %r15, 0x10(%rax)
testb $0x1, %dl
je 0x1d7116
movb %bpl, 0x8(%r14)
movzbl %bpl, %edi
callq 0x1d3279
cmpl $0x8, %eax
je 0x1d710c
leaq 0x3ab37(%rip), %rdx # 0x211c08
leaq 0x10... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::SetRepeatedEnum(int, int, int) | void ExtensionSet::SetRepeatedEnum(int number, int index, int value) {
Extension* extension = FindOrNull(number);
GOOGLE_CHECK(extension != nullptr) << "Index out-of-bounds (field is empty).";
GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, ENUM);
extension->repeated_enum_value->Set(index, value);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
movl %ecx, 0x4(%rsp)
callq 0x1d2e1e
movq %rax, %r14
testq %rax, %rax
jne 0x1d74bd
leaq 0x3a795(%rip), %rdx # 0x211c08
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x217, %ecx # imm = 0x217
callq 0x1cb72a
leaq 0x3aac0(%ri... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::AddEnum(int, unsigned char, bool, int, google::protobuf::FieldDescriptor const*) | void ExtensionSet::AddEnum(int number, FieldType type, bool packed, int value,
const FieldDescriptor* descriptor) {
Extension* extension;
if (MaybeNewExtension(number, descriptor, &extension)) {
extension->type = type;
GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r9, %r12
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %r14
movl %r8d, 0x4(%rsp)
callq 0x1d9f38
movq %rax, %rbx
movq %r12, 0x10(%rax)
testb $0x1, %dl
je 0x1d7629
movb %r15b, 0x8(%rbx)
movzbl %r15b, %edi
callq 0x1d3279
cmpl $0x8, %eax
je 0x1d761... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::GetString(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const std::string& ExtensionSet::GetString(
int number, const std::string& default_value) const {
const Extension* extension = FindOrNull(number);
if (extension == nullptr || extension->is_cleared) {
// Not present. Return the default value.
return default_value;
} else {
GOOGLE_DCHECK_TYPE(*exte... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
callq 0x1d2e1e
testq %rax, %rax
je 0x1d7806
movq %rax, %rbx
testb $0x1, 0xa(%rax)
jne 0x1d7806
cmpb $0x0, 0x9(%rbx)
je 0x1d77b3
leaq 0x3a490(%rip), %rdx # 0x211c08
leaq 0x10(%rsp), %r14
pushq $0x3
popq %rsi
movq %r14, %rdi
movl $0x237, %ecx # imm = 0... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::MutableString[abi:cxx11](int, unsigned char, google::protobuf::FieldDescriptor const*) | std::string* ExtensionSet::MutableString(int number, FieldType type,
const FieldDescriptor* descriptor) {
Extension* extension;
if (MaybeNewExtension(number, descriptor, &extension)) {
extension->type = type;
GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, %r14
callq 0x1d9f38
movq %rax, %rbx
movq %r15, 0x10(%rax)
testb $0x1, %dl
je 0x1d78b7
movb %bpl, 0x8(%rbx)
movzbl %bpl, %edi
callq 0x1d3279
cmpl $0x9, %eax
je 0x1d78a3
leaq 0x3a3a0(%rip), %rdx # 0x211c08
leaq 0x1... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::MutableRepeatedString[abi:cxx11](int, int) | std::string* ExtensionSet::MutableRepeatedString(int number, int index) {
Extension* extension = FindOrNull(number);
GOOGLE_CHECK(extension != nullptr) << "Index out-of-bounds (field is empty).";
GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, STRING);
return extension->repeated_string_value->Mutable(index);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
callq 0x1d2e1e
movq %rax, %r14
testq %rax, %rax
jne 0x1d7b1f
leaq 0x3a133(%rip), %rdx # 0x211c08
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x255, %ecx # imm = 0x255
callq 0x1cb72a
leaq 0x3a45e(%rip), %rsi # 0x211f... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::MutableMessage(int, unsigned char, google::protobuf::MessageLite const&, google::protobuf::FieldDescriptor const*) | MessageLite* ExtensionSet::MutableMessage(int number, FieldType type,
const MessageLite& prototype,
const FieldDescriptor* descriptor) {
Extension* extension;
if (MaybeNewExtension(number, descriptor, &extension)) {
extension->t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r15
callq 0x1d9f38
movq %rax, %r14
movq %r12, 0x10(%rax)
testb $0x1, %dl
je 0x1d7ee9
movb %bpl, 0x8(%r14)
movzbl %bpl, %edi
callq 0x1d3279
cmpl $0xa, %eax
je 0x1d7ec6
leaq 0x39d7d(%rip), %r... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::UnsafeArenaSetAllocatedMessage(int, unsigned char, google::protobuf::FieldDescriptor const*, google::protobuf::MessageLite*) | void ExtensionSet::UnsafeArenaSetAllocatedMessage(
int number, FieldType type, const FieldDescriptor* descriptor,
MessageLite* message) {
if (message == nullptr) {
ClearExtension(number);
return;
}
Extension* extension;
if (MaybeNewExtension(number, descriptor, &extension)) {
extension->type... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r15
testq %r8, %r8
je 0x1d82d1
movq %r8, %rbx
movq %rcx, %r12
movl %edx, %ebp
movq %r15, %rdi
callq 0x1d9f38
movq %rax, %r14
movq %r12, 0x10(%rax)
testb $0x1, %dl
je 0x1d82e5
movb %bpl, 0x8(%r14)
movzbl %bpl, %edi
callq 0x1d3279
cmpl $0... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::UnsafeShallowSwapExtension(google::protobuf::internal::ExtensionSet*, int) | void ExtensionSet::UnsafeShallowSwapExtension(ExtensionSet* other, int number) {
if (this == other) return;
Extension* this_ext = FindOrNull(number);
Extension* other_ext = other->FindOrNull(number);
if (this_ext == other_ext) return;
GOOGLE_DCHECK_EQ(GetArena(), other->GetArena());
if (this_ext != null... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq %rsi, %rdi
je 0x1d9de6
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %esi
callq 0x1d2e1e
movq %rax, %r12
movq %r14, %rdi
movl %ebx, %esi
callq 0x1d2e1e
cmpq %rax, %r12
je 0x1d9de6
movq %rax, %r13
movq (%r15), %rax
cmpq ... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::FindExtensionInfoFromFieldNumber(int, int, google::protobuf::internal::ExtensionFinder*, google::protobuf::internal::ExtensionInfo*, bool*) const | bool ExtensionSet::FindExtensionInfoFromFieldNumber(
int wire_type, int field_number, ExtensionFinder* extension_finder,
ExtensionInfo* extension, bool* was_packed_on_wire) const {
if (!extension_finder->Find(field_number, extension)) {
return false;
}
WireFormatLite::WireType expected_wire_type =
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %r9, %r14
movq %r8, %r15
movl %esi, %ebx
movq (%rcx), %rax
movq %rcx, %rdi
movl %edx, %esi
movq %r8, %rdx
callq *0x10(%rax)
testb %al, %al
je 0x1da17b
movzbl 0xc(%r15), %edi
callq 0x1da1e6
movl %eax, %eax
leaq 0x373dd(%rip), %rcx # 0x211530
movl (%rc... | /apple[P]coremltools/deps/protobuf/src/google/protobuf/extension_set.cc |
trico_write_attributes_uint64 | int trico_write_attributes_uint64(void* a, const uint64_t* attrib, uint32_t nr_of_attribs)
{
struct trico_archive* arch = (struct trico_archive*)a;
uint8_t header = (uint8_t)trico_attribute_uint64_stream;
if (!write(&header, 1, 1, arch))
return 0;
if (!write(&nr_of_attribs, sizeof(uint32_t), 1, arch))
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4078, %rsp # imm = 0x4078
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, 0x2c(%rsp)
leaq 0x7(%rsp), %rdi
movb $0x14, (%rdi)
pushq $0x1
popq %rdx
movq %rdx, %rsi
movq %rbx, %rcx
callq 0x6ace
xorl %ebp, %ebp
testl %eax, %eax
... | /janm31415[P]trico/trico/trico.c |
trico_read_vec3_double | static int trico_read_vec3_double(void* a, double** vertices, enum trico_stream_type st)
{
struct trico_archive* arch = (struct trico_archive*)a;
if (trico_get_next_stream_type(arch) != st)
return 0;
uint32_t nr_vertices;
if (!read(&nr_vertices, sizeof(uint32_t), 1, arch))
return 0;
uint32_t nr_o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
xorl %ebp, %ebp
cmpl %edx, 0x24(%rdi)
jne 0x8512
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14(%rsp), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x8882
testl %eax, %eax
je 0x8510
leaq 0x4(%rsp), %rdi
pushq $0x4
popq %rsi
pushq... | /janm31415[P]trico/trico/trico.c |
trico_read_vec2_float | static int trico_read_vec2_float(void* a, float** uv, enum trico_stream_type st)
{
struct trico_archive* arch = (struct trico_archive*)a;
if (trico_get_next_stream_type(arch) != st)
return 0;
uint32_t nr_vec2_positions;
if (!read(&nr_vec2_positions, sizeof(uint32_t), 1, arch))
return 0;
uint32_t n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorl %ebp, %ebp
cmpl %edx, 0x24(%rdi)
jne 0x8f83
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x8882
testl %eax, %eax
je 0x8f81
movq %rsp, %rdi
pushq $0x4
popq %rsi
pushq $0x1
... | /janm31415[P]trico/trico/trico.c |
trico_read_vec2_double | int trico_read_vec2_double(void* a, double** uv, enum trico_stream_type st)
{
struct trico_archive* arch = (struct trico_archive*)a;
if (trico_get_next_stream_type(arch) != st)
return 0;
uint32_t nr_uv_positions;
if (!read(&nr_uv_positions, sizeof(uint32_t), 1, arch))
return 0;
uint32_t nr_of_comp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorl %ebp, %ebp
cmpl %edx, 0x24(%rdi)
jne 0x910b
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x8882
testl %eax, %eax
je 0x9109
movq %rsp, %rdi
pushq $0x4
popq %rsi
pushq $0x1
... | /janm31415[P]trico/trico/trico.c |
trico_read_attributes_float | int trico_read_attributes_float(void* a, float** attrib)
{
struct trico_archive* arch = (struct trico_archive*)a;
if (trico_get_next_stream_type(arch) != trico_attribute_float_stream)
return 0;
uint32_t nr_attrib;
if (!read(&nr_attrib, sizeof(uint32_t), 1, arch))
return 0;
uint32_t nr_of_compresse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %ebp, %ebp
cmpl $0xf, 0x24(%rdi)
jne 0x9214
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x8882
testl %eax, %eax
je 0x9212
leaq 0x4(%rsp), %rdi
pushq $0x4
popq %rsi
pushq ... | /janm31415[P]trico/trico/trico.c |
trico_read_attributes_double | int trico_read_attributes_double(void* a, double** attrib)
{
struct trico_archive* arch = (struct trico_archive*)a;
if (trico_get_next_stream_type(arch) != trico_attribute_double_stream)
return 0;
uint32_t nr_attrib;
if (!read(&nr_attrib, sizeof(uint32_t), 1, arch))
return 0;
uint32_t nr_of_compre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %ebp, %ebp
cmpl $0x10, 0x24(%rdi)
jne 0x92ee
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x8882
testl %eax, %eax
je 0x92ec
leaq 0x4(%rsp), %rdi
pushq $0x4
popq %rsi
pushq... | /janm31415[P]trico/trico/trico.c |
LZ4_compress_fast_extState_fastReset | int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration)
{
LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
if (dstCapacity >= LZ4_compressBound(srcSiz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %r13d
movl %ecx, %ebx
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
cmpl $0x2, %r9d
pushq $0x1
popq %rax
cmovll %eax, %r13d
xorl %ecx, %ecx
cmpl $0x7e000000, %ebx # imm = 0x7E000000
ja 0xb8a6
movl $0xff, %e... | /janm31415[P]trico/lz4/lz4.c |
LZ4_compress_forceExtDict | int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize)
{
LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
int result;
LZ4_renormDictT(streamPtr, srcSize);
if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movl %ecx, %esi
callq 0x10da2
movl 0x4018(%r14), %eax
movl %eax, %r8d
cmpl $0x10000, %eax # imm = 0x10000
setb %cl
movl 0x4000(%r14), %r12d
cmpl %eax, %r12d
seta %d... | /janm31415[P]trico/lz4/lz4.c |
LZ4_decompress_safe_withSmallPrefix | LZ4_FORCE_O2_GCC_PPC64LE
static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, int compressedSize, int maxOutputSize,
size_t prefixSize)
{
return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
pushq $-0x1
popq %r12
testq %rdi, %rdi
je 0x144dd
movq %rdi, %r11
testl %ecx, %ecx
je 0x14281
testl %edx, %edx
je 0x144dd
movq %rsi, %r10
movq %rsi, %rbp
subq %r8, %rbp
movslq %edx, %rax
leaq (%r11,%rax), %rdx
movq %rdx, 0x10(%rsp)
movsl... | /janm31415[P]trico/lz4/lz4.c |
LZ4_decompress_fast_continue | LZ4_FORCE_O2_GCC_PPC64LE
int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize)
{
LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
int result;
assert(originalSize >= 0);
if (lz4sd->prefixSize == 0) {
as... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r13
movq %rdi, %rbx
movq 0x18(%rdi), %r8
testq %r8, %r8
je 0x145f9
movslq %ebp, %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rbx), %rcx
cmpq %r13, %rcx
je 0x14624
movq %r8, 0x8(%rbx)
subq %r8, %rcx
movq %rcx, (%rbx)
... | /janm31415[P]trico/lz4/lz4.c |
PDCLIB_print | const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
{
const char * orig_spec = spec;
if ( *( ++spec ) == '%' )
{
/* %% -> print single '%' */
PUT( *spec );
return ++spec;
}
/* Initializing status structure */
status->flags = 0;
status->... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl 0x1(%rax), %eax
cmpl $0x25, %eax
jne 0x27fd
jmp 0x2785
movq -0x10(%rbp), ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print.c |
PDCLIB_print_integer | void _PDCLIB_print_integer( imaxdiv_t div, struct _PDCLIB_status_t * status )
{
if ( status->current == 0 && div.quot == 0 && div.rem == 0 && status->prec == 0 )
{
intformat( 0, status );
}
else
{
++(status->current);
if ( div.quot != 0 )
{
_PDCLIB_print_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x48b9
cmpq $0x0, -0x10(%rbp)
jne 0x48b9
cmpq $0x0, -0x8(%rbp)
jne 0x48b9
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x48b9
movq -0x18(%rbp), %rsi
xorl %... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_integer.c |
PDCLIB_print_string | void _PDCLIB_print_string( const char * s, struct _PDCLIB_status_t * status )
{
if ( status->flags & E_char )
{
status->prec = 1;
}
else
{
if ( status->prec < 0 )
{
status->prec = strlen( s );
}
else
{
int i;
for ( ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x4eac
movq -0x10(%rbp), %rax
movl $0x1, 0x30(%rax)
jmp 0x4f0b
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jge 0x4eca
movq -0x8(%rbp), %rdi
callq 0x57... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_string.c |
puts | int puts( const char * s )
{
_PDCLIB_LOCK( stdout->mtx );
if ( _PDCLIB_prepwrite( stdout ) == EOF )
{
_PDCLIB_UNLOCK( stdout->mtx );
return EOF;
}
while ( *s != '\0' )
{
stdout->buffer[ stdout->bufidx++ ] = *s++;
if ( stdout->bufidx == stdout->bufsize )
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x3cb5(%rip), %rax # 0x9058
movq (%rax), %rdi
addq $0x48, %rdi
callq 0x52a0
leaq 0x3ca2(%rip), %rax # 0x9058
movq (%rax), %rdi
callq 0x26c0
cmpl $-0x1, %eax
jne 0x53e2
leaq 0x3c8e(%rip), %rax # 0x9058
movq (%rax), %rdi
addq $0x48, %r... | /DevSolar[P]pdclib/functions/stdio/puts.c |
supermap::io::FileOutputStream::FileOutputStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | FileOutputStream::FileOutputStream(const std::string &filename, bool append)
: filename_(filename), ofs_(filename, append ? std::ios_base::app : std::ios_base::out) {
if (!ofs_.good() || ofs_.bad()) {
throw FileException(filename, "Unable to open for writing");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq 0x6aab(%rip), %rax # 0xefd8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %r... | /Glebanister[P]supermap/src/io/OutputStream.cpp |
supermap::io::RamFileManager::getFileIterator(std::filesystem::__cxx11::path const&) const | std::deque<RamFileManager::File>::const_iterator RamFileManager::getFileIterator(
const std::filesystem::path &file) const {
auto it = getFileIteratorNoThrow(file);
if (it == files.end()) {
throw FileException(file, "Not found");
}
return it;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x7180
movq (%rbx), %rax
cmpq 0x38(%r15), %rax
je 0x8ef3
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x7150
movq %rax, %rbx
lea... | /Glebanister[P]supermap/src/io/RamFileManager.cpp |
supermap::io::EncapsulatedFileManager::rename(std::filesystem::__cxx11::path const&, std::filesystem::__cxx11::path const&) | void EncapsulatedFileManager::rename(const std::filesystem::path &prevPath, const std::filesystem::path &nextPath) {
innerManager_->rename(makeRootPath(prevPath), makeRootPath(nextPath));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
movq 0x18(%rdi), %rbx
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x74c0
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x74c0
movq (%rbx), %rax
leaq 0x28(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq *0x18(%rax... | /Glebanister[P]supermap/src/io/EncapsulatedFileManager.cpp |
void ruckig::WaypointsCalculator<3ul, ruckig::StandardVector>::vector_to_json<std::vector<double, std::allocator<double>>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nloh... | static void vector_to_json(nlohmann::json& j, const V& vector) {
j = nlohmann::json::array();
auto& j_vector = j.get_ref<nlohmann::json::array_t&>();
j_vector.resize(vector.size());
for (size_t i = 0; i < vector.size(); ++i) {
j_vector[i] = vector[i];
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x18(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1266c
movq %r14, %rdi
movq %r15, %rsi
callq 0x10a4a
movq %r15, %rdi
callq 0x10a8e
movq %r14, %rdi
callq 0x134... | /pantor[P]ruckig/include/ruckig/calculator_cloud.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::size() const | size_type size() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return 0;
}
case value_t::array:
{
// delegate call to array_t::size()
... | movzbl (%rdi), %eax
testl %eax, %eax
je 0x10f6b
cmpl $0x1, %eax
je 0x10f5f
cmpl $0x2, %eax
jne 0x10f68
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x4, %rax
retq
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rax
retq
pushq $0x1
popq %rax
retq
| /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::empty() const | bool empty() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return true;
}
case value_t::array:
{
// delegate call to array_t::empty()
... | movzbl (%rdi), %eax
testl %eax, %eax
je 0x10f97
cmpl $0x1, %eax
je 0x10f8a
cmpl $0x2, %eax
jne 0x10f9a
movq 0x8(%rdi), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jmp 0x10f93
movq 0x8(%rdi), %rax
cmpq $0x0, 0x28(%rax)
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
| /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsign... | const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numer... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x110fb
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0xd170
movq %rax, %rbx
movq %r14, %rdi
callq 0x1237c
leaq 0x8(%rsp), %rdx... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::... | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r15
movq %rsi, %r12
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq 0x8(%r12), %rsi
addq 0x8(%rcx), %rsi
callq 0xd450
movq %rbx, %rdi
movq %r12, %rsi
movq %r15,... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std:... | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
mov... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destr... | void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x11cbe
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(nlohma... | basic_json(basic_json&& other) noexcept
: json_base_class_t(std::forward<json_base_class_t>(other)),
m_data(std::move(other.m_data))
{
// check that passed value is valid
other.assert_invariant(false);
// invalidate payload
other.m_data.m_type = value_t::null;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x11194
movb $0x0, (%rbx)
andq $0x0, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11194
| /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::_... | reference operator[](typename object_t::key_type key)
{
// implicitly convert null value to an empty object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value.object = create<object_t>();
assert_invariant();
}
// operator[] o... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0x12187
movb $0x1, (%r14)
callq 0x112c2
movq %rax, 0x8(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x11194
movb (%r14), %al
cmpb $0x1, %al
jne 0x121ad
movq 0x8(%r14), %rdi
leaq 0x10(%rsp), %rdx
and... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::detail::type_error nlohmann::json_abi_v3_11_3::detail::type_error::create<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_... | static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x983f(%rip), %rsi # 0x1ba8e
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1142a
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x11638
leaq 0x8(%rsp), %rdi
movq... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::type_name() const | JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
... | movzbl (%rdi), %eax
cmpq $0x9, %rax
ja 0x12394
leaq 0x8ee4(%rip), %rcx # 0x1b270
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x9730(%rip), %rax # 0x1bacb
retq
| /pantor[P]ruckig/third_party/nlohmann/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::exception::diagnostics<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::... | static std::string diagnostics(const BasicJsonType* leaf_element)
{
#if JSON_DIAGNOSTICS
std::vector<std::string> tokens;
for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
{
switch (current->m_parent->type())... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x9ef1(%rip), %rsi # 0x1c4bc
leaq 0xf(%rsp), %rdx
callq 0x1142a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(std::i... | basic_json(initializer_list_t init,
bool type_deduction = true,
value_t manual_type = value_t::array)
{
// check if each element is an array with two elements whose first
// element is a string
bool is_an_object = std::all_of(init.begin(), init.end(),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
imulq $0x18, %rdx, %r13
leaq (%rsi,%r13), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
movq %r15, %rsi
callq 0x1281b
testb %r12b, %r12b
jne 0x12700
cmpb $0x... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::detail::type_error nlohmann::json_abi_v3_11_3::detail::type_error::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t) | static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x9248(%rip), %rsi # 0x1ba8e
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1142a
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %ebp, %edx
callq 0x11638
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x116ae
... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(std::i... | value_type const& operator*() const
{
return value_ref ? *value_ref : owned_value;
} | pushq %rbx
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
cmoveq %rsi, %rdi
cmpb $0x2, (%rdi)
jne 0x12b17
movq %rsi, %rbx
callq 0x10f3e
cmpq $0x2, %rax
jne 0x12b17
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
cmoveq %rbx, %rdi
xorl %esi, %esi
callq 0x110d4
cmpb $0x3, (%rax)
sete %al
jmp 0x12b19
xorl %eax, %eax
popq %rbx
retq
nop
| /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(nlohma... | basic_json(const basic_json& other)
: json_base_class_t(other)
{
m_data.m_type = other.m_data.m_type;
// check of passed value is valid
other.assert_invariant();
switch (m_data.m_type)
{
case value_t::object:
{
m_data.m_value =... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movb (%rsi), %al
movb %al, (%rdi)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x11194
movzbl (%rbx), %eax
decl %eax
cmpl $0x7, %eax
ja 0x12b90
leaq 0x85c8(%rip), %rcx # 0x1b114
movslq (%rcx,%rax,4), %rax
addq %r... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::detail::type_error nlohmann::json_abi_v3_11_3::detail::type_error::create<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_... | static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x823d(%rip), %rsi # 0x1ba8e
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1142a
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x11638
leaq 0x8(%rsp), %rdi
movq... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [29], char const*>(char const (&) [29], char const*&&) | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x12609
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd450
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x13af2
mov... | /pantor[P]ruckig/third_party/nlohmann/json.hpp |
main | int main(int argc, char* argv[]) {
int num_filter_order(kDefaultNumFilterOrder);
double alpha(kDefaultAlpha);
int num_stage(kDefaultNumStage);
int frame_period(kDefaultFramePeriod);
int interpolation_period(kDefaultInterpolationPeriod);
int num_pade_order(kDefaultNumPadeOrder);
bool transposition_flag(kDe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp # imm = 0x818
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc(%rsp), %rax
movl $0x19, (%rax)
movabsq $0x3fd6666666666666, %rax # imm = 0x3FD6666666666666
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rax
movl $0x0, (%rax)... | /sp-nitech[P]SPTK/src/main/imglsadf.cc |
(anonymous namespace)::InputSourcePreprocessingForMelCepstrum::Get(std::vector<double, std::allocator<double>>*) | bool Get(std::vector<double>* mlsa_digital_filter_coefficients) override {
if (!is_valid_) {
return false;
}
if (!source_->Get(&mel_cepstrum_)) {
return false;
}
if (!mel_cepstrum_to_mlsa_digital_filter_coefficients_.Run(
mel_cepstrum_, mlsa_digital_filter_coefficients)) {
... | cmpb $0x1, 0x60(%rdi)
jne 0x540b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x68(%r14), %r15
movq (%rdi), %rax
movq %r15, %rsi
callq *0x20(%rax)
testb %al, %al
je 0x540e
leaq 0x20(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x61aa
testb %al, %al
je 0x540e
movsd 0x8... | /sp-nitech[P]SPTK/src/main/imglsadf.cc |
sptk::InverseMglsaDigitalFilter::InverseMglsaDigitalFilter(int, int, int, double, bool) | InverseMglsaDigitalFilter::InverseMglsaDigitalFilter(int num_filter_order,
int num_pade_order,
int num_stage,
double alpha,
... | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0xc8fc(%rip), %rax # 0x12b98
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movsd %xmm0, 0x10(%rdi)
movb %r8b, 0x18(%rdi)
addq $0x20, %rdi
movl %r8d, %ecx
callq 0x6658
movb $0x1, 0x58(%rbx)
cmpl $0x0, 0x8(%rbx)
js 0x62e2
cmpl $0x0, ... | /sp-nitech[P]SPTK/src/filter/inverse_mglsa_digital_filter.cc |
sptk::InverseMglsaDigitalFilter::Run(std::vector<double, std::allocator<double>> const&, double, double*, sptk::InverseMglsaDigitalFilter::Buffer*) const | bool InverseMglsaDigitalFilter::Run(
const std::vector<double>& filter_coefficients, double filter_input,
double* filter_output, InverseMglsaDigitalFilter::Buffer* buffer) const {
// Check inputs.
if (!is_valid_ ||
filter_coefficients.size() !=
static_cast<std::size_t>(num_filter_order_ + 1)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpb $0x1, 0x58(%rdi)
jne 0x65a2
movq %rcx, %r12
xorl %eax, %eax
testq %rcx, %rcx
je 0x65b5
movq %rdx, %rbx
testq %rdx, %rdx
je 0x65b5
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movq %rdx, %rdi
subq %rcx, %rdi... | /sp-nitech[P]SPTK/src/filter/inverse_mglsa_digital_filter.cc |
bool sptk::ReadStream<long double>(long double*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x84ef
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
jne 0x84ef
movq %rdi, %rsi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x32b0
cmpq $0x10, 0x8(%rbx)
jne 0x84ef
movq (%rbx), %rax
movq -0x18(%rax), %rax
t... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<long double>(int, int, std::vector<long double, std::allocator<long double>> const&, std::ostream*, int*) | bool WriteStream(int write_point, int write_size,
const std::vector<T>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_size);
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
sets %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
jne 0xa403
movq %rdx, %r12
movl %esi, %r15d
movl %edi, %r13d
leal (%r15,%r13), %eax
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::Matrix::Matrix(sptk::Matrix const&) | Matrix::Matrix(const Matrix& matrix)
: num_row_(matrix.num_row_),
num_column_(matrix.num_column_),
data_(matrix.data_),
index_(num_row_) {
for (int i(0); i < num_row_; ++i) {
index_[i] = &data_[i * num_column_];
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x741f(%rip), %rax # 0x12d28
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
addq $0x10, %rsi
movq %rbx, %rdi
callq 0xc2b8
leaq 0x28(%r15), %r14
movslq 0x8(%r15), %rsi
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::Resize(int, int) | void Matrix::Resize(int num_row, int num_column) {
num_row_ = num_row < 0 ? 0 : num_row;
num_column_ = num_column < 0 ? 0 : num_column;
data_.resize(num_row_ * num_column_);
index_.resize(num_row_);
Fill(0.0);
for (int i(0); i < num_row_; ++i) {
index_[i] = &data_[i * num_column_];
}
} | pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movq %rdi, %r15
testl %edx, %edx
cmovgl %edx, %eax
movl %esi, 0x8(%rdi)
movl %eax, 0xc(%rdi)
leaq 0x10(%rdi), %rbx
imull %eax, %esi
movq %rbx, %rdi
callq 0x5ff8
leaq 0x28(%r15), %r14
movslq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xc286
... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::SymmetricMatrix::At(int, int) | double& SymmetricMatrix::At(int row, int column) {
if (row < column) {
std::swap(row, column);
}
if (column < 0 || num_dimension_ <= row) {
throw std::out_of_range(kErrorMessageForOutOfRange);
}
return index_[row][column];
} | pushq %r14
pushq %rbx
pushq %rax
cmpl %edx, %esi
movl %edx, %eax
cmovgl %esi, %eax
cmovll %esi, %edx
testl %edx, %edx
js 0xc87e
cmpl %eax, 0x8(%rdi)
jle 0xc87e
movslq %eax, %rcx
movq 0x28(%rdi), %rsi
movl %edx, %eax
shlq $0x3, %rax
addq (%rsi,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
CircularArrayTest_size_Test::TestBody() | TEST_F(CircularArrayTest, size) {
CircularArray<TestObject, 2> ca;
ASSERT_EQ(0U, ca.size());
ca.push_back(TestObject(1));
ASSERT_EQ(1U, ca.size());
ca.push_back(TestObject(2));
ASSERT_EQ(2U, ca.size());
ca.pop_back();
ASSERT_EQ(1U, ca.size());
ca.pop_back();
ASSERT_EQ(0U, ca.size());
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movl 0x19490f(%rip), %eax # 0x1d78d8
xorl %ecx, %ecx
movb $0x0, 0x28(%rsp,%rcx)
movq $0x0, 0x20(%rsp,%rcx)
leaq 0xc(%rcx), %rdx
movq %rdx, %rcx
cmpq $0x18, %rdx
jne 0x42fcb
addl $0x2, %eax
movl %eax, 0x1948e9(%rip) # 0x1d78d8
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rsp)
leaq ... | /wapm-packages[P]wabt/src/test-circular-array.cc |
wabt::CircularArray<(anonymous namespace)::TestObject, 4ul>::push_back((anonymous namespace)::TestObject const&) | void push_back(const value_type& value) {
assert(size_ < kCapacity);
SetElement(at(size_++), value);
} | movq 0x30(%rdi), %rax
cmpq $0x4, %rax
jae 0x43a82
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rdi)
addl 0x38(%rdi), %eax
andl $0x3, %eax
leaq (%rax,%rax,2), %rax
leaq (%rdi,%rax,4), %rax
cmpb $0x0, 0x8(%rax)
jne 0x43a66
incl 0x193e76(%rip) # 0x1d78dc
movb $0x0, 0x8(%rax)
movq $0x0, (%rax)
movl (%rsi), %ecx
movl %ecx... | /wapm-packages[P]wabt/include/wabt/circular-array.h |
InterpTest_Disassemble_Test::InterpTest_Disassemble_Test() | TEST_F(InterpTest, Disassemble) {
ReadModule(s_fac_module);
MemoryStream stream;
module_desc_.istream.Disassemble(&stream);
auto buf = stream.ReleaseOutputBuffer();
ExpectBufferStrEq(*buf,
R"( 0| alloca 1
8| i32.const 1
16| local.set $2, %[-1]
24| local.get $1
32| local.get $3
40| i32.eqz %[-1]... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x67472
leaq 0xf6cb2(%rip), %rax # 0x141d48
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movw $0x0, 0x10(%rsi)
movabsq $0x1000001010101, %rax # imm = 0x1000001010101
movq %rax, 0x1(%rsi)
movw $0x101, 0x9(%rsi) ... | /wapm-packages[P]wabt/src/test-interp.cc |
InterpTest_Fac_Test::InterpTest_Fac_Test() | TEST_F(InterpTest, Fac) {
ReadModule(s_fac_module);
Instantiate();
auto func = GetFuncExport(0);
Values results;
Trap::Ptr trap;
Result result = func->Call(store_, {Value::Make(5)}, results, &trap);
ASSERT_EQ(Result::Ok, result);
EXPECT_EQ(1u, results.size());
EXPECT_EQ(120u, results[0].Get<u32>());... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x67472
leaq 0xf6bae(%rip), %rax # 0x141d48
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movw $0x0, 0x10(%rsi)
movabsq $0x1000001010101, %rax # imm = 0x1000001010101
movq %rax, 0x1(%rsi)
movw $0x101, 0x9(%rsi) ... | /wapm-packages[P]wabt/src/test-interp.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [12]>(char const (&) [12]) | 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, %r15
movq %r15, %rdi
callq 0x63ca8
movq (%r15), %r12
addq $0x10, %r12
movq %r14, %rdi
callq 0x2d390
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2d910
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b55a
movq (%r15), %... | /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/gtest.h |
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 0x63ca8
movq (%r14), %r15
movq (%r12), %r14
addq $0x10, %r14
testq %r15, %r15
je 0x4b408
movq %r15, %rdi
callq 0x2d390
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
jmp 0x4b417
leaq 0x9d7f1(%ri... | /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/gtest.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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x63ca8
movq (%r15), %r12
addq $0x10, %r12
movq %r14, %rdi
callq 0x2d390
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2d910
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b55a
movq (%r15), %... | /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<wabt::ErrorLevel, wabt::ErrorLevel>(char const*, char const*, wabt::ErrorLevel const&, wabt::ErrorLevel 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,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %rcx, %rsi
callq 0x6145e
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x6145e
movq %rbx, %rdi
movq %r12, %rsi
movq %r... | /wapm-packages[P]wabt/third_party/gtest/googletest/include/gtest/gtest.h |
testing::internal::BoolFromGTestEnv(char const*, bool) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const string_value = posix::GetEnv(env_var.c_str());
return string_value == nullptr ? defaul... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x781aa
movq (%r14), %r14
movq %r14, %rdi
callq 0x2d6f0
testq %rax, %rax
je 0x61549
leaq 0x9a5ec(%rip), %rsi # 0xfbb28
movq %rax, %rdi
callq 0x2d7d0
testl %eax, %eax
setne %bl
leaq 0x18(%rsp), %rax
cmpq... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest-port.cc |
testing::internal::StringFromGTestEnv(char const*, char const*) | const char* StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const value = posix::GetEnv(env_var.c_str());
return value == nullptr ? ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x781aa
movq (%r14), %r15
movq %r15, %rdi
callq 0x2d6f0
movq %rax, %r14
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0x615af
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x2d0f0
testq %r14, %r14
... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest-port.cc |
testing::internal::OutputFlagAlsoCheckEnvVar[abi:cxx11]() | std::string OutputFlagAlsoCheckEnvVar(){
std::string default_value_for_output_flag = "";
const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
if (nullptr != xml_output_file_env) {
default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
}
return default_value_for_output_fl... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x915bb(%rip), %rdx # 0xf2b9a
movq %rdx, %rsi
callq 0x4e296
leaq 0x92245(%rip), %rdi # 0xf3833
callq 0x2d6f0
testq %rax, %rax
je 0x616b0
movq %rax, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x1... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest-port.cc |
testing::UnitTest::GetInstance() | UnitTest* UnitTest::GetInstance() {
// CodeGear C++Builder insists on a public destructor for the
// default implementation. Use this implementation to keep good OO
// design with private destructor.
#if defined(__BORLANDC__)
static UnitTest* const instance = new UnitTest;
return instance;
#else
static Un... | movb 0x1763c0(%rip), %al # 0x1d7e78
testb %al, %al
je 0x61ac4
leaq 0x17636d(%rip), %rax # 0x1d7e30
retq
pushq %rax
callq 0x2de6a
addq $0x8, %rsp
jmp 0x61abc
| /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest.cc |
testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&) | std::string AppendUserMessage(const std::string& gtest_msg,
const Message& user_msg) {
// Appends the user message if it's non-empty.
const std::string user_msg_string = user_msg.GetString();
if (user_msg_string.empty()) {
return gtest_msg;
}
return gtest_msg + "\n" + user_m... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x63e89
cmpq $0x0, 0x8(%r15)
je 0x61e41
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
call... | /wapm-packages[P]wabt/third_party/gtest/googletest/src/gtest.cc |
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.