name string | code string | asm string | file string |
|---|---|---|---|
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 3u, 8u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0xf440
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::getTags() const | std::vector<uint64_t> getTags() const {
std::vector<uint64_t> ret;
if (isTagged()) {
// always need the actual first byte, so use ptr() directly
uint8_t const* start = ptr();
while (SliceStaticData::TypeMap[*start] == ValueType::Tagged) {
uint8_t offset;
uint64_t tag;
... | subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x57(%rsp)
callq 0xf630
movq 0x20(%rsp), %rdi
callq 0xf640
testb $0x1, %al
jne 0xf4f2
jmp 0xf5f7
movq 0x20(%rsp), %rdi
callq 0xf660
movq %rax, 0... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::hasTag(unsigned long) const | bool hasTag(uint64_t tagId) const {
// always need the actual first byte, so use ptr() directly
uint8_t const* start = ptr();
while (SliceStaticData::TypeMap[*start] == ValueType::Tagged) {
uint8_t offset;
uint64_t tag;
if (*start == 0xee) {
tag = readIntegerFixed<uint64_t, 1>(st... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf660
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x15532(%rip), %rax # 0x24cb0
cmpb $0x12, (%rax,%rcx)
jne 0xf842
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xee, %eax
jne 0xf7b1
... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::hash(unsigned long) const | inline uint64_t hash(uint64_t seed = defaultSeed64) const {
std::size_t const size = checkOverflow(byteSize());
if (size == 1 && seed == defaultSeed64) {
uint64_t h = SliceStaticData::PrecalculatedHashesForDefaultSeed[head()];
VELOCYPACK_ASSERT(h != 0);
return h;
}
return VELOCYPACK_HA... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xf9d0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x1, 0x10(%rsp)
jne 0xfb79
movl $0xdeadbeef, %eax # imm = 0xDEADBEEF
cmpq %rax, 0x18(%rsp)
jne 0xfb79
movq (%rsp), %rdi
callq 0x... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::ArrayIterator::ArrayIterator(arangodb::velocypack::Slice) | explicit ArrayIterator(Slice slice)
: _slice{slice}, _current{nullptr}, _size{0}, _position{0} {
auto const head = slice.head();
if (VELOCYPACK_UNLIKELY(slice.type(head) != ValueType::Array)) {
throw Exception{Exception::InvalidValueType, "Expecting Array slice"};
}
_size = slice.arrayLength... | subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x20(%rsp), %rdi
callq 0xf950
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %edi
callq 0xfa40
cmpb $0x4, %al
set... | /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::ObjectIterator::ObjectIterator(arangodb::velocypack::Slice, bool) | explicit ObjectIterator(Slice slice, bool useSequentialIteration = false)
: _slice{slice}, _current{nullptr}, _size{0}, _position{0} {
auto const head = slice.head();
if (VELOCYPACK_UNLIKELY(slice.type(head) != ValueType::Object)) {
throw Exception{Exception::InvalidValueType, "Expecting Object slic... | subq $0x28, %rsp
movb %dl, %al
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x20(%rsp), %rdi
callq 0xf950
movb %al, 0x16(%rsp)
movzb... | /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::ObjectIterator::next() | void next() noexcept {
if (VELOCYPACK_UNLIKELY(!valid())) {
return;
}
++_position;
if (_current != nullptr) {
// skip over key
_current += Slice(_current).byteSize();
// skip over value
_current += Slice(_current).byteSize();
}
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x10230
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x10364
jmp 0x10369
jmp 0x103f5
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x8(%rax)
je 0x103f5
movq 0x28... | /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::stringSliceLength() const | ValueLength stringSliceLength() const noexcept {
// check if the type has a fixed length first
auto const h = head();
if (h == 0xbf) {
// long UTF-8 String
return static_cast<ValueLength>(
1 + 8 + readIntegerFixed<ValueLength, 8>(start() + 1));
}
return static_cast<ValueLength>... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf950
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0xbf, %eax
jne 0x10709
movq 0x8(%rsp), %rdi
callq 0xf940
movq %rax, %rdi
addq $0x1, %rdi
callq 0xe950
addq $0x9, %rax
movq %rax, 0x20(%rsp)
jmp 0x1071b
movzbl 0x17(%rsp), %ea... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::getFirstTag() const | constexpr uint64_t getFirstTag() const {
// always need the actual first byte, so use ptr() directly
return !isTagged() ? 0
: (*ptr() == 0xee
? readIntegerFixed<uint64_t, 1>(ptr() + 1)
: (*ptr() == 0xef
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xf640
testb $0x1, %al
jne 0x10b15
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x10b91
movq 0x18(%rsp), %rdi
callq 0xf660
movzbl (%rax), %eax
cmpl $0xee, %eax
jne 0x10b46
movq 0x18(%rsp), %rdi
callq 0xf660
movq %rax, %rdi
addq $0x1, ... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::findDataOffset(unsigned char) const | ValueLength findDataOffset(uint8_t head) const noexcept {
// Must be called for a non-empty array or object at start():
VELOCYPACK_ASSERT(head != 0x01 && head != 0x0a && head <= 0x14);
unsigned int fsm = SliceStaticData::FirstSubMap[head];
uint8_t const* start = this->start();
if (fsm == 0) {
... | subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rdi
movzbl 0x17(%rsp), %eax
movl %eax, %ecx
leaq 0x14f4d(%rip), %rax # 0x26050
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
callq 0xf940
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x1113c
movq 0x8(%rsp), %rdi
addq $0x... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::resolveExternals() const | SliceType resolveExternals() const {
uint8_t const* current = start();
while (*current == 0x1d) {
current =
reinterpret_cast<uint8_t const*>(SliceType(current).extractPointer());
}
return SliceType(current);
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xf940
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1d, %eax
jne 0x12cf5
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x99c0
leaq 0x8(%rsp), %rdi
callq 0x12c20
movq %rax, 0x10(%rsp)
jmp 0x12cc8
movq 0x10(%rsp), %rsi
leaq 0... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::getString(unsigned long&) const | char const* getString(ValueLength& length) const {
uint8_t const h = head();
if (h >= 0x40 && h <= 0xbe) {
// short UTF-8 String
length = h - 0x40;
return reinterpret_cast<char const*>(start() + 1);
}
if (h == 0xbf) {
// long UTF-8 String
length = readIntegerFixed<ValueLen... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf950
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x40, %eax
jl 0x13532
movzbl 0x17(%rsp), %eax
cmpl $0xbe, %eax
jg 0x13532
movq 0x8(%rsp), %rdi
movzbl 0x17(%rsp), %eax
subl $0x40, %eax
movslq %eax, %rc... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::getStringUnchecked(unsigned long&) const | char const* getStringUnchecked(ValueLength& length) const noexcept {
uint8_t const h = head();
if (h >= 0x40 && h <= 0xbe) {
// short UTF-8 String
length = h - 0x40;
return reinterpret_cast<char const*>(start() + 1);
}
// long UTF-8 String
length = readIntegerFixed<ValueLength, 8>... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xf950
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x40, %eax
jl 0x1362d
movzbl 0xf(%rsp), %eax
cmpl $0xbe, %eax
jg 0x1362d
movq (%rsp), %rdi
movzbl 0xf(%rsp), %eax
subl $0x40, %eax
movslq %eax, %rcx
movq 0x1... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::copyString[abi:cxx11]() const | std::string copyString() const {
uint8_t h = head();
if (h >= 0x40 && h <= 0xbe) {
// short UTF-8 String
ValueLength length = h - 0x40;
return std::string(reinterpret_cast<char const*>(start() + 1),
static_cast<std::size_t>(length));
}
if (h == 0xbf) {
V... | subq $0xa8, %rsp
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0xf950
movb %al, 0x8f(%rsp)
movzbl 0x8f(%rsp), %eax
cmpl $0x40, %eax
jl 0x1380b
movzbl 0x8f(%rsp), %eax
cmpl $0xbe, %eax
jg 0x1380b
movq 0x50(%rsp), ... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::copyBinary() const | std::vector<uint8_t> copyBinary() const {
if (!isBinary()) {
throw Exception(Exception::InvalidValueType, "Expecting type Binary");
}
uint8_t const h = head();
VELOCYPACK_ASSERT(h >= 0xc0 && h <= 0xc7);
std::vector<uint8_t> out;
ValueLength length =
readIntegerNonEmpty<ValueLengt... | subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x109d0
testb $0x1, %al
jne 0x13cec
movl $0x18, %edi
callq 0x40d0
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
movl $0x11, %esi
leaq 0x11237(%rip), %rdx ... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::byteSize(unsigned char const*) const | ValueLength byteSize(uint8_t const* start) const {
// check if the type has a fixed length first
ValueLength l =
static_cast<ValueLength>(SliceStaticData::FixedTypeLengths[*start]);
if (l != 0) {
// return fixed length
return l;
}
return byteSizeDynamic(start);
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x12078(%rip), %rax # 0x26150
movzbl (%rax,%rcx), %eax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x140f5
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
j... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::getBCD(signed char&, int&, unsigned long&) const | uint8_t const* getBCD(int8_t& sign, int32_t& exponent,
ValueLength& mantissaLength) const {
if (VELOCYPACK_UNLIKELY(!isBCD())) {
throw Exception(Exception::InvalidValueType, "Expecting type BCD");
}
uint64_t type = head();
bool positive = type >= 0xc8 && type <= 0xcf;
... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x109f0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15203
jmp 0x1523e
movl $0x18, %edi
callq 0x40d0
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
m... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::ObjectIterator::key(bool) const | [[nodiscard]] Slice key(bool translate = true) const {
if (VELOCYPACK_UNLIKELY(!valid())) {
throw Exception{Exception::IndexOutOfBounds};
}
if (_current != nullptr) {
Slice s{_current};
return translate ? s.makeKey() : s;
}
return _slice.getNthKey(_position, translate);
} | subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x10230
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1571d
jmp 0x15751
movl $0x18, %edi
callq 0x40d0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
movl $0xd, %esi
c... | /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::ArrayIterator::first() const | [[nodiscard]] uint8_t const* first() const noexcept {
if (VELOCYPACK_UNLIKELY(_size == 0)) {
return nullptr;
}
auto const head = _slice.head();
VELOCYPACK_ASSERT(head != 0x01); // no empty array allowed here
if (head == 0x13) {
return _slice.start() + _slice.getStartOffsetFromCompact();... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x10(%rax)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15d05
jmp 0x15d10
movq $0x0, 0x30(%rsp)
jmp 0x15d81
movq 0x18(%rsp), %rdi
callq 0xf950
movb %al, 0x27(%rsp)
movzbl 0x27(%rsp), %eax
cmpl $0x13, %eax
jne... | /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::ObjectIterator::first(bool) const | [[nodiscard]] uint8_t const* first(bool useSequentialIteration) const noexcept {
if (VELOCYPACK_UNLIKELY(_size == 0)) {
return nullptr;
}
auto const head = _slice.head();
VELOCYPACK_ASSERT(head != 0x0a); // no empty object allowed here
if (head == 0x14) {
return _slice.start() + _slice.... | subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x10(%rax)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15dbe
jmp 0x15dcc
movq $0x0, 0x30(%rsp)
jmp 0x15e51
movq 0x18(%rsp), %rdi
callq 0xf950
movb %al, 0x26... | /arangodb[P]velocypack/include/velocypack/Iterator.h |
arangodb::velocypack::Utf8Helper::isValidUtf8(unsigned char const*, unsigned long) | bool Utf8Helper::isValidUtf8(uint8_t const* p, ValueLength len) {
uint8_t const* end = p + len;
uint8_t state = ValidChar;
while (p < end) {
state = states[256 + state * 16 + states[*p++]];
if (state == InvalidChar) {
return false;
}
}
return (state == ValidChar);
} | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movb $0x0, -0x21(%rsp)
movq -0x10(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x18cae
movzbl -0x21(%rsp), %eax
shll $0x4, %eax
addl $0x100, %eax # imm = 0x100
movq -0x10(%rsp), %rcx
movq %rcx, %rdx
a... | /arangodb[P]velocypack/src/Utf8Helper.cpp |
VELOCYPACK_XXH32_update | XXH_PUBLIC_API XXH_errorcode XXH32_update(XXH32_state_t* state,
const void* input, size_t len) {
if (input == NULL)
#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && \
(XXH_ACCEPT_NULL_INPUT_POINTER >= 1)
return XXH_OK;
#else
return XXH_ERROR;
#endif
{
const xx... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x191d8
movl $0x1, 0x74(%rsp)
jmp 0x19567
movq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movl %eax, %ecx
movq 0x68(%rsp), %rax... | /arangodb[P]velocypack/src/xxhash.h |
XXH32_round | static xxh_u32 XXH32_round(xxh_u32 acc, xxh_u32 input) {
acc += input * XXH_PRIME32_2;
acc = XXH_rotl32(acc, 13);
acc *= XXH_PRIME32_1;
#if defined(__GNUC__) && defined(__SSE4_1__) && \
!defined(XXH_ENABLE_AUTOVECTORIZE)
/*
* UGLY HACK:
* This inline assembly hack forces acc into a normal register. Th... | movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
imull $0x85ebca77, -0x8(%rsp), %eax # imm = 0x85EBCA77
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
roll $0xd, %eax
movl %eax, -0x4(%rsp)
imull $0x9e3779b1, -0x4(%rsp), %eax # imm = 0x9E3779B1
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%ra... | /arangodb[P]velocypack/src/xxhash.h |
VELOCYPACK_XXH64 | XXH_PUBLIC_API XXH64_hash_t XXH64(const void* input, size_t len,
XXH64_hash_t seed) {
#if 0
/* Simple version, good for code maintenance, but unfortunately slow for small inputs */
XXH64_state_t state;
XXH64_reset(&state, seed);
XXH64_update(&state, (const xxh_u8*)input... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movl $0x1, %ecx
callq 0x19c30
addq $0x18, %rsp
retq
nop
| /arangodb[P]velocypack/src/xxhash.h |
XXH64_endian_align | XXH_FORCE_INLINE xxh_u64 XXH64_endian_align(const xxh_u8* input, size_t len,
xxh_u64 seed, XXH_alignment align) {
const xxh_u8* bEnd = input + len;
xxh_u64 h64;
#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && \
(XXH_ACCEPT_NULL_INPUT_POINTER >= 1)
if (input == NULL) ... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movq 0x70(%rsp), %rax
addq 0x68(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x20, 0x68(%rsp)
jb 0x19e3b
movq 0x50(%rsp), %rax
addq $-0x20, %rax
movq %rax, 0x40(%rsp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B1... | /arangodb[P]velocypack/src/xxhash.h |
VELOCYPACK_XXH64_reset | XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr,
XXH64_hash_t seed) {
XXH64_state_t state; /* use a local state to memcpy() in order to avoid
strict-aliasing warnings */
memset(&state, 0, sizeof(state));
state.v1 = seed + XXH_PRIM... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x40f0
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
addq 0x58(%rsp), %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movabsq $-0x3d... | /arangodb[P]velocypack/src/xxhash.h |
VELOCYPACK_XXH64_update | XXH_PUBLIC_API XXH_errorcode XXH64_update(XXH64_state_t* state,
const void* input, size_t len) {
if (input == NULL)
#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && \
(XXH_ACCEPT_NULL_INPUT_POINTER >= 1)
return XXH_OK;
#else
return XXH_ERROR;
#endif
{
const xx... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0x19fa7
movl $0x1, 0x94(%rsp)
jmp 0x1a398
movq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rcx
movq 0x88(%rsp), %rax
addq (%rax), %r... | /arangodb[P]velocypack/src/xxhash.h |
XXH_swap64 | static xxh_u64 XXH_swap64(xxh_u64 x) {
return ((x << 56) & 0xff00000000000000ULL) |
((x << 40) & 0x00ff000000000000ULL) |
((x << 24) & 0x0000ff0000000000ULL) |
((x << 8) & 0x000000ff00000000ULL) |
((x >> 8) & 0x00000000ff000000ULL) |
((x >> 24) & 0x0000000000ff0000ULL) |
... | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shlq $0x38, %rax
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
andq %rcx, %rax
movq -0x8(%rsp), %rcx
shlq $0x28, %rcx
movabsq $0xff000000000000, %rdx # imm = 0xFF000000000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
shlq $0x18, %rcx
movabsq $0xff000... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_64bits_internal | XXH_FORCE_INLINE XXH64_hash_t
XXH3_64bits_internal(const void* XXH_RESTRICT input, size_t len,
XXH64_hash_t seed64, const void* XXH_RESTRICT secret,
size_t secretLen, XXH3_hashLong64_f f_hashLong) {
XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN);
/*
* If an action is to b... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %r9, (%rsp)
cmpq $0x10, 0x20(%rsp)
ja 0x1bb1c
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x1d8e0
movq %rax, 0x30(%rsp)
jmp 0x1bba0
cmpq $0x... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_reset_internal | static void XXH3_reset_internal(XXH3_state_t* statePtr, XXH64_hash_t seed,
const void* secret, size_t secretSize) {
size_t const initStart = offsetof(XXH3_state_t, bufferedSize);
size_t const initLength =
offsetof(XXH3_state_t, nbStripesPerBlock) - initStart;
XXH_ASSERT(offse... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq $0x200, 0x10(%rsp) # imm = 0x200
movq $0x18, 0x8(%rsp)
movq 0x30(%rsp), %rdi
addq $0x200, %rdi # imm = 0x200
xorl %esi, %esi
movl $0x18, %edx
callq 0x40f0
movq 0x30(%rsp), %rax
movl $0xc2b2ae3d,... | /arangodb[P]velocypack/src/xxhash.h |
VELOCYPACK_XXH3_64bits_reset_withSeed | XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr,
XXH64_hash_t seed) {
if (statePtr == NULL) return XXH_ERROR;
if (seed == 0) return XXH3_64bits_reset(statePtr);
if (seed != statePtr->seed)
XXH3_initCustomSecret(statePtr->cu... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1c0cf
movl $0x1, 0x14(%rsp)
jmp 0x1c129
cmpq $0x0, (%rsp)
jne 0x1c0e6
movq 0x8(%rsp), %rdi
callq 0x1beb0
movl %eax, 0x14(%rsp)
jmp 0x1c129
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x228(%rcx), %rax
je 0x1c10a
movq 0x8(%rsp), %rdi
addq... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_update | XXH_FORCE_INLINE XXH_errorcode XXH3_update(XXH3_state_t* state,
const xxh_u8* input, size_t len,
XXH3_f_accumulate_512 f_acc512,
XXH3_f_scrambleAcc f_scramble) {
if (input == NULL)
#if defi... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x1c2f2
movl $0x1, 0x74(%rsp)
jmp 0x1c591
movq 0x60(%rsp), %rax
addq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
cmpq $0x0, 0x238(%rax)
jne 0x1c320
mov... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_accumulate_512_sse2 | XXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_accumulate_512_sse2(
void* XXH_RESTRICT acc, const void* XXH_RESTRICT input,
const void* XXH_RESTRICT secret) {
/* SSE2 is just a half-scale version of the AVX2 version. */
XXH_ASSERT((((size_t)acc) & 15) == 0);
{
XXH_ALIGN(16) __m128i* const xacc = (__m128i*... | subq $0xc8, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, -0x8(%rsp)
cmpq $0x4, -0x8(%rsp)
jae 0x1c737
movq 0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
shlq $0x4, ... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_scrambleAcc_sse2 | XXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_scrambleAcc_sse2(
void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret) {
XXH_ASSERT((((size_t)acc) & 15) == 0);
{
XXH_ALIGN(16) __m128i* const xacc = (__m128i*)acc;
/* Unaligned. This is mainly for pointer arithmetic, and because
* _mm_loadu_si128 requ... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x9e3779b1, 0x108(%rsp) # imm = 0x9E3779B1
movl 0x108(%rsp), %eax
movl %eax, 0x164(%rsp)
movl %eax, 0x160(%rsp)
movl %eax, 0x15c(%rsp)
movl... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_digest_long | XXH_FORCE_INLINE void XXH3_digest_long(XXH64_hash_t* acc,
const XXH3_state_t* state,
const unsigned char* secret) {
/*
* Digest on a local copy. This way, the state remains unaltered, and it can
* continue ingesting more input afterwa... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movl $0x40, %edx
callq 0x4130
movq 0x78(%rsp), %rax
cmpl $0x40, 0x200(%rax)
jb 0x1cbfc
movq 0x78(%rsp), %rax
movl 0x200(%rax), %eax
subl $0x1, %eax
shrl $0x6, %eax
movl %eax, %eax
movq %rax, 0x... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_128bits_internal | XXH_FORCE_INLINE XXH128_hash_t
XXH3_128bits_internal(const void* input, size_t len, XXH64_hash_t seed64,
const void* XXH_RESTRICT secret, size_t secretLen,
XXH3_hashLong128_f f_hl128) {
XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN);
/*
* If an action is to be taken if ... | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
cmpq $0x10, 0x28(%rsp)
ja 0x1d082
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x1e6c0
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_hashLong_128b_default | XXH_NO_INLINE XXH128_hash_t XXH3_hashLong_128b_default(
const void* XXH_RESTRICT input, size_t len, XXH64_hash_t seed64,
const void* XXH_RESTRICT secret, size_t secretLen) {
(void)seed64;
(void)secret;
(void)secretLen;
return XXH3_hashLong_128b_internal(input, len, XXH3_kSecret,
... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x94a3(%rip), %rdx # 0x26600
leaq -0xbc4(%rip), %r8 # 0x1c5a0
leaq -0xa2b(%rip), %r9 # 0x1c740
movl $0xc0, %ecx
callq 0x1f210
movq %r... | /arangodb[P]velocypack/src/xxhash.h |
VELOCYPACK_XXH3_128bits_reset_withSeed | XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSeed(XXH3_state_t* statePtr,
XXH64_hash_t seed) {
if (statePtr == NULL) return XXH_ERROR;
if (seed == 0) return XXH3_128bits_reset(statePtr);
if (seed != statePtr->seed)
XXH3_initCustomSecret(statePtr-... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1d3ff
movl $0x1, 0x14(%rsp)
jmp 0x1d459
cmpq $0x0, (%rsp)
jne 0x1d416
movq 0x8(%rsp), %rdi
callq 0x1d310
movl %eax, 0x14(%rsp)
jmp 0x1d459
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x228(%rcx), %rax
je 0x1d43a
movq 0x8(%rsp), %rdi
addq... | /arangodb[P]velocypack/src/xxhash.h |
XXH32_avalanche | static xxh_u32 XXH32_avalanche(xxh_u32 h32) {
h32 ^= h32 >> 15;
h32 *= XXH_PRIME32_2;
h32 ^= h32 >> 13;
h32 *= XXH_PRIME32_3;
h32 ^= h32 >> 16;
return (h32);
} | movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0xf, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
imull $0x85ebca77, -0x4(%rsp), %eax # imm = 0x85EBCA77
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0xd, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
imull $0xc2b2ae3d, -0x4(%rsp), %eax # imm = 0xC2B2AE3D
mo... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_len_129to240_64b | XXH_NO_INLINE XXH64_hash_t XXH3_len_129to240_64b(
const xxh_u8* XXH_RESTRICT input, size_t len,
const xxh_u8* XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed) {
XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
(void)secretSize;
XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);
#define XXH3_MIDSI... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, 0x4(%rsp)
movl $0x0, (... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_len_9to16_64b | XXH_FORCE_INLINE XXH64_hash_t XXH3_len_9to16_64b(const xxh_u8* input,
size_t len,
const xxh_u8* secret,
XXH64_hash_t seed) {
XXH_ASSERT(input != NULL);
XXH_ASSERT(secret... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x50(%rsp), %rdi
addq $0x18, %rdi
callq 0x1a400
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
addq $0x20, %rdi
callq 0x1a400
movq %rax, %rcx
movq (%rsp), %rax
xorq %rcx, %rax
addq 0x48(%rsp), %rax
movq %rax, 0x40(%rs... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_len_4to8_64b | XXH_FORCE_INLINE XXH64_hash_t XXH3_len_4to8_64b(const xxh_u8* input, size_t len,
const xxh_u8* secret,
XXH64_hash_t seed) {
XXH_ASSERT(input != NULL);
XXH_ASSERT(secret != NULL);
XXH_ASSERT(4 <= len && len < 8);
seed... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl %eax, %edi
callq 0x19b90
movl %eax, %eax
shlq $0x20, %rax
xorq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x195f0
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
addq 0... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_rrmxmx | static XXH64_hash_t XXH3_rrmxmx(xxh_u64 h64, xxh_u64 len) {
/* this mix is inspired by Pelle Evensen's rrmxmx */
h64 ^= XXH_rotl64(h64, 49) ^ XXH_rotl64(h64, 24);
h64 *= 0x9FB21C651E98DF25ULL;
h64 ^= (h64 >> 35) + len;
h64 *= 0x9FB21C651E98DF25ULL;
return XXH_xorshift64(h64, 28);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
rolq $0x31, %rax
movq 0x10(%rsp), %rcx
rolq $0x18, %rcx
xorq %rcx, %rax
xorq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movabsq $-0x604de39ae16720db, %rax # imm = 0x9FB21C651E98DF25
imulq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp)... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_mix16B | XXH_FORCE_INLINE xxh_u64 XXH3_mix16B(const xxh_u8* XXH_RESTRICT input,
const xxh_u8* XXH_RESTRICT secret,
xxh_u64 seed64) {
#if defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \
&& defined(__i386__) && defined(__SSE2__) /* x86 ... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1a400
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0x1a400
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1a400
movq %rax, %rcx
movq 0x8(%... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_len_0to16_128b | XXH_FORCE_INLINE XXH128_hash_t XXH3_len_0to16_128b(const xxh_u8* input,
size_t len,
const xxh_u8* secret,
XXH64_hash_t seed) {
XXH_ASSERT(len <= 16);
{
if (len... | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
cmpq $0x8, 0x38(%rsp)
jbe 0x1e708
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x1ecb0
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
jmp 0x1e7f2
cmpq $0x4, 0x38(%rsp)
j... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_len_17to128_128b | XXH_FORCE_INLINE XXH128_hash_t XXH3_len_17to128_128b(
const xxh_u8* XXH_RESTRICT input, size_t len,
const xxh_u8* XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed) {
XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
(void)secretSize;
XXH_ASSERT(16 < len && len <= 128);
{
XXH128_hash_t acc;
... | subq $0x88, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
cmpq $0x20, 0x68(%rsp)
jbe 0x1e964
cmpq $0x40, 0x68(%rsp)
jbe 0x1... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_len_129to240_128b | XXH_NO_INLINE XXH128_hash_t XXH3_len_129to240_128b(
const xxh_u8* XXH_RESTRICT input, size_t len,
const xxh_u8* XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed) {
XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
(void)secretSize;
XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);
{
XXH128_h... | subq $0x88, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x68(%rsp), %rax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, 0x3c(%rsp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x0,... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_len_9to16_128b | XXH_FORCE_INLINE XXH128_hash_t XXH3_len_9to16_128b(const xxh_u8* input,
size_t len,
const xxh_u8* secret,
XXH64_hash_t seed) {
XXH_ASSERT(input != NULL);
XXH_ASSER... | subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x50(%rsp), %rdi
addq $0x20, %rdi
callq 0x1a400
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
addq $0x28, %rdi
callq 0x1a400
movq %rax, %rcx
movq (%rsp), %rax
xorq %rcx, %rax
movq 0x48(%rsp), %rcx
subq %rcx, %rax
mov... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_len_1to3_128b | XXH_FORCE_INLINE XXH128_hash_t XXH3_len_1to3_128b(const xxh_u8* input,
size_t len,
const xxh_u8* secret,
XXH64_hash_t seed) {
/* A doubled version of 1to3_64b with diff... | subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rax
movb (%rax), %al
movb %al, 0x37(%rsp)
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
shrq %rcx
movb (%rax,%rcx), %al
movb %al, 0x36(%rsp)
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %rax
movb -0x1(%rax... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_hashLong_128b_internal | XXH_FORCE_INLINE XXH128_hash_t XXH3_hashLong_128b_internal(
const void* XXH_RESTRICT input, size_t len,
const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble) {
XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;
XXH3_hashLong_... | subq $0x98, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x74bc(%rip), %rsi # 0x26700
movl $0x40, %edx
callq 0x4130
leaq 0x10(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x70(%rsp),... | /arangodb[P]velocypack/src/xxhash.h |
absl::lts_20240722::strings_internal::Splitter<absl::lts_20240722::ByChar, absl::lts_20240722::SkipEmpty, std::basic_string_view<char, std::char_traits<char>>>::ConvertToContainer<std::vector<std::basic_string_view<char, std::char_traits<char>>, std::allocator<std::basic_string_view<char, std::char_traits<char>>>>, std... | std::vector<absl::string_view, A> operator()(
const Splitter& splitter) const {
struct raw_view {
const char* data;
size_t size;
operator absl::string_view() const { // NOLINT(runtime/explicit)
return {data, size};
}
};
std::vector<absl::string_view, ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x9d62
leaq 0x8(%rsp), %r14
leaq 0x38(%rsp), %r15
cmpl $0x2, 0x10(%rsp)
je 0x9d38
xorl %r12d, %r12d
movq 0x18(%r... | /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/strings/internal/str_split_internal.h |
upb::generator::FieldInitializer[abi:cxx11](upb::FieldDefPtr, upb_MiniTableField const*, upb_MiniTableField const*) | std::string FieldInitializer(upb::FieldDefPtr field,
const upb_MiniTableField* field64,
const upb_MiniTableField* field32) {
return absl::Substitute(
"{$0, $1, $2, $3, $4, $5}", upb_MiniTableField_Number(field64),
ArchDependentSize(field32->UPB_PRI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdx), %esi
leaq 0x140(%rsp), %rdi
callq 0xb82a
movzwl 0x4(%r15), %esi
movzwl 0x4(%r14), %edx
leaq 0x60(%rsp), %r12
movq %r12, %rdi
callq 0xb543
movq (%r12), %rax
movq ... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/common.cc |
upb::generator::GetModeInit[abi:cxx11](upb_MiniTableField const*, upb_MiniTableField const*) | std::string GetModeInit(const upb_MiniTableField* field32,
const upb_MiniTableField* field64) {
std::string ret;
uint8_t mode32 = field32->UPB_PRIVATE(mode);
switch (mode32 & kUpb_FieldMode_Mask) {
case kUpb_FieldMode_Map:
ret = "(int)kUpb_FieldMode_Map";
break;
case kU... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
movzbl 0xb(%rsi), %ebp
movl %ebp, %eax
andl $0x3, %eax
leaq 0x1ebb7(%rip), %rcx # 0x2a1a4
movslq (%rcx,%rax,4), %rax
addq %r... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/common.cc |
upb::generator::AddExtensionsFromMessage(upb::MessageDefPtr, std::vector<upb::FieldDefPtr, std::allocator<upb::FieldDefPtr>>*) | void AddExtensionsFromMessage(upb::MessageDefPtr message,
std::vector<upb::FieldDefPtr>* exts) {
for (int i = 0; i < message.nested_extension_count(); i++) {
exts->push_back(message.nested_extension(i));
}
for (int i = 0; i < message.nested_message_count(); i++) {
AddExtensio... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq %rsp, %r15
movq %r14, %rdi
callq 0x1d913
cmpl %eax, %ebp
jge 0xc0b6
movq %r14, %rdi
movl %ebp, %esi
callq 0x1da7f
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd48a
incl %ebp
jmp 0xc08d
xorl %ebp, %eb... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/file_layout.cc |
upb::generator::SortedExtensions(upb::FileDefPtr) | std::vector<upb::FieldDefPtr> SortedExtensions(upb::FileDefPtr file) {
std::vector<upb::FieldDefPtr> ret;
ret.reserve(file.toplevel_extension_count());
for (int i = 0; i < file.toplevel_extension_count(); i++) {
ret.push_back(file.toplevel_extension(i));
}
for (int i = 0; i < file.toplevel_message_count()... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x1bc7f
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xca60
xorl %ebp, %ebp
movq %rsp, %r15
movq %r14, %rdi
callq 0x1bc7f
cmpl %eax, %ebp
jge 0xc141
movq ... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/file_layout.cc |
upb::generator::FieldNumberOrder(upb::MessageDefPtr) | std::vector<upb::FieldDefPtr> FieldNumberOrder(upb::MessageDefPtr message) {
std::vector<upb::FieldDefPtr> fields;
fields.reserve(message.field_count());
for (int i = 0; i < message.field_count(); i++) {
fields.push_back(message.field(i));
}
std::sort(fields.begin(), fields.end(),
[](upb::Fiel... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x1d8f0
movslq %eax, %rsi
movq %rbx, %rdi
callq 0xca60
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x1d8f0
cmpl %eax,... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/file_layout.cc |
upb::generator::FastDecodeTable[abi:cxx11](upb::MessageDefPtr, upb::generator::DefPoolPair const&) | std::vector<TableEntry> FastDecodeTable(upb::MessageDefPtr message,
const DefPoolPair& pools) {
std::vector<TableEntry> table;
for (const auto field : FieldHotnessOrder(message)) {
TableEntry ent;
int slot = GetTableSlot(field);
// std::cerr << "table slot: " << f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdx, 0x38(%rsp)
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
andq $0x0, 0x10(%rdi)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rsi, %rdi
callq 0x1d8f0
movslq %eax, ... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/minitable/fasttable.cc |
absl::lts_20240722::SubstituteAndAppend(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::basic_string_view<char, std::char_traits<char>>, absl::lts_20240722::substitute_internal::Arg const&, absl::lts_20240722::substitute_internal::Arg const&, absl::lts_20240722::substitute_internal... | inline void SubstituteAndAppend(absl::Nonnull<std::string*> output,
absl::string_view format,
const substitute_internal::Arg& a0,
const substitute_internal::Arg& a1,
const substitute_internal:... | subq $0x48, %rsp
movq 0x50(%rsp), %rax
movups (%rcx), %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movups (%r8), %xmm0
movaps %xmm0, 0x10(%rcx)
movups (%r9), %xmm0
movaps %xmm0, 0x20(%rcx)
movups (%rax), %xmm0
movaps %xmm0, 0x30(%rcx)
pushq $0x4
popq %r8
callq 0x9320
addq $0x48, %rsp
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/strings/substitute.h |
absl::lts_20240722::SubstituteAndAppend(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::basic_string_view<char, std::char_traits<char>>, absl::lts_20240722::substitute_internal::Arg const&, absl::lts_20240722::substitute_internal::Arg const&, absl::lts_20240722::substitute_internal... | inline void SubstituteAndAppend(absl::Nonnull<std::string*> output,
absl::string_view format,
const substitute_internal::Arg& a0,
const substitute_internal::Arg& a1,
const substitute_internal:... | subq $0x38, %rsp
movups (%rcx), %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movups (%r8), %xmm0
movaps %xmm0, 0x10(%rcx)
movups (%r9), %xmm0
movaps %xmm0, 0x20(%rcx)
pushq $0x3
popq %r8
callq 0x9320
addq $0x38, %rsp
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/strings/substitute.h |
upb::generator::WriteMiniTableSourceIncludes(upb::FileDefPtr, upb::generator::MiniTableOptions const&, upb::generator::Output&) | void WriteMiniTableSourceIncludes(upb::FileDefPtr file,
const MiniTableOptions& options,
Output& output) {
output(FileWarning(file.name()));
output(
"#include <stddef.h>\n"
"#include \"upb/generated_code_support.h\"\n"
"#include ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1bc36
movq %rax, %r12
movq %rax, %rdi
callq 0x9130
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xbb67
movq (%r13), %rdx
movq 0x8(%r13), %rsi
movq %rbx... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/minitable/generator.cc |
upb::generator::WriteMiniTableSource(upb::generator::DefPoolPair const&, upb::FileDefPtr, upb::generator::MiniTableOptions const&, upb::generator::Output&) | void WriteMiniTableSource(const DefPoolPair& pools, upb::FileDefPtr file,
const MiniTableOptions& options, Output& output) {
WriteMiniTableSourceIncludes(file, options, output);
std::vector<upb::MessageDefPtr> messages = SortedMessages(file);
std::vector<upb::FieldDefPtr> extensions = S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xef24
leaq 0x58(%rsp), %rdi
movq %r13, %rsi
callq 0xc024
leaq 0x40(%rsp), %rdi
movq %r13, %rsi
callq 0xc0e8
leaq 0x28(... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/minitable/generator.cc |
upb::generator::(anonymous namespace)::WriteExtension(upb::generator::DefPoolPair const&, upb::FieldDefPtr, upb::generator::Output&) | void WriteExtension(const DefPoolPair& pools, upb::FieldDefPtr ext,
Output& output) {
output("UPB_LINKARR_APPEND(upb_AllExts)\n");
output("const upb_MiniTableExtension $0 = {\n ", ExtensionVarName(ext));
output("$0,\n", FieldInitializer(pools, ext));
output(" &$0,\n", MessageVarName(ext.co... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1eb2f(%rip), %rdx # 0x2ed9c
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x1085c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xee8b
leaq 0x1eb2e(%rip), %rdx # 0x2edbd
pushq $0x26
pop... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/minitable/generator.cc |
upb::generator::MultipleSourceFilename[abi:cxx11](upb::FileDefPtr, std::basic_string_view<char, std::char_traits<char>>, int*) | std::string MultipleSourceFilename(upb::FileDefPtr file,
absl::string_view full_name, int* i) {
*i += 1;
return absl::StrCat(StripExtension(file.name()), ".upb_weak_minitables/",
*i, ".upb.c");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %r14
movq %rdi, %rbx
incl (%r8)
movq %rsi, %rdi
callq 0x1bc36
movq %rax, %r15
movq %rax, %rdi
callq 0x9130
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xba23
movq (%r12), %rax
movq 0x8(%r12), %rcx
movq %rcx, 0x58(%rsp)... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/minitable/generator.cc |
upb::generator::WriteMiniTableMultipleSources(upb::generator::DefPoolPair const&, upb::FileDefPtr, upb::generator::MiniTableOptions const&, upb::generator::Plugin*) | void WriteMiniTableMultipleSources(const DefPoolPair& pools,
upb::FileDefPtr file,
const MiniTableOptions& options,
Plugin* plugin) {
std::vector<upb::MessageDefPtr> messages = SortedMessages(file);
std::vector<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x30(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x58(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xc024
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0xc0e8
leaq 0x60(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
callq 0xbde7
lea... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/minitable/generator.cc |
void upb::generator::Output::operator()<>(std::basic_string_view<char, std::char_traits<char>>) | void operator()(absl::string_view format, const Arg&... arg) {
Write(absl::Substitute(format, arg...));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1385e
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x128f6
leaq 0x8(%rsp), %rdi
callq 0x9150
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9150
movq %rbx, %rdi
cal... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/common.h |
void upb::generator::Output::operator()<char [13], unsigned long>(std::basic_string_view<char, std::char_traits<char>>, char const (&) [13], unsigned long const&) | void operator()(absl::string_view format, const Arg&... arg) {
Write(absl::Substitute(format, arg...));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
callq 0xb9a2
leaq 0x58(%rsp), %r13
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq (%rbx), %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x12aa2
leaq 0x8(%rsp)... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/common.h |
void upb::generator::Output::operator()<char const*>(std::basic_string_view<char, std::char_traits<char>>, char const* const&) | void operator()(absl::string_view format, const Arg&... arg) {
Write(absl::Substitute(format, arg...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rcx), %rdi
callq 0xb9a2
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xbc3a
movq (%r12), %rdx
movq 0x8(%r12), %rs... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/common.h |
std::pair<absl::lts_20240722::container_internal::raw_hash_set<absl::lts_20240722::container_internal::FlatHashSetPolicy<upb_MiniTable const*>, absl::lts_20240722::container_internal::HashEq<upb_MiniTable const*, void>::Hash, absl::lts_20240722::container_internal::HashEq<upb_MiniTable const*, void>::Eq, std::allocator... | std::pair<iterator, bool> find_or_prepare_insert_soo(const K& key) {
if (empty()) {
const HashtablezInfoHandle infoz = try_sample_soo();
if (infoz.IsSampled()) {
resize_with_soo_infoz(infoz);
} else {
common().set_full_soo();
return {soo_iterator(), true};
}
} els... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x1, 0x8(%rsi)
ja 0x1157e
movq %r14, %rdi
callq 0x11a98
movq %r14, %rdi
callq 0x11ac4
movq %r14, %rdi
callq 0x11ad8
jmp 0x115c0
movq %rdx, %r15
movq %r14, %rdi
callq 0x118f6
movq (%rax), %rax
cmpq (%r15), %rax
je 0x115d5
pushq $0x3
popq %rsi
movq %r... | /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/container/internal/raw_hash_set.h |
absl::lts_20240722::container_internal::DoSanitizeOnSetCtrl(absl::lts_20240722::container_internal::CommonFields const&, unsigned long, absl::lts_20240722::container_internal::ctrl_t, unsigned long) | inline void DoSanitizeOnSetCtrl(const CommonFields& c, size_t i, ctrl_t h,
size_t slot_size) {
assert(i < c.capacity());
auto* slot_i = static_cast<const char*>(c.slot_array()) + i * slot_size;
if (IsFull(h)) {
SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
} else {
Sa... | cmpq %rsi, (%rdi)
jbe 0x1220f
retq
pushq %rax
leaq 0x1a785(%rip), %rdi # 0x2c99c
leaq 0x18f2f(%rip), %rsi # 0x2b14d
leaq 0x1a788(%rip), %rcx # 0x2c9ad
movl $0x70c, %edx # imm = 0x70C
callq 0x9250
| /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/container/internal/raw_hash_set.h |
void absl::lts_20240722::container_internal::Deallocate<8ul, std::allocator<char>>(std::allocator<char>*, void*, unsigned long) | void Deallocate(Alloc* alloc, void* p, size_t n) {
static_assert(Alignment > 0, "");
assert(n && "n must be positive");
using M = AlignedType<Alignment>;
using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
... | testq %rdx, %rdx
je 0x12247
addq $0x7, %rdx
andq $-0x8, %rdx
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x9360
pushq %rax
leaq 0x1a423(%rip), %rdi # 0x2c672
leaq 0x1a436(%rip), %rsi # 0x2c68c
leaq 0x1a84a(%rip), %rcx # 0x2caa7
pushq $0x58
popq %rdx
callq 0x9250
nop
| /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/container/internal/container_memory.h |
void absl::lts_20240722::container_internal::DeallocateStandard<8ul>(absl::lts_20240722::container_internal::CommonFields&, absl::lts_20240722::container_internal::PolicyFunctions const&) | ABSL_ATTRIBUTE_NOINLINE void DeallocateStandard(CommonFields& common,
const PolicyFunctions& policy) {
// Unpoison before returning the memory to the allocator.
SanitizerUnpoisonMemoryRegion(common.slot_array(),
policy.slot_size * commo... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11f48
movq %r14, %rdi
callq 0x12134
movq %rax, %r15
movq (%rbx), %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x123a0
leaq 0xf(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1222f
addq $0x10, %rsp
popq %rbx
popq %r14
popq ... | /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/container/internal/raw_hash_set.h |
absl::lts_20240722::container_internal::AssertSameContainer(absl::lts_20240722::container_internal::ctrl_t const*, absl::lts_20240722::container_internal::ctrl_t const*, void const* const&, void const* const&, unsigned char const*, unsigned char const*) | inline void AssertSameContainer(const ctrl_t* ctrl_a, const ctrl_t* ctrl_b,
const void* const& slot_a,
const void* const& slot_b,
const GenerationType* generation_ptr_a,
const GenerationType* ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x38b32(%rip), %rax # 0x4afc8
addq $0x10, %rax
movq %rdi, %rcx
xorq %rax, %rcx
movq %rsi, %rdx
xorq %rax, %rdx
orq %rcx, %rdx
je 0x124e8
movq %rsi, %r15
movq %rdi, %r12
cmpq %rax, %rsi
sete %cl
cmpq %rax, %rdi
sete %al
xorb ... | /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/container/internal/raw_hash_set.h |
absl::lts_20240722::container_internal::raw_hash_set<absl::lts_20240722::container_internal::FlatHashSetPolicy<upb_MiniTable const*>, absl::lts_20240722::container_internal::HashEq<upb_MiniTable const*, void>::Hash, absl::lts_20240722::container_internal::HashEq<upb_MiniTable const*, void>::Eq, std::allocator<upb_MiniT... | iterator find_soo(const key_arg<K>& key) {
assert(is_soo());
return empty() || !PolicyTraits::apply(EqualElement<K>{key, eq_ref()},
PolicyTraits::element(soo_slot()))
? end()
: soo_iterator();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x11542
testb %al, %al
je 0x12685
cmpq $0x2, 0x8(%rbx)
jb 0x1266c
movq %rbx, %rdi
callq 0x118f6
movq (%rax), %rax
cmpq (%r14), %rax
je 0x12676
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r... | /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/container/internal/raw_hash_set.h |
absl::lts_20240722::container_internal::raw_hash_set<absl::lts_20240722::container_internal::FlatHashSetPolicy<upb_MiniTable const*>, absl::lts_20240722::container_internal::HashEq<upb_MiniTable const*, void>::Hash, absl::lts_20240722::container_internal::HashEq<upb_MiniTable const*, void>::Eq, std::allocator<upb_MiniT... | iterator find_non_soo(const key_arg<K>& key, size_t hash) {
assert(!is_soo());
auto seq = probe(common(), hash);
const ctrl_t* ctrl = control();
while (true) {
Group g{ctrl + seq.offset()};
for (uint32_t i : g.Match(H2(hash))) {
if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x11542
testb %al, %al
jne 0x12803
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1216b
movq %rbx, %rdi
callq 0x122e2
movq %rax, %r12
andb $0x7f, %r15b
movzbl %r15b, %ea... | /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/container/internal/raw_hash_set.h |
upb::generator::Output::Write(std::basic_string_view<char, std::char_traits<char>>) | void Write(absl::string_view data) {
std::string stripped;
if (absl::StartsWith(data, "\n ")) {
size_t indent = data.substr(1).find_first_not_of(' ');
if (indent != absl::string_view::npos) {
// Remove indentation from all lines.
auto line_prefix = data.substr(0, indent + 1);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x1b990(%rip), %rcx # 0x2e2b6
pushq $0x2
popq %rax
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x12aca
testb %a... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/common.h |
void upb::generator::Output::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::basic_string<char, std::... | void operator()(absl::string_view format, const Arg&... arg) {
Write(absl::Substitute(format, arg...));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq 0x130(%rsp), %rbx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
leaq 0xc8(%rsp), %r13
movq %rcx, (%r13)
movq %rax, 0x8(%r13)
movl (%r8), %esi
leaq 0x98(%rsp), %rbp
movq %... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/common.h |
upb_Array_New_dont_copy_me__upb_internal_use_only | UPB_INLINE struct upb_Array* UPB_PRIVATE(_upb_Array_New)(upb_Arena* arena,
size_t init_capacity,
int elem_size_lg2) {
UPB_ASSERT(elem_size_lg2 != 1);
UPB_ASSERT(elem_size_lg2 <= 4);
const size_t array... | pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edx
je 0x13524
movl %edx, %ebp
cmpl $0x5, %edx
jge 0x1353d
movq %rsi, %rbx
movl %ebp, %ecx
shlq %cl, %rsi
addq $0x18, %rsi
callq 0x1363f
movq %rax, %r14
testq %rax, %rax
je 0x1351c
movq %r14, %rsi
addq $0x18, %rsi
movslq %ebp, %rdx
movq %r14, %rdi
callq 0x1368c
andq $0x0, 0x... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/array.h |
upb_Message_SetField_dont_copy_me__upb_internal_use_only | UPB_INLINE bool UPB_PRIVATE(_upb_Message_SetField)(struct upb_Message* msg,
const upb_MiniTableField* f,
upb_MessageValue val,
upb_Arena* a) {
if (upb_MiniTableField... | subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
testb $0x8, 0xb(%rsi)
jne 0x13593
leaq 0x8(%rsp), %rdx
callq 0x1375d
movb $0x1, %al
jmp 0x135a0
leaq 0x8(%rsp), %rdx
movq %r8, %rcx
callq 0x136df
addq $0x18, %rsp
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/accessors.h |
upb_Array_SetTaggedPtr_dont_copy_me__upb_internal_use_only | UPB_INLINE void UPB_PRIVATE(_upb_Array_SetTaggedPtr)(struct upb_Array* array,
void* data, size_t lg2) {
UPB_ASSERT(lg2 != 1);
UPB_ASSERT(lg2 <= 4);
const size_t bits = lg2 - (lg2 != 0);
array->UPB_ONLYBITS(data) = (uintptr_t)data | bits;
} | pushq %rax
cmpq $0x1, %rdx
je 0x136a9
cmpq $0x5, %rdx
jae 0x136c2
cmpq $0x1, %rdx
adcq $-0x1, %rdx
orq %rsi, %rdx
movq %rdx, (%rdi)
popq %rax
retq
leaq 0x1b8ae(%rip), %rdi # 0x2ef5e
leaq 0x1b8b0(%rip), %rsi # 0x2ef67
leaq 0x1ba93(%rip), %rcx # 0x2f151
pushq $0x36
jmp 0x136d9
leaq 0x1b98d(%rip), %rdi # 0... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/internal/array.h |
upb::generator::ParseOptions(upb::generator::MiniTableOptions*, upb::generator::Plugin*) | bool ParseOptions(MiniTableOptions* options, Plugin* plugin) {
for (const auto& pair : ParseGeneratorParameter(plugin->parameter())) {
if (pair.first == "bootstrap_stage") {
options->bootstrap = true;
} else if (pair.first == "experimental_strip_nonfunctional_codegen") {
options->strip_nonfunction... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
movq %rsi, %rdi
callq 0x13e08
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x13dca
movq (%r12), %rbx
movq 0x8(%r12), %r14
leaq 0x1(%r15), %rbp
leaq 0x2(%r15), %r13
leaq 0x1baed(%rip), %... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/minitable/main.cc |
google_protobuf_compiler_CodeGeneratorRequest_parameter | UPB_INLINE upb_StringView google_protobuf_compiler_CodeGeneratorRequest_parameter(const google_protobuf_compiler_CodeGeneratorRequest* msg) {
upb_StringView default_val = upb_StringView_FromString("");
upb_StringView ret;
const upb_MiniTableField field = {2, UPB_SIZE(28, 24), 64, kUpb_NoSub, 12, (int)kUpb_FieldMo... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x16cc4(%rip), %rdi # 0x2ac2f
callq 0x14015
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movabsq $0x40001800000002, %rax # imm = 0x40001800000002
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movl $0x920cffff, 0x8(%rdi) # imm = 0x920CFFFF
callq 0x12ba5
tes... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb_generator/cmake/google/protobuf/compiler/plugin.upb.h |
void absl::lts_20240722::container_internal::raw_hash_set<absl::lts_20240722::container_internal::FlatHashSetPolicy<std::basic_string_view<char, std::char_traits<char>>>, absl::lts_20240722::container_internal::StringHash, absl::lts_20240722::container_internal::StringEq, std::allocator<std::basic_string_view<char, std... | void emplace_at(iterator iter, Args&&... args) {
construct(iter.slot(), std::forward<Args>(args)...);
assert(PolicyTraits::apply(FindElement{*this}, *iter) == iter &&
"constructed value does not match the lookup key");
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %r14, %rdi
callq 0x15508
movq %rbx, %rdi
movq %rax, %rsi
callq 0x15584
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movaps (%r14), %xmm0
movq... | /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/container/internal/raw_hash_set.h |
absl::lts_20240722::hash_internal::MixingHashState::Read1To3(unsigned char const*, unsigned long) | static uint32_t Read1To3(const unsigned char* p, size_t len) {
// The trick used by this implementation is to avoid branches if possible.
unsigned char mem0 = p[0];
unsigned char mem1 = p[len / 2];
unsigned char mem2 = p[len - 1];
#ifdef ABSL_IS_LITTLE_ENDIAN
unsigned char significant2 = mem2;
u... | movzbl -0x1(%rdi,%rsi), %eax
leaq -0x1(%rsi), %rdx
movq %rsi, %rcx
shrq %rcx
movzbl (%rdi,%rcx), %esi
shll $0x3, %ecx
shll %cl, %esi
shll $0x3, %edx
movl %edx, %ecx
shll %cl, %eax
movzbl (%rdi), %ecx
orl %ecx, %eax
orl %esi, %eax
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/hash/internal/hash.h |
absl::lts_20240722::container_internal::raw_hash_set<absl::lts_20240722::container_internal::FlatHashSetPolicy<std::basic_string_view<char, std::char_traits<char>>>, absl::lts_20240722::container_internal::StringHash, absl::lts_20240722::container_internal::StringEq, std::allocator<std::basic_string_view<char, std::cha... | iterator find_soo(const key_arg<K>& key) {
assert(is_soo());
return empty() || !PolicyTraits::apply(EqualElement<K>{key, eq_ref()},
PolicyTraits::element(soo_slot()))
? end()
: soo_iterator();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x14960
testb %al, %al
je 0x15634
cmpq $0x2, 0x8(%rbx)
jb 0x15628
movq %rsp, %r15
movq %r14, (%r15)
movq %rbx, 0x8(%r15)
movq %rbx, %rdi
callq 0x14dd2
movq %r15, %rdi
movq %rax, %rsi
callq 0x15463
testb %al, %al
je 0x15628
movq %rbx... | /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/container/internal/raw_hash_set.h |
absl::lts_20240722::container_internal::raw_hash_set<absl::lts_20240722::container_internal::FlatHashSetPolicy<std::basic_string_view<char, std::char_traits<char>>>, absl::lts_20240722::container_internal::StringHash, absl::lts_20240722::container_internal::StringEq, std::allocator<std::basic_string_view<char, std::cha... | inline void dealloc() {
assert(capacity() != 0);
// Unpoison before returning the memory to the allocator.
SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
infoz().Unregister();
Deallocate<BackingArrayAlignment(alignof(slot_type))>(
&alloc_ref(), common().backing_... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x14e08
testq %rax, %rax
je 0x159e1
movq %rbx, %rdi
callq 0x14e32
movq %rbx, %rdi
callq 0x14e08
movq %rbx, %rdi
callq 0x15a00
movq %rbx, %rdi
callq 0x12134
movq %rax, %r14
pushq $0x10
popq %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x123a0
movq %rbx, %rdi
movq... | /pybind[P]pybind11_protobuf/build_O2/_deps/absl-src/absl/container/internal/raw_hash_set.h |
upb_Status_VAppendErrorFormat | void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt,
va_list args) {
size_t len;
if (!status) return;
status->ok = false;
len = strlen(status->msg);
vsnprintf(status->msg + len, sizeof(status->msg) - len, fmt, args);
status->msg[_kUpb_Status_MaxMessage -... | testq %rdi, %rdi
je 0x16098
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
movb %bpl, (%rdi)
incq %rdi
callq 0x9130
leaq (%rbx,%rax), %rdi
incq %rdi
movl $0x1ff, %esi # imm = 0x1FF
subq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/base/status.c |
upb_Arena_FindRoot | static upb_ArenaRoot _upb_Arena_FindRoot(upb_Arena* a) {
upb_ArenaInternal* ai = upb_Arena_Internal(a);
uintptr_t poc = upb_Atomic_Load(&ai->parent_or_count, memory_order_acquire);
while (_upb_Arena_IsTaggedPointer(poc)) {
upb_ArenaInternal* next = _upb_Arena_PointerFromTagged(poc);
UPB_ASSERT(ai != next)... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rbx
addq $0x10, %r15
movq %r15, %r14
testb $0x1, %bl
jne 0x16144
movq %rbx, %rdi
callq 0x161d2
cmpq %rax, %r14
je 0x16150
movq %rax, %r15
movq 0x8(%rax), %rbx
testb $0x1, %bl
jne 0x16110
movq %rbx, %rdi
callq 0x161d2
cmpq %rax, %r14
je 0x1616f
movq %rbx... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/arena.c |
upb_Arena_Contains_dont_copy_me__upb_internal_use_only | bool UPB_PRIVATE(_upb_Arena_Contains)(const upb_Arena* a, void* ptr) {
upb_ArenaInternal* ai = upb_Arena_Internal(a);
UPB_ASSERT(ai);
upb_MemBlock* block = upb_Atomic_Load(&ai->blocks, memory_order_relaxed);
while (block) {
uintptr_t beg = (uintptr_t)block;
uintptr_t end = beg + block->size;
if ((u... | movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x161ac
cmpq %rsi, %rax
ja 0x161a7
movl 0x8(%rax), %ecx
addq %rax, %rcx
cmpq %rsi, %rcx
ja 0x161ac
movq (%rax), %rax
jmp 0x16192
testq %rax, %rax
setne %al
retq
| /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/arena.c |
upb_Arena_Init | upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc) {
UPB_ASSERT(sizeof(void*) * UPB_ARENA_SIZE_HACK >= sizeof(upb_ArenaState));
upb_ArenaState* a;
if (n) {
/* Align initial pointer up so that we return properly-aligned pointers. */
void* aligned = (void*)UPB_ALIGN_UP((uintptr_t)mem, UPB_MAL... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
testq %rsi, %rsi
je 0x1637e
leaq 0x7(%rdi), %r15
andq $-0x8, %r15
movq %r15, %rcx
subq %rdi, %rcx
xorl %eax, %eax
subq %rcx, %rsi
cmovaeq %rsi, %rax
cmpq $0x37, %rax
jbe 0x1637e
andq $-0x8, %rax
leaq (%r15,%rax), %rbx
addq $-0x38, %rbx
leaq (%r15,%r... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/arena.c |
upb_Arena_Fuse | bool upb_Arena_Fuse(upb_Arena* a1, upb_Arena* a2) {
if (a1 == a2) return true; // trivial fuse
#ifdef UPB_TRACING_ENABLED
upb_Arena_LogFuse(a1, a2);
#endif
upb_ArenaInternal* ai1 = upb_Arena_Internal(a1);
upb_ArenaInternal* ai2 = upb_Arena_Internal(a2);
// Do not fuse initial blocks since we cannot lifeti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %bl
cmpq %rsi, %rdi
je 0x16600
movq %rdi, %r15
testb $0x1, 0x10(%rdi)
jne 0x165fe
movq %rsi, %r14
testb $0x1, 0x10(%rsi)
jne 0x165fe
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x16100
movq %rax, %r12
movq %rdx, %r13
movq %r14, %rdi
callq... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/arena.c |
upb_Array_New | upb_Array* upb_Array_New(upb_Arena* a, upb_CType type) {
const int lg2 = UPB_PRIVATE(_upb_CType_SizeLg2)(type);
return UPB_PRIVATE(_upb_Array_New)(a, 4, lg2);
} | pushq %r14
pushq %rbx
pushq %rax
decl %esi
leaq 0x1bc53(%rip), %rax # 0x3233c
movsbq (%rsi,%rax), %rbx
pushq $0x4
popq %rsi
movl %ebx, %ecx
shlq %cl, %rsi
addq $0x18, %rsi
callq 0x16d0b
movq %rax, %r14
testq %rax, %rax
je 0x16726
movq %r14, %rsi
addq $0x18, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x16c64
andq $0... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/array.c |
upb_Array_Insert | bool upb_Array_Insert(upb_Array* arr, size_t i, size_t count,
upb_Arena* arena) {
UPB_ASSERT(!upb_Array_IsFrozen(arr));
UPB_ASSERT(arena);
UPB_ASSERT(i <= arr->UPB_PRIVATE(size));
UPB_ASSERT(count + arr->UPB_PRIVATE(size) >= count);
const size_t oldsize = arr->UPB_PRIVATE(size);
if (!U... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testb $0x4, (%rdi)
jne 0x16a23
testq %rcx, %rcx
je 0x16a3c
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rsi
movq %rsi, %r12
subq %rbx, %r12
jb 0x16a55
movq %rdx, %r14
addq %rdx, %rsi
jb 0x16a6e
movq %r15, %rdi
movq %rcx, %rdx
callq 0x168f6
movl %eax, %ebp
testb... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/array.c |
upb_Arena_Malloc | UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) {
void* UPB_PRIVATE(_upb_Arena_SlowMalloc)(struct upb_Arena * a, size_t size);
size = UPB_ALIGN_MALLOC(size);
const size_t span = size + UPB_ASAN_GUARD_SIZE;
if (UPB_UNLIKELY(UPB_PRIVATE(_upb_ArenaHas)(a) < span)) {
return UPB_PRIVATE(... | addq $0x7, %rsi
andq $-0x8, %rsi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq %rsi, %rcx
jb 0x16225
leaq 0x7(%rax), %rcx
andq $-0x8, %rcx
cmpq %rax, %rcx
jne 0x16d3a
addq %rax, %rsi
movq %rsi, (%rdi)
retq
pushq %rax
leaq 0x1831d(%rip), %rdi # 0x2f05f
leaq 0x18353(%rip), %rsi # 0x2f09c
leaq 0x183c... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/internal/arena.h |
upb_Arena_Malloc | UPB_API_INLINE void* upb_Arena_Malloc(struct upb_Arena* a, size_t size) {
void* UPB_PRIVATE(_upb_Arena_SlowMalloc)(struct upb_Arena * a, size_t size);
size = UPB_ALIGN_MALLOC(size);
const size_t span = size + UPB_ASAN_GUARD_SIZE;
if (UPB_UNLIKELY(UPB_PRIVATE(_upb_ArenaHas)(a) < span)) {
return UPB_PRIVATE(... | addq $0x7, %rsi
andq $-0x8, %rsi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq %rsi, %rcx
jb 0x16225
leaq 0x7(%rax), %rcx
andq $-0x8, %rcx
cmpq %rax, %rcx
jne 0x1706d
addq %rax, %rsi
movq %rsi, (%rdi)
retq
pushq %rax
leaq 0x17fea(%rip), %rdi # 0x2f05f
leaq 0x18020(%rip), %rsi # 0x2f09c
leaq 0x1809... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mem/internal/arena.h |
upb_Message_AddUnknown_dont_copy_me__upb_internal_use_only | bool UPB_PRIVATE(_upb_Message_AddUnknown)(upb_Message* msg, const char* data,
size_t len, upb_Arena* arena) {
UPB_ASSERT(!upb_Message_IsFrozen(msg));
if (!UPB_PRIVATE(_upb_Message_Realloc)(msg, len, arena)) return false;
upb_Message_Internal* in = UPB_PRIVATE(_upb_Message... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testb $0x1, (%rdi)
jne 0x1717e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x16e3c
movl %eax, %ebp
testb %al, %al
je 0x17171
movq (%r15), %r15
andq $-0x2, %r15
movl 0x4(%r15), %edi
addq %r15, %rdi
movq %r14, %rsi
movq %rbx,... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/message.c |
upb_Message_DeleteUnknown | void upb_Message_DeleteUnknown(upb_Message* msg, const char* data, size_t len) {
UPB_ASSERT(!upb_Message_IsFrozen(msg));
upb_Message_Internal* in = UPB_PRIVATE(_upb_Message_GetInternal)(msg);
const char* internal_unknown_end = UPB_PTR_AT(in, in->unknown_end, char);
#ifndef NDEBUG
size_t full_unknown_size;
co... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testb $0x1, %r14b
jne 0x17257
movq %rdx, %rbx
movl 0x4(%r14), %ecx
testq %r14, %r14
je 0x17217
leaq 0xc(%r14), %rax
cmpq %rsi, %rax
ja 0x172bb
leaq -0xc(%rcx), %rdx
jmp 0x1721b
xorl %eax, %eax
xorl %edx, %edx
addq %rdx, %rax
cmpq %rsi, %rax
jbe 0x17270
testq %rbx, %rbx... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/message/message.c |
upb_MiniTableField_CheckIsArray_dont_copy_me__upb_internal_use_only | UPB_INLINE void UPB_PRIVATE(_upb_MiniTableField_CheckIsArray)(
const struct upb_MiniTableField* f) {
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) ==
kUpb_FieldRep_NativePointer);
UPB_ASSUME(upb_MiniTableField_IsArray(f));
UPB_ASSUME(f->presence == 0);
} | pushq %rax
movb 0xb(%rdi), %al
cmpb $-0x41, %al
jbe 0x177e3
andb $0x3, %al
cmpb $0x1, %al
jne 0x17802
cmpw $0x0, 0x6(%rdi)
jne 0x17821
popq %rax
retq
leaq 0x1766d(%rip), %rdi # 0x2ee57
leaq 0x12f67(%rip), %rsi # 0x2a758
leaq 0x176c0(%rip), %rcx # 0x2eeb8
movl $0xc4, %edx
callq 0x9250
leaq 0x1771c(%rip), %rd... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_table/internal/field.h |
upb_MiniTableField_CheckIsMap_dont_copy_me__upb_internal_use_only | UPB_INLINE void UPB_PRIVATE(_upb_MiniTableField_CheckIsMap)(
const struct upb_MiniTableField* f) {
UPB_ASSUME(UPB_PRIVATE(_upb_MiniTableField_GetRep)(f) ==
kUpb_FieldRep_NativePointer);
UPB_ASSUME(upb_MiniTableField_IsMap(f));
UPB_ASSUME(f->presence == 0);
} | pushq %rax
movb 0xb(%rdi), %al
cmpb $-0x41, %al
jbe 0x17940
testb $0x3, %al
jne 0x1795f
cmpw $0x0, 0x6(%rdi)
jne 0x1797e
popq %rax
retq
leaq 0x17510(%rip), %rdi # 0x2ee57
leaq 0x12e0a(%rip), %rsi # 0x2a758
leaq 0x1b0a7(%rip), %rcx # 0x329fc
movl $0xcc, %edx
callq 0x9250
leaq 0x1b101(%rip), %rdi # 0x32a6... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_table/internal/field.h |
upb_MiniTable_NextOneofField | bool upb_MiniTable_NextOneofField(const upb_MiniTable* m,
const upb_MiniTableField** f) {
const upb_MiniTableField* ptr = *f;
const upb_MiniTableField* end =
&m->UPB_PRIVATE(fields)[m->UPB_PRIVATE(field_count)];
while (++ptr < end) {
if (ptr->presence == (*f)->presence)... | movq (%rsi), %rcx
movzwl 0x12(%rdi), %eax
imulq $0xc, %rax, %rax
addq 0x8(%rdi), %rax
leaq 0xc(%rcx), %rdi
movq %rdi, %rdx
cmpq %rax, %rdi
jae 0x17a80
movzwl 0x6(%rdx), %r8d
leaq 0xc(%rdx), %rdi
cmpw 0x6(%rcx), %r8w
jne 0x17a61
addq $-0xc, %rdi
movq %rdi, (%rsi)
cmpq %rax, %rdx
setb %al
retq
nop
| /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/mini_table/message.c |
upb_DefPool_SetFeatureSetDefaults | bool upb_DefPool_SetFeatureSetDefaults(upb_DefPool* s,
const char* serialized_defaults,
size_t serialized_len,
upb_Status* status) {
const UPB_DESC(FeatureSetDefaults)* defaults = UPB_DESC(
Featu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %rbp
leaq 0x32abe(%rip), %rdi # 0x4a6b8
movq %rbp, %rsi
callq 0x18676
testq %rax, %rax
je 0x17c2d
movq %rax, %r15
movq %rbp, (%rsp)
leaq 0x32aa3(%rip), %rcx... | /pybind[P]pybind11_protobuf/build_O2/_deps/protobuf-src/upb/reflection/def_pool.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.