name string | code string | asm string | file string |
|---|---|---|---|
CoreML::Specification::MILSpec::ListValue::SerializeWithCachedSizes(google::protobuf::io::CodedOutputStream*) const | void ListValue::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:CoreML.Specification.MILSpec.ListValue)
::google::protobuf::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// repeated .CoreML.Specification.MILSpec.Value va... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x330600
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x3262fe
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %e... | /hollance[P]coremltools/build_O0/mlmodel/format/MIL.pb.cc |
CoreML::Specification::MILSpec::DictionaryValue_KeyValuePair::MergeFrom(CoreML::Specification::MILSpec::DictionaryValue_KeyValuePair const&) | void DictionaryValue_KeyValuePair::MergeFrom(const DictionaryValue_KeyValuePair& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:CoreML.Specification.MILSpec.DictionaryValue.KeyValuePair)
GOOGLE_DCHECK_NE(&from, this);
_internal_metadata_.MergeFrom(from._internal_metadata_);
::google::protobuf... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movq -0x50(%rbp), %rax
movb $0x0, -0x89(%rbp)
cmpq %rcx, %rax
je 0x326f60
jmp 0x326fbe
leaq 0xcd8f9(%rip), %rdx # 0x3f4860
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movl $0x3, ... | /hollance[P]coremltools/build_O0/mlmodel/format/MIL.pb.cc |
bool google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual<google::protobuf::internal::MapEntryImpl<google::protobuf::internal::MapEntryLite<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Value, (google::protobuf::internal::WireFormatLite::Fiel... | inline bool WireFormatLite::ReadMessageNoVirtual(
io::CodedInputStream* input, MessageType_WorkAroundCppLookupDefect* value) {
int length;
if (!input->ReadVarintSizeAsInt(&length)) return false;
std::pair<io::CodedInputStream::Limit, int> p =
input->IncrementRecursionDepthAndPushLimit(length);
if (p.s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0xddf50
testb $0x1, %al
jne 0x3290e7
movb $0x0, -0x1(%rbp)
jmp 0x329125
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3aca00
movq %rax, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/wire_format_lite_inl.h |
bool google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual<CoreML::Specification::MILSpec::TensorType>(google::protobuf::io::CodedInputStream*, CoreML::Specification::MILSpec::TensorType*) | inline bool WireFormatLite::ReadMessageNoVirtual(
io::CodedInputStream* input, MessageType_WorkAroundCppLookupDefect* value) {
int length;
if (!input->ReadVarintSizeAsInt(&length)) return false;
std::pair<io::CodedInputStream::Limit, int> p =
input->IncrementRecursionDepthAndPushLimit(length);
if (p.s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0xddf50
testb $0x1, %al
jne 0x32c3b7
movb $0x0, -0x1(%rbp)
jmp 0x32c3f5
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3aca00
movq %rax, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/wire_format_lite_inl.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>::InnerMap::iterator_base<google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>::KeyValuePair... | void SearchFrom(size_type start_bucket) {
GOOGLE_DCHECK(m_->index_of_first_non_null_ == m_->num_buckets_ ||
m_->table_[m_->index_of_first_non_null_] != NULL);
node_ = NULL;
for (bucket_index_ = start_bucket; bucket_index_ < m_->num_buckets_;
bucket_index_++) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movq 0x8(%rcx), %rax
movq 0x18(%rax), %rax
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, -0x49(%rbp)
cmpq %rcx, %rax
je 0x336be5
movq -0xb8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>::InnerMap::clear() | void clear() {
for (size_type b = 0; b < num_buckets_; b++) {
if (TableEntryIsNonEmptyList(b)) {
Node* node = static_cast<Node*>(table_[b]);
table_[b] = NULL;
do {
Node* next = node->next;
DestroyNode(node);
node = next;
} while (... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq $0x0, -0x10(%rbp)
movq -0xb0(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x33870a
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x336e60
testb $0x1, %al
jne 0x3384cd
jmp 0x338524
mov... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::internal::GenericTypeHandler<CoreML::Specification::MILSpec::ValueType>::New(google::protobuf::Arena*) | static inline GenericType* New(Arena* arena) {
return ::google::protobuf::Arena::CreateMaybeMessage<Type>(
arena, static_cast<GenericType*>(0));
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x33c96b
movl $0x20, %edi
callq 0x37220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x315620
jmp 0x33c93e
movq -0x50(... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::RepeatedPtrFieldBase::Clear<google::protobuf::RepeatedPtrField<CoreML::Specification::MILSpec::Argument_Binding>::TypeHandler>() | void RepeatedPtrFieldBase::Clear() {
const int n = current_size_;
GOOGLE_DCHECK_GE(n, 0);
if (n > 0) {
void* const* elements = rep_->elements;
int i = 0;
do {
TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
} while (i < n);
current_size_ = 0;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb $0x0, -0x49(%rbp)
cmpl $0x0, %eax
jl 0x33d83b
jmp 0x33d88a
leaq 0x818b3(%rip), %rdx # 0x3bf0f5
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::internal::MapArenaMessageCreator<CoreML::Specification::MILSpec::Function, false>::CreateMessage(google::protobuf::Arena*) | static inline Type* CreateMessage(Arena* arena) {
return Arena::Create<Type>(arena);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x33f0c3
movl $0x78, %edi
callq 0x37220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x30d1e0
jmp 0x33f096
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x33f11... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map_type_handler.h |
google::protobuf::internal::MapEntryImpl<google::protobuf::internal::MapEntryLite<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block, (google::protobuf::internal::WireFormatLite::FieldType)9, (google::protobuf::internal::WireFormatLite::FieldType)11, 0>... | ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(bool deterministic,
::google::protobuf::uint8* output) const {
output = KeyTypeHandler::InternalWriteToArray(kKeyFieldNumber, key(),
deterministic, ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
callq *0x88(%rax)
movq %rax, %rsi
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rcx
movl $0x1, %edi
andb $0x1, %al
movzbl %... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map_entry_lite.h |
google::protobuf::internal::MapEntryImpl<google::protobuf::internal::MapEntryLite<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block, (google::protobuf::internal::WireFormatLite::FieldType)9, (google::protobuf::internal::WireFormatLite::FieldType)11, 0>... | virtual inline const ValueMapEntryAccessorType& value() const {
GOOGLE_CHECK(default_instance_ != NULL);
return ValueTypeHandler::DefaultIfNotInitialized(value_,
default_instance_->value_);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x8(%rax), %rax
movb $0x0, -0x41(%rbp)
cmpq $0x0, %rax
je 0x340e64
jmp 0x340ead
leaq 0x84d0c(%rip), %rdx # 0x3c5b77
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x3, %esi
movl $0xa2, %ecx
callq... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map_entry_lite.h |
google::protobuf::internal::MapEntryImpl<google::protobuf::internal::MapEntryLite<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block, (google::protobuf::internal::WireFormatLite::FieldType)9, (google::protobuf::internal::WireFormatLite::FieldType)11, 0>... | ~MapEntryImpl() {
if (this != default_instance_) {
if (GetArenaNoVirtual() != NULL) return;
KeyTypeHandler::DeleteNoArena(key_);
ValueTypeHandler::DeleteNoArena(value_);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1f2175(%rip), %rcx # 0x5330c0
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq 0x8(%rax), %rax
je 0x340f9a
movq -0x18(%rbp), %rdi
callq 0x340ff0
movq %rax, -0x20(%rbp)
jmp 0x340f67
movq -0x20(%rbp), %rax
cmpq... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map_entry_lite.h |
google::protobuf::internal::MapEntryImpl<google::protobuf::internal::MapEntryLite<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block, (google::protobuf::internal::WireFormatLite::FieldType)9, (google::protobuf::internal::WireFormatLite::FieldType)11, 0>... | void MergeFromInternal(const MapEntryImpl& from) {
if (from._has_bits_[0]) {
if (from.has_key()) {
KeyTypeHandler::EnsureMutable(&key_, GetArenaNoVirtual());
KeyTypeHandler::Merge(from.key(), &key_, GetArenaNoVirtual());
set_has_key();
}
if (from.has_value()) {
Valu... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x3412e2
movq -0x10(%rbp), %rdi
callq 0x341390
testb $0x1, %al
jne 0x341215
jmp 0x341273
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x10... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map_entry_lite.h |
google::protobuf::internal::MapEntryLite<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Argument, (google::protobuf::internal::WireFormatLite::FieldType)9, (google::protobuf::internal::WireFormatLite::FieldType)11, 0> const* google::protobuf::internal::do... | inline To down_cast(From* f) { // so we only accept pointers
// Ensures that To is a sub-type of From *. This test is here only
// for compile-time type checking, and has no overhead in an
// optimized build at run-time, as it will be optimized away
// completely.
if (false) {
implicit_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, %al
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x3424fd
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3424e7
movq -0x18(%rbp), %rdi
leaq 0x1f168f(%rip), %rsi # 0x533b60
leaq 0x1f0d50(%rip), %rdx # 0x533228
xorl %ea... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/stubs/casts.h |
bool google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual<CoreML::Specification::MILSpec::Argument>(google::protobuf::io::CodedInputStream*, CoreML::Specification::MILSpec::Argument*) | inline bool WireFormatLite::ReadMessageNoVirtual(
io::CodedInputStream* input, MessageType_WorkAroundCppLookupDefect* value) {
int length;
if (!input->ReadVarintSizeAsInt(&length)) return false;
std::pair<io::CodedInputStream::Limit, int> p =
input->IncrementRecursionDepthAndPushLimit(length);
if (p.s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0xddf50
testb $0x1, %al
jne 0x3427f7
movb $0x0, -0x1(%rbp)
jmp 0x342835
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3aca00
movq %rax, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/wire_format_lite_inl.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>::MapAllocator<void*>::allocate(unsigned long, void const*) | pointer allocate(size_type n, const void* hint = 0) {
// If arena is not given, malloc needs to be called which doesn't
// construct element object.
if (arena_ == NULL) {
return static_cast<pointer>(::operator new(n * sizeof(value_type)));
} else {
return reinterpret_cast<pointer... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0xd8(%rbp)
movq %rsi, -0xe0(%rbp)
movq %rdx, -0xe8(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xf0(%rbp)
cmpq $0x0, (%rax)
jne 0x343070
movq -0xe0(%rbp), %rdi
shlq $0x3, %rdi
callq 0x37220
movq %rax, -0xd0(%rbp)
jmp 0x3432af
movq -0xf0(%rbp... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Value>::InnerMap::InnerMap(unsigned long, google::protobuf::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, google::protobuf::Map<std::__cxx11::basi... | InnerMap(size_type n, hasher h, Allocator alloc)
: hasher(h),
num_elements_(0),
seed_(Seed()),
table_(NULL),
alloc_(alloc) {
n = TableSize(n);
table_ = CreateEmptyTable(n);
num_buckets_ = index_of_first_non_null_ = n;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq $0x0, (%rdi)
callq 0x3435c0
movq -0x28(%rbp), %rdi
movq %rax, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x28(%rdi)
movq -0x20(%rbp)... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>::InnerMap::insert(google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>::KeyValuePair ... | std::pair<iterator, bool> insert(const KeyValuePair& kv) {
std::pair<const_iterator, size_type> p = FindHelper(kv.key());
// Case 1: key was already present.
if (p.first.node_ != NULL)
return std::make_pair(iterator(p.first), false);
// Case 2: insert.
if (ResizeIfLoadIsOutOfRange(... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, -0xb0(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x344280
movq -0xa8(%rbp), %rsi
movq %rax, %rdx
leaq -0x30(%rbp), %rdi
callq 0x2895c0
cmpq $0x0, -0x30(%rbp)
je... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
void google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>::MapAllocator<google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>::KeyValuePair... | void construct(NodeType* p, Args&&... args) {
// Clang 3.6 doesn't compile static casting to void* directly. (Issue
// #1266) According C++ standard 5.2.9/1: "The static_cast operator shall
// not cast away constness". So first the maybe const pointer is casted to
// const void* and after the co... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x344ef0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>::InnerMap::TransferList(void* const*, unsigned long) | void TransferList(void* const* table, size_type index) {
Node* node = static_cast<Node*>(table[index]);
do {
Node* next = node->next;
InsertUnique(BucketNumber(*KeyPtrFromNodePtr(node)), node);
node = next;
} while (node != NULL);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
m... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>::InnerMap::InsertUniqueInTree(unsigned long, google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpe... | iterator InsertUniqueInTree(size_type b, Node* node) {
GOOGLE_DCHECK_EQ(table_[b], table_[b ^ 1]);
// Maintain the invariant that node->next is NULL for all Nodes in Trees.
node->next = NULL;
return iterator(static_cast<Tree*>(table_[b])
->insert(KeyPtrFromNodePtr(node))
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, -0xa8(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movq 0x20(%rcx), %rax
movq -0x10(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x20(%rcx), %rcx
movq -0x10(%rbp), %rdx
xo... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Value>::CreateValueTypeInternal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | value_type* CreateValueTypeInternal(const Key& key) {
if (arena_ == NULL) {
return new value_type(key);
} else {
value_type* value = reinterpret_cast<value_type*>(
Arena::CreateArray<uint8>(arena_, sizeof(value_type)));
Arena::CreateInArenaStorage(const_cast<Key*>(&value->first), are... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0xd8(%rbp)
movq %rsi, -0xe0(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0x100(%rbp)
cmpq $0x0, (%rax)
jne 0x3467cd
movl $0x50, %edi
callq 0x37220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x108(%rbp)
movq -0xe0(%rbp), %rsi
callq 0x348f00
j... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Value>::InnerMap::ResizeIfLoadIsOutOfRange(unsigned long) | bool ResizeIfLoadIsOutOfRange(size_type new_size) {
const size_type kMaxMapLoadTimes16 = 12; // controls RAM vs CPU tradeoff
const size_type hi_cutoff = num_buckets_ * kMaxMapLoadTimes16 / 16;
const size_type lo_cutoff = hi_cutoff / 4;
// We don't care how many elements are in trees. If a lot ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0xc, -0x20(%rbp)
imulq $0xc, 0x8(%rax), %rax
shrq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq $0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x2... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::internal::MapEntryImpl<google::protobuf::internal::MapEntryLite<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Value, (google::protobuf::internal::WireFormatLite::FieldType)9, (google::protobuf::internal::WireFormatLite::FieldType)11, 0>... | bool MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream* input) {
// Look for the expected thing: a key and then a value. If it fails,
// invoke the enclosing class's MergePartialFromCodedStream, or return
// false if that would be pointless.
if (input->ExpectTag(kKeyTag)) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0xa, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpl $0x80, -0x2c(%rbp)
jae 0x34999a
movq -0x88(%rbp), %rcx
movq (%rc... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map_entry_lite.h |
google::protobuf::internal::MapEntryImpl<google::protobuf::internal::MapEntryLite<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Value, (google::protobuf::internal::WireFormatLite::FieldType)9, (google::protobuf::internal::WireFormatLite::FieldType)11, 0>... | bool ReadBeyondKeyValuePair(::google::protobuf::io::CodedInputStream* input)
GOOGLE_ATTRIBUTE_COLD {
typedef MoveHelper<KeyTypeHandler::kIsEnum,
KeyTypeHandler::kIsMessage,
KeyTypeHandler::kWireType ==
WireFormatLite::WIRETYPE_LENG... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, %rcx
addq $0x38, %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rdi
callq 0x349e70
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x349e20
movq -0x20(%rbp), %rdi
movq 0x30(%rdi), %ra... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map_entry_lite.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>::InnerMap::iterator_base<google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>::KeyVal... | void SearchFrom(size_type start_bucket) {
GOOGLE_DCHECK(m_->index_of_first_non_null_ == m_->num_buckets_ ||
m_->table_[m_->index_of_first_non_null_] != NULL);
node_ = NULL;
for (bucket_index_ = start_bucket; bucket_index_ < m_->num_buckets_;
bucket_index_++) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movq 0x8(%rcx), %rax
movq 0x18(%rax), %rax
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, -0x49(%rbp)
cmpq %rcx, %rax
je 0x34a575
movq -0xb8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>::swap(google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Function>&) | void swap(Map& other) {
if (arena_ == other.arena_) {
std::swap(default_enum_value_, other.default_enum_value_);
std::swap(elements_, other.elements_);
} else {
// TODO(zuguang): optimize this. The temporary copy can be allocated
// in the same arena as the other message, and the "other ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x34ceb0
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xdd4b0
movq -0x40(%rbp), %rdi... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>::Init() | void Init() {
elements_ = Arena::Create<InnerMap>(arena_, 0, hasher(), Allocator(arena_));
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq (%rax), %rcx
movq %rcx, -0x98(%rbp)
movl $0x0, -0x84(%rbp)
movq (%rax), %rsi
leaq -0x90(%rbp), %rdi
callq 0x34d650
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x84(%rbp), %rax
movq %rax, -0x50(%... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>::InnerMap::Seed() const | size_type Seed() const {
// random_device can throw, so avoid it unless we are compiling with
// exceptions enabled.
#if __cpp_exceptions && LANG_CXX11
try {
std::random_device rd;
std::knuth_b knuth(rd());
std::uniform_int_distribution<size_type> u;
return u(knuth);
... | pushq %rbp
movq %rsp, %rbp
subq $0x1bf0, %rsp # imm = 0x1BF0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1be0(%rbp)
leaq -0x1398(%rbp), %rdi
callq 0xfcd80
jmp 0x34d718
leaq -0x1398(%rbp), %rdi
callq 0xfce20
movl %eax, -0x1be4(%rbp)
jmp 0x34d72c
movl -0x1be4(%rbp), %eax
movl %eax, %eax
movl %ea... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
void google::protobuf::internal::RepeatedPtrFieldBase::Destroy<google::protobuf::RepeatedPtrField<CoreML::Specification::MILSpec::NamedValueType>::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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x34de06
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x34de06
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
movl %ecx, -0xc(%rbp)
movq 0x10(%rax), %rax
addq $0x8, %ra... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>::InnerMap::InsertUnique(unsigned long, google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>... | iterator InsertUnique(size_type b, Node* node) {
GOOGLE_DCHECK(index_of_first_non_null_ == num_buckets_ ||
table_[index_of_first_non_null_] != NULL);
// In practice, the code that led to this point may have already
// determined whether we are inserting into an empty list, a short list,
... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x178(%rbp)
movq %rdi, -0x170(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x168(%rbp)
movq 0x18(%rcx), %rax
movq 0x8(%rcx), %rcx
movb $0x0, -0x51(%rbp)
cmpq %rcx, %rax
je 0x3... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>::MapAllocator<std::_Rb_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*>>::allocate(unsigned long, void const*) | pointer allocate(size_type n, const void* hint = 0) {
// If arena is not given, malloc needs to be called which doesn't
// construct element object.
if (arena_ == NULL) {
return static_cast<pointer>(::operator new(n * sizeof(value_type)));
} else {
return reinterpret_cast<pointer... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0xd8(%rbp)
movq %rsi, -0xe0(%rbp)
movq %rdx, -0xe8(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xf0(%rbp)
cmpq $0x0, (%rax)
jne 0x35034d
imulq $0x28, -0xe0(%rbp), %rdi
callq 0x37220
movq %rax, -0xd0(%rbp)
jmp 0x350589
movq -0xf0(%rbp), %rax
... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
void google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>::MapAllocator<std::_Rb_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*>>::construct<std::__cxx11::basic_string<char, std::char_trait... | void construct(NodeType* p, Args&&... args) {
// Clang 3.6 doesn't compile static casting to void* directly. (Issue
// #1266) According C++ standard 5.2.9/1: "The static_cast operator shall
// not cast away constness". So first the maybe const pointer is casted to
// const void* and after the co... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
| /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
void google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>::insert<google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Block>::const_iterator>(google::... | void insert(InputIt first, InputIt last) {
for (InputIt it = first; it != last; ++it) {
iterator exist_it = find(it->first);
if (exist_it == end()) {
operator[](it->first) = it->second;
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x60(%... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
void google::protobuf::internal::RepeatedPtrFieldBase::MergeFrom<google::protobuf::RepeatedPtrField<CoreML::Specification::MILSpec::Argument_Binding>::TypeHandler>(google::protobuf::internal::RepeatedPtrFieldBase const&) | inline void RepeatedPtrFieldBase::MergeFrom(const RepeatedPtrFieldBase& other) {
GOOGLE_DCHECK_NE(&other, this);
if (other.current_size_ == 0) return;
MergeFromInternal(
other, &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, -0x49(%rbp)
cmpq %rcx, %rax
je 0x35323a
jmp 0x353289
leaq 0x6beb4(%rip), %rdx # 0x3bf0f5
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl $0x3, %e... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/repeated_field.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Argument>::MapAllocator<void*>::allocate(unsigned long, void const*) | pointer allocate(size_type n, const void* hint = 0) {
// If arena is not given, malloc needs to be called which doesn't
// construct element object.
if (arena_ == NULL) {
return static_cast<pointer>(::operator new(n * sizeof(value_type)));
} else {
return reinterpret_cast<pointer... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0xd8(%rbp)
movq %rsi, -0xe0(%rbp)
movq %rdx, -0xe8(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xf0(%rbp)
cmpq $0x0, (%rax)
jne 0x353a70
movq -0xe0(%rbp), %rdi
shlq $0x3, %rdi
callq 0x37220
movq %rax, -0xd0(%rbp)
jmp 0x353caf
movq -0xf0(%rbp... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Argument>::InnerMap::ResizeIfLoadIsOutOfRange(unsigned long) | bool ResizeIfLoadIsOutOfRange(size_type new_size) {
const size_type kMaxMapLoadTimes16 = 12; // controls RAM vs CPU tradeoff
const size_type hi_cutoff = num_buckets_ * kMaxMapLoadTimes16 / 16;
const size_type lo_cutoff = hi_cutoff / 4;
// We don't care how many elements are in trees. If a lot ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0xc, -0x20(%rbp)
imulq $0xc, 0x8(%rax), %rax
shrq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq $0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x2... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Argument>::InnerMap::InsertUnique(unsigned long, google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Arg... | iterator InsertUnique(size_type b, Node* node) {
GOOGLE_DCHECK(index_of_first_non_null_ == num_buckets_ ||
table_[index_of_first_non_null_] != NULL);
// In practice, the code that led to this point may have already
// determined whether we are inserting into an empty list, a short list,
... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x178(%rbp)
movq %rdi, -0x170(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x168(%rbp)
movq 0x18(%rcx), %rax
movq 0x8(%rcx), %rcx
movb $0x0, -0x51(%rbp)
cmpq %rcx, %rax
je 0x3... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Argument>::InnerMap::TransferList(void* const*, unsigned long) | void TransferList(void* const* table, size_type index) {
Node* node = static_cast<Node*>(table[index]);
do {
Node* next = node->next;
InsertUnique(BucketNumber(*KeyPtrFromNodePtr(node)), node);
node = next;
} while (node != NULL);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
m... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::Map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Argument>::InnerMap::CopyListToTree(unsigned long, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, google::protobuf::Map<std::__cxx11::basic_str... | size_type CopyListToTree(size_type b, Tree* tree) {
size_type count = 0;
Node* node = static_cast<Node*>(table_[b]);
while (node != NULL) {
tree->insert(KeyPtrFromNodePtr(node));
++count;
Node* next = node->next;
node->next = NULL;
node = next;
}
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x20(%rbp)
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x355bce
movq -0x18(%rbp), %rax
movq %rax, -... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map.h |
google::protobuf::internal::MapFieldLite<google::protobuf::internal::MapEntryLite<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CoreML::Specification::MILSpec::Argument, (google::protobuf::internal::WireFormatLite::FieldType)9, (google::protobuf::internal::WireFormatLite::FieldType)11,... | EntryType* NewEntry() const {
if (arena_ == NULL) {
return new EntryType();
} else {
return Arena::CreateMessage<EntryType>(arena_);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, (%rax)
jne 0x356e6d
movl $0x30, %edi
callq 0x37220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0x3416f0
jmp 0x356e3b
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x356f84
mov... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/map_field_lite.h |
void google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<CoreML::Specification::MILSpec::Dimension>::TypeHandler>(void**, void**, int, int) | void RepeatedPtrFieldBase::MergeFromInnerLoop(
void** our_elems, void** other_elems, int length, int already_allocated) {
// Split into two loops, over ranges [0, allocated) and [allocated, length),
// to avoid a branch within the loop.
for (int i = 0; i < already_allocated && i < length; i++) {
// Alread... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x20(%rbp), %ecx
movb %al, -0x61(%rbp)
jge 0x3590... | /hollance[P]coremltools/mlmodel/../deps/protobuf/src/google/protobuf/repeated_field.h |
CoreML::NeuralNetworkSpecValidator::validateInnerProductLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateInnerProductLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 1, 1));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
if (ndArrayInterpretation) {
HANDLE_RESULT_AND_RETU... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateActivation(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateActivation(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 1, 1));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
if (ndArrayInterpretation) {
if (layer.activation().Nonlin... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validatePooling3dLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validatePooling3dLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 1, 1));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1))
if (ndArrayInterpretation) {
HANDLE_RESULT_AND_RETU... | pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
movq %rdi, -0x2d0(%rbp)
movq %rdi, %rax
movq %rax, -0x2e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2d8(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1, %ecx
movl %ecx... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateReshapeStaticLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateReshapeStaticLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 1, 1));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
const auto& params = layer.reshapestatic();
if (params... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x3a4a80
movq -0x90(%rbp), %rdi
callq 0x283f90
movb %al, -0x81... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateMultiplyBroadcastableLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateMultiplyBroadcastableLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 2, 2));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
return Result();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x2, %ecx
movl %ecx, %edx
callq 0x3a4a80
movq -0x40(%rbp), %rdi
callq 0x283f90
movb %al, -0x32... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateGatherLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateGatherLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 2, 2));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
return Result();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x2, %ecx
movl %ecx, %edx
callq 0x3a4a80
movq -0x40(%rbp), %rdi
callq 0x283f90
movb %al, -0x32... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateGatherNDLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateGatherNDLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 2, 2));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
return Result();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x2, %ecx
movl %ecx, %edx
callq 0x3a4a80
movq -0x40(%rbp), %rdi
callq 0x283f90
movb %al, -0x32... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateSignLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateSignLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 1, 1));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
return Result();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x3a4a80
movq -0x40(%rbp), %rdi
callq 0x283f90
movb %al, -0x32... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateReverseSeqLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateReverseSeqLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 2, 2));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
return Result();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x2, %ecx
movl %ecx, %edx
callq 0x3a4a80
movq -0x40(%rbp), %rdi
callq 0x283f90
movb %al, -0x32... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateFlattenTo2DLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateFlattenTo2DLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 1, 1));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
const auto& params = layer.flattento2d();
// axis should... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x3a4a80
movq -0x98(%rbp), %rdi
callq 0x283f90
movb %al, -0x89... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateGetShapeLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateGetShapeLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 1, 1));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
return Result();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x3a4a80
movq -0x40(%rbp), %rdi
callq 0x283f90
movb %al, -0x32... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateRandomBernoulliLikeLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateRandomBernoulliLikeLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 1, 1));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 1, 1));
const auto& params = layer.randombernoullilike();
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x3a4a80
movq -0x90(%rbp), %rdi
callq 0x283f90
movb %al, -0x81... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
CoreML::NeuralNetworkSpecValidator::validateNMSLayer(CoreML::Specification::NeuralNetworkLayer const&) | Result NeuralNetworkSpecValidator::validateNMSLayer(const Specification::NeuralNetworkLayer& layer) {
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateInputCount(layer, 2, 5));
HANDLE_RESULT_AND_RETURN_ON_ERROR(validateOutputCount(layer, 4, 4));
return Result();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
movl $0x2, %edx
movl $0x5, %ecx
callq 0x3a4a80
movq -0x40(%rbp), %rdi
callq 0x283f90
movb %al, -0x32... | /hollance[P]coremltools/mlmodel/src/Validation/NeuralNetwork/NeuralNetworkLayerValidator.cpp |
google::protobuf::io::CodedOutputStream::CodedOutputStream(google::protobuf::io::ZeroCopyOutputStream*) | CodedOutputStream::CodedOutputStream(ZeroCopyOutputStream* output)
: output_(output),
buffer_(NULL),
buffer_size_(0),
total_bytes_(0),
had_error_(false),
aliasing_enabled_(false),
serialization_deterministic_is_overridden_(false) {
// Eagerly Refresh() so buffer space is immediately availabl... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movb $0x0, 0x18(%rdi)
movb $0x0, 0x19(%rdi)
movb $0x0, 0x1a(%rdi)
callq 0x3aec70... | /hollance[P]coremltools/deps/protobuf/src/google/protobuf/io/coded_stream.cc |
google::protobuf::MessageLite::ParseFromCodedStream(google::protobuf::io::CodedInputStream*) | bool MessageLite::ParseFromCodedStream(io::CodedInputStream* input) {
return InlineParseFromCodedStream(input, this);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rsi, -0xa0(%rbp)
movq -0x98(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x88(%rbp), %rcx
movq -0x90(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq %rax,... | /hollance[P]coremltools/deps/protobuf/src/google/protobuf/message_lite.cc |
google::protobuf::MessageLite::SerializePartialToCodedStream(google::protobuf::io::CodedOutputStream*) const | bool MessageLite::SerializePartialToCodedStream(
io::CodedOutputStream* output) const {
const size_t size = ByteSizeLong(); // Force size to be cached.
if (size > INT_MAX) {
GOOGLE_LOG(ERROR) << "Exceeded maximum protobuf size of 2GB: " << size;
return false;
}
uint8* buffer = output->GetDirectBuf... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq (%rdi), %rax
callq *0x60(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
jbe 0x3b2d1a
leaq 0x4b58b(%rip), %rdx # 0x3fe218
leaq -0x58(%rbp), %rdi
... | /hollance[P]coremltools/deps/protobuf/src/google/protobuf/message_lite.cc |
google::protobuf::internal::LogMessage::operator<<(char) | DECLARE_STREAM_OPERATOR(char , "%c" )
DECLARE_STREAM_OPERATOR(int , "%d" )
DECLARE_STREAM_OPERATOR(unsigned int , "%u" )
DECLARE_STREAM_OPERATOR(long , "%ld")
DECLARE_STREAM_OPERATOR(unsigned long, "%lu")
DECLARE_STREAM_OPERATOR(double , "%g" )
DECLARE_STREAM_OPERATOR(void* , "%p" ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
movsbl -0x9(%rbp), %ecx
movl $0x80, %esi
leaq 0x49eff(%rip), %rdx # 0x3fe9f6
movb $0x0, %al
callq 0x375b0
movq -0x98(%rbp), %rdi
movb $0x0, -0x11(... | /hollance[P]coremltools/deps/protobuf/src/google/protobuf/stubs/common.cc |
google::protobuf::StringPiece::find(google::protobuf::StringPiece, unsigned long) const | stringpiece_ssize_type StringPiece::find(StringPiece s, size_type pos) const {
if (length_ <= 0 || pos > static_cast<size_type>(length_)) {
if (length_ == 0 && pos == 0 && s.length_ == 0) return 0;
return npos;
}
const char *result = std::search(ptr_ + pos, ptr_ + length_,
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x8(%rax)
jle 0x3b9015
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x8(%rcx), %rax
jbe 0x3b9042
movq -0x38(%rbp), %rax
c... | /hollance[P]coremltools/deps/protobuf/src/google/protobuf/stubs/stringpiece.cc |
ted_ub::LGMTreeIndex<cost_model::UnitCostModelLD<label::StringLabel>, node::TreeIndexLGM>::get_mapped_ancestors_counts(node::TreeIndexLGM const&, node::TreeIndexLGM const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int... | void LGMTreeIndex<CostModel, TreeIndex>::get_mapped_ancestors_counts(
const TreeIndex& t1, const TreeIndex& t2,
std::vector<std::pair<int, int>>& mapping,
std::vector<int>& t1_count_mapped_anc,
std::vector<int>& t2_count_mapped_anc) const {
std::vector<int> t1_mapped_nodes(t1.tree_size_); // indexed i... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x9e50
movq -0xc0(%rbp)... | /DatabaseGroup[P]tree-similarity/src/ted_ub/lgm_tree_index_impl.h |
mcpl_internal_malloc | MCPL_LOCAL char * mcpl_internal_malloc(size_t n)
{
char * res = (char*)malloc(n ? n : 1);
if (!res)
mcpl_error("memory allocation failed");
return res;
} | pushq %rax
cmpq $0x1, %rdi
adcq $0x0, %rdi
callq 0x2330
testq %rax, %rax
je 0x2711
popq %rcx
retq
leaq 0x7a02(%rip), %rdi # 0xa11a
callq *0xdb5a(%rip) # 0x10278
leaq 0x798f(%rip), %rdi # 0xa0b4
leaq 0x7998(%rip), %rsi # 0xa0c4
xorl %eax, %eax
callq 0x21d0
movl $0x1, %edi
callq 0x2440
| /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_internal_realloc | MCPL_LOCAL void * mcpl_internal_realloc( void* mem, size_t new_size)
{
void * res = realloc( mem, new_size );
if (!res)
mcpl_error("memory allocation failed");
return res;
} | pushq %rax
callq 0x2390
testq %rax, %rax
je 0x2793
popq %rcx
retq
leaq 0x7980(%rip), %rdi # 0xa11a
callq *0xdad8(%rip) # 0x10278
leaq 0x790d(%rip), %rdi # 0xa0b4
leaq 0x7916(%rip), %rsi # 0xa0c4
xorl %eax, %eax
callq 0x21d0
movl $0x1, %edi
callq 0x2440
| /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_store_string | MCPL_LOCAL void mcpl_store_string(char** dest, const char * src)
{
size_t n = strlen(src);
if (n>65534) {
n = 65534;
mcpl_error("string length out of range");
}
if (*dest)
free(*dest);
*dest = mcpl_internal_malloc(n+1);
//Usage of strncpy cause compiler warning on newer gcc, so we use memcpy
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x21a0
cmpq $0xffff, %rax # imm = 0xFFFF
jae 0x281c
movq %rax, %r15
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x27f2
callq 0x2070
movq %r15, %rdi
incq %rdi
callq 0x26fc
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r1... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_write_string | MCPL_LOCAL void mcpl_write_string(FILE* f, const char * str, const char * errmsg)
{
size_t n = strlen(str);
if ( n >= 4294967295 )
mcpl_error("too large string encountered ");
mcpl_write_buffer(f,(uint32_t)n,str,errmsg);//nb: we don't write the terminating null-char
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x21a0
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jae 0x28fe
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x2848
leaq 0x7849(%rip), %rdi #... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_recalc_psize | MCPL_LOCAL void mcpl_recalc_psize(mcpl_outfile_t of)
{
MCPLIMP_OUTFILEDECODE;
unsigned fp = f->opt_singleprec ? sizeof(float) : sizeof(double);
f->particle_size = 7*fp;
if (f->opt_polarisation)
f->particle_size += 3*fp;
if (!f->opt_universalpdgcode)
f->particle_size += sizeof(int32_t);
if (!f->opt_u... | movl 0x4c(%rdi), %eax
movl 0x50(%rdi), %ecx
xorl %r8d, %r8d
testl %ecx, %ecx
sete %r9b
movl $0x38, %esi
movl $0x1c, %edx
cmovel %esi, %edx
movl %edx, 0x70(%rdi)
testl %eax, %eax
je 0x2978
testl %ecx, %ecx
movl $0x50, %esi
movl $0x28, %edx
cmovel %esi, %edx
movl %edx, 0x70(%rdi)
movl 0x54(%rdi), %esi
testl %esi, %esi
jn... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_platform_compatibility_check | MCPL_LOCAL void mcpl_platform_compatibility_check(void) {
MCPL_STATIC_ASSERT(CHAR_BIT==8);
MCPL_STATIC_ASSERT(sizeof(float)==4);
MCPL_STATIC_ASSERT(sizeof(double)==8);
int32_t m1_32 = -1;
int32_t not0_32 = ~((int32_t)0);
int64_t m1_64 = -1;
int64_t not0_64 = ~((int64_t)0);
if ( m1_32 != not0_32 || m1_6... | retq
| /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_create_outfile | mcpl_outfile_t mcpl_create_outfile(const char * filename)
{
//Sanity check chosen filename and append ".mcpl" if missing to help people
//who forgot to add the extension (in the hope of higher consistency).
if (!filename)
mcpl_error("mcpl_create_outfile called with null string.");
size_t n = strlen(filename... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x2b9a
movq %rdi, %r14
callq 0x21a0
testq %rax, %rax
je 0x2ba3
movq %rax, %r15
cmpq $0x1001, %rax # imm = 0x1001
jae 0x2bac
movq %r14, %rdi
movl $0x2e, %esi
callq 0x21f0
movq %rax, %r12
xorq %r14, %rax
movq %r15, %rcx
xorq $0x5, ... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_enable_polarisation | void mcpl_enable_polarisation(mcpl_outfile_t of)
{
MCPLIMP_OUTFILEDECODE;
if (f->opt_polarisation)
return;
if (!f->header_notwritten)
mcpl_error("mcpl_enable_polarisation called too late.");
f->opt_polarisation = 1;
mcpl_recalc_psize(of);
} | cmpl $0x0, 0x4c(%rdi)
je 0x2e99
retq
cmpl $0x0, 0x60(%rdi)
je 0x2eab
movl $0x1, 0x4c(%rdi)
jmp 0x2943
pushq %rax
leaq 0x7485(%rip), %rdi # 0xa338
callq *0xd3bf(%rip) # 0x10278
leaq 0x71f4(%rip), %rdi # 0xa0b4
leaq 0x71fd(%rip), %rsi # 0xa0c4
xorl %eax, %eax
callq 0x21d0
movl $0x1, %edi
callq 0x... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_write_header | MCPL_LOCAL void mcpl_write_header(mcpl_outfileinternal_t * f)
{
if (!f->header_notwritten)
mcpl_error("Logical error!");
const char * errmsg="Errors encountered while attempting to write file header.";
//Always start the file with an unsigned char-array (for endian agnosticity)
//containing magic word (MCP... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x0, 0x60(%rdi)
je 0x3313
movq %rdi, %rbx
movabsq $0x4c3330304c50434d, %rax # imm = 0x4C3330304C50434D
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movl $0x1234567, 0x10(%rsp) # imm = 0x1234567
movq 0x8(%rbx), %rcx
movl $0x1, %esi
movl $0x8, %edx
callq 0x2450
cmpq $0x8... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_unitvect_pack_adaptproj | MCPL_LOCAL void mcpl_unitvect_pack_adaptproj(const double* in, double* out) {
//Precise packing of unit vector into 2 floats + 1 bit using the "Adaptive
//Projection Packing" method (T. Kittelmann, 2017).
//
//The Adaptive Projection Packing method is a variant on the traditional projection
//method where on... | movsd (%rdi), %xmm0
movapd 0x6d08(%rip), %xmm3 # 0xa030
movapd %xmm0, %xmm1
andpd %xmm3, %xmm1
leaq 0x8(%rdi), %rax
movsd 0x8(%rdi), %xmm2
andpd %xmm3, %xmm2
movsd 0x10(%rdi), %xmm4
andpd %xmm4, %xmm3
movapd %xmm1, %xmm5
cmpunordsd %xmm1, %xmm5
movapd %xmm5, %xmm6
andpd %xmm2, %xmm6
movapd %xmm2, %xmm7
maxsd %xmm1,... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_unitvect_unpack_adaptproj | MCPL_LOCAL void mcpl_unitvect_unpack_adaptproj( const double* in, double* out ) {
//Unpacking for the "Adaptive Projection Packing" method (T. Kittelmann, 2017).
//See mcpl_unitvect_pack_adaptproj for more information.
//
//Note that the arrays "in" and "out" are both of dimension 3, however in[2]
//will con... | movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movapd 0x6c4c(%rip), %xmm2 # 0xa030
andpd %xmm0, %xmm2
ucomisd 0x6c18(%rip), %xmm2 # 0xa008
jbe 0x3437
movsd %xmm1, 0x8(%rsi)
movsd 0x6c09(%rip), %xmm0 # 0xa008
movapd %xmm0, %xmm1
divsd (%rdi), %xmm1
movsd %xmm1, 0x10(%rsi)
movsd 0x8(%rdi), %xmm2
mulsd %xmm1, %xmm... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_update_nparticles | MCPL_LOCAL void mcpl_update_nparticles(FILE* f, uint64_t n)
{
//Seek and update nparticles at correct location in header:
const char * errmsg = ( "Errors encountered while attempting "
"to update number of particles in file." );
int64_t savedpos = MCPL_FTELL(f);
if (savedpos<0)
mcp... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
callq 0x22a0
testq %rax, %rax
js 0x3981
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2360
testl %eax, %eax
jne 0x3981
movq %rsp, %rdi
movl $0x1, %esi
movl $0x8, %edx
movq %rbx, %rcx
callq 0x2450
cmpq $0x8, %rax
jne 0x3981
movq... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_close_outfile | void mcpl_close_outfile(mcpl_outfile_t of)
{
MCPLIMP_OUTFILEDECODE;
if (f->header_notwritten)
mcpl_write_header(f);
if (f->nparticles)
mcpl_update_nparticles(f->file,f->nparticles);
mcpl_internal_cleanup_outfile(f);
} | pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x60(%rdi)
je 0x3a0b
movq %rbx, %rdi
callq 0x305a
movq 0x68(%rbx), %rsi
testq %rsi, %rsi
je 0x3a1d
movq 0x8(%rbx), %rdi
callq 0x3922
movq %rbx, %rdi
popq %rbx
jmp 0x2a11
| /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_transfer_metadata | void mcpl_transfer_metadata(mcpl_file_t source, mcpl_outfile_t target)
{
//Note that MCPL format version 2 and 3 have the same meta-data in the header,
//except of course the version number itself.
if (mcpl_hdr_little_endian(source) != mcpl_platform_is_little_endian())
mcpl_error("mcpl_transfer_metadata can ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x38(%rdi), %eax
movl $0x1234567, 0x10(%rsp) # imm = 0x1234567
cmpl $0x1, %eax
jne 0x3b73
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rbx, %rdi
callq 0x2180
cmpl $0x0, 0x48(%r14)
je 0x3a80
xorl %ebp, %ebp
movq %r14,... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_closeandgzip_outfile | int mcpl_closeandgzip_outfile(mcpl_outfile_t of)
{
MCPLIMP_OUTFILEDECODE;
char * filename = f->filename;
f->filename = NULL;//prevent free in mcpl_close_outfile
mcpl_close_outfile(of);
int rc = mcpl_gzip_file(filename);
free(filename);
return rc;
} | pushq %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movq $0x0, (%rdi)
callq 0x2480
movq %rbx, %rdi
callq 0x2200
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2070
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_read_buffer | MCPL_LOCAL uint64_t mcpl_read_buffer(mcpl_fileinternal_t* f, unsigned* n, char ** buf, const char * errmsg)
{
//Reads buffer and returns number of bytes consumed from file
size_t nb;
if (f->filegz)
nb = gzread(f->filegz, n, sizeof(*n));
else
nb = fread(n, 1, sizeof(*n), f->file);
if (nb!=sizeof(*n))
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x3d31
movq %r14, %rsi
movl $0x4, %edx
callq 0x2280
cltq
jmp 0x3d46
movq (%r15), %rcx
movl $0x1, %esi
movl $0x4, %edx
movq %r14, %rdi
callq 0x2120
cmpq $0x4, %r... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_actual_open_file | MCPL_LOCAL mcpl_file_t mcpl_actual_open_file(const char * filename, int * repair_status)
{
int caller_is_mcpl_repair = *repair_status;
*repair_status = 0;//file not broken
if (!filename)
mcpl_error("mcpl_open_file called with null string");
mcpl_platform_compatibility_check();
mcpl_file_t out;
out.in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl (%rsi), %ebp
movq %rsi, 0x10(%rsp)
movl $0x0, (%rsi)
testq %rdi, %rdi
je 0x45f6
movq %rdi, %r15
movl $0x1, %edi
movl $0x100, %esi # imm = 0x100
callq 0x273d
movq %rax, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movq %r1... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_repair | void mcpl_repair(const char * filename)
{
int repair_status = 1;
mcpl_file_t f = mcpl_actual_open_file(filename,&repair_status);
uint64_t nparticles = mcpl_hdr_nparticles(f);
mcpl_close_file(f);
if (repair_status==0) {
mcpl_error("File does not appear to be broken.");
} else if (repair_status==1) {
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movl $0x1, (%r15)
movq %r15, %rsi
callq 0x4092
movq 0x40(%rax), %rbx
movq %rax, %rdi
callq 0x3f1a
movl (%r15), %eax
cmpl $0x2, %eax
je 0x4760
cmpl $0x1, %eax
je 0x4769
testl %eax, %eax
je 0x4772
leaq 0x8(%rsp), %r15
movq %r15, %rdi
m... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_rewind | int mcpl_rewind(mcpl_file_t ff)
{
MCPLIMP_FILEDECODE;
int already_there = (f->current_particle_idx==0);
f->current_particle_idx = 0;
int notEOF = f->current_particle_idx<f->nparticles;
if (notEOF&&!already_there) {
int error;
if (f->filegz) {
error = ! mcpl_gzseek( f->filegz, f->first_particle_p... | pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %r14
movq 0x88(%rdi), %rax
movq $0x0, 0x88(%rdi)
testq %r14, %r14
je 0x4ba7
testq %rax, %rax
je 0x4ba7
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4bb7
movq 0x80(%rdi), %rbx
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2140
cmpq %rbx, %rax
jne 0x4bcf
xorl %eax... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_seek | int mcpl_seek(mcpl_file_t ff,uint64_t ipos)
{
MCPLIMP_FILEDECODE;
int already_there = (f->current_particle_idx==ipos);
f->current_particle_idx = (ipos<f->nparticles?ipos:f->nparticles);
int notEOF = f->current_particle_idx<f->nparticles;
if (notEOF&&!already_there) {
int error;
if (f->filegz) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x40(%rdi), %r15
movq 0x88(%rdi), %rax
movq %rsi, %r14
cmpq %rsi, %r15
cmovbq %r15, %r14
movq %r14, 0x88(%rdi)
jbe 0x4c4f
cmpq %rbx, %rax
je 0x4c4f
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4c5d
movl 0x78(%rdi), %ecx
imulq %rcx, %r14
addq 0x80(%rdi), %r14
movq %rax... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_transfer_last_read_particle | void mcpl_transfer_last_read_particle(mcpl_file_t source, mcpl_outfile_t target)
{
mcpl_outfileinternal_t * ft = (mcpl_outfileinternal_t *)target.internal;
assert(ft);
mcpl_fileinternal_t * fs = (mcpl_fileinternal_t *)source.internal;
assert(fs);
if ( fs->current_particle_idx==0 && fs->particle->weight==0.0 ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x88(%rdi)
jne 0x4d76
movq 0x90(%r14), %rax
movsd 0x58(%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4d76
jp 0x4d76
cmpl $0x0, 0x60(%rax)
je 0x4f00
movslq 0x54(%rbx), %rdx
testq %rdx, %rdx
je 0x4d92
movq 0x90(%r14), %rax
movslq 0x6... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_dump_header | void mcpl_dump_header(mcpl_file_t f)
{
printf("\n Basic info\n");
printf(" Format : MCPL-%i\n",mcpl_hdr_version(f));
printf(" No. of particles : %" PRIu64 "\n",mcpl_hdr_nparticles(f));
printf(" Header storage : %" PRIu64 " bytes\n",mcpl_hdr_header_size(f));
printf(" Data storage... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x7387(%rip), %rdi # 0xc2d4
callq 0x2100
movl 0x18(%rbx), %esi
leaq 0x5f02(%rip), %rdi # 0xae5e
xorl %eax, %eax
callq 0x21d0
movq 0x40(%rbx), %rsi
leaq 0x5f12(%rip), %rdi # 0xae80
xorl %eax, %eax
callq... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_dump_particles | void mcpl_dump_particles(mcpl_file_t f, uint64_t nskip, uint64_t nlimit,
int(filter)(const mcpl_particle_t*))
{
int has_uf = mcpl_hdr_has_userflags(f);
int has_pol = mcpl_hdr_has_polarisation(f);
double uweight = mcpl_hdr_universal_weight(f);
printf("index pdgcode ekin[MeV] ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r15
movl 0x1c(%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0x20(%rdi), %r12d
movsd 0x30(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x5ecc(%rip), %rdi # 0xb0bf
xorl %eax, %eax
callq... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_dump | void mcpl_dump(const char * filename, int parts, uint64_t nskip, uint64_t nlimit)
{
if (parts<0||parts>2)
mcpl_error("mcpl_dump got forbidden value for argument parts");
mcpl_file_t f = mcpl_open_file(filename);
{
char * bn = mcpl_basename(filename);
printf("Opened MCPL file %s:\n",bn);
free(bn);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x3, %esi
jae 0x53ed
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
callq 0x4092
movq %rax, %r15
movq %r12, %rdi
callq 0x2470
movq %rax, %r12
leaq 0x5e44(%rip), %rdi # 0xb1ea
movq %... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_actual_can_merge | MCPL_LOCAL int mcpl_actual_can_merge(mcpl_file_t ff1, mcpl_file_t ff2)
{
mcpl_fileinternal_t * f1 = (mcpl_fileinternal_t *)ff1.internal;
mcpl_fileinternal_t * f2 = (mcpl_fileinternal_t *)ff2.internal;
assert(f1);
assert(f2);
if (f1->first_particle_pos!=f2->first_particle_pos)
return 0;//different header
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x80(%rdi), %rax
xorl %ebx, %ebx
cmpq 0x80(%rsi), %rax
jne 0x558e
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movq 0x10(%rsi), %rsi
callq 0x2260
testl %eax, %eax
jne 0x558e
movl 0x1c(%r15), %eax
cmpl 0x1c(%r14), %eax
jne 0... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_forcemerge_files | mcpl_outfile_t mcpl_forcemerge_files( const char * file_output,
unsigned nfiles,
const char ** files,
int keep_userflags )
{
////////////////////////////////////
// Initial sanity check of input: //
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testl %esi, %esi
je 0x5a8e
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movl %esi, %edi
movq %rdx, %rsi
callq 0x5618
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x80b0
movq %rbx, %rdi
callq 0x866c
test... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_usage_progname | char* mcpl_usage_progname( const char * argv0 )
{
//Basically return the basename, but with any trailing .exe/.EXE discarded.
char * bn = mcpl_basename(argv0);
size_t npn = strlen(bn);
const int has_exe_suffix = ( npn > 4
&& ( strcmp(bn+(npn-4),".exe")==0
... | pushq %r14
pushq %rbx
pushq %rax
callq 0x2470
movq %rax, %rbx
movq %rax, %rdi
callq 0x21a0
cmpq $0x5, %rax
jb 0x5f5f
leaq (%rbx,%rax), %r14
addq $-0x4, %r14
leaq 0x5727(%rip), %rsi # 0xb661
movq %r14, %rdi
callq 0x2260
testl %eax, %eax
je 0x5f59
leaq 0x5719(%rip), %rsi # 0xb666
movq %r14, %rdi
callq 0x2260
te... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_tool_usage | MCPL_LOCAL int mcpl_tool_usage( char** argv, const char * errmsg ) {
if (errmsg) {
printf("ERROR: %s\n\n",errmsg);
printf("Run with -h or --help for usage information\n");
return 1;
}
char * progname = mcpl_usage_progname(argv[0]);
printf("Tool for inspecting or modifying Monte Carlo Particle List (... | pushq %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x5fc5
leaq 0x56cc(%rip), %rdi # 0xb674
xorl %eax, %eax
callq 0x21d0
leaq 0x6c85(%rip), %rdi # 0xcc3b
callq 0x2100
movl $0x1, %ebp
jmp 0x6265
movq (%rdi), %rdi
callq 0x23a0
movq %rax, %rbx
leaq 0x640d(%rip), %rdi # 0xc3e4
callq 0x2100
movl $0xa, %edi
c... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_tool | int mcpl_tool(int argc,char** argv) {
int nfilenames = 0;
char ** filenames = NULL;
const char * blobkey = NULL;
const char * pdgcode_str = NULL;
int opt_justhead = 0;
int opt_nohead = 0;
int64_t opt_num_limit = -1;
int64_t opt_num_skip = -1;
int opt_merge = 0;
int opt_forcemerge = 0;
int opt_kee... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
movq $-0x1, %rax
movq %rax, 0x88(%rsp)
movq %rax, 0x60(%rsp)
cmpl $0x2, %edi
jl 0x6789
movq %rsi, %r13
movl %edi, %r12d
movq %r12, 0x98(%rsp)
negq %r12
movq $0x0, 0x30(%rsp)
movl $0x1, %r15d
movl $0x0, %eax
movq... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_internal_dump_to_stdout | void mcpl_internal_dump_to_stdout( const char * data,
unsigned long ldata )
{
#ifdef _WIN32
int the_stdout_fileno = _fileno(stdout);
if ( the_stdout_fileno == -2 )
mcpl_error("stdout is not associated with an output stream");
if ( the_stdout_fileno == -1 )
mcpl_error("co... | pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
movl $0x1, %edi
movq %rbx, %rdx
callq 0x2160
cmpq %rbx, %rax
jne 0x7342
popq %rbx
retq
leaq 0x4c93(%rip), %rdi # 0xbfdc
callq *0x8f29(%rip) # 0x10278
leaq 0x2d5e(%rip), %rdi # 0xa0b4
leaq 0x2d67(%rip), %rsi # 0xa0c4
xorl %eax, %eax
callq 0x21d0
movl $0... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_internal_do_gzip | MCPL_LOCAL int mcpl_internal_do_gzip(const char *filename)
{
//Open input file:
FILE *handle_in = mcpl_internal_fopen(filename, "rb");
if (!handle_in)
return 0;
//Construct output file name by appending .gz:
size_t nn = strlen(filename);
char * outfn = mcpl_internal_malloc(nn + 4);
memcpy(outfn,filen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4008, %rsp # imm = 0x4008
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x80b0
leaq 0x3373(%rip), %rsi # 0xa723
movq %r14, %rdi
callq 0x839d
xorl %ebp, %ebp
testq %rax, %rax
je 0x749b
movq %rax, %r14
movq %r... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_generic_fwrite | void mcpl_generic_fwrite( mcpl_generic_wfilehandle_t* fh,
const char * src, uint64_t nbytes )
{
MCPL_STATIC_ASSERT( sizeof(size_t) >= sizeof(uint32_t) );
MCPL_STATIC_ASSERT( sizeof(int) >= sizeof(int32_t) );
//Write nbytes. For safety, we do this in chunks well inside 32bit limit.
con... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x20000000, %rdx # imm = 0x20000000
jb 0x7562
movl $0x1fffffff, %r12d # imm = 0x1FFFFFFF
movl $0x1fffffff, %edx # imm = 0x1FFFFFFF
movq %r14, %rdi
movq %r15, %rsi
callq 0x21b0
addq $-0x1fffffff,... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_generic_fwclose | void mcpl_generic_fwclose( mcpl_generic_wfilehandle_t* fh )
{
if ( !fh->internal )
mcpl_error("Error trying to close invalid file handle");
fclose( (FILE*)(fh->internal) );
fh->mode = 0;
fh->current_pos = 0;
fh->internal = NULL;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x75db
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x0, 0x10(%rbx)
popq %rbx
retq
leaq 0x4a52(%rip), %rdi # 0xc034
callq *0x8c90(%rip) # 0x10278
leaq 0x2ac5(%rip), %rdi # 0xa0b4
leaq 0x2ace(%rip), %rsi # 0xa0c4
xorl... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_generic_fopen_try | mcpl_generic_filehandle_t mcpl_generic_fopen_try( const char * filename )
{
mcpl_generic_filehandle_t res;
res.mode = 0;
res.current_pos = 0;
res.internal = NULL;
const char * lastdot = strrchr(filename, '.');
if (lastdot && strcmp(lastdot, ".gz") == 0) {
MCPL_STATIC_ASSERT( sizeof(gzFile) == sizeof(vo... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl $0x0, 0x10(%rdi)
movq %rsi, %rdi
movl $0x2e, %esi
callq 0x21f0
testq %rax, %rax
je 0x76b8
leaq 0x4432(%rip), %rsi # 0xbade
movq %rax, %rdi
callq 0x2260
testl %eax, %eax
je 0x76dc
leaq 0x8(... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_generic_fclose | void mcpl_generic_fclose( mcpl_generic_filehandle_t* fh )
{
if ( !fh->internal )
mcpl_error("Error trying to close invalid file handle");
//NB: We only use 1 bit in mode flag for now, so we dont have to actually do
//"fh->mode & 0x1" to test if it is gzipped.
if ( fh->mode )
gzclose((gzFile)(fh->intern... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x776f
cmpl $0x0, 0x10(%rbx)
je 0x775b
callq 0x2060
jmp 0x7760
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x0, 0x10(%rbx)
popq %rbx
retq
leaq 0x48be(%rip), %rdi # 0xc034
callq *0x8afc(%rip) # 0x10278
leaq 0x2931(%rip), %rdi ... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_generic_fread_try | unsigned mcpl_generic_fread_try( mcpl_generic_filehandle_t* fh,
char * dest, unsigned nbytes )
{
MCPL_STATIC_ASSERT( sizeof(size_t) >= sizeof(uint32_t) );
MCPL_STATIC_ASSERT( sizeof(unsigned) >= sizeof(int32_t) );
MCPL_STATIC_ASSERT( sizeof(z_off_t) >= sizeof(int32_t) );
if ( n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x7927
je 0x78bb
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
movl $0x8000, %eax # imm = 0x8000
cmpl %eax, %ebp
movl $0x8000, %r12d # imm = 0x8000
cmovbl %ebp, %r12d
cmpl $0x0, 0x10(%r1... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_internal_buf_create | MCPL_LOCAL mcpl_buffer_t mcpl_internal_buf_create( size_t capacity )
{
mcpl_buffer_t res;
res.size = 0;
if ( capacity == 0 ) {
res.buf = NULL;
res.capacity = 0;
} else {
res.buf = mcpl_internal_malloc(capacity);
res.capacity = capacity;
}
return res;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x8(%rdi)
testq %rsi, %rsi
je 0x7951
movq %rbx, %rdi
callq 0x26fc
jmp 0x7953
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_internal_buf_squeeze | MCPL_LOCAL void mcpl_internal_buf_squeeze(mcpl_buffer_t* buf)
{
if ( buf->size == buf->capacity )
return;
char * oldbuf = buf->buf;
char * newbuf = mcpl_internal_malloc( buf->size );
memcpy( newbuf, oldbuf, buf->size );
buf->buf = newbuf;
free(oldbuf);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
cmpq 0x10(%rbx), %rdi
jne 0x797d
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %r14
callq 0x26fc
movq %rax, %r15
movq 0x8(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x22f0
movq %r15, (%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
mcpl_internal_buf_reserve | MCPL_LOCAL void mcpl_internal_buf_reserve(mcpl_buffer_t* buf, size_t n)
{
if ( n <= buf->capacity )
return;
char * oldbuf = buf->buf;
char * newbuf = mcpl_internal_malloc( n );
memcpy( newbuf, oldbuf, buf->size );
buf->buf = newbuf;
buf->capacity = n;
free(oldbuf);
} | cmpq %rsi, 0x10(%rdi)
jae 0x7a23
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq %rsi, %rdi
callq 0x26fc
movq %rax, %r12
movq 0x8(%r14), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x22f0
movq %r12, (%r14)
movq %rbx, 0x10(%r14)
movq %r15, %rdi
addq $0x8, %rsp... | /mctools[P]mcpl/mcpl_core/src/mcpl.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.