name string | code string | asm string | file string |
|---|---|---|---|
google::protobuf::RepeatedField<double>::AddNAlreadyReserved(int) | inline Element* RepeatedField<Element>::AddNAlreadyReserved(int n) {
GOOGLE_DCHECK_GE(total_size_ - current_size_, n)
<< total_size_ << ", " << current_size_;
// Warning: sometimes people call this when n == 0 and total_size_ == 0. In
// this case the return pointer points to a zero size array (n == 0). Hen... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
subl %eax, %ecx
cmpl %esi, %ecx
jge 0x14749b
leaq 0xf8394(%rip), %rdx # 0x23f7cf
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x4f9, %ecx # ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<double>::Get(int) const | inline const Element& RepeatedField<Element>::Get(int index) const {
GOOGLE_DCHECK_GE(index, 0);
GOOGLE_DCHECK_LT(index, current_size_);
return elements()[index];
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jns 0x147613
leaq 0xf81f6(%rip), %rdx # 0x23f7cf
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x510, %ecx # imm = 0x510
callq 0x104040
leaq 0xf824f(%rip), %rsi ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<double>::InternalDeallocate(google::protobuf::RepeatedField<double>::Rep*, int) | void InternalDeallocate(Rep* rep, int size) {
if (rep != NULL) {
Element* e = &rep->elements[0];
Element* limit = &rep->elements[size];
for (; e < limit; e++) {
e->~Element();
}
if (rep->arena == NULL) {
#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)... | pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x1476cb
cmpq $0x0, (%rsi)
je 0x1476cd
popq %rbp
retq
movq %rsi, %rdi
popq %rbp
jmp 0xff870
| /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<double>::InternalSwap(google::protobuf::RepeatedField<double>*) | inline void RepeatedField<Element>::InternalSwap(RepeatedField* other) {
GOOGLE_DCHECK(this != other);
GOOGLE_DCHECK(GetArena() == other->GetArena());
// Swap all fields at once.
static_assert(std::is_standard_layout<RepeatedField<Element>>::value,
"offsetof() requires standard layout before c+... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
jne 0x147801
leaq 0xf8008(%rip), %rdx # 0x23f7cf
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x5a7, %ecx # imm = 0x5A7
callq 0x104040
leaq 0xfa966(%rip), %rsi ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<double>::operator=(google::protobuf::RepeatedField<double>&&) | inline RepeatedField<Element>& RepeatedField<Element>::operator=(
RepeatedField&& other) noexcept {
// We don't just call Swap(&other) here because it would perform 3 copies if
// the two fields are on different arenas.
if (this != &other) {
if (this->GetArena() != other.GetArena()) {
CopyFrom(other... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x14791a
movq %rsi, %r14
cmpl $0x0, 0x4(%rbx)
je 0x1478d7
movq %rbx, %rdi
callq 0xf98b0
addq $-0x8, %rax
jmp 0x1478db
leaq 0x8(%rbx), %rax
movq (%rax), %r15
cmpl $0x0, 0x4(%r14)
je 0x1478f3
movq %r14, %rdi
callq 0x... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<double>::Set(int, double const&) | inline void RepeatedField<Element>::Set(int index, const Element& value) {
GOOGLE_DCHECK_GE(index, 0);
GOOGLE_DCHECK_LT(index, current_size_);
elements()[index] = value;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jns 0x147bc8
leaq 0xf7c41(%rip), %rdx # 0x23f7cf
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movl $0x3, %esi
movl $0x52c, %ecx # imm = 0x52C
callq 0x104040
l... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<double>::Truncate(int) | inline void RepeatedField<Element>::Truncate(int new_size) {
GOOGLE_DCHECK_LE(new_size, current_size_);
if (current_size_ > 0) {
current_size_ = new_size;
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %eax
cmpl %esi, %eax
jge 0x147f70
leaq 0xf789c(%rip), %rdx # 0x23f7cf
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x63d, %ecx # imm = 0x63D
callq 0x104040
leaq 0xf885... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<double>::MergeFrom(google::protobuf::RepeatedField<double> const&) | inline void RepeatedField<Element>::MergeFrom(const RepeatedField& other) {
GOOGLE_DCHECK_NE(&other, this);
if (other.current_size_ != 0) {
int existing_size = size();
Reserve(existing_size + other.size());
AddNAlreadyReserved(other.size());
CopyArray(Mutable(existing_size), &other.Get(0), other.siz... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0x147ffd
leaq 0xf780c(%rip), %rdx # 0x23f7cf
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x57b, %ecx # imm = 0x57B
callq 0x104040
leaq 0xf79a2(%rip), %rsi ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<double>::Swap(google::protobuf::RepeatedField<double>*) | void RepeatedField<Element>::Swap(RepeatedField* other) {
if (this == other) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
RepeatedField<Element> temp(other->GetArena());
temp.MergeFrom(*this);
CopyFrom(*other);
other->UnsafeArenaSwap(&temp);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpq %rsi, %rdi
je 0x148455
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x4(%rdi)
je 0x1483be
movq %r14, %rdi
callq 0xf98b0
addq $-0x8, %rax
jmp 0x1483c2
leaq 0x8(%r14), %rax
movq (%rax), %r15
cmpl $0x0, 0x4(%rbx)
je 0x1483d9
movq %rbx, %rdi
ca... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<double>::erase(double const*) | inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
const_iterator position) {
return erase(position, position + 1);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rax
movq %rdi, %rbx
addq $0x8, %rsi
movq 0x8(%rdi), %rdx
subq %rdx, %rax
movslq (%rdi), %rcx
leaq (%rdx,%rcx,8), %r12
shrq $0x3, %rax
movslq %eax, %r14
leaq (%rdx,%r14,8), %r15
subq %rsi, %r12
je 0x148664
movq %r15, %rdi... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedField<double>::FastAdder::Add(double const&) | void Add(const Element& val) {
if (kIsPod) {
if (index_ == capacity_) {
repeated_field_->current_size_ = index_;
repeated_field_->Reserve(index_ + 1);
capacity_ = repeated_field_->total_size_;
buffer_ = repeated_field_->unsafe_elements();
}
buffer_[i... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %esi
cmpl 0xc(%rdi), %esi
jne 0x148829
movq (%rbx), %rdi
movl %esi, (%rdi)
incl %esi
callq 0xfbbd0
movq (%rbx), %rax
movl 0x4(%rax), %ecx
movl %ecx, 0xc(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rbx)
movl 0x8(%rbx), %esi
... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TypeHandler::Type const& google::protobuf::internal::RepeatedPtrFieldBase::at<google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TypeHandle... | inline const typename TypeHandler::Type& RepeatedPtrFieldBase::at(
int index) const {
GOOGLE_CHECK_GE(index, 0);
GOOGLE_CHECK_LT(index, current_size_);
return *cast<TypeHandler>(rep_->elements[index]);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jns 0x148cbf
leaq 0xf6b4a(%rip), %rdx # 0x23f7cf
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x6a5, %ecx # imm = 0x6A5
callq 0x104040
leaq 0xf6ba3(%rip), %rsi ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::DeleteSubrange(int, int) | inline void RepeatedPtrField<Element>::DeleteSubrange(int start, int num) {
GOOGLE_DCHECK_GE(start, 0);
GOOGLE_DCHECK_GE(num, 0);
GOOGLE_DCHECK_LE(start + num, size());
for (int i = 0; i < num; ++i) {
RepeatedPtrFieldBase::Delete<TypeHandler>(start + i);
}
ExtractSubrange(start, num, NULL);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
testl %esi, %esi
jns 0x148f06
leaq 0xf6903(%rip), %rdx # 0x23f7cf
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movl $0x3, %esi
movl $0x894, %ecx # imm = 0x894
call... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::internal::RepeatedPtrFieldBase::InternalSwap(google::protobuf::internal::RepeatedPtrFieldBase*) | void RepeatedPtrFieldBase::InternalSwap(RepeatedPtrFieldBase* other) {
GOOGLE_DCHECK(this != other);
GOOGLE_DCHECK(GetArena() == other->GetArena());
// Swap all fields at once.
static_assert(std::is_standard_layout<RepeatedPtrFieldBase>::value,
"offsetof() requires standard layout before c++17"... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
jne 0x1491cb
leaq 0xf663e(%rip), %rdx # 0x23f7cf
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0xa11, %ecx # imm = 0xA11
callq 0x104040
leaq 0xf8f9c(%rip), %rsi ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::SpaceUsedExcludingSelfLong() const | inline size_t RepeatedPtrField<Element>::SpaceUsedExcludingSelfLong() const {
return RepeatedPtrFieldBase::SpaceUsedExcludingSelfLong<TypeHandler>();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq 0xc(%rdi), %rbx
shlq $0x3, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x14943e
cmpl $0x0, (%rax)
jle 0x14943a
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%rax,%r15,8), %rdi
callq 0x106770
addq %rax, %rbx
addq $0x20, %rbx
incq %r15
movq 0x1... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ExtractSubrangeInternal(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>**, std::integral_constant<bool, true>) | inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
int start, int num, Element** elements, std::true_type) {
GOOGLE_DCHECK_GE(start, 0);
GOOGLE_DCHECK_GE(num, 0);
GOOGLE_DCHECK_LE(start + num, size());
if (num > 0) {
// Save the values of the removed elements if requested.
if (elements... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebx
movl %esi, %r14d
testl %esi, %esi
movq %rcx, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
js 0x14969e
movq %rcx, %r12
movq %rdi, %r13
jmp 0x1496ed
leaq 0xf612a(%rip), %rdx # 0x23f7cf
leaq -0x88(%rbp), %r13
movq ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::RepeatedPtrFieldBase::AddCleared<google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TypeHandler>(google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TypeHandl... | inline void RepeatedPtrFieldBase::AddCleared(
typename TypeHandler::Type* value) {
GOOGLE_DCHECK(GetArena() == NULL)
<< "AddCleared() can only be used on a RepeatedPtrField not on an arena.";
GOOGLE_DCHECK(TypeHandler::GetArena(value) == NULL)
<< "AddCleared() can only accept values not on an arena.... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x149a61
leaq 0xf5db7(%rip), %rdx # 0x23f7cf
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x7ff, %ecx # imm = 0x7FF
callq 0x104040
leaq 0xf5e7f(%rip), %rsi ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::erase(google::protobuf::internal::RepeatedPtrIterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const>) | inline typename RepeatedPtrField<Element>::iterator
RepeatedPtrField<Element>::erase(const_iterator position) {
return erase(position, position + 1);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
subq %rcx, %rbx
movq %rbx, %rsi
shrq $0x3, %rsi
leaq 0x8(%rbx), %rdx
shrq $0x3, %rdx
subl %esi, %edx
callq 0x1060f0
movq 0x10(%r14), %rax
leaq 0x8(%rax), %rcx
te... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::RepeatedPtrFieldBase::SwapFallback<google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TypeHandler>(google::protobuf::internal::RepeatedPtrFieldBase*) | void RepeatedPtrFieldBase::SwapFallback(RepeatedPtrFieldBase* other) {
GOOGLE_DCHECK(other->GetArena() != GetArena());
// Copy semantics in this case. We try to improve efficiency by placing the
// temporary on |other|'s arena so that messages are copied twice rather than
// three times.
RepeatedPtrFieldBase... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq (%rdi), %rax
jne 0x149e1b
leaq 0xf59f1(%rip), %rdx # 0x23f7cf
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x689, %ecx # imm = 0x689
callq 0x104040
leaq 0xf8... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::RepeatedPtrFieldBase::AddAllocatedSlowWithCopy<google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TypeHandler>(google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char... | void RepeatedPtrFieldBase::AddAllocatedSlowWithCopy(
// Pass value_arena and my_arena to avoid duplicate virtual call (value) or
// load (mine).
typename TypeHandler::Type* value, Arena* value_arena, Arena* my_arena) {
// Ensure that either the value is in the same arena, or if not, we do the
// appropr... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %rbx
testq %rcx, %rcx
sete %al
testq %rdx, %rdx
setne %cl
orb %al, %cl
jne 0x149f0d
movq %r12, %rdi
movq %r14, %rsi
callq 0x106da0
jmp 0x149f38
movq %rdx, %r15
cmpq %rdx, %r12
je 0x149f38
testq %r12, %r12
j... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TypeHandler::Type* google::protobuf::internal::RepeatedPtrFieldBase::ReleaseLastInternal<google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>:... | inline typename TypeHandler::Type* RepeatedPtrFieldBase::ReleaseLastInternal(
std::true_type) {
// First, release an element.
typename TypeHandler::Type* result = UnsafeArenaReleaseLast<TypeHandler>();
// Now perform a copy if we're on an arena.
Arena* arena = GetArena();
if (arena == NULL) {
return r... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jg 0x14a055
leaq 0xf57b7(%rip), %rdx # 0x23f7cf
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x7ec, %ecx # imm = 0x7EC
callq 0x104040
leaq 0xf5859(%rip), %rsi # 0x23... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/repeated_field.h |
google::protobuf::strings::UncheckedArrayByteSink::Append(char const*, unsigned long) | void UncheckedArrayByteSink::Append(const char* data, size_t n) {
if (data != dest_) {
// Catch cases where the pointer returned by GetAppendBuffer() was modified.
GOOGLE_DCHECK(!(dest_ <= data && data < (dest_ + n)))
<< "Append() data[] overlaps with dest_[]";
memcpy(dest_, data, n);
}
dest_ ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
cmpq %rsi, %rdi
je 0x14a232
movq %rsi, %r15
setbe %al
leaq (%rdi,%rbx), %rcx
cmpq %rsi, %rcx
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x14a223
leaq 0xf821a(%rip), %rdx # 0x24... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.cc |
google::protobuf::strings::CheckedArrayByteSink::Append(char const*, unsigned long) | void CheckedArrayByteSink::Append(const char* bytes, size_t n) {
size_t available = capacity_ - size_;
if (n > available) {
n = available;
overflowed_ = true;
}
if (n > 0 && bytes != (outbuf_ + size_)) {
// Catch cases where the pointer returned by GetAppendBuffer() was modified.
GOOGLE_DCHECK(!... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdi
movq %rcx, %rax
subq %rdi, %rax
cmpq %rdx, %rax
jae 0x14a2b6
movb $0x1, 0x20(%rbx)
movq %rax, %r14
testq %r14, %r14
je 0x14a350
movq 0x8(%rb... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.cc |
google::protobuf::strings::GrowingArrayByteSink::Expand(unsigned long) | void GrowingArrayByteSink::Expand(size_t amount) { // Expand by at least 50%.
size_t new_capacity = std::max(capacity_ + amount, (3 * capacity_) / 2);
char* bigger = new char[new_capacity];
memcpy(bigger, buf_, size_);
delete[] buf_;
buf_ = bigger;
capacity_ = new_capacity;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
addq %rax, %rsi
leaq (%rax,%rax,2), %r14
shrq %r14
cmpq %r14, %rsi
cmovaq %rsi, %r14
movq %r14, %rdi
callq 0xf90d0
movq %rax, %r15
movq 0x10(%rbx), %r12
movq 0x18(%rbx), %rdx
movq %rax, %rdi
movq %r12, %rsi
callq... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.cc |
google::protobuf::strings::GrowingArrayByteSink::GetBuffer(unsigned long*) | char* GrowingArrayByteSink::GetBuffer(size_t* nbytes) {
ShrinkToFit();
char* b = buf_;
*nbytes = size_;
buf_ = nullptr;
size_ = capacity_ = 0;
return b;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x101ab0
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq %rcx, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq $0x0, 0x18(%r14)
popq %rbx
popq %r14
popq %rbp
retq
| /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.cc |
google::protobuf::strings::GrowingArrayByteSink::ShrinkToFit() | void GrowingArrayByteSink::ShrinkToFit() {
// Shrink only if the buffer is large and size_ is less than 3/4
// of capacity_.
if (capacity_ > 256 && size_ < (3 * capacity_) / 4) {
char* just_enough = new char[size_];
memcpy(just_enough, buf_, size_);
delete[] buf_;
buf_ = just_enough;
capacity_... | movq 0x8(%rdi), %rax
cmpq $0x101, %rax # imm = 0x101
jb 0x14a5d9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq (%rax,%rax,2), %rax
shrq $0x2, %rax
cmpq %rax, %r14
jae 0x14a5d1
movq %r14, %rdi
callq 0xf90d0
movq %rax, %r15
movq 0x10(%rbx), %r... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.cc |
google::protobuf::strings::ArrayByteSource::Skip(unsigned long) | void ArrayByteSource::Skip(size_t n) {
GOOGLE_DCHECK_LE(n, input_.size());
input_.remove_prefix(n);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
jae 0x14a661
leaq 0xf7dcd(%rip), %rdx # 0x2423f0
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x9d, %ecx
callq 0x104040
leaq 0xf7f7d(%rip), %rsi # 0x... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.cc |
google::protobuf::strings::LimitByteSource::Skip(unsigned long) | void LimitByteSource::Skip(size_t n) {
GOOGLE_DCHECK_LE(n, limit_);
source_->Skip(n);
limit_ -= n;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x10(%rdi)
jae 0x14a794
leaq 0xf7c96(%rip), %rdx # 0x2423f0
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0xb9, %ecx
callq 0x104040
leaq 0xf7e6d(%rip), %rsi # 0x2425e4
movq %r15... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.cc |
google::protobuf::strings::LimitByteSource::CopyTo(google::protobuf::strings::ByteSink*, unsigned long) | void LimitByteSource::CopyTo(ByteSink *sink, size_t n) {
GOOGLE_DCHECK_LE(n, limit_);
source_->CopyTo(sink, n);
limit_ -= n;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdx, 0x10(%rdi)
jae 0x14a825
leaq 0xf7c05(%rip), %rdx # 0x2423f0
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movl $0x3, %esi
movl $0xbf, %ecx
callq 0x104040
leaq 0xf7ddc(%rip), %r... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.cc |
google::protobuf::strings::UncheckedArrayByteSink::~UncheckedArrayByteSink() | class PROTOBUF_EXPORT UncheckedArrayByteSink : public ByteSink {
public:
explicit UncheckedArrayByteSink(char* dest) : dest_(dest) {}
virtual void Append(const char* data, size_t n) override;
// Returns the current output pointer so that a caller can see how many bytes
// were produced.
//
// Note: this m... | pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0xff870
| /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.h |
google::protobuf::strings::StringByteSink::~StringByteSink() | class PROTOBUF_EXPORT StringByteSink : public ByteSink {
public:
explicit StringByteSink(string* dest) : dest_(dest) {}
virtual void Append(const char* data, size_t n) override;
private:
string* dest_;
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringByteSink);
} | pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0xff870
| /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.h |
google::protobuf::strings::ArrayByteSource::~ArrayByteSource() | class PROTOBUF_EXPORT ArrayByteSource : public ByteSource {
public:
explicit ArrayByteSource(StringPiece s) : input_(s) {}
virtual size_t Available() const override;
virtual StringPiece Peek() override;
virtual void Skip(size_t n) override;
private:
StringPiece input_;
GOOGLE_DISALLOW_EVIL_CONSTRUCTOR... | pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0xff870
| /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.h |
google::protobuf::strings::CheckedArrayByteSink::~CheckedArrayByteSink() | class PROTOBUF_EXPORT CheckedArrayByteSink : public ByteSink {
public:
CheckedArrayByteSink(char* outbuf, size_t capacity);
virtual void Append(const char* bytes, size_t n) override;
// Returns the number of bytes actually written to the sink.
size_t NumberOfBytesWritten() const { return size_; }
// Return... | pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0xff870
| /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/bytestream.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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movl %edi, %r14d
cmpl $0x2df5a5, %esi # imm = 0x2DF5A5
jl 0x14a9a1
movl %esi, %r12d
leaq 0xf7f42(%rip), %rdx # 0x24280c
leaq -0x98(%rbp), %rdi
movl $0x3, %esi
movl $0x4c, %ecx
callq 0x104040
leaq -0x80(%r... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/common.cc |
google::protobuf::internal::VersionString[abi:cxx11](int) | 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 %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movslq %esi, %r9
imulq $0x431bde83, %r9, %rcx # imm = 0x431BDE83
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x32, %rcx
addl %eax, %ecx
imulq $0x10624dd3, %r9, %rax # imm = 0x10624DD3
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rax
addl %e... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/common.cc |
google::protobuf::internal::DefaultLogHandler(google::protobuf::LogLevel, char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void DefaultLogHandler(LogLevel level, const char* filename, int line,
const string& message) {
if (level < GOOGLE_PROTOBUF_MIN_LOG_LEVEL) {
return;
}
static const char* level_names[] = { "INFO", "WARNING", "ERROR", "FATAL" };
// We use fprintf() instead of cerr because we want this ... | testl %edi, %edi
jns 0x14ac04
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %r8d
movq %rsi, %rax
movq 0x173e81(%rip), %rbx # 0x2bea98
movq (%rbx), %r10
movl %edi, %edx
leaq 0xf7f55(%rip), %rsi # 0x242b78
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
movq (%rcx), %r9
leaq 0xf7f0d(%rip), %rsi #... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/common.cc |
google::protobuf::internal::LogMessage::operator<<(google::protobuf::StringPiece const&) | LogMessage& LogMessage::operator<<(const StringPiece& value) {
message_ += value.ToString();
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x14ac93
leaq -0x20(%rbp), %rcx
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rcx, -0x10(%rcx)
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0xfb680
movq (%r14), %rsi
movq 0x8(%r14), %rdx
... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/common.cc |
google::protobuf::internal::LogMessage::operator<<(google::protobuf::util::Status const&) | LogMessage& LogMessage::operator<<(const util::Status& status) {
message_ += status.ToString();
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0xfd3d0
leaq 0x18(%rbx), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0xfae50
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14ad28
callq 0xff870
movq %rbx, %rax
addq $... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/common.cc |
google::protobuf::ghtonl(unsigned int) | uint32 ghtonl(uint32 x) {
union {
uint32 result;
uint8 result_array[4];
};
result_array[0] = static_cast<uint8>(x >> 24);
result_array[1] = static_cast<uint8>((x >> 16) & 0xFF);
result_array[2] = static_cast<uint8>((x >> 8) & 0xFF);
result_array[3] = static_cast<uint8>(x & 0xFF);
return result;
} | pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
bswapl %eax
popq %rbp
retq
| /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/common.cc |
google::protobuf::FatalException::~FatalException() | FatalException::~FatalException() throw() {} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x173238(%rip), %rax # 0x2be478
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x14b259
callq 0xff870
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x105d70
nop
| /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/common.cc |
google::protobuf::FatalException::FatalException(char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | FatalException(const char* filename, int line, const std::string& message)
: filename_(filename), line_(line), message_(message) {} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1731d9(%rip), %rax # 0x2be478
addq $0x10, %rax
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movl %edx, 0x10(%rdi)
addq $0x18, %rdi
leaq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
callq 0xfb730
popq %r... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/common.h |
google::protobuf::uint128::DivModImpl(google::protobuf::uint128, google::protobuf::uint128, google::protobuf::uint128*, google::protobuf::uint128*) | void uint128::DivModImpl(uint128 dividend, uint128 divisor,
uint128* quotient_ret, uint128* remainder_ret) {
if (divisor == 0) {
GOOGLE_LOG(FATAL) << "Division or mod by zero: dividend.hi=" << dividend.hi_
<< ", lo=" << dividend.lo_;
} else if (dividend < divisor) ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rax
orq %rcx, %rax
jne 0x14b396
leaq 0xf78d6(%rip), %rdx # 0x242c08
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x56, %ecx
callq 0x104040
leaq 0xf792e(%rip)... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/int128.cc |
google::protobuf::Fls128(google::protobuf::uint128) | static inline int Fls128(uint128 n) {
if (uint64 hi = Uint128High64(n)) {
return Fls64(hi) + 64;
}
return Fls64(Uint128Low64(n));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
testq %rsi, %rsi
je 0x14b52c
xorl %eax, %eax
movq %rsi, %rcx
shrq $0x20, %rcx
cmoveq %rsi, %rcx
setne %al
shll $0x5, %eax
movl %ecx, %edx
shrl $0x10, %edx
leal 0x10(%rax), %esi
cmpq $0x10000, %rcx # imm = 0x10000
cmovbl %eax, %esi
cmovbl %ecx, %... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/int128.cc |
google::protobuf::operator<<(std::ostream&, google::protobuf::uint128 const&) | std::ostream& operator<<(std::ostream& o, const uint128& b) {
std::ios_base::fmtflags flags = o.flags();
// Select a divisor which is the largest power of the base < 2^64.
uint128 div;
std::streamsize div_base_log;
switch (flags & std::ios::basefield) {
case std::ios::hex:
div =
static_ca... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %r13d
movl %r13d, %eax
andl $0x4a, %eax
cmpl $0x8, %eax
je 0x14b6d4
cmpl $0x40, %eax
jne 0x14b6e9
mo... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/int128.cc |
google::protobuf::util::internal::StatusOrHelper::Crash(google::protobuf::util::Status const&) | void StatusOrHelper::Crash(const Status& status) {
GOOGLE_LOG(FATAL) << "Attempting to fetch value instead of handling error "
<< status.ToString();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0xf6f53(%rip), %rdx # 0x242de4
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x29, %ecx
callq 0x104040
leaq 0xf6fad(%rip), %rsi # 0x242e5b
movq %r14, %rdi
callq 0x104760
movq %rax, %r14
leaq -0x38(%rbp), %rdi
m... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/statusor.cc |
google::protobuf::StringPiece::rfind(char, unsigned long) const | stringpiece_ssize_type StringPiece::rfind(char c, size_type pos) const {
// Note: memrchr() is not available on Windows.
if (length_ <= 0) return npos;
for (stringpiece_ssize_type i =
std::min(pos, static_cast<size_type>(length_ - 1));
i >= 0; --i) {
if (ptr_[i] == c) {
return i;
}
}
... | movq 0x8(%rdi), %rcx
movq $-0x1, %rax
testq %rcx, %rcx
jle 0x14c439
pushq %rbp
movq %rsp, %rbp
decq %rcx
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
movq (%rdi), %rdx
cmpb %sil, (%rdx,%rcx)
je 0x14c435
leaq -0x1(%rcx), %rdi
testq %rcx, %rcx
movq %rdi, %rcx
jg 0x14c421
jmp 0x14c438
movq %rcx, %rax
popq %rbp
retq
| /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/stringpiece.cc |
google::protobuf::StringPiece::find_first_not_of(google::protobuf::StringPiece, unsigned long) const | stringpiece_ssize_type StringPiece::find_first_not_of(StringPiece s,
size_type pos) const {
if (length_ <= 0) return npos;
if (s.length_ <= 0) return 0;
// Avoid the cost of BuildLookupTable() for a single-character search.
if (s.length_ == 1) return find_fi... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq 0x8(%rdi), %r13
movq $-0x1, %rax
testq %r13, %r13
jle 0x14c5c3
movq %rdx, %r12
testq %rdx, %rdx
jle 0x14c562
movq %rcx, %rbx
movq %rsi, %r15
cmpq $0x1, %r12
jne 0x14c566
cmpq %rbx, %r13
jbe ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/stringpiece.cc |
google::protobuf::StringPiece::find_last_not_of(google::protobuf::StringPiece, unsigned long) const | stringpiece_ssize_type StringPiece::find_last_not_of(StringPiece s,
size_type pos) const {
if (length_ <= 0) return npos;
stringpiece_ssize_type i = std::min(pos, static_cast<size_type>(length_ - 1));
if (s.length_ <= 0) return i;
// Avoid the cost of Build... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq 0x8(%rdi), %r12
movq $-0x1, %rax
testq %r12, %r12
jle 0x14c7ac
movq %rdx, %r15
decq %r12
cmpq %rcx, %r12
cmovaeq %rcx, %r12
testq %rdx, %rdx
jle 0x14c7a9
movq %rsi, %r14
movq %rdi, %rbx
cmpq... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/stringpiece.cc |
google::protobuf::SStringPrintf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, ...) | const string& SStringPrintf(string* dst, const char* format, ...) {
va_list ap;
va_start(ap, format);
dst->clear();
StringAppendV(dst, format, ap);
va_end(ap);
return *dst;
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq -0xd0(%rbp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x14cde4
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %x... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/stringprintf.cc |
google::protobuf::StringPrintfVector(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&) | string StringPrintfVector(const char* format, const std::vector<string>& v) {
GOOGLE_CHECK_LE(v.size(), kStringPrintfVectorMaxArgs)
<< "StringPrintfVector currently only supports up to "
<< kStringPrintfVectorMaxArgs << " arguments. "
<< "Feel free to add support for more if you need it.";
// Add... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rcx
movq 0x8(%rdx), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
cmpq $0x401, %rdx # imm = 0x401
jb 0x14cf5e
leaq 0xf61c9(%rip), %rdx # 0... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/stringprintf.cc |
google::protobuf::internal::UTF8GenericScan(google::protobuf::internal::UTF8StateMachineObj const*, char const*, int, int*) | int UTF8GenericScan(const UTF8ScanObj* st,
const char * str,
int str_length,
int* bytes_consumed) {
*bytes_consumed = 0;
if (str_length == 0) return kExitOK;
int eshift = st->entry_shift;
const uint8* isrc = reinterpret_cast<const uint8*>(str);
cons... | movl $0x0, (%rcx)
testl %edx, %edx
je 0x14d292
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rsi, %r8
movl (%rdi), %r12d
movl 0x10(%rdi), %ecx
movslq %edx, %rax
leaq (%rsi,%rax), %r10
cmpl $0x7, %edx
leaq -0x7(%rsi,%rax), %rax
cmovlq %rsi, %rax
movq %rax, -0x40(... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/structurally_valid.cc |
google::protobuf::internal::UTF8GenericScanFastAscii(google::protobuf::internal::UTF8StateMachineObj const*, char const*, int, int*) | int UTF8GenericScanFastAscii(const UTF8ScanObj* st,
const char * str,
int str_length,
int* bytes_consumed) {
*bytes_consumed = 0;
if (str_length == 0) return kExitOK;
const uint8* isrc = reinterpret_cast<const uint8*>(str);
const uint8* src = isrc;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x40(%rbp)
movl $0x0, (%rcx)
testl %edx, %edx
je 0x14d3ce
movl %edx, %r15d
movq %rsi, %r14
movq %rcx, -0x38(%rbp)
movslq %edx, %rax
leaq (%rsi,%rax), %rbx
cmpl $0x7, %edx
leaq -0x7(%rsi,%rax), %r13
cmovlq %rsi... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/structurally_valid.cc |
google::protobuf::internal::UTF8CoerceToStructurallyValid(google::protobuf::StringPiece const&, char*, char) | char* UTF8CoerceToStructurallyValid(const StringPiece& src_str,
char* idst,
const char replace_char) {
const char* isrc = src_str.data();
const int len = src_str.length();
int n = UTF8SpnStructurallyValid(src_str);
if (n == len) { ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x30(%rbp)
movq %rsi, %r15
movq (%rdi), %rbx
movq 0x8(%rdi), %r14
callq 0x102d30
cmpl %r14d, %eax
je 0x14d519
movslq %r14d, %r14
movslq %eax, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x104410... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/structurally_valid.cc |
google::protobuf::ReplaceCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char) | void ReplaceCharacters(string *s, const char *remove, char replacewith) {
const char *str_start = s->c_str();
const char *str = str_start;
for (str = strpbrk(str, remove);
str != nullptr;
str = strpbrk(str + 1, remove)) {
(*s)[str - str_start] = replacewith;
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %r12
movq %r12, %rdi
callq 0x105400
testq %rax, %rax
je 0x14d586
movq %rax, %rcx
subq %r12, %rcx
movq (%r15), %rdx
movb %bl, (%rdx,%rcx)
incq %rax
movq %rax, %rdi
movq %r14, %rsi
jmp 0x14d... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::StripWhitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | void StripWhitespace(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 (first > 0... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testl %r14d, %r14d
jle 0x14d642
movl %r14d, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x14d65d
movq (%rbx), %rcx
movzbl (%rcx,%r15), %ecx
leal -0x9(%rcx), %edx
cmpl... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::StringReplace(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_s... | void StringReplace(const string& s, const string& oldsub,
const string& newsub, bool replace_all,
string* res) {
if (oldsub.empty()) {
res->append(s); // if empty, append the given string.
return;
}
string::size_type start_pos = 0;
string::size_type pos;
do {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, -0x40(%rbp)
movq %rdi, %r12
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x14d6fc
movq %rsi, %r13
movq %r8, -0x38(%rbp)
xorl %ebx, %ebx
movq -0x38(%rbp), %r14
movq (%r13), %rsi
movq %r12, %rd... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::StringReplace(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) | string StringReplace(const string& s, const string& oldsub,
const string& newsub, bool replace_all) {
string ret;
StringReplace(s, oldsub, newsub, replace_all, &ret);
return ret;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movl %r8d, %ecx
movq %rbx, %r8
callq 0x1034f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::SplitStringUsing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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(const string& full,
const char* delim,
std::vector<string>* result) {
std::back_insert_iterator< std::vector<string> > it(*result);
SplitStringToIteratorUsing(full, delim, it);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r14
movb (%rsi), %bl
testb %bl, %bl
je 0x14d7c9
cmpb $0x0, 0x1(%r15)
je 0x14d8a6
movq %r15, %rdi
callq 0xfbac0
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, ... | /LLNL[P]wcs/build_O3/src/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<string>& components,
const char* delim,
string * result) {
JoinStringsIterator(components.begin(), components.end(), delim, result);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, -0x38(%rbp)
movq (%rdi), %r12
movq 0x8(%rdi), %r13
testq %rdx, %rdx
jne 0x14dacc
leaq 0xf6726(%rip), %rdx # 0x2441b8
leaq -0x70(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x10d, %ecx ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::UnescapeCEscapeSequences(char const*, char*, 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>>>>*) | int UnescapeCEscapeSequences(const char* source, char* dest,
std::vector<string> *errors) {
GOOGLE_DCHECK(errors == nullptr) << "Error reporting not implemented.";
char* d = dest;
const char* p = source;
// Small optimization for case where source = dest and there's no escaping
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x14dbf7
leaq 0xf660a(%rip), %rdx # 0x2441b8
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x142, %ecx # imm = 0x142
callq 0x104040
leaq 0xf6663(%rip), %rsi ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::UnescapeCEscapeString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string UnescapeCEscapeString(const string& src) {
std::unique_ptr<char[]> unescaped(new char[src.size() + 1]);
int len = UnescapeCEscapeSequences(src.c_str(), unescaped.get(), nullptr);
return string(unescaped.get(), len);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rdi
incq %rdi
callq 0xf90d0
movq %rax, %rbx
movq (%r15), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xfd150
cltq
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq %rbx, %rdx
addq %rax, %rdx
movq %r14, %rdi... | /LLNL[P]wcs/build_O3/src/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movq %rdx, %rbx
testl %esi, %esi
jle 0x14e0b8
movq %rdi, %r13
movslq %esi, %r12
addq %rdi, %r12
leaq 0xf62f0(%rip), %rax # 0x244286
leaq 0xf62f0(%rip), %rsi # 0x24428d
testb %r8b, %r8b
cmovneq %ra... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::CEscapeAndAppend(google::protobuf::StringPiece, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | void CEscapeAndAppend(StringPiece src, string* dest) {
size_t escaped_len = CEscapedLength(src);
if (escaped_len == src.size()) {
dest->append(src.data(), src.size());
return;
}
size_t cur_dest_len = dest->size();
dest->resize(cur_dest_len + escaped_len);
char* append_ptr = &(*dest)[cur_dest_len];
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x50(%rbp)
testq %rsi, %rsi
jle 0x14e141
xorl %r13d, %r13d
leaq -0x58(%rbp), %... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::CEscape(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string CEscape(const string& src) {
string dest;
CEscapeAndAppend(src, &dest);
return dest;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
testq %r15, %r15
jns 0x14e27e
leaq 0xeff26(%rip), %rsi # 0x23e19c
movq %r15, %rdi
callq 0xfd670
movq %r14, ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::strings::Utf8SafeCEscape(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string Utf8SafeCEscape(const 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, false, true);
GOOGLE_DCHEC... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rsi), %r12d
leal (,%r12,4), %eax
leal 0x1(,%r12,4), %r13d
testl %eax, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnsl %r13d, %eax
movslq %eax, %rdi
callq 0xf90d0
movq... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::strings::CHexEscape(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string CHexEscape(const 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_DCHECK_GE(... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rsi), %r12d
leal (,%r12,4), %eax
leal 0x1(,%r12,4), %r13d
testl %eax, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnsl %r13d, %eax
movslq %eax, %rdi
callq 0xf90d0
movq... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::strto32_adaptor(char const*, char**, int) | int32 strto32_adaptor(const char *nptr, char **endptr, int base) {
const int saved_errno = errno;
errno = 0;
const long result = strtol(nptr, endptr, base);
if (errno == ERANGE && result == LONG_MIN) {
return kint32min;
} else if (errno == ERANGE && result == LONG_MAX) {
return kint32max;
} else if ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
callq 0xf93a0
movq %rax, %rbx
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%rbx)
movq %r12, %rdi
movq %r15, %... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::strtou32_adaptor(char const*, char**, int) | uint32 strtou32_adaptor(const char *nptr, char **endptr, int base) {
const int saved_errno = errno;
errno = 0;
const unsigned long result = strtoul(nptr, endptr, base);
if (errno == ERANGE && result == ULONG_MAX) {
return kuint32max;
} else if (errno == 0 && result > kuint32max) {
errno = ERANGE;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
callq 0xf93a0
movq %rax, %rbx
movl (%rax), %r13d
movl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xfafb0
movl (%rbx), %edx
cmpl $0x22, %edx
sete %sil
cmp... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::FastInt32ToBuffer(int, char*) | char *FastInt32ToBuffer(int32 i, char* buffer) {
// We could collapse the positive and negative sections, but that
// would be slightly slower for positive numbers...
// 12 bytes is enough to store -2**32, -4294967296.
char* p = buffer + kFastInt32ToBufferOffset;
*p-- = '\0';
if (i >= 0) {
do {
*p... | pushq %rbp
movq %rsp, %rbp
movb $0x0, 0xb(%rsi)
testl %edi, %edi
js 0x14e719
addq $0xb, %rsi
movl $0xcccccccd, %ecx # imm = 0xCCCCCCCD
leaq -0x1(%rsi), %rax
movl %edi, %edx
imulq %rcx, %rdx
shrq $0x23, %rdx
leal (%rdx,%rdx), %r8d
leal (%r8,%r8,4), %r8d
movl %edi, %r9d
subl %r8d, %r9d
orb $0x30, %r9b
movb %r9b, -0... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::FastHexToBuffer(int, char*) | char *FastHexToBuffer(int i, char* buffer) {
GOOGLE_CHECK(i >= 0) << "FastHexToBuffer() wants non-negative integers, not " << i;
static const char *hexdigits = "0123456789abcdef";
char *p = buffer + 21;
*p-- = '\0';
do {
*p-- = hexdigits[i & 15]; // mod by 16
i >>= 4; // divide b... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %r14d
testl %edi, %edi
jns 0x14e7fa
leaq 0xf5a12(%rip), %rdx # 0x2441b8
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x37d, %ecx # imm = 0x37D
callq 0x104040
leaq 0xf5ad0(%rip), %rsi ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::InternalFastHexToBuffer(unsigned long, char*, int) | char *InternalFastHexToBuffer(uint64 value, char* buffer, int num_byte) {
static const char *hexdigits = "0123456789abcdef";
buffer[num_byte] = '\0';
for (int i = num_byte - 1; i >= 0; i--) {
#ifdef _M_X64
// MSVC x64 platform has a bug optimizing the uint32(value) in the #else
// block. Given that the ui... | pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
movslq %edx, %rcx
movb $0x0, (%rsi,%rcx)
testl %ecx, %ecx
jle 0x14e87e
movl %edx, %ecx
incq %rcx
leaq 0xf5f3d(%rip), %rdx # 0x2447a0
movl %edi, %esi
andl $0xf, %esi
movb (%rsi,%rdx), %sil
movb %sil, -0x2(%rax,%rcx)
shrq $0x4, %rdi
decq %rcx
cmpq $0x1, %rcx
ja 0x14e863
popq... | /LLNL[P]wcs/build_O3/src/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);
} | pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
jns 0x14ea80
movb $0x2d, (%rsi)
incq %rsi
negl %edi
popq %rbp
jmp 0x105760
| /LLNL[P]wcs/build_O3/src/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq %rdi, %rax
shrq $0x20, %rax
jne 0x14eab1
movl %r14d, %edi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x105760
movq %r14, %rax
shrq $0x9, %rax
movabsq $0x44b82fa09b5a53, %rcx # imm = 0x44B82FA09B5A53
mulq ... | /LLNL[P]wcs/build_O3/src/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);
} | pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
jns 0x14ebeb
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
popq %rbp
jmp 0xfed90
| /LLNL[P]wcs/build_O3/src/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x90(%rbp), %r15
movq %r15, %rsi
callq 0xfe3e0
movq (%r15), %r15
testq %rbx, %rbx
je 0x14f185
movq %r15, (%rbx)
cmpb $0x2e, (%r15)
jne 0x14f361
leaq 0xf54e9(%rip), %rdx # 0x24467f... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::safe_strtob(google::protobuf::StringPiece, bool*) | bool safe_strtob(StringPiece str, bool* value) {
GOOGLE_CHECK(value != nullptr) << "nullptr output boolean given.";
if (CaseEqual(str, "true") || CaseEqual(str, "t") ||
CaseEqual(str, "yes") || CaseEqual(str, "y") ||
CaseEqual(str, "1")) {
*value = true;
return true;
}
if (CaseEqual(str, "fa... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
jne 0x14f41b
leaq 0xf4dec(%rip), %rdx # 0x2441b8
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
movl $0x3, %esi
movl $0x51f, %ecx # imm = 0x51F
callq 0x104040
l... | /LLNL[P]wcs/build_O3/src/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0xf93a0
movq %rax, %rbx
movl $0x0, (%rax)
leaq -0x20(%rbp), %rsi
movq %r15, %rdi
callq 0x102210
movss %xmm0, (%r14)
cmpb $0x0, (%r15)
je 0x14f71e
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x14f722
xorl %eax, %... | /LLNL[P]wcs/build_O3/src/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rsi
callq 0xfa780
movsd %xmm0, (%r14)
movq (%r15), %rax
cmpq %rbx, %rax
je 0x14f775
movzbl (%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jae 0x14f770
incq %rax
movq %rax, -0x20(... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::safe_strto32(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int*) | bool safe_strto32(const string& str, int32* value) {
return safe_int_internal(str, value);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xfb730
movq %r14, %rdi
movq %rbx, %rsi
callq 0x101ec0
movl %eax, %ebx
movq -0x38... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::safe_strtou32(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int*) | bool safe_strtou32(const string& str, uint32* value) {
return safe_uint_internal(str, value);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xfb730
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf9f80
movl %eax, %ebx
movq -0x38(... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::safe_strto64(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long*) | bool safe_strto64(const string& str, int64* value) {
return safe_int_internal(str, value);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xfb730
movq %r14, %rdi
movq %rbx, %rsi
callq 0xff280
movl %eax, %ebx
movq -0x38(... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::safe_strtou64(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long*) | bool safe_strtou64(const string& str, uint64* value) {
return safe_uint_internal(str, value);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xfb730
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfc7d0
movl %eax, %ebx
movq -0x38(... | /LLNL[P]wcs/build_O3/src/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... | pushq %rbp
movq %rsp, %rbp
leaq 0x30(%rdi), %rax
shll $0x2, %edx
addb $-0x4, %dl
movq %rsi, %r8
btsq %rdx, %r8
xorl %ecx, %ecx
leaq 0xf4e36(%rip), %rdx # 0x2447a0
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, %... | /LLNL[P]wcs/build_O3/src/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&) | string StrCat(const AlphaNum &a, const AlphaNum &b, const AlphaNum &c) {
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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x40(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq 0x8(%r14), %rsi
movq %rcx, -0x38(%rbp)
ad... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::GlobalReplaceSubstring(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>>*) | int GlobalReplaceSubstring(const string& substring,
const string& replacement,
string* s) {
GOOGLE_CHECK(s != nullptr);
if (s->empty() || substring.empty())
return 0;
string tmp;
int num_replacements = 0;
int pos = 0;
for (int match_pos = s->find(sub... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
testq %rdx, %rdx
jne 0x150a45
leaq 0xf37ad(%rip), %rdx # 0x2441b8
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movl $0x3, %esi
movl $0x658, %ecx # imm = 0x65... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::Base64UnescapeInternal(char const*, int, char*, int, signed char const*) | int Base64UnescapeInternal(const char *src_param, int szsrc,
char *dest, int szdest,
const signed char* unbase64) {
static const char kPad64Equals = '=';
static const char kPad64Dot = '.';
int decode = 0;
int destidx = 0;
int state = 0;
unsigned int ch ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdi, %r9
movq %rdx, -0x38(%rbp)
testq %rdx, %rdx
je 0x150dd8
cmpl $0x4, %esi
jl 0x150f89
xorl %r11d, %r11d
xorl %edx, %edx
movl %r14d, -0x2c(%rbp)
movzbl (%r9), %eax
testq %rax, %rax
je 0x150c63
movzbl 0x1(%r9), %ec... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::Base64UnescapeInternal(char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, signed char const*) | static bool Base64UnescapeInternal(const char* src, int slen, string* dest,
const signed char* unbase64) {
// Determine the size of the output string. Base64 encodes every 3 bytes into
// 4 characters. any leftover chars are added directly for good measure.
// This is document... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r13
leal 0x3(%r12), %eax
testl %esi, %esi
cmovnsl %esi, %eax
sarl $0x2, %eax
movl %esi, %r15d
subl %eax, %r15d
movslq %r15d, %rsi
xorl %r14d, %r14d
movq ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::Base64EscapeInternal(unsigned char const*, int, char*, int, char const*, bool) | int Base64EscapeInternal(const unsigned char *src, int szsrc,
char *dest, int szdest, const char *base64,
bool do_padding) {
static const char kPad64 = '=';
if (szsrc <= 0) return 0;
if (szsrc * 4 > szdest * 3) return 0;
char *cur_dest = dest;
const unsigne... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
xorl %eax, %eax
testl %esi, %esi
jle 0x151592
movq %rdx, %rbx
leal (,%rsi,4), %edx
leal (%rcx,%rcx,2), %r10d
cmpl %r10d, %edx
jg 0x151592
movl %esi, %edx
leaq (%rdi,%rdx), %r14
addq %rdi, %rdx
addq $-0x3, %rdx
movq %rbx, %r12
cmpq %... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/strutil.cc |
google::protobuf::internal::DateTimeToSeconds(google::protobuf::internal::DateTime const&, long*) | bool DateTimeToSeconds(const DateTime& time, int64* seconds) {
if (!ValidateDateTime(time)) {
return false;
}
*seconds = SecondsSinceCommonEra(time) - kSecondsFromEraToEpoch;
return true;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %r9d
leal -0x2710(%r9), %eax
cmpl $0xffffd8f1, %eax # imm = 0xFFFFD8F1
jb 0x152763
movl 0x4(%rdi), %edx
leal -0xd(%rdx), %eax
cmpl $-0xc, %eax
jb 0x152763
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %ecx
leal -0x20(... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/time.cc |
google::protobuf::internal::(anonymous namespace)::ParseTimezoneOffset(char const*, long*) | const char* ParseInt(const char* data, int width, int min_value,
int max_value, int* result) {
if (!ascii_isdigit(*data)) {
return nullptr;
}
int value = 0;
for (int i = 0; i < width; ++i, ++data) {
if (ascii_isdigit(*data)) {
value = value * 10 + (*data - '0');
} else {
... | movb (%rdi), %al
addb $-0x30, %al
xorl %ecx, %ecx
cmpb $0x9, %al
ja 0x1530de
leaq 0x2(%rdi), %rdx
xorl %eax, %eax
movzbl (%rdi,%rax), %r8d
leal -0x30(%r8), %r9d
cmpb $0x9, %r9b
ja 0x1530e1
leal (%rcx,%rcx,4), %ecx
leal (%r8,%rcx,2), %ecx
addl $-0x30, %ecx
incq %rax
cmpl $0x2, %eax
jne 0x1530bb
jmp 0x1530e7
xorl %eax, %... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/stubs/time.cc |
google::protobuf::internal::WireFormatLite::SkipMessage(google::protobuf::io::CodedInputStream*) | bool WireFormatLite::SkipMessage(io::CodedInputStream* input) {
while (true) {
uint32 tag = input->ReadTag();
if (tag == 0) {
// End of input. This is a valid place to end, so return true.
return true;
}
WireFormatLite::WireType wire_type = WireFormatLite::GetTagWireType(tag);
if (w... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x1532e5
movzbl (%rax), %esi
testb %sil, %sil
js 0x1532e7
incq %rax
movq %rax, (%rbx)
jmp 0x1532f1
xorl %esi, %esi
movq %rbx, %rdi
callq 0xfa7a0
movl %eax, %esi
movl %esi, 0x20(%rbx)
testl %esi, %esi
sete %al
mov... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::SkipMessage(google::protobuf::io::CodedInputStream*, google::protobuf::io::CodedOutputStream*) | bool WireFormatLite::SkipMessage(io::CodedInputStream* input,
io::CodedOutputStream* output) {
while (true) {
uint32 tag = input->ReadTag();
if (tag == 0) {
// End of input. This is a valid place to end, so return true.
return true;
}
WireFormatLite::Wire... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%r15), %rax
cmpq 0x8(%r15), %rax
jae 0x153901
movzbl (%rax), %r14d
testb %r14b, %r14b
js 0x153904
incq %rax
movq %rax, (%r15)
jmp 0x153912
xorl %r14d, %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0xfa7a0
movl %e... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::ReadPackedEnumPreserveUnknowns(google::protobuf::io::CodedInputStream*, int, bool (*)(int), google::protobuf::io::CodedOutputStream*, google::protobuf::RepeatedField<int>*) | bool WireFormatLite::ReadPackedEnumPreserveUnknowns(
io::CodedInputStream* input, int field_number, bool (*is_valid)(int),
io::CodedOutputStream* unknown_fields_stream, RepeatedField<int>* values) {
uint32 length;
if (!input->ReadVarint32(&length)) return false;
io::CodedInputStream::Limit limit = input->... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rcx, -0x38(%rbp)
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
jae 0x153b3c
movzbl (%rax), %esi
testb %sil, %sil
js 0x153b3e
incq %rax
movq %rax, (%rbx)
jmp 0... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteFloatArray(float const*, int, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteFloatArray(const float* a, int n,
io::CodedOutputStream* output) {
WriteArray<float>(a, n, output);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
shll $0x2, %edx
movq (%rbx), %rax
movq 0x40(%rbx), %r14
subq %r14, %rax
movslq %edx, %r15
cmpq %r15, %rax
jl 0x153d5c
movq %r14, %rdi
movq %r15, %rdx
callq 0xfe9a0
addq %r15, %r14
movq %r14, 0x40(%rbx)... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteSFixed32Array(int const*, int, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteSFixed32Array(const int32* a, int n,
io::CodedOutputStream* output) {
WriteArray<int32>(a, n, output);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
shll $0x2, %edx
movq (%rbx), %rax
movq 0x40(%rbx), %r14
subq %r14, %rax
movslq %edx, %r15
cmpq %r15, %rax
jl 0x153eac
movq %r14, %rdi
movq %r15, %rdx
callq 0xfe9a0
addq %r15, %r14
movq %r14, 0x40(%rbx)... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteSFixed64Array(long const*, int, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteSFixed64Array(const int64* a, int n,
io::CodedOutputStream* output) {
WriteArray<int64>(a, n, output);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
shll $0x3, %edx
movq (%rbx), %rax
movq 0x40(%rbx), %r14
subq %r14, %rax
movslq %edx, %r15
cmpq %r15, %rax
jl 0x153f00
movq %r14, %rdi
movq %r15, %rdx
callq 0xfe9a0
addq %r15, %r14
movq %r14, 0x40(%rbx)... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteBoolArray(bool const*, int, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteBoolArray(const bool* a, int n,
io::CodedOutputStream* output) {
WriteArray<bool>(a, n, output);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
movq (%rbx), %rax
movq 0x40(%rbx), %r14
subq %r14, %rax
movslq %edx, %r15
cmpq %r15, %rax
jl 0x153f51
movq %r14, %rdi
movq %r15, %rdx
callq 0xfe9a0
addq %r15, %r14
movq %r14, 0x40(%rbx)
addq $0x8, %rsp... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteUInt32(int, unsigned int, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteUInt32(int field_number, uint32 value,
io::CodedOutputStream* output) {
WriteTag(field_number, WIRETYPE_VARINT, output);
WriteUInt32NoTag(value, output);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %r15d
shll $0x3, %r15d
movq 0x40(%rdx), %rax
cmpq %rax, (%rdx)
jbe 0x154234
cmpl $0x7f, %r15d
ja 0x15418c
movb %r15b, (%rax)
incq %rax
jmp 0x1541cd
movl %r15d, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %r... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteUInt64(int, unsigned long, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteUInt64(int field_number, uint64 value,
io::CodedOutputStream* output) {
WriteTag(field_number, WIRETYPE_VARINT, output);
WriteUInt64NoTag(value, output);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
shll $0x3, %r15d
movq 0x40(%rdx), %rax
cmpq %rax, (%rdx)
jbe 0x154330
cmpl $0x7f, %r15d
ja 0x154284
movb %r15b, (%rax)
incq %rax
jmp 0x1542c5
movl %r15d, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %r1... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.cc |
google::protobuf::internal::WireFormatLite::WriteSInt64(int, long, google::protobuf::io::CodedOutputStream*) | void WireFormatLite::WriteSInt64(int field_number, int64 value,
io::CodedOutputStream* output) {
WriteTag(field_number, WIRETYPE_VARINT, output);
WriteSInt64NoTag(value, output);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
shll $0x3, %r15d
movq 0x40(%rdx), %rax
cmpq %rax, (%rdx)
jbe 0x154539
cmpl $0x7f, %r15d
ja 0x154482
movb %r15b, (%rax)
incq %rax
jmp 0x1544c3
movl %r15d, %ecx
orb $-0x80, %cl
movb %cl, (%rax)
movl %r1... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.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.