name string | code string | asm string | file string |
|---|---|---|---|
google::protobuf::UnknownFieldSet::DeleteSubrange(int, int) | void UnknownFieldSet::DeleteSubrange(int start, int num) {
// Delete the specified fields.
for (int i = 0; i < num; ++i) {
(fields_)[i + start].Delete();
}
// Slide down the remaining fields.
for (int i = start + num; i < fields_.size(); ++i) {
(fields_)[i - num] = (fields_)[i];
}
// Pop off the #... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
testl %edx, %edx
jle 0x1ad096
movslq %ebp, %r15
movl %r14d, %r12d
shlq $0x4, %r15
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x1acb90
addq $0x10, %r15
decq %r12
jne 0x1ad082
addl %r14d, %ebp
movslq %ebp, %rax
movq (%rbx... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/unknown_field_set.cc |
google::protobuf::internal::UnknownFieldParse(unsigned int, google::protobuf::internal::InternalMetadataWithArena*, char const*, google::protobuf::internal::ParseContext*) | const char* UnknownFieldParse(uint32 tag, InternalMetadataWithArena* metadata,
const char* ptr, ParseContext* ctx) {
return UnknownFieldParse(tag, metadata->mutable_unknown_fields(), ptr, ctx);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %edi, %ebp
movq (%rsi), %rax
testb $0x1, %al
je 0x1ad41a
andq $-0x2, %rax
movl %ebp, %edi
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1ad590
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/unknown_field_set.cc |
char const* google::protobuf::internal::FieldParser<google::protobuf::internal::UnknownFieldParserHelper>(unsigned long, google::protobuf::internal::UnknownFieldParserHelper&, char const*, google::protobuf::internal::ParseContext*) | PROTOBUF_MUST_USE_RESULT const char* FieldParser(uint64 tag, T& field_parser,
const char* ptr,
ParseContext* ctx) {
uint32 number = tag >> 3;
GOOGLE_PROTOBUF_PARSER_ASSERT(number != 0);
using WireType = internal::Wir... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
shrq $0x3, %r14
testl %r14d, %r14d
je 0x1ad6bd
andl $0x7, %edi
cmpq $0x5, %rdi
ja 0x1ad6bd
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x2efbef(%rip), %rax # 0x49d1b4
movslq (%rax,%rdi,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movsbq (%rbx), %rdx
leaq 0... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/parse_context.h |
google::protobuf::internal::WireFormat::SkipMessage(google::protobuf::io::CodedInputStream*, google::protobuf::UnknownFieldSet*) | bool WireFormat::SkipMessage(io::CodedInputStream* input,
UnknownFieldSet* unknown_fields) {
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 w... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rax
cmpq 0x8(%r14), %rax
jae 0x1ade83
movzbl (%rax), %esi
testb %sil, %sil
js 0x1ade85
incq %rax
movq %rax, (%r14)
jmp 0x1ade8f
xorl %esi, %esi
movq %r14, %rdi
callq 0x17e23e
movl %eax, %esi
movl %esi, 0x20(%r14)
testl %esi, %esi
sete %al
mo... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format.cc |
google::protobuf::internal::WireFormat::ComputeUnknownMessageSetItemsSize(google::protobuf::UnknownFieldSet const&) | size_t WireFormat::ComputeUnknownMessageSetItemsSize(
const UnknownFieldSet& unknown_fields) {
size_t size = 0;
for (int i = 0; i < unknown_fields.field_count(); i++) {
const UnknownField& field = unknown_fields.field(i);
// The only unknown fields that are allowed to exist in a MessageSet are
// m... | movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
shrq $0x4, %rdx
testl %edx, %edx
jle 0x1ae6d9
leaq 0x2ebf25(%rip), %rax # 0x49a5a0
movq (%rax), %rsi
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
addq $0x8, %rcx
xorl %eax, %eax
cmpl $0x3, -0x4(%rcx)
jne 0x1ae6cf
addq %rsi, %rax
movl -0x8(%rcx), %edi
orl $0x1... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format.cc |
google::protobuf::internal::WireFormat::ParseAndMergePartial(google::protobuf::io::CodedInputStream*, google::protobuf::Message*) | bool WireFormat::ParseAndMergePartial(io::CodedInputStream* input,
Message* message) {
const Descriptor* descriptor = message->GetDescriptor();
const Reflection* message_reflection = message->GetReflection();
while (true) {
uint32 tag = input->ReadTag();
if (tag == 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0xa8(%rax)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa8(%rax)
movq %rdx, (%rsp)
movq (%r14), %rax
movl $0x0, %ebp
cmpq 0x8(%r14), %rax
jae 0x1ae72a
movzb... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format.cc |
google::protobuf::internal::WireFormat::ParseAndMergeMessageSetItem(google::protobuf::io::CodedInputStream*, google::protobuf::Message*) | bool WireFormat::ParseAndMergeMessageSetItem(io::CodedInputStream* input,
Message* message) {
struct MSReflective {
bool ParseField(int type_id, io::CodedInputStream* input) {
const FieldDescriptor* field =
message_reflection->FindKnownExtensionByNumber... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0xa8(%rax)
movq %rdx, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x44(%rsp), %r12
xorl %ebp, %ebp
movq (%r14), %... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format.cc |
google::protobuf::internal::WireFormat::InternalSerializeWithCachedSizesToArray(google::protobuf::Message const&, unsigned char*, google::protobuf::io::EpsCopyOutputStream*) | uint8* WireFormat::InternalSerializeWithCachedSizesToArray(
const Message& message, uint8* target, io::EpsCopyOutputStream* stream) {
const Descriptor* descriptor = message.GetDescriptor();
const Reflection* message_reflection = message.GetReflection();
std::vector<const FieldDescriptor*> fields;
// Field... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %r13
movq (%r15), %rax
movq %r15, %rdi
callq *0xa8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%r13), %rax
c... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format.cc |
google::protobuf::internal::WireFormat::ByteSize(google::protobuf::Message const&) | size_t WireFormat::ByteSize(const Message& message) {
const Descriptor* descriptor = message.GetDescriptor();
const Reflection* message_reflection = message.GetReflection();
size_t our_size = 0;
std::vector<const FieldDescriptor*> fields;
// Fields of map entry should always be serialized.
if (descriptor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%r15), %rax
cmpb $0x1, 0x4b(%rax)
movq %rdx, ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format.cc |
google::protobuf::io::CodedInputStream::ReadVarint32(unsigned int*) | inline bool CodedInputStream::ReadVarint32(uint32* value) {
uint32 v = 0;
if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
v = *buffer_;
if (v < 0x80) {
*value = v;
Advance(1);
return true;
}
}
int64 result = ReadVarint32Fallback(v);
*value = static_cast<uint32>(result);
ret... | pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
jae 0x1b3e09
movzbl (%rax), %esi
testb %sil, %sil
js 0x1b3e0b
movl %esi, (%rbx)
incq %rax
movq %rax, (%rdi)
movb $0x1, %al
jmp 0x1b3e18
xorl %esi, %esi
callq 0x17deb8
movl %eax, (%rbx)
testq %rax, %rax
setns %al
popq %rbx
retq
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/coded_stream.h |
google::protobuf::internal::MapKeySorter::SortKey(google::protobuf::Message const&, google::protobuf::Reflection const*, google::protobuf::FieldDescriptor const*) | static std::vector<MapKey> SortKey(const Message& message,
const Reflection* reflection,
const FieldDescriptor* field) {
std::vector<MapKey> sorted_key_list;
for (MapIterator it =
reflection->MapBegin(const_cast<Message*>(&me... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, (%rsp)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x194a62
leaq 0x38(%rsp), %rbp
leaq 0x8(%rsp), %rb... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/wire_format.cc |
google::protobuf::internal::ExtensionSet::Extension::GetSize() const | int ExtensionSet::Extension::GetSize() const {
GOOGLE_DCHECK(is_repeated);
switch (cpp_type(type)) {
#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
case WireFormatLite::CPPTYPE_##UPPERCASE: \
return repeated_##LOWERCASE##_value->size()
HANDLE_TYPE(INT32, int32);
HANDLE_TYPE(INT64, int64);
HANDLE_T... | pushq %rbx
subq $0x40, %rsp
movzbl 0x8(%rdi), %eax
leaq 0x2e3d88(%rip), %rcx # 0x49a5b0
movl (%rcx,%rax,4), %eax
decl %eax
cmpl $0x9, %eax
ja 0x1b6851
leaq 0x2e6e8f(%rip), %rcx # 0x49d6c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
movl (%rax), %eax
jmp 0x1b6897
movq (%rdi), %rax
movl ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::MutableRawRepeatedField(int) | void* ExtensionSet::MutableRawRepeatedField(int number) {
Extension* extension = FindOrNull(number);
GOOGLE_CHECK(extension != NULL) << "Extension not found.";
// We assume that all the RepeatedField<>* pointers have the same
// size and alignment within the anonymous union in Extension.
return extension->rep... | pushq %r14
pushq %rbx
subq $0x48, %rsp
callq 0x1b6996
movq %rax, %rbx
testq %rax, %rax
jne 0x1b7f4b
leaq 0x2e5c81(%rip), %rdx # 0x49db80
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x1bb, %ecx # imm = 0x1BB
callq 0x1885e8
leaq 0x2e5e8a(%rip), %rsi # 0x49dda7
movq %r14, %rdi
callq 0x1880... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/extension_set.cc |
unsigned long google::protobuf::internal::(anonymous namespace)::SizeOfUnion<google::protobuf::internal::ExtensionSet::KeyValue*, std::_Rb_tree_iterator<std::pair<int const, google::protobuf::internal::ExtensionSet::Extension>>>(google::protobuf::internal::ExtensionSet::KeyValue*, google::protobuf::internal::ExtensionS... | size_t SizeOfUnion(ItX it_xs, ItX end_xs, ItY it_ys, ItY end_ys) {
size_t result = 0;
while (it_xs != end_xs && it_ys != end_ys) {
++result;
if (it_xs->first < it_ys->first) {
++it_xs;
} else if (it_xs->first == it_ys->first) {
++it_xs;
++it_ys;
} else {
++it_ys;
}
}
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
setne %cl
cmpq %r15, %rdx
setne %dl
andb %cl, %dl
xorl %r12d, %r12d
cmpb $0x1, %dl
jne 0x1b902a
movl 0x20(%rax), %ecx
cmpl %ecx, (%r14)
jge 0x1b900f
addq $0x20, %r14
jmp 0x1b901d
jne 0x... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::InternalExtensionMergeFrom(int, google::protobuf::internal::ExtensionSet::Extension const&) | void ExtensionSet::InternalExtensionMergeFrom(
int number, const Extension& other_extension) {
if (other_extension.is_repeated) {
Extension* extension;
bool is_new =
MaybeNewExtension(number, other_extension.descriptor, &extension);
if (is_new) {
// Extension did not already exist in set... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
cmpb $0x1, 0x9(%rdx)
jne 0x1b9113
movq 0x10(%rbx), %r12
movq %r15, %rdi
movl %ebp, %esi
callq 0x1b9bd0
movq %rax, %r14
movq %r12, 0x10(%rax)
movb 0x8(%rbx), %cl
movzbl %cl, %eax
testb $0x1,... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/extension_set.cc |
google::protobuf::internal::ExtensionSet::FindOrNullInLargeMap(int) | ExtensionSet::Extension* ExtensionSet::FindOrNullInLargeMap(int key) {
assert(is_large());
LargeMap::iterator it = map_.large->find(key);
if (it != map_.large->end()) {
return &it->second;
}
return NULL;
} | movq 0x10(%rdi), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x1be4f0
addq $0x8, %rax
movq %rax, %rdx
xorl %edi, %edi
cmpl %esi, 0x20(%rcx)
setl %dil
cmovgeq %rcx, %rdx
movq 0x10(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x1be4c6
cmpq %rax, %rdx
je 0x1be4f0
leaq 0x28(%rdx), %rcx
xorl %eax, %eax
cmpl %esi, 0x20(%rdx)
c... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/extension_set.cc |
void google::protobuf::internal::RepeatedPtrFieldBase::UnsafeArenaAddAllocated<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::TypeHandler>(google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::TypeHandler::Type*) | void RepeatedPtrFieldBase::UnsafeArenaAddAllocated(
typename TypeHandler::Type* value) {
// Make room for the new pointer.
if (!rep_ || current_size_ == total_size_) {
// The array is completely full with no cleared objects, so grow it.
Reserve(total_size_ + 1);
++rep_->allocated_size;
} else if (... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1bfbbb
movl 0x8(%r14), %esi
movl 0xc(%r14), %edi
cmpl %edi, %esi
je 0x1bfbbf
movslq %esi, %rdx
movslq (%rax), %rcx
cmpl %edi, %ecx
jne 0x1bfbe7
movq 0x8(%rax,%rdx,8), %rdi
testq %rdi, %rdi
je 0x1bfbcf
cmpq $0x0,... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::MessageLite::ParsePartialFromIstream(std::istream*) | bool MessageLite::ParsePartialFromIstream(std::istream* input) {
io::IstreamInputStream zero_copy_input(input);
return ParsePartialFromZeroCopyStream(&zero_copy_input) && input->eof();
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x17f202
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1c15c7
testb %al, %al
je 0x1c0a6e
movq (%rbx), %rax
movq -0x18(%rax)... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/message_lite.cc |
google::protobuf::StringAppendV(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, __va_list_tag*) | void StringAppendV(string* dst, const char* format, va_list ap) {
// First try with a small fixed size buffer
static const int kSpaceLength = 1024;
char space[kSpaceLength];
// It's possible for methods that use a va_list to invalidate
// the data in it upon use. The fix is to make a copy
// of the struct... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
leaq 0x20(%rsp), %rdi
movl $0x400, %esi # imm = 0x... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/stringprintf.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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jle 0x1c2888
xorl %eax, %eax
leaq 0x2dc581(%rip), %rcx # 0x49edf0
xorl %esi, %esi
movzbl (%r14,%rax), %edx
movsbq (%rdx,%rcx), %rdx
addq %rdx, %rsi
incq %rax
cmpq %rax, %rbx
jne 0x1c2871
jmp 0x1c28... | /google[P]bloaty/third_party/protobuf/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %r12d
leal (,%r12,4), %eax
leal 0x1(,%r12,4), %ebp
testl %eax, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnsl %ebp, %eax
movslq %eax, %rdi
callq 0x6d040
movq %rax, %r14
movq (%r15), %rdi
movl %r12d, %esi... | /google[P]bloaty/third_party/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 0x1c308d
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
jmp 0x1c308d
| /google[P]bloaty/third_party/protobuf/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x7e620
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c531d
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1c3914... | /google[P]bloaty/third_party/protobuf/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
jne 0x1c4408
leaq 0x2dab25(%rip), %rdx # 0x49eef0
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl $0x3, %esi
movl $0x65c, %ecx # imm = 0x65C
callq 0x1885e8
leaq 0x... | /google[P]bloaty/third_party/protobuf/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorl %eax, %eax
testl %esi, %esi
jle 0x1c4ebd
movq %rdx, %rbx
leal (,%rsi,4), %edx
leal (%rcx,%rcx,2), %r10d
cmpl %r10d, %edx
jg 0x1c4ebd
movl %esi, %edx
leaq (%rdi,%rdx), %r14
addq %rdi, %rdx
addq $-0x3, %rdx
movq %rbx, %r12
cmpq %rdi, %rdx
jbe 0x1c4d3a
movl... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc |
google::protobuf::DescriptorPool::Tables::~Tables() | DescriptorPool::Tables::~Tables() {
GOOGLE_DCHECK(checkpoints_.empty());
} | pushq %rbx
movq %rdi, %rbx
movq 0x220(%rdi), %rdi
testq %rdi, %rdi
je 0x1c5e73
callq 0x6d670
movq 0x208(%rbx), %rdi
testq %rdi, %rdi
je 0x1c5e84
callq 0x6d670
movq 0x1f0(%rbx), %rdi
testq %rdi, %rdi
je 0x1c5e95
callq 0x6d670
movq 0x1d8(%rbx), %rdi
testq %rdi, %rdi
je 0x1c5ea6
callq 0x6d670
leaq 0x1a8(%rbx), %rdi
callq ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorPool::Tables::AddSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, google::protobuf::Symbol) | bool DescriptorPool::Tables::AddSymbol(const std::string& full_name,
Symbol symbol) {
if (InsertIfNotPresent(&symbols_by_name_, full_name.c_str(), symbol)) {
symbols_after_checkpoint_.push_back(full_name.c_str());
return true;
} else {
return false;
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x138, %rdi # imm = 0x138
movq (%rsi), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
leaq 0x18(%rsp), %rdx
movq %rdi, (%rdx)
callq 0x1e595c
movl %edx, %ebp
testb $0x1, %dl
je 0x1c6c61
m... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorPool::Tables::AddFile(google::protobuf::FileDescriptor const*) | bool DescriptorPool::Tables::AddFile(const FileDescriptor* file) {
if (InsertIfNotPresent(&files_by_name_, file->name().c_str(), file)) {
files_after_checkpoint_.push_back(file->name().c_str());
return true;
} else {
return false;
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x170, %rdi # imm = 0x170
movq (%rsi), %rax
movq (%rax), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, 0x8(%rsi)
leaq 0x18(%rsp), %rdx
movq %rdi, (%rdx)
callq 0x1e5cc8
movl %edx, %ebp
testb $0x1, %dl
je 0x1c6f31
... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorPool::DescriptorPool(google::protobuf::DescriptorPool const*) | DescriptorPool::DescriptorPool(const DescriptorPool* underlay)
: mutex_(nullptr),
fallback_database_(nullptr),
default_error_collector_(nullptr),
underlay_(underlay),
tables_(new Tables),
enforce_dependencies_(true),
lazily_build_dependencies_(false),
allow_unknown_(false),... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movl $0x238, %edi # imm = 0x238
callq 0x6df20
movq %rax, %r14
movq %rax, %rdi
callq 0x1c5c46
movq %r14, 0x20(%rbx)
movb $0x1, 0x28(%rbx)
leaq 0x38(%rbx), %rax
xorl %ecx, %ecx
m... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::FileDescriptor::CopyJsonNameTo(google::protobuf::FileDescriptorProto*) const | void FileDescriptor::CopyTo(FileDescriptorProto* proto) const {
proto->set_name(name());
if (!package().empty()) proto->set_package(package());
// TODO(liujisi): Also populate when syntax="proto2".
if (syntax() == SYNTAX_PROTO3) proto->set_syntax(SyntaxName(syntax()));
for (int i = 0; i < dependency_count();... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x2c(%rdi), %ecx
cmpl 0x38(%rsi), %ecx
jne 0x1cada0
movq %rsi, %rbx
movq %rdi, %r14
movl 0x38(%rdi), %eax
cmpl 0x80(%rsi), %eax
jne 0x1cada0
testl %ecx, %ecx
jle 0x1cad66
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x68(%r14), %rdi
addq %r15, %rdi
movq 0x40... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::OneofDescriptor::CopyTo(google::protobuf::OneofDescriptorProto*) const | void OneofDescriptor::CopyTo(OneofDescriptorProto* proto) const {
proto->set_name(name());
if (&options() != &OneofOptions::default_instance()) {
proto->mutable_options()->CopyFrom(options());
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdx
orl $0x1, 0x10(%rsi)
leaq 0x18(%rsi), %rdi
movq 0x8(%rsi), %rsi
testb $0x1, %sil
jne 0x1cb078
movq (%rdi), %rax
cmpq 0x3a9f42(%rip), %rax # 0x574f60
je 0x1cb02d
movq %rax, %rdi
movq %rdx, %rsi
callq 0x6d3a0
jmp 0x1cb032
callq 0x9820a
... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::ServiceDescriptor::DebugString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, google::protobuf::DebugStringOptions const&) const | void ServiceDescriptor::DebugString(
std::string* contents,
const DebugStringOptions& debug_string_options) const {
SourceLocationCommentPrinter comment_printer(this, /* prefix */ "",
debug_string_options);
comment_printer.AddPreComment(contents);
strings::S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1c014e(%rip), %rdx # 0x38e631
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x7fe20
leaq 0x38(%rsp), %rbp
leaq 0x58(... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::Descriptor::DebugStringWithOptions[abi:cxx11](google::protobuf::DebugStringOptions const&) const | std::string Descriptor::DebugStringWithOptions(
const DebugStringOptions& options) const {
std::string contents;
DebugString(0, &contents, options, /* include_opening_clause */ true);
return contents;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rcx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movl $0x1, %r8d
callq 0x1cd346
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r1... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::FieldDescriptor::DebugStringWithOptions[abi:cxx11](google::protobuf::DebugStringOptions const&) const | std::string FieldDescriptor::DebugStringWithOptions(
const DebugStringOptions& debug_string_options) const {
std::string contents;
int depth = 0;
if (is_extension()) {
strings::SubstituteAndAppend(&contents, "extend .$0 {\n",
containing_type()->full_name());
depth = 1;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %esi, %esi
cmpb $0x1, 0x42(%r14)
jne 0x1cf692
movq 0x50(%... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::(anonymous namespace)::FormatBracketedOptions(int, google::protobuf::Message const&, google::protobuf::DescriptorPool const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool FormatBracketedOptions(int depth, const Message& options,
const DescriptorPool* pool, std::string* output) {
std::vector<std::string> all_options;
if (RetrieveOptions(depth, options, pool, &all_options)) {
output->append(Join(all_options, ", "));
}
return !all_options.empty(... | pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
callq 0x1e1512
testb %al, %al
je 0x1cf822
leaq 0x1bed67(%rip), %rdx # 0x38e557
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x19e5c5
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rdi
cal... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::OneofDescriptor::DebugStringWithOptions[abi:cxx11](google::protobuf::DebugStringOptions const&) const | std::string OneofDescriptor::DebugStringWithOptions(
const DebugStringOptions& options) const {
std::string contents;
DebugString(0, &contents, options);
return contents;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rcx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1cf190
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1cf... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::EnumDescriptor::DebugStringWithOptions[abi:cxx11](google::protobuf::DebugStringOptions const&) const | std::string EnumDescriptor::DebugStringWithOptions(
const DebugStringOptions& options) const {
std::string contents;
DebugString(0, &contents, options);
return contents;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rcx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1cc996
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1cf... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::EnumValueDescriptor::DebugString(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, google::protobuf::DebugStringOptions const&) const | void EnumValueDescriptor::DebugString(
int depth, std::string* contents,
const DebugStringOptions& debug_string_options) const {
std::string prefix(depth * 2, ' ');
SourceLocationCommentPrinter comment_printer(this, prefix,
debug_string_options);
comment_pri... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
leal (%rsi,%rsi), %eax
movslq %eax, %rsi
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movl $0x20, %edx
c... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::EnumValueDescriptor::DebugStringWithOptions[abi:cxx11](google::protobuf::DebugStringOptions const&) const | std::string EnumValueDescriptor::DebugStringWithOptions(
const DebugStringOptions& options) const {
std::string contents;
DebugString(0, &contents, options);
return contents;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rcx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1cf94a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1cf... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::ServiceDescriptor::DebugStringWithOptions[abi:cxx11](google::protobuf::DebugStringOptions const&) const | std::string ServiceDescriptor::DebugStringWithOptions(
const DebugStringOptions& options) const {
std::string contents;
DebugString(&contents, options);
return contents;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x1ce4b8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1cfe25
callq 0x6d670
movq %r14, %rd... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::FieldDescriptor::is_packed() const | inline bool FieldDescriptor::is_repeated() const {
return label() == LABEL_REPEATED;
} | cmpl $0x3, 0x3c(%rdi)
jne 0x1d04fb
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x1d04d9
leaq 0x1092a(%rip), %rax # 0x1e0df0
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdx
movq %rbx, (%rdx)
callq 0x196376
movl 0x38(%rbx), %eax
addl $-0xd, %eax
cmpl $-0x5, %eax
ja 0x1... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.h |
google::protobuf::Descriptor::GetSourceLocation(google::protobuf::SourceLocation*) const | bool Descriptor::GetSourceLocation(SourceLocation* out_location) const {
std::vector<int> path;
GetLocationPath(&path);
return file()->GetSourceLocation(path, out_location);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x1d057a
movq 0x10(%r14), %rdi
movq %rsp, %rsi
movq %rbx, %rdx
callq 0x1d033e
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d0556
callq 0x6d670
movl %ebx,... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::OneofDescriptor::GetSourceLocation(google::protobuf::SourceLocation*) const | bool OneofDescriptor::GetSourceLocation(SourceLocation* out_location) const {
std::vector<int> path;
GetLocationPath(&path);
return containing_type()->file()->GetSourceLocation(path, out_location);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x1d085a
movq 0x10(%r14), %rax
movq 0x10(%rax), %rdi
movq %rsp, %rsi
movq %rbx, %rdx
callq 0x1d033e
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d0836
ca... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::EnumDescriptor::GetSourceLocation(google::protobuf::SourceLocation*) const | bool EnumDescriptor::GetSourceLocation(SourceLocation* out_location) const {
std::vector<int> path;
GetLocationPath(&path);
return file()->GetSourceLocation(path, out_location);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x1d0948
movq 0x10(%r14), %rdi
movq %rsp, %rsi
movq %rbx, %rdx
callq 0x1d033e
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d0924
callq 0x6d670
movl %ebx,... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::ServiceDescriptor::GetLocationPath(std::vector<int, std::allocator<int>>*) const | void ServiceDescriptor::GetLocationPath(std::vector<int>* output) const {
output->push_back(FileDescriptorProto::kServiceFieldNumber);
output->push_back(index());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x6, 0x4(%rsp)
movq 0x8(%rsi), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0x1d0bcb
movl $0x6, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1d0be0
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0xd354a
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
m... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorBuilder::FindSymbolNotEnforcingDeps(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | Symbol DescriptorBuilder::FindSymbolNotEnforcingDeps(const std::string& name,
bool build_it) {
Symbol result = FindSymbolNotEnforcingDepsHelper(pool_, name, build_it);
// Only find symbols which were defined in this file or one of its
// dependencies.
const F... | pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rsi
callq 0x1d1f74
leaq 0x10(%rsp), %rdi
movl %eax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x1e27d4
movq %rax, 0x8(%rsp)
cmpq 0x58(%rbx), %rax
je 0x1d2107
movq 0x78(%rbx), %rcx
testq %rcx, %rcx
je 0x1d2126
leaq 0x70(%rbx), %rsi
movq %r... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorBuilder::AllocateOptions(google::protobuf::FileOptions const&, google::protobuf::FileDescriptor*) | void DescriptorBuilder::AllocateOptions(const FileOptions& orig_options,
FileDescriptor* descriptor) {
std::vector<int> options_path;
options_path.push_back(FileDescriptorProto::kOptionsFieldNumber);
// We add the dummy token so that LookupSymbol does the right thing.
All... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsp, %rdx
movl $0x8, (%rdx)
xorl %esi, %esi
callq 0xd354a
movq 0x8(%rbx), %rax
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r1... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorBuilder::OptionInterpreter::AddWithoutInterpreting(google::protobuf::UninterpretedOption const&, google::protobuf::Message*) | void DescriptorBuilder::OptionInterpreter::AddWithoutInterpreting(
const UninterpretedOption& uninterpreted_option, Message* options) {
const FieldDescriptor* field =
options->GetDescriptor()->FindFieldByName("uninterpreted_option");
GOOGLE_CHECK(field != nullptr);
options->GetReflection()
->AddM... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rax
movq %rdx, %rdi
callq *0xa8(%rax)
movq %rax, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2c241d(%rip), %rsi # 0x4a0c61
leaq 0x2c242a(%rip), %rdx # 0x4a0c75
leaq 0x8(%rsp), %r12
mo... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorBuilder::OptionInterpreter::SetOptionValue(google::protobuf::FieldDescriptor const*, google::protobuf::UnknownFieldSet*) | bool DescriptorBuilder::OptionInterpreter::SetOptionValue(
const FieldDescriptor* option_field, UnknownFieldSet* unknown_fields) {
// We switch on the CppType to validate.
switch (option_field->cpp_type()) {
case FieldDescriptor::CPPTYPE_INT32:
if (uninterpreted_option_->has_positive_int_value()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %rdi
testq %rdi, %rdi
je 0x1deca5
leaq 0x215e(%rip), %rax # 0x1e0df0
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x20(%rsp), %rdx
movq %r14, (%rdx)
callq 0x196376
movl 0x38... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::(anonymous namespace)::RetrieveOptions(int, google::protobuf::Message const&, google::protobuf::DescriptorPool 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... | bool RetrieveOptions(int depth, const Message& options,
const DescriptorPool* pool,
std::vector<std::string>* option_entries) {
// When printing custom options for a descriptor, we must use an options
// message built on top of the same DescriptorPool where the descriptor
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %ebp
movq (%rsi), %rax
movq %rsi, %rdi
callq *0xa8(%rax)
movq 0x10(%rax), %rax
cmpq %rbx, 0x10(%rax)
je 0x1e1571
movq (%r15), %rax
movq %r15, %rdi
callq *0xa8(%rax)
movq 0x8(%rax), %rdx
mov... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::FileDescriptorProto::add_dependency(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void FileDescriptorProto::add_dependency(const std::string& value) {
dependency_.Add()->assign(value);
// @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1e2b12
movslq 0x20(%r14), %rcx
movl (%rax), %esi
cmpl %esi, %ecx
jge 0x1e2b18
leal 0x1(%rcx), %edx
movl %edx, 0x20(%r14)
movq 0x8(%rax,%rcx,8), %rdi
jmp 0x1e2b8b
movl 0x24(%r14), %esi
jmp 0... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.h |
void google::protobuf::DescriptorBuilder::AllocateOptions<google::protobuf::EnumDescriptor>(google::protobuf::EnumDescriptor::OptionsType const&, google::protobuf::EnumDescriptor*, int) | void DescriptorBuilder::AllocateOptions(
const typename DescriptorT::OptionsType& orig_options,
DescriptorT* descriptor, int options_field_tag) {
std::vector<int> options_path;
descriptor->GetLocationPath(&options_path);
options_path.push_back(options_field_tag);
AllocateOptionsImpl(descriptor->full_nam... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, 0xc(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rdx, %rdi
callq 0x1d0948
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x1e34cb
mov... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
void google::protobuf::DescriptorBuilder::AllocateOptions<google::protobuf::ServiceDescriptor>(google::protobuf::ServiceDescriptor::OptionsType const&, google::protobuf::ServiceDescriptor*, int) | void DescriptorBuilder::AllocateOptions(
const typename DescriptorT::OptionsType& orig_options,
DescriptorT* descriptor, int options_field_tag) {
std::vector<int> options_path;
descriptor->GetLocationPath(&options_path);
options_path.push_back(options_field_tag);
AllocateOptionsImpl(descriptor->full_nam... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, 0xc(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rdx, %rdi
callq 0x1d0b9c
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x1e361f
mov... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::DescriptorBuilder::OptionInterpreter::AggregateOptionFinder::FindExtension(google::protobuf::Message*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const FieldDescriptor* FindExtension(Message* message,
const std::string& name) const override {
assert_mutex_held(builder_->pool_);
const Descriptor* descriptor = message->GetDescriptor();
Symbol result =
builder_->LookupSymbolNoPlaceholder(name, descriptor->f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *0xa8(%rax)
movq %rax, %r14
movq 0x8(%r15), %rdi
movq 0x8(%rax), %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x1d2234
movq %rdx, %rbx
cmpl $0x1, %eax
... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
google::protobuf::EnumOptions* google::protobuf::DescriptorPool::Tables::AllocateMessage<google::protobuf::EnumOptions>(google::protobuf::EnumOptions*) | Type* DescriptorPool::Tables::AllocateMessage(Type* /* dummy */) {
Type* result = new Type;
messages_.emplace_back(result);
return result;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x50, %edi
callq 0x6df20
movq %rax, %rbx
movq %rax, %rdi
callq 0x1f73fa
movq %rbx, (%rsp)
movq 0xf8(%r14), %rsi
cmpq 0x100(%r14), %rsi
je 0x1e904f
movq %rbx, (%rsi)
addq $0x8, 0xf8(%r14)
jmp 0x1e9067
addq $0xf0, %r14
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rdx
... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.cc |
void google::protobuf::internal::RepeatedPtrFieldBase::Destroy<google::protobuf::RepeatedPtrField<google::protobuf::SourceCodeInfo_Location>::TypeHandler>() | void RepeatedPtrFieldBase::Destroy() {
if (rep_ != NULL && arena_ == NULL) {
int n = rep_->allocated_size;
void* const* elements = rep_->elements;
for (int i = 0; i < n; i++) {
TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
}
#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x1ea8b7
cmpq $0x0, (%rbx)
jne 0x1ea8b7
movslq (%r14), %r15
testq %r15, %r15
jle 0x1ea8af
xorl %r12d, %r12d
movq 0x8(%r14,%r12,8), %rdi
testq %rdi, %rdi
je 0x1ea8a3
movq (%rdi), %rax
callq *0x8(%rax)
incq %r... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::FieldDescriptorProto_Type_IsValid(int) | bool FieldDescriptorProto_Type_IsValid(int value) {
switch (value) {
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
return true;
d... | decl %edi
cmpl $0x12, %edi
setb %al
retq
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::FieldOptions_CType_IsValid(int) | bool FieldOptions_CType_IsValid(int value) {
switch (value) {
case 0:
case 1:
case 2:
return true;
default:
return false;
}
} | cmpl $0x3, %edi
setb %al
retq
| /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::FileDescriptorSet::ByteSizeLong() const | size_t FileDescriptorSet::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.protobuf.FileDescriptorSet)
size_t total_size = 0;
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// repea... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x20(%rdi), %r14
movq 0x28(%rdi), %rax
leaq 0x8(%rax), %r15
testq %rax, %rax
cmoveq %rax, %r15
testq %r14, %r14
je 0x1eb63a
leaq (,%r14,8), %r12
xorl %r13d, %r13d
movq (%r15,%r13), %rdi
callq 0x1ecaee
addq %rax, %r14
orl $0x1, %eax
bsrl %eax,... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::DescriptorProto_ExtensionRange::MergeFrom(google::protobuf::DescriptorProto_ExtensionRange const&) | void DescriptorProto_ExtensionRange::MergeFrom(const DescriptorProto_ExtensionRange& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.DescriptorProto.ExtensionRange)
GOOGLE_DCHECK_NE(&from, this);
_internal_metadata_.MergeFrom(from._internal_metadata_);
::PROTOBUF_NAMESPACE_ID::... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0x1ee08f
andq $-0x2, %rsi
movq %r15, %rdi
callq 0x988d2
movl 0x10(%r14), %ebp
testb $0x7, %bpl
je 0x1ee0f5
testb $0x1, %bpl
je 0x1ee0d8
orb $0x1, 0x10(%rbx)
movq 0x18(%rbx... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::DescriptorProto::InternalSwap(google::protobuf::DescriptorProto*) | void DescriptorProto::InternalSwap(DescriptorProto* other) {
using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
field_.InternalSwap(&other->field_);
nested_type_.InternalSwap(&other->nested_type_);
enum_type_.InternalSwap(&other->enum_type_);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
testb $0x1, 0x8(%rdi)
jne 0x1f016a
testb $0x1, %sil
jne 0x1f0174
jmp 0x1f0181
testb $0x1, %sil
je 0x1f03bf
andq $-0x2, %rsi
leaq 0x8(%r14), %rdi
callq 0x98b34
movl 0x10(%r14), %eax
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%r14)
movl %eax... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::FieldDescriptorProto::FieldDescriptorProto(google::protobuf::FieldDescriptorProto const&) | FieldDescriptorProto::FieldDescriptorProto(const FieldDescriptorProto& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_internal_metadata_(nullptr),
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom(from._internal_metadata_);
name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStr... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x381bb8(%rip), %rax # 0x572690
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq $0x0, 0x8(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0x1f0b0a
andq $-0x2, %rsi
... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::EnumDescriptorProto::EnumDescriptorProto() | EnumDescriptorProto::EnumDescriptorProto()
: ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.EnumDescriptorProto)
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x380451(%rip), %rax # 0x5728d0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movq $0x0, 0x58(%rdi)
movl 0x3efac9(%rip), %eax ... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::ServiceDescriptorProto::~ServiceDescriptorProto() | ServiceDescriptorProto::~ServiceDescriptorProto() {
// @@protoc_insertion_point(destructor:google.protobuf.ServiceDescriptorProto)
SharedDtor();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x37ec42(%rip), %rax # 0x572a50
movq %rax, (%rdi)
movq 0x30(%rdi), %r14
cmpq 0x381144(%rip), %r14 # 0x574f60
je 0x1f3e3c
testq %r14, %r14
je 0x1f3e34
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x1f3e34
callq 0x6d670
movq %r14, %rdi
callq 0x6d67... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::ServiceOptions::MergeFrom(google::protobuf::Message const&) | void ServiceOptions::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:google.protobuf.ServiceOptions)
GOOGLE_DCHECK_NE(&from, this);
const ServiceOptions* source =
::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ServiceOptions>(
&from... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3787eb(%rip), %rsi # 0x570c30
leaq 0x37b3bc(%rip), %rdx # 0x573808
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x6d7b0
testq %rax, %rax
je 0x1f846d
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f4384
movq %r14, %rdi
mov... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::MethodOptions::MethodOptions() | MethodOptions::MethodOptions()
: ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.MethodOptions)
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x37ab72(%rip), %rax # 0x573110
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x1b6632
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movq $0x0, 0x40(%r14)
movl 0x3e9bb0(%rip), %eax # 0x5e2178
testl %e... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::MethodDescriptorProto::SharedDtor() | void MethodDescriptorProto::SharedDtor() {
GOOGLE_DCHECK(GetArenaNoVirtual() == nullptr);
name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
input_type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
output_type_.DestroyNoArena(&::PROTOBU... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
cmpq 0x3785b0(%rip), %r14 # 0x574f60
je 0x1fc9d0
testq %r14, %r14
je 0x1fc9c8
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x1fc9c8
callq 0x6d670
movq %r14, %rdi
callq 0x6d670
movq 0x20(%rbx), %r14
cmpq 0x378585(%rip), %r14 # 0x5... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.cc |
google::protobuf::SourceCodeInfo_Location::_internal_add_path(int) | inline void SourceCodeInfo_Location::_internal_add_path(::PROTOBUF_NAMESPACE_ID::int32 value) {
path_.Add(value);
} | pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x18(%rdi), %esi
cmpl 0x1c(%rdi), %esi
jne 0x1fcc41
leaq 0x18(%r14), %r15
incl %esi
movq %r15, %rdi
callq 0x18285a
movl (%r15), %esi
movq 0x20(%r14), %rax
leal 0x1(%rsi), %ecx
movl %ecx, 0x18(%r14)
movslq %esi, %rcx
movl %ebx, (%rax,%rcx,4)
popq %rbx... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/descriptor.pb.h |
google::protobuf::internal::ExtensionSet::ReleaseMessage(google::protobuf::FieldDescriptor const*, google::protobuf::MessageFactory*) | MessageLite* ExtensionSet::ReleaseMessage(const FieldDescriptor* descriptor,
MessageFactory* factory) {
Extension* extension = FindOrNull(descriptor->number());
if (extension == NULL) {
// Not present. Return NULL.
return NULL;
} else {
GOOGLE_DCHECK_TYPE(*ex... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x44(%rsi), %esi
callq 0x1b6996
testq %rax, %rax
je 0x203f51
movq %rax, %r12
testb $0x10, 0xa(%rax)
jne 0x203f56
cmpq $0x0, (%rbx)
movq (%r12), %r15
je 0x203f93
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/extension_set_heavy.cc |
google::protobuf::internal::ExtensionSet::UnsafeArenaReleaseMessage(google::protobuf::FieldDescriptor const*, google::protobuf::MessageFactory*) | MessageLite* ExtensionSet::UnsafeArenaReleaseMessage(
const FieldDescriptor* descriptor, MessageFactory* factory) {
Extension* extension = FindOrNull(descriptor->number());
if (extension == NULL) {
// Not present. Return NULL.
return NULL;
} else {
GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, MESSAGE... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movl 0x44(%rsi), %esi
callq 0x1b6996
testq %rax, %rax
je 0x20401e
movq %rax, %r12
testb $0x10, 0xa(%rax)
movq (%rax), %r15
je 0x204010
movq %r14, %rdi
callq 0x1c84d4
movq (%r13), %rcx
movq %r13, %rdi
movq %rax, %rsi
c... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/extension_set_heavy.cc |
google::protobuf::internal::ExtensionSet::SerializeMessageSetWithCachedSizesToArray(unsigned char*) const | uint8* ExtensionSet::SerializeMessageSetWithCachedSizesToArray(
uint8* target) const {
io::EpsCopyOutputStream stream(
target, MessageSetByteSize(),
io::CodedOutputStream::IsDefaultSerializationDeterministic());
return InternalSerializeMessageSetWithCachedSizesToArray(target, &stream);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1be814
leaq 0x4de56a(%rip), %rcx # 0x6e2e81
movb (%rcx), %cl
andb $0x1, %cl
cltq
addq %rbx, %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
xorl %eax, %eax
movq %rax, 0x8(%rdx)
movq %rax, 0x30(%rdx)
movw $0x0, 0x38(%rdx)
movb %cl, 0x3a(%rdx)
... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/extension_set_heavy.cc |
google::protobuf::io::Tokenizer::Refresh() | void Tokenizer::Refresh() {
if (read_error_) {
current_char_ = '\0';
return;
}
// If we're in a token, append the rest of the buffer to it.
if (record_target_ != NULL && record_start_ < buffer_size_) {
record_target_->append(buffer_ + record_start_,
buffer_size_ - record_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x98(%rdi)
jne 0x205e4b
movb $0x0, 0x80(%rbx)
jmp 0x205eeb
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x205e86
movslq 0xb0(%rbx), %rax
movl 0x90(%rbx), %ecx
cmpl %eax, %ecx
jle 0x205e86
movq %rax, %rsi
addq 0x88(%rbx), %rsi
subl %eax, %ecx
movs... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/tokenizer.cc |
google::protobuf::io::Tokenizer::IsIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool Tokenizer::IsIdentifier(const std::string& text) {
// Mirrors IDENTIFIER definition in Tokenizer::Next() above.
if (text.size() == 0) return false;
if (!Letter::InClass(text.at(0))) return false;
if (!AllInClass<Alphanumeric>(text.substr(1))) return false;
return true;
} | pushq %rbx
subq $0x20, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x207c42
movq %rdi, %rsi
movq (%rdi), %rax
movb (%rax), %al
cmpb $0x5f, %al
je 0x207c49
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x207c49
xorl %ebx, %ebx
jmp 0x207cd6
movq %rsp, %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x6d700
movq (%rb... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/tokenizer.cc |
absl::strings_internal::Base64EscapeInternal(unsigned char const*, unsigned long, char*, unsigned long, char const*, bool) | size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest,
size_t szdest, const char* base64,
bool do_padding) {
static const char kPad64 = '=';
if (szsrc * 4 > szdest * 3) return 0;
char* cur_dest = dest;
const unsigned char* cur_sr... | pushq %rbp
pushq %r14
pushq %rbx
leaq (,%rsi,4), %rax
leaq (%rcx,%rcx,2), %r10
cmpq %r10, %rax
jbe 0x2082cc
xorl %eax, %eax
jmp 0x20845b
leaq (%rdi,%rsi), %r10
cmpq $0x3, %rsi
jb 0x208339
leaq -0x3(%r10), %rsi
cmpq %rdi, %rsi
jbe 0x208339
movq %rdx, %rax
movl (%rdi), %r11d
bswapl %r11d
movl %r11d, %ebx
shrl $0x8, %ebx
... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/internal/escaping.cc |
testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile[abi:cxx11]() | std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
std::string s = GTEST_FLAG_GET(output);
const char* const gtest_output_flag = s.c_str();
std::string format = GetOutputFormat();
if (format.empty())
format = std::string(kDefaultOutputFormat);
const char* const colon = strchr(gtest_output_flag... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbx
leaq 0xf8(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x4d7061(%rip), %rsi # 0x6e3c38
movq 0x4d7062(%rip), %rdx # 0x6e3c40
addq %rsi, %rdx
leaq 0xe8(%rsp), %r14
movq %r14, %rdi
callq 0x7e620
mo... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::EqFailure(char const*, 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) | AssertionResult EqFailure(const char* lhs_expression,
const char* rhs_expression,
const std::string& lhs_value,
const std::string& rhs_value,
bool ignoring_case) {
Message msg;
msg << "Expected equality of these ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x20ee60
movq (%r15), %rax
movq %rax, (%rsp)
leaq 0x10(%rax), %r15
leaq 0x296a6a(%rip), %rsi ... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::DoubleNearPredFormat(char const*, char const*, char const*, double, double, double) | AssertionResult DoubleNearPredFormat(const char* expr1,
const char* expr2,
const char* abs_error_expr,
double val1,
double val2,
double... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movapd %xmm0, %xmm3
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, 0x28(%rsp)
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x40(%rsp)
subsd %xmm1, %xmm0
andpd 0x280ac(%rip), %xmm0 # 0x2386d0
movsd %xmm2, 0x38(%rsp)
movlpd %xmm0, 0x30(%rsp)
ucomisd %xmm0, %xmm2
ja... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRNE(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
const char* s2_expression,
const char* s1,
const char* s2) {
if (!String::CStringEquals(s1, s2)) {
return AssertionSuccess();
} else {
return AssertionFailur... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x210cf3
orq %r8, %rcx
jne 0x210d06
leaq 0x10(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x26848(%... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<wchar_t const*>(bool, char const*, char const*, wchar_t const* const&, wchar_t const* const&) | AssertionResult IsSubstringImpl(
bool expected_to_be_substring,
const char* needle_expr, const char* haystack_expr,
const StringType& needle, const StringType& haystack) {
if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x2110cd
cmpq %rdi, %rsi
sete %al
j... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRNE(char const*, char const*, wchar_t const*, wchar_t const*) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
const char* s2_expression,
const wchar_t* s1,
const wchar_t* s2) {
if (!String::WideCStringEquals(s1, s2)) {
return AssertionSuccess();
}
return AssertionFail... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x211ca1
orq %r8, %rcx
jne 0x211cb4
leaq 0x8(%rsp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::String::CaseInsensitiveWideCStringEquals(wchar_t const*, wchar_t const*) | bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
const wchar_t* rhs) {
if (lhs == nullptr) return rhs == nullptr;
if (rhs == nullptr) return false;
#if GTEST_OS_WINDOWS
return _wcsicmp(lhs, rhs) == 0;
#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movq %rdi, %rax
orq %rsi, %rax
sete %al
testb %cl, %cl
jne 0x211d58
pushq %rax
callq 0x6de30
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
nop
| /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::String::FormatIntWidthN[abi:cxx11](int, int) | std::string String::FormatIntWidthN(int value, int width) {
std::stringstream ss;
ss << std::setfill('0') << std::setw(width) << value;
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x6d4b0
movq 0x10(%r15), %rax
movq -0x18(%rax), %rcx
leaq (%rsp,%rcx), %r15
addq $0x10, %r15
cmpb $0x0, 0xe1(%r15)
jne 0x211e0c
movq %r15, %rdi
mo... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RegisterParameterizedTests() | void UnitTestImpl::RegisterParameterizedTests() {
if (!parameterized_tests_registered_) {
parameterized_test_registry_.RegisterTests();
type_parameterized_test_registry_.CheckForInstantiations();
parameterized_tests_registered_ = true;
}
} | cmpb $0x0, 0x160(%rdi)
jne 0x213c81
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xe8(%rdi), %r14
movq 0xf0(%rdi), %r15
cmpq %r15, %r14
je 0x213c69
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x213c55
leaq 0x100(%rbx), %rdi
callq 0x20c0c4
movb $0x1, 0x160(%rbx)
popq %rbx
popq %r14... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::ColoredPrintf(testing::internal::(anonymous namespace)::GTestColor, char const*, ...) | static void ColoredPrintf(GTestColor color, const char *fmt, ...) {
va_list args;
va_start(args, fmt);
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
const bool use_color = AlwaysFalse();
#else
static const bool in_col... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x214aab
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrintTestPartResult(testing::TestPartResult const&) | static void PrintTestPartResult(const TestPartResult& test_part_result) {
const std::string& result =
PrintTestPartResultToString(test_part_result);
printf("%s\n", result.c_str());
fflush(stdout);
// If the test program runs in Visual Studio or a debugger, the
// following statements add the test part r... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x212ee3
movq (%rbx), %rdi
callq 0x6dba0
movq 0x35fb9b(%rip), %rax # 0x574f48
movq (%rax), %rdi
callq 0x6d810
movq (%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2153cf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6d6d0
addq $0x20,... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTest... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x29164b(%rip), %rsi # 0x4a71fd
xorl %ebp, %ebp
movl $0x2, %edi
xorl %eax, %eax
callq 0x214a47
movq 0x40(%rbx), %rdi
callq 0x20ebfc
leaq 0x292156(%rip), %rdx # 0x4a7d26
leaq 0x290a11(%rip), %rcx # 0x4a65e8
leaq 0x8(%rsp), %rdi
mo... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Failed()) {
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
PrintTestName(test_info.test_suite_name(), test_info.name());
PrintFullTestCommentIfPresent(test_info);
if (GTEST_FLAG_GET(print_time)) {
... | pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x21271a
testb %al, %al
je 0x215f5c
leaq 0x2913b1(%rip), %rsi # 0x4a7274
movl $0x1, %edi
xorl %eax, %eax
callq 0x214a47
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x2913dd(%rip), %rdi # 0x4a72ba
xorl %eax, %eax
callq 0x6d080
movq 0x40(%rbx)... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*) | XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
: output_file_(output_file) {
if (output_file_.empty()) {
GTEST_LOG_(FATAL) << "XML output file may not be null";
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x35d7c0(%rip), %rax # 0x573ee0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x3(%rsp), %rdx
callq 0x8b570
cmpq $0x0, 0x10(%rbx)
jne 0x216775
leaq 0x28ff88(%rip), %rdx # 0x4a66c7
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0xfa2, %ecx # imm = 0xFA2
callq 0... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
const std::string& str) {
std::string output;
output.reserve(str.size());
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
if (IsValidXmlCharacter(*it))
output.push_back(*it);
return output;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x6dbe0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x21765a
movq (%r14), %rcx
movl $0x2600, %ebp # imm = 0x2600
mov... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* jsonout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintJsonUnitTest(&stream, unit_test);
fprintf(jsonout, "%s", StringStreamToString(&str... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x216870
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6d4b0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x21afa2
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x20f0c9
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq ... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::FormatTimeInMillisAsDuration[abi:cxx11](long) | static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
::std::stringstream ss;
ss << (static_cast<double>(ms) * 1e-3) << "s";
return ss.str();
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x6d4b0
leaq 0x10(%rsp), %rdi
cvtsi2sd %r14, %xmm0
mulsd 0x288920(%rip), %xmm0 # 0x4a5488
callq 0x6dc30
leaq 0x26e84c(%rip), %rsi # 0x48b3c0
movl $0x1, %edx
movq %rax, %rdi
callq 0x6d7c0
leaq 0x18... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::UnitTest::GetMutableTestSuite(int) | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x21f668
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x21f668
movl %esi, %edx
movslq (%rcx,%rdx,4), %rcx
testq %rcx, %rcx
js 0x21f668
movq 0xb8(%rax), %rax
movq (%rax,%rcx,8), %rax
retq
xorl %eax, %eax
retq
nop
| /google[P]bloaty/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::UnitTestImpl::RunAllTests() | bool UnitTestImpl::RunAllTests() {
// True if and only if Google Test is initialized before RUN_ALL_TESTS() is
// called.
const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
// Do not run any test if the --help flag was specified.
if (g_help_flag)
return true;
// Repeats the c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x4c4470(%rip), %rsi # 0x6e3cb8
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x82280
movq (%r14), %r13
movq 0x8(%r14), %rbp
movq %r14, %rdi
callq 0x7fa7a
movb $0x1, %r14b
cmpb $0x0, 0x4c437b(%rip) # 0x6e3be9
jne... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::PostFlagParsingInit() | void UnitTestImpl::PostFlagParsingInit() {
// Ensures that this function does not execute more than once.
if (!post_flag_parse_init_performed_) {
post_flag_parse_init_performed_ = true;
#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
// Register to send notifications about key process state changes.
lis... | cmpb $0x0, 0x218(%rdi)
je 0x220900
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x218(%rdi)
leaq 0x238(%rdi), %r14
callq 0x227e67
movq %r14, %rdi
movq %rax, %rsi
callq 0x23310e
cmpq $0x0, 0x238(%rbx)
je 0x22093a
movq 0x1f8(%rbx), %rax
movb $0x0, 0x8(%rax)
movq %rbx, %rdi
callq 0x213c36
movq %rbx, %r... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::WriteToShardStatusFileIfNeeded() | bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
if (lhs == nullptr) return rhs == nullptr;
if (rhs == nullptr) return false;
return posix::StrCaseCmp(lhs, rhs) == 0;
} | pushq %rbx
leaq 0x284992(%rip), %rdi # 0x4a5570
callq 0x6d880
testq %rax, %rax
je 0x220c08
movq %rax, %rbx
leaq 0x188a4(%rip), %rsi # 0x239496
movq %rax, %rdi
callq 0x6d820
testq %rax, %rax
je 0x220c0a
movq %rax, %rdi
popq %rbx
jmp 0x6d6a0
popq %rbx
retq
leaq 0x286ce0(%rip), %rsi # 0x4a78f1
leaq 0x284958(%rip... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ShuffleTests() | void UnitTestImpl::ShuffleTests() {
// Shuffles the death test suites.
ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
// Shuffles the non-death test suites.
ShuffleRange(random(), last_death_test_suite_ + 1,
static_cast<int>(test_suites_.size()), &test_suite_indices... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x220(%rdi), %rbx
movl 0x164(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x22f33e
movl 0x164(%r14), %esi
incl %esi
movq 0xc0(%r14), %rdx
subq 0xb8(%r14), %rdx
shrq $0x3, %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::InitGoogleTest() | void InitGoogleTest() {
// Since Arduino doesn't have a command line, fake out the argc/argv arguments
int argc = 1;
const auto arg0 = "dummy";
char* argv0 = const_cast<char*>(arg0);
char** argv = &argv0;
#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, ar... | subq $0x18, %rsp
leaq 0xc(%rsp), %rdi
movl $0x1, (%rdi)
leaq 0x27def5(%rip), %rax # 0x49f99c
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
callq 0x22f8d2
addq $0x18, %rsp
retq
| /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::InDeathTestChild() | bool InDeathTestChild() {
# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
// On Windows and Fuchsia, death tests are thread-safe regardless of the value
// of the death_test_style flag.
return !GTEST_FLAG_GET(internal_run_death_test).empty();
# else
if (GTEST_FLAG_GET(death_test_style) == "threadsafe")
return ... | pushq %rax
leaq 0x4c217e(%rip), %rdi # 0x6e3d48
leaq 0x285e87(%rip), %rsi # 0x4a7a58
callq 0x6d1e0
xorl %ecx, %ecx
cmpq $0x0, 0x4c2150(%rip) # 0x6e3d30
setne %cl
testl %eax, %eax
movzbl 0x4c217d(%rip), %eax # 0x6e3d69
cmovel %ecx, %eax
andb $0x1, %al
popq %rcx
retq
nop
| /google[P]bloaty/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::GetThreadCount() | size_t GetThreadCount() {
const std::string filename =
(Message() << "/proc/" << getpid() << "/stat").GetString();
return ReadProcFileField<size_t>(filename, 19);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x258, %rsp # imm = 0x258
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x20ee60
movq (%rbx), %rbx
leaq 0x10(%rbx), %r14
leaq 0x2835b1(%rip), %rsi # 0x4a7e72
movl $0x6, %edx
movq %r14, %rdi
callq 0x6d7c0
callq 0x6dae0
movq %r14, %rdi
movl %eax, %esi
callq 0x... | /google[P]bloaty/third_party/googletest/googletest/src/gtest-port.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<const internal::StringView&>::Matcher(const std::string& s) {
*this = Eq(s);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x34bb01(%rip), %r14 # 0x574798
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x7e620
leaq 0x10(%r... | /google[P]bloaty/third_party/googletest/googletest/src/gtest-matchers.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.