name string | code string | asm string | file string |
|---|---|---|---|
brotli::ZopfliCostModel::SetFromCommands(unsigned long, unsigned long, unsigned char const*, unsigned long, brotli::Command const*, unsigned long, unsigned long) | void SetFromCommands(size_t num_bytes,
size_t position,
const uint8_t* ringbuffer,
size_t ringbuffer_mask,
const Command* commands,
size_t num_commands,
size_t last_insert_len) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
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 -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
movl $0x0, -0x4c(%rbp)
le... | /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
void brotli::CreateBackwardReferences<brotli::HashLongestMatchQuickly<16, 2, false>>(unsigned long, unsigned long, bool, unsigned char const*, unsigned long, int, int, brotli::HashLongestMatchQuickly<16, 2, false>*, int*, unsigned long*, brotli::Command*, unsigned long*, unsigned long*) | void CreateBackwardReferences(size_t num_bytes,
size_t position,
bool is_last,
const uint8_t* ringbuffer,
size_t ringbuffer_mask,
const int quality,
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movb %dl, %al
movq 0x40(%rbp), %rdx
movq 0x38(%rbp), %rdx
movq 0x30(%rbp), %rdx
movq 0x28(%rbp), %rdx
movq 0x20(%rbp), %rdx
movq 0x18(%rbp), %rdx
movl 0x10(%rbp), %edx
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
andb $0x1, %al... | /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
void brotli::CreateBackwardReferences<brotli::HashLongestMatch<14, 5, 4>>(unsigned long, unsigned long, bool, unsigned char const*, unsigned long, int, int, brotli::HashLongestMatch<14, 5, 4>*, int*, unsigned long*, brotli::Command*, unsigned long*, unsigned long*) | void CreateBackwardReferences(size_t num_bytes,
size_t position,
bool is_last,
const uint8_t* ringbuffer,
size_t ringbuffer_mask,
const int quality,
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movb %dl, %al
movq 0x40(%rbp), %rdx
movq 0x38(%rbp), %rdx
movq 0x30(%rbp), %rdx
movq 0x28(%rbp), %rdx
movq 0x20(%rbp), %rdx
movq 0x18(%rbp), %rdx
movl 0x10(%rbp), %edx
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
andb $0x1, %al... | /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
void brotli::CreateBackwardReferences<brotli::HashLongestMatch<15, 6, 10>>(unsigned long, unsigned long, bool, unsigned char const*, unsigned long, int, int, brotli::HashLongestMatch<15, 6, 10>*, int*, unsigned long*, brotli::Command*, unsigned long*, unsigned long*) | void CreateBackwardReferences(size_t num_bytes,
size_t position,
bool is_last,
const uint8_t* ringbuffer,
size_t ringbuffer_mask,
const int quality,
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movb %dl, %al
movq 0x40(%rbp), %rdx
movq 0x38(%rbp), %rdx
movq 0x30(%rbp), %rdx
movq 0x28(%rbp), %rdx
movq 0x20(%rbp), %rdx
movq 0x18(%rbp), %rdx
movl 0x10(%rbp), %edx
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
andb $0x1, %al... | /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
brotli::HashLongestMatchQuickly<16, 1, true>::FindLongestMatch(unsigned char const*, unsigned long, int const*, unsigned long, unsigned long, unsigned long, unsigned long*, unsigned long*, unsigned long*, double*) | inline bool FindLongestMatch(const uint8_t * __restrict ring_buffer,
const size_t ring_buffer_mask,
const int* __restrict distance_cache,
const size_t cur_ix,
const size_t max_length,
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %r... | /urbit[P]h2o/deps/brotli/enc/././hash.h |
brotli::ComputeDistanceCode(unsigned long, unsigned long, int, int const*) | inline size_t ComputeDistanceCode(size_t distance,
size_t max_distance,
int quality,
const int* dist_cache) {
if (distance <= max_distance) {
if (distance == static_cast<size_t>(dist_cache[0])) {
return 0;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcc00e
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jne 0xcbf1e
movq $0x0, -0x8(%rbp)
jmp 0xcc01a
movq -0x10(%rbp)... | /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
brotli::HashLongestMatchQuickly<16, 1, true>::HashBytes(unsigned char const*) | static uint32_t HashBytes(const uint8_t *data) {
// Computing a hash based on 5 bytes works much better for
// qualities 1 and 3, where the next hash value is likely to replace
uint64_t h = (BROTLI_UNALIGNED_LOAD64(data) << 24) * kHashMul32;
// The higher bits contain more mixture from the multiplicatio... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc7640
shlq $0x18, %rax
imulq $0x1e35a7bd, %rax, %rax # imm = 0x1E35A7BD
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x30, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /urbit[P]h2o/deps/brotli/enc/././hash.h |
brotli::HashLongestMatchQuickly<16, 2, false>::FindLongestMatch(unsigned char const*, unsigned long, int const*, unsigned long, unsigned long, unsigned long, unsigned long*, unsigned long*, unsigned long*, double*) | inline bool FindLongestMatch(const uint8_t * __restrict ring_buffer,
const size_t ring_buffer_mask,
const int* __restrict distance_cache,
const size_t cur_ix,
const size_t max_length,
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
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 -0x8(%rbp), %rax
movq %rax... | /urbit[P]h2o/deps/brotli/enc/././hash.h |
brotli::HashLongestMatchQuickly<17, 4, true>::FindLongestMatch(unsigned char const*, unsigned long, int const*, unsigned long, unsigned long, unsigned long, unsigned long*, unsigned long*, unsigned long*, double*) | inline bool FindLongestMatch(const uint8_t * __restrict ring_buffer,
const size_t ring_buffer_mask,
const int* __restrict distance_cache,
const size_t cur_ix,
const size_t max_length,
... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
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 ... | /urbit[P]h2o/deps/brotli/enc/././hash.h |
brotli::HashLongestMatch<14, 4, 4>::FindLongestMatch(unsigned char const*, unsigned long, int const*, unsigned long, unsigned long, unsigned long, unsigned long*, unsigned long*, unsigned long*, double*) | bool FindLongestMatch(const uint8_t * __restrict data,
const size_t ring_buffer_mask,
const int* __restrict distance_cache,
const size_t cur_ix,
const size_t max_length,
const size_t max_backward,
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
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 ... | /urbit[P]h2o/deps/brotli/enc/././hash.h |
brotli::HashLongestMatch<14, 5, 4>::FindLongestMatch(unsigned char const*, unsigned long, int const*, unsigned long, unsigned long, unsigned long, unsigned long*, unsigned long*, unsigned long*, double*) | bool FindLongestMatch(const uint8_t * __restrict data,
const size_t ring_buffer_mask,
const int* __restrict distance_cache,
const size_t cur_ix,
const size_t max_length,
const size_t max_backward,
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
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 ... | /urbit[P]h2o/deps/brotli/enc/././hash.h |
brotli::HashLongestMatch<15, 6, 10>::FindLongestMatch(unsigned char const*, unsigned long, int const*, unsigned long, unsigned long, unsigned long, unsigned long*, unsigned long*, unsigned long*, double*) | bool FindLongestMatch(const uint8_t * __restrict data,
const size_t ring_buffer_mask,
const int* __restrict distance_cache,
const size_t cur_ix,
const size_t max_length,
const size_t max_backward,
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
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 ... | /urbit[P]h2o/deps/brotli/enc/././hash.h |
brotli::HashLongestMatch<15, 7, 10>::FindLongestMatch(unsigned char const*, unsigned long, int const*, unsigned long, unsigned long, unsigned long, unsigned long*, unsigned long*, unsigned long*, double*) | bool FindLongestMatch(const uint8_t * __restrict data,
const size_t ring_buffer_mask,
const int* __restrict distance_cache,
const size_t cur_ix,
const size_t max_length,
const size_t max_backward,
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
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 ... | /urbit[P]h2o/deps/brotli/enc/././hash.h |
brotli::CopyLiteralsToByteArray(brotli::Command const*, unsigned long, unsigned char const*, unsigned long, unsigned long, std::vector<unsigned char, std::allocator<unsigned char>>*) | void CopyLiteralsToByteArray(const Command* cmds,
const size_t num_commands,
const uint8_t* data,
const size_t offset,
const size_t mask,
std::vector<uint8_t>* literals) {
/... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %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 $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xcf6ce
movq -0x8(%rbp), %rax
imulq $0x18, -0... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
brotli::RemapBlockIds(unsigned char*, unsigned long) | size_t RemapBlockIds(uint8_t* block_ids, const size_t length) {
std::map<uint8_t, uint8_t> new_id;
size_t next_id = 0;
for (size_t i = 0; i < length; ++i) {
if (new_id.find(block_ids[i]) == new_id.end()) {
new_id[block_ids[i]] = static_cast<uint8_t>(next_id);
++next_id;
}
}
for (size_t i =... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd0110
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xcf98c
movq -0x8(%rbp), %rsi
movq -0x50(%rbp), %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq ... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
brotli::BuildBlockSplit(std::vector<unsigned char, std::allocator<unsigned char>> const&, brotli::BlockSplit*) | void BuildBlockSplit(const std::vector<uint8_t>& block_ids, BlockSplit* split) {
uint8_t cur_id = block_ids[0];
uint8_t max_type = cur_id;
uint32_t cur_length = 1;
for (size_t i = 1; i < block_ids.size(); ++i) {
uint8_t next_id = block_ids[i];
if (next_id != cur_id) {
split->types.push_back(cur_id... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd02c0
movb (%rax), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x12(%rbp)
movl $0x1, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, ... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
brotli::SplitBlock(brotli::Command const*, unsigned long, unsigned char const*, unsigned long, unsigned long, brotli::BlockSplit*, brotli::BlockSplit*, brotli::BlockSplit*) | void SplitBlock(const Command* cmds,
const size_t num_commands,
const uint8_t* data,
const size_t pos,
const size_t mask,
BlockSplit* literal_split,
BlockSplit* insert_and_copy_split,
BlockSplit* dist_split) ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xd03b0
movq -0x90(%rbp), %r9
movq -0x8(%rbp)... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
brotli::FastLog2(unsigned long) | static inline double FastLog2(size_t v) {
if (v < sizeof(kLog2Table) / sizeof(kLog2Table[0])) {
return kLog2Table[v];
}
#if defined(_MSC_VER) && _MSC_VER <= 1600
// Visual Studio 2010 does not have the log2() function defined, so we use
// log() and a multiplication instead.
static const double kLog2Inv =... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x100, -0x10(%rbp) # imm = 0x100
jae 0xcfd01
movq -0x10(%rbp), %rcx
leaq 0x85edf(%rip), %rax # 0x155bd0
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xcfd32
movaps 0x64328(%rip), %xmm1 # 0x134030
movq -0x... | /urbit[P]h2o/deps/brotli/enc/./././fast_log.h |
brotli::BitsEntropy(unsigned int const*, unsigned long) | static inline double BitsEntropy(const uint32_t *population, size_t size) {
size_t sum;
double retval = ShannonEntropy(population, size, &sum);
if (retval < sum) {
// At least one bit per literal is needed.
retval = static_cast<double>(sum);
}
return retval;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xcfe10
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movaps 0x6427e(%rip), %xmm2 # 0x134030
movq -0x18(%rbp), %xmm0
punpckldq %xmm2, %xmm0 # xmm0 ... | /urbit[P]h2o/deps/brotli/enc/././bit_cost.h |
brotli::ShannonEntropy(unsigned int const*, unsigned long, unsigned long*) | static inline double ShannonEntropy(const uint32_t *population, size_t size,
size_t *total) {
size_t sum = 0;
double retval = 0;
const uint32_t *population_end = population + size;
size_t p;
if (size & 1) {
goto odd_number_of_elements_left;
}
while (population < pop... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
andq $0x1, %rax
cm... | /urbit[P]h2o/deps/brotli/enc/././bit_cost.h |
void brotli::SplitByteVector<brotli::Histogram<704>, unsigned short>(std::vector<unsigned short, std::allocator<unsigned short>> const&, unsigned long, unsigned long, unsigned long, double, brotli::BlockSplit*) | void SplitByteVector(const std::vector<DataType>& data,
const size_t literals_per_histogram,
const size_t max_histograms,
const size_t sampling_stride_length,
const double block_switch_cost,
BlockSplit* split) {
i... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdc370
testb $0x1, %al
jne 0xd0763
jmp 0xd0773
movq -0x30(%rbp), %rax
movq $0x1, (%... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
void brotli::InitialEntropyCodes<brotli::Histogram<256>, unsigned char>(unsigned char const*, unsigned long, unsigned long, unsigned long, unsigned long, std::vector<brotli::Histogram<256>, std::allocator<brotli::Histogram<256>>>*) | void InitialEntropyCodes(const DataType* data, size_t length,
size_t literals_per_histogram,
size_t max_histograms,
size_t stride,
std::vector<HistogramType>* vec) {
size_t total_histograms = length / literals_per_hist... | pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp # imm = 0x470
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
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
void brotli::RefineEntropyCodes<brotli::Histogram<256>, unsigned char>(unsigned char const*, unsigned long, unsigned long, std::vector<brotli::Histogram<256>, std::allocator<brotli::Histogram<256>>>*) | void RefineEntropyCodes(const DataType* data, size_t length,
size_t stride,
std::vector<HistogramType>* vec) {
size_t iters =
kIterMulForRefining * length / stride + kMinItersForRefining;
unsigned int seed = 7;
iters = ((iters + vec->size() - 1) / vec->size())... | pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
shlq %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
addq $0x64, %rax
movq %rax, -0x28(%rbp)
movl $0x7, -0x2c(%rbp)
movq -0x28(%rb... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
void brotli::FindBlocks<unsigned char, 256>(unsigned char const*, unsigned long, double, std::vector<brotli::Histogram<256>, std::allocator<brotli::Histogram<256>>> const&, unsigned char*) | void FindBlocks(const DataType* data, const size_t length,
const double block_switch_bitcost,
const std::vector<Histogram<kSize> > &vec,
uint8_t *block_id) {
if (vec.size() <= 1) {
for (size_t i = 0; i < length; ++i) {
block_id[i] = 0;
}
return;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd5020
cmpq $0x1, %rax
ja 0xd3cf0
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xd3ceb
movq -0x28(%rbp... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
void brotli::BuildBlockHistograms<brotli::Histogram<256>, unsigned char>(unsigned char const*, unsigned long, unsigned char*, std::vector<brotli::Histogram<256>, std::allocator<brotli::Histogram<256>>>*) | void BuildBlockHistograms(const DataType* data, const size_t length,
uint8_t* block_ids,
std::vector<HistogramType>* histograms) {
size_t num_types = RemapBlockIds(block_ids, length);
assert(num_types <= 256);
histograms->clear();
histograms->resize(num_types)... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcf8a0
movq %rax, -0x28(%rbp)
cmpq $0x100, -0x28(%rbp) # imm = 0x100
ja 0xd4205
jmp 0xd4224
leaq 0x813b0(%rip), %rdi # 0x155... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
void brotli::ClusterBlocks<brotli::Histogram<256>, unsigned char>(unsigned char const*, unsigned long, unsigned char*) | void ClusterBlocks(const DataType* data, const size_t length,
uint8_t* block_ids) {
std::vector<HistogramType> histograms;
std::vector<uint32_t> block_index(length);
uint32_t cur_idx = 0;
HistogramType cur_histogram;
for (size_t i = 0; i < length; ++i) {
bool block_boundary = (i + 1 == ... | pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp # imm = 0x4F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd3960
movq -0x10(%rbp), %rax
movq %rax, -0x4c8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x4c0(%rbp)
callq 0xc22b0
movq -0x4c8(%rbp), %rsi
movq -0x4c0(%... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
double brotli::PopulationCost<256>(brotli::Histogram<256> const&) | double PopulationCost(const Histogram<kSize>& histogram) {
if (histogram.total_count_ == 0) {
return 12;
}
int count = 0;
for (int i = 0; i < kSize; ++i) {
if (histogram.data_[i] > 0) {
++count;
}
}
if (count == 1) {
return 12;
}
if (count == 2) {
return static_cast<double>(20 ... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x400(%rax)
jne 0xd609f
movsd 0x7f40b(%rip), %xmm0 # 0x1554a0
movsd %xmm0, -0x8(%rbp)
jmp 0xd64ea
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x100, -0x18(%rbp) # imm = 0x100
jge... | /urbit[P]h2o/deps/brotli/enc/././bit_cost.h |
brotli::ClusterCostDiff(unsigned long, unsigned long) | inline double ClusterCostDiff(size_t size_a, size_t size_b) {
size_t size_c = size_a + size_b;
return static_cast<double>(size_a) * FastLog2(size_a) +
static_cast<double>(size_b) * FastLog2(size_b) -
static_cast<double>(size_c) * FastLog2(size_c);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, %xmm0
movaps 0x5abc1(%rip), %xmm1 # 0x134030
movaps %xmm1, -0x50(%rbp)
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[... | /urbit[P]h2o/deps/brotli/enc/./cluster.h |
void brotli::InitialEntropyCodes<brotli::Histogram<704>, unsigned short>(unsigned short const*, unsigned long, unsigned long, unsigned long, unsigned long, std::vector<brotli::Histogram<704>, std::allocator<brotli::Histogram<704>>>*) | void InitialEntropyCodes(const DataType* data, size_t length,
size_t literals_per_histogram,
size_t max_histograms,
size_t stride,
std::vector<HistogramType>* vec) {
size_t total_histograms = length / literals_per_hist... | pushq %rbp
movq %rsp, %rbp
subq $0xb70, %rsp # imm = 0xB70
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
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
void brotli::BuildBlockHistograms<brotli::Histogram<704>, unsigned short>(unsigned short const*, unsigned long, unsigned char*, std::vector<brotli::Histogram<704>, std::allocator<brotli::Histogram<704>>>*) | void BuildBlockHistograms(const DataType* data, const size_t length,
uint8_t* block_ids,
std::vector<HistogramType>* histograms) {
size_t num_types = RemapBlockIds(block_ids, length);
assert(num_types <= 256);
histograms->clear();
histograms->resize(num_types)... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcf8a0
movq %rax, -0x28(%rbp)
cmpq $0x100, -0x28(%rbp) # imm = 0x100
ja 0xdcbc5
jmp 0xdcbe4
leaq 0x789f0(%rip), %rdi # 0x155... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
void brotli::ClusterBlocks<brotli::Histogram<704>, unsigned short>(unsigned short const*, unsigned long, unsigned char*) | void ClusterBlocks(const DataType* data, const size_t length,
uint8_t* block_ids) {
std::vector<HistogramType> histograms;
std::vector<uint32_t> block_index(length);
uint32_t cur_idx = 0;
HistogramType cur_histogram;
for (size_t i = 0; i < length; ++i) {
bool block_boundary = (i + 1 == ... | pushq %rbp
movq %rsp, %rbp
subq $0xbf0, %rsp # imm = 0xBF0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xdc3b0
movq -0x10(%rbp), %rax
movq %rax, -0xbc8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xbc0(%rbp)
callq 0xc22b0
movq -0xbc8(%rbp), %rsi
movq -0xbc0(%... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
void brotli::RandomSample<brotli::Histogram<704>, unsigned short>(unsigned int*, unsigned short const*, unsigned long, unsigned long, brotli::Histogram<704>*) | void RandomSample(unsigned int* seed,
const DataType* data,
size_t length,
size_t stride,
HistogramType* sample) {
size_t pos = 0;
if (stride >= length) {
pos = 0;
stride = length;
} else {
pos = MyRand(seed) % (length - stride + ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0xddb20
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xddb40
mo... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
void brotli::ClusterHistograms<brotli::Histogram<704>>(std::vector<brotli::Histogram<704>, std::allocator<brotli::Histogram<704>>> const&, unsigned long, unsigned long, unsigned long, std::vector<brotli::Histogram<704>, std::allocator<brotli::Histogram<704>>>*, std::vector<unsigned int, std::allocator<unsigned int>>*) | void ClusterHistograms(const std::vector<HistogramType>& in,
size_t num_contexts, size_t num_blocks,
size_t max_histograms,
std::vector<HistogramType>* out,
std::vector<uint32_t>* histogram_symbols) {
const size_t in_size = nu... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
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
imulq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)... | /urbit[P]h2o/deps/brotli/enc/./cluster.h |
double brotli::PopulationCost<704>(brotli::Histogram<704> const&) | double PopulationCost(const Histogram<kSize>& histogram) {
if (histogram.total_count_ == 0) {
return 12;
}
int count = 0;
for (int i = 0; i < kSize; ++i) {
if (histogram.data_[i] > 0) {
++count;
}
}
if (count == 1) {
return 12;
}
if (count == 2) {
return static_cast<double>(20 ... | pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp # imm = 0x390
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xb00(%rax)
jne 0xde51f
movsd 0x76f8b(%rip), %xmm0 # 0x1554a0
movsd %xmm0, -0x8(%rbp)
jmp 0xde96a
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x2c0, -0x18(%rbp) # imm = 0x2C0
jge... | /urbit[P]h2o/deps/brotli/enc/././bit_cost.h |
void brotli::HistogramCombine<brotli::Histogram<704>>(brotli::Histogram<704>*, unsigned int*, unsigned int*, unsigned long, unsigned long) | void HistogramCombine(HistogramType* out,
uint32_t* cluster_size,
uint32_t* symbols,
size_t symbols_size,
size_t max_clusters) {
double cost_diff_threshold = 0.0;
size_t min_cluster_size = 1;
// Uniquify the list of symbols.
... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x1, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x20(%rbp), %rcx
leaq (%rax,%rcx,4), %... | /urbit[P]h2o/deps/brotli/enc/./cluster.h |
void brotli::HistogramRemap<brotli::Histogram<704>>(brotli::Histogram<704> const*, unsigned long, brotli::Histogram<704>*, unsigned int*) | void HistogramRemap(const HistogramType* in, size_t in_size,
HistogramType* out, uint32_t* symbols) {
// Uniquify the list of symbols.
std::vector<uint32_t> all_symbols(symbols, symbols + in_size);
std::sort(all_symbols.begin(), all_symbols.end());
std::vector<uint32_t>::iterator last =
... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x10(%rbp), %rcx
leaq (%rax,%rcx,4), %rax
movq %rax, -0xe8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xe0(%r... | /urbit[P]h2o/deps/brotli/enc/./cluster.h |
void brotli::HistogramReindex<brotli::Histogram<704>>(std::vector<brotli::Histogram<704>, std::allocator<brotli::Histogram<704>>>*, std::vector<unsigned int, std::allocator<unsigned int>>*) | void HistogramReindex(std::vector<HistogramType>* out,
std::vector<uint32_t>* symbols) {
std::vector<HistogramType> tmp(*out);
std::map<uint32_t, uint32_t> new_index;
uint32_t next_index = 0;
for (size_t i = 0; i < symbols->size(); ++i) {
if (new_index.find((*symbols)[i]) == new_index.... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xdfa90
leaq -0x58(%rbp), %rdi
callq 0xda9f0
movl $0x0, -0x5c(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc1f30
movq %... | /urbit[P]h2o/deps/brotli/enc/./cluster.h |
void brotli::CompareAndPushToQueue<brotli::Histogram<704>>(brotli::Histogram<704> const*, unsigned int const*, unsigned int, unsigned int, std::vector<brotli::HistogramPair, std::allocator<brotli::HistogramPair>>*) | void CompareAndPushToQueue(const HistogramType* out,
const uint32_t* cluster_size,
uint32_t idx1, uint32_t idx2,
std::vector<HistogramPair>* pairs) {
if (idx1 == idx2) {
return;
}
if (idx2 < idx1) {
uint32_t t = idx2;
idx... | pushq %rbp
movq %rsp, %rbp
subq $0xb80, %rsp # imm = 0xB80
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0xdf75a
jmp 0xdf9fb
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xdf774
movl -0x1... | /urbit[P]h2o/deps/brotli/enc/./cluster.h |
void brotli::RefineEntropyCodes<brotli::Histogram<520>, unsigned short>(unsigned short const*, unsigned long, unsigned long, std::vector<brotli::Histogram<520>, std::allocator<brotli::Histogram<520>>>*) | void RefineEntropyCodes(const DataType* data, size_t length,
size_t stride,
std::vector<HistogramType>* vec) {
size_t iters =
kIterMulForRefining * length / stride + kMinItersForRefining;
unsigned int seed = 7;
iters = ((iters + vec->size() - 1) / vec->size())... | pushq %rbp
movq %rsp, %rbp
subq $0x890, %rsp # imm = 0x890
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
shlq %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
addq $0x64, %rax
movq %rax, -0x28(%rbp)
movl $0x7, -0x2c(%rbp)
movq -0x28(%rb... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
void brotli::FindBlocks<unsigned short, 520>(unsigned short const*, unsigned long, double, std::vector<brotli::Histogram<520>, std::allocator<brotli::Histogram<520>>> const&, unsigned char*) | void FindBlocks(const DataType* data, const size_t length,
const double block_switch_bitcost,
const std::vector<Histogram<kSize> > &vec,
uint8_t *block_id) {
if (vec.size() <= 1) {
for (size_t i = 0; i < length; ++i) {
block_id[i] = 0;
}
return;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe1280
cmpq $0x1, %rax
ja 0xe0310
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xe030b
movq -0x28(%rbp... | /urbit[P]h2o/deps/brotli/enc/block_splitter.cc |
brotli::BuildAndStoreHuffmanTreeFast(unsigned int const*, unsigned long, unsigned long, unsigned char*, unsigned short*, unsigned long*, unsigned char*) | void BuildAndStoreHuffmanTreeFast(const uint32_t *histogram,
const size_t histogram_total,
const size_t max_bits,
uint8_t* depth,
uint16_t* bits,
size... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq 0x10(%rbp), %rax
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 $0x0, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3f5b0
... | /urbit[P]h2o/deps/brotli/enc/brotli_bit_stream.cc |
brotli::MoveToFrontTransform(std::vector<unsigned int, std::allocator<unsigned int>> const&) | std::vector<uint32_t> MoveToFrontTransform(const std::vector<uint32_t>& v) {
if (v.empty()) return v;
uint32_t max_value = *std::max_element(v.begin(), v.end());
std::vector<uint32_t> mtf(max_value + 1);
for (uint32_t i = 0; i <= max_value; ++i) mtf[i] = i;
std::vector<uint32_t> result(v.size());
for (size_... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe8390
testb $0x1, %al
jne 0xe51c0
jmp 0xe51d5
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe83d0
jmp 0xe53f6
movq -0x10(%rbp), %r... | /urbit[P]h2o/deps/brotli/enc/brotli_bit_stream.cc |
brotli::RunLengthCodeZeros(std::vector<unsigned int, std::allocator<unsigned int>> const&, unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>*, std::vector<unsigned int, std::allocator<unsigned int>>*) | void RunLengthCodeZeros(const std::vector<uint32_t>& v_in,
uint32_t* max_run_length_prefix,
std::vector<uint32_t>* v_out,
std::vector<uint32_t>* extra_bits) {
uint32_t max_reps = 0;
for (size_t i = 0; i < v_in.size();) {
for (; i < v_in.siz... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc1f30
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
ja... | /urbit[P]h2o/deps/brotli/enc/brotli_bit_stream.cc |
void brotli::BlockEncoder::BuildAndStoreEntropyCodes<520>(std::vector<brotli::Histogram<520>, std::allocator<brotli::Histogram<520>>> const&, unsigned long*, unsigned char*) | void BuildAndStoreEntropyCodes(
const std::vector<Histogram<kSize> >& histograms,
size_t* storage_ix, uint8_t* storage) {
depths_.resize(histograms.size() * alphabet_size_);
bits_.resize(histograms.size() * alphabet_size_);
for (size_t i = 0; i < histograms.size(); ++i) {
size_t ix = i * a... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0xf8, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe1280
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x38(%rbp), %rax
i... | /urbit[P]h2o/deps/brotli/enc/brotli_bit_stream.cc |
brotli::BlockEncoder::StoreSymbol(unsigned long, unsigned long*, unsigned char*) | void StoreSymbol(size_t symbol, size_t* storage_ix, uint8_t* storage) {
if (block_len_ == 0) {
++block_ix_;
block_len_ = block_lengths_[block_ix_];
entropy_ix_ = block_types_[block_ix_] * alphabet_size_;
StoreBlockSwitch(block_split_code_, block_ix_, storage_ix, storage);
}
--block_l... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0xe8(%rax)
jne 0xe8cb0
movq -0x30(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe0(%rax)
movq 0x18(%rax), %rdi
m... | /urbit[P]h2o/deps/brotli/enc/brotli_bit_stream.cc |
void brotli::BlockEncoder::StoreSymbolWithContext<6>(unsigned long, unsigned long, std::vector<unsigned int, std::allocator<unsigned int>> const&, unsigned long*, unsigned char*) | void StoreSymbolWithContext(size_t symbol, size_t context,
const std::vector<uint32_t>& context_map,
size_t* storage_ix, uint8_t* storage) {
if (block_len_ == 0) {
++block_ix_;
block_len_ = block_lengths_[block_ix_];
size_t block_type = b... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %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 -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, 0xe8(%rax)
jne 0xe8dd0
movq -0x50(%rbp), %rax
movq 0xe0(%rax), %rcx
addq $0x1, %rcx
m... | /urbit[P]h2o/deps/brotli/enc/brotli_bit_stream.cc |
yoml__parse_node | static yoml_t *yoml__parse_node(yaml_parser_t *parser, yaml_event_type_t *unhandled, yoml_parse_args_t *parse_args)
{
yoml_t *node;
yaml_event_t event;
if (unhandled != NULL)
*unhandled = YAML_NO_EVENT;
/* wait for a node that is not a stream/doc start event */
while (1) {
if (!yam... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10e3c8
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x10e3ca
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xa8580
cmpl $0x0, %eax
jne 0x10e3ec
movq $0x0, -0x8(%rbp)
jmp 0x1... | /urbit[P]h2o/deps/yoml/yoml-parser.h |
yoml__resolve_merge | static inline int yoml__resolve_merge(yoml_t **target, yaml_parser_t *parser, yoml_parse_args_t *parse_args)
{
size_t i, j;
switch ((*target)->type) {
case YOML_TYPE_SCALAR:
break;
case YOML_TYPE_SEQUENCE:
for (i = 0; i != (*target)->data.sequence.size; ++i) {
if (yoml__reso... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movq %rax, -0x48(%rbp)
subq $0x3, %rax
ja 0x10ecee
movq -0x48(%rbp), %rax
leaq 0xaea86(%rip), %rcx # 0x1bd46c
movslq (%rcx,%rax,4), %rax
addq %r... | /urbit[P]h2o/deps/yoml/yoml-parser.h |
yoml__parse_mapping | static inline yoml_t *yoml__parse_mapping(yaml_parser_t *parser, yaml_event_t *event, yoml_parse_args_t *parse_args)
{
yoml_t *map = yoml__new_node(parse_args->filename, YOML_TYPE_MAPPING, offsetof(yoml_t, data.mapping.elements),
event->data.mapping_start.anchor, event->data.mapping_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %r8
movq -0x10(%rbp), %r9
movl $0x2, %esi
movl $0x40, %edx
callq 0x10ed00
movq %rax... | /urbit[P]h2o/deps/yoml/yoml-parser.h |
uECC_generate_random_int | uECC_VLI_API int uECC_generate_random_int(uECC_word_t *random,
const uECC_word_t *top,
wordcount_t num_words) {
uECC_word_t mask = (uECC_word_t)-1;
uECC_word_t tries;
bitcount_t num_bits = uECC_vli_numBits(top, num_words);
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq $-0x1, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x112950
movw %ax, -0x32(%rbp)
cmpq $0x0, 0xdf482(%rip) # 0x1ef6b8
jne 0x110244
movl $0x0, -0x4(%rbp)
jmp 0x1102... | /urbit[P]h2o/deps/picotls/deps/micro-ecc/uECC.c |
uECC_valid_public_key | int uECC_valid_public_key(const uint8_t *public_key, uECC_Curve curve) {
#if uECC_VLI_NATIVE_LITTLE_ENDIAN
uECC_word_t *_public = (uECC_word_t *)public_key;
#else
uECC_word_t _public[uECC_MAX_WORDS * 2];
#endif
#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
uECC_vli_bytesToNative(_public, public_key, curve->num_by... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %edx
callq 0x110610
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
... | /urbit[P]h2o/deps/picotls/deps/micro-ecc/uECC.c |
uECC_vli_numBits | uECC_VLI_API bitcount_t uECC_vli_numBits(const uECC_word_t *vli, const wordcount_t max_words) {
uECC_word_t i;
uECC_word_t digit;
wordcount_t num_digits = vli_numDigits(vli, max_words);
if (num_digits == 0) {
return 0;
}
digit = vli[num_digits - 1];
for (i = 0; digit; ++i) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x114e90
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x0, %eax
jne 0x112983
movw $0x0, -0x2(%rbp)
jmp 0x1129d6
movq -0x10(%rbp), %rax
movsbl -0x29(%rbp),... | /urbit[P]h2o/deps/picotls/deps/micro-ecc/uECC.c |
uECC_vli_mult | uECC_VLI_API void uECC_vli_mult(uECC_word_t *result,
const uECC_word_t *left,
const uECC_word_t *right,
wordcount_t num_words) {
uECC_word_t r0 = 0;
uECC_word_t r1 = 0;
uECC_word_t r2 = 0;
wordcount_t i, k;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x3a(%rbp)
movsbl -0x3a(%rbp), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jge 0x114a98
m... | /urbit[P]h2o/deps/picotls/deps/micro-ecc/uECC.c |
uECC_vli_mmod | uECC_VLI_API void uECC_vli_mmod(uECC_word_t *result,
uECC_word_t *product,
const uECC_word_t *mod,
wordcount_t num_words) {
uECC_word_t mod_multiple[2 * uECC_MAX_WORDS];
uECC_word_t tmp[2 * uECC_MAX_WORDS];
uECC_... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movsbl -0x19(%rbp), %eax
shll %eax
shll $0x6, %eax
movl %eax, -0xe4(%rbp)
movq -... | /urbit[P]h2o/deps/picotls/deps/micro-ecc/uECC.c |
sub_word | static uint32_t sub_word(uint32_t w, const uint8_t *sbox)
{
uint8_t a = byte(w, 0),
b = byte(w, 1),
c = byte(w, 2),
d = byte(w, 3);
#if CF_CACHE_SIDE_CHANNEL_PROTECTION
select_u8x4(&a, &b, &c, &d, sbox, 256);
#else
a = sbox[a];
b = sbox[b];
c = sbox[c];
d = sbox[d];
#endif
re... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, -0x11(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0x12(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0x13(%rbp... | /urbit[P]h2o/deps/picotls/deps/cifra/src/aes.c |
write64_be | static inline void write64_be(uint64_t v, uint8_t buf[8])
{
*buf++ = (v >> 56) & 0xff;
*buf++ = (v >> 48) & 0xff;
*buf++ = (v >> 40) & 0xff;
*buf++ = (v >> 32) & 0xff;
*buf++ = (v >> 24) & 0xff;
*buf++ = (v >> 16) & 0xff;
*buf++ = (v >> 8) & 0xff;
*buf = v & 0xff;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
shrq $0x38, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
shrq $0x30, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x10(%r... | /urbit[P]h2o/deps/picotls/deps/cifra/src/bitops.h |
poly1305_full_reduce | static void poly1305_full_reduce(uint32_t x[17])
{
uint32_t xsub[17];
size_t i;
for (i = 0; i < 17; i++)
xsub[i] = x[i];
poly1305_add(xsub, negative_1305);
/* If x - (2 ** 130 - 5) is negative, then
* x didn't need reduction: we discard the results.
* Do this in a side-channel silent way. */
ui... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x58(%rbp)
cmpq $0x11, -0x58(%rbp)
jae 0x11a88c
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x58(%rbp), %rax
movl %ecx, -0x50(%rbp,%rax,4)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x11a... | /urbit[P]h2o/deps/picotls/deps/cifra/src/poly1305.c |
sha512_update_block | static void sha512_update_block(void *vctx, const uint8_t *inp)
{
cf_sha512_context *ctx = vctx;
uint64_t W[16];
uint64_t a = ctx->H[0],
b = ctx->H[1],
c = ctx->H[2],
d = ctx->H[3],
e = ctx->H[4],
f = ctx->H[5],
g = ctx->H[6],
h = ctx-... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movq 0... | /urbit[P]h2o/deps/picotls/deps/cifra/src/sha512.c |
free_exporter_master_secret | static void free_exporter_master_secret(ptls_t *tls, int is_early)
{
uint8_t *slot = is_early ? tls->exporter_master_secret.early : tls->exporter_master_secret.one_rtt;
if (slot == NULL)
return;
assert(tls->key_schedule != NULL);
ptls_clear_memory(slot, tls->key_schedule->hashes[0].algo->digest_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x11cfd6
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x11cfe5
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmp... | /urbit[P]h2o/deps/picotls/lib/picotls.c |
handle_input | static int handle_input(ptls_t *tls, ptls_buffer_t *sendbuf, ptls_buffer_t *decryptbuf, const void *input, size_t *inlen,
ptls_handshake_properties_t *properties)
{
struct st_ptls_record_t rec;
int ret;
/* extract the record */
if ((ret = parse_record(tls, &rec, input, inlen)) !... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x50(%rbp), %rsi
callq 0x123390
movl %eax, -0x54(%rbp)
cmpl $0x0,... | /urbit[P]h2o/deps/picotls/lib/picotls.c |
ptls_hkdf_expand_label | int ptls_hkdf_expand_label(ptls_hash_algorithm_t *algo, void *output, size_t outlen, ptls_iovec_t secret, const char *label,
ptls_iovec_t hash_value, const char *base_label)
{
ptls_buffer_t hkdf_label;
uint8_t hkdf_label_buf[512];
int ret;
ptls_buffer_init(&hkdf_label, hkdf_l... | pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp # imm = 0x2E0
movq 0x20(%rbp), %rax
leaq 0x10(%rbp), %rax
movq %rax, -0x2a0(%rbp)
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x250(%rbp), %rsi
leaq -0x50(%rbp), %rdi
... | /urbit[P]h2o/deps/picotls/lib/picotls.c |
ptls_hmac_create | ptls_hash_context_t *ptls_hmac_create(ptls_hash_algorithm_t *algo, const void *key, size_t key_size)
{
struct st_picotls_hmac_context_t *ctx;
if ((ctx = malloc(offsetof(struct st_picotls_hmac_context_t, key) + algo->block_size)) == NULL)
return NULL;
*ctx = (struct st_picotls_hmac_context_t){{hmac... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
callq 0x40240
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x120c5b
movq $0x0, -0x8(%rbp)
jmp 0x120d20
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
le... | /urbit[P]h2o/deps/picotls/lib/picotls.c |
hmac_final | static void hmac_final(ptls_hash_context_t *_ctx, void *md, ptls_hash_final_mode_t mode)
{
struct st_picotls_hmac_context_t *ctx = (struct st_picotls_hmac_context_t *)_ctx;
assert(mode != PTLS_HASH_FINAL_MODE_SNAPSHOT || !"not supported");
if (md != NULL) {
ctx->hash->final(ctx->hash, md, PTLS_HAS... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x2, -0x14(%rbp)
je 0x120d93
jmp 0x120db2
leaq 0x9e4d6(%rip), %rdi # 0x1bf270
leaq 0x9d98e(%rip), %rsi # 0x1be72f
movl $0xddc, %edx # imm ... | /urbit[P]h2o/deps/picotls/lib/picotls.c |
ptls_hkdf_expand | int ptls_hkdf_expand(ptls_hash_algorithm_t *algo, void *output, size_t outlen, ptls_iovec_t prk, ptls_iovec_t info)
{
ptls_hash_context_t *hmac = NULL;
size_t i;
uint8_t digest[PTLS_MAX_DIGEST_SIZE];
for (i = 0; (i * algo->digest_size) < outlen; ++i) {
if (hmac == NULL) {
if ((hmac ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
imulq 0x8(%rcx), %rax
cmp... | /urbit[P]h2o/deps/picotls/lib/picotls.c |
green_poller_dump | static void green_poller_dump(green_poller_t poller)
{
static const char* states[] = {
"pending",
"aborted",
"complete",
};
fprintf(stderr, "poller @ 0x%p, size=%zu, used=%zu, busy=%zu:\n",
poller, poller->size, poller->used, poller->busy);
int w = (int)ceil(log10((do... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2f75(%rip), %r14 # 0x5ff8
movq (%r14), %rdi
movq 0x18(%rbx), %r8
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %r9
leaq 0x14c8(%rip), %rsi # 0x4561
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2090
movsd 0x20(%rbx), %xmm1
... | /AndreLouisCaron[P]libgreen/src/green.c |
green_future_set_result | int green_future_set_result(green_future_t future, void * p, int i)
{
if (future == NULL) {
return GREEN_EINVAL;
}
green_assert(future->refs > 0);
if (future->state == green_future_aborted) {
return GREEN_ECANCELED;
}
if (future->state == green_future_complete) {
return ... | pushq %rbx
testq %rdi, %rdi
je 0x35c7
cmpl $0x0, 0x8(%rdi)
jle 0x3603
movl 0x20(%rdi), %eax
cmpl $0x1, %eax
je 0x35cb
cmpl $0x2, %eax
jne 0x35d2
pushq $0x8
jmp 0x35cd
pushq $0x1
jmp 0x35cd
pushq $0x4
popq %rbx
movl %ebx, %eax
popq %rbx
retq
movl %edx, 0x18(%rdi)
movq %rsi, 0x10(%rdi)
movl $0x2, 0x20(%rdi)
movq 0x28(%rd... | /AndreLouisCaron[P]libgreen/src/green.c |
Catch::Detail::Approx::setEpsilon(double) | void Approx::setEpsilon(double newEpsilon) {
CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
"Invalid Approx::epsilon: " << newEpsilon << '.'
<< " Approx::epsilon has to be in [0, 1]");
m_epsilon = newEpsilon;
} | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movsd 0x78(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x143a75
movsd 0xce5f7(%rip), %xmm0 # 0x212060
ucomisd 0x78(%rsp), %xmm0
jae 0x143b34
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x15883... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::AssertionResult::getExpressionInMacro[abi:cxx11]() const | std::string AssertionResult::getExpressionInMacro() const {
std::string expr;
if( m_info.macroName.empty() )
expr = static_cast<std::string>(m_info.capturedExpression);
else {
expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
expr... | subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x57(%rsp)
callq 0x142a20
movq 0x18(%rsp), %rdi
callq 0x17f570
testb $0x1, %al
jne 0x1447bf
jmp 0x14480f
movq 0x18(%rsp), %rsi
addq $0x20, %rsi
l... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string trim( std::string const& str ) {
static char const* whitespaceChars = "\n\r\t ";
std::string::size_type start = str.find_first_not_of( whitespaceChars );
std::string::size_type end = str.find_last_not_of( whitespaceChars );
return start != std::string::npos ? str.substr( sta... | subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x129df9(%rip), %rsi # 0x274780
xorl %eax, %eax
movl %eax, %edx
callq 0x142420
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x129ddf(%rip), %rsi # 0x274780
movq $-... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::RunContext::sectionStarted(Catch::SectionInfo const&, Catch::Counts&) | bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
if (!sectionTracker.isOpen())
return false;
m_activ... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x1c8, %rax # imm = 0x1C8
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rsi
movq %rsi, %rdx
addq $0x40, %rdx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x15b510
movq 0x10(%rsp)... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::RunContext::acquireGeneratorTracker(Catch::StringRef, Catch::SourceLineInfo const&) | auto RunContext::acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
using namespace Generators;
GeneratorTracker& tracker = GeneratorTracker::acquire(m_trackerContext,
TestCaseTracking::... | subq $0xa8, %rsp
movq %rsi, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rdi, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x1c8, %rax # imm = 0x1C8
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x98(%rsp), %rsi
callq 0x17f5c0
movq 0x18(%rsp), %rsi
movq... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::RunContext::sectionEnded(Catch::SectionEndInfo const&) | void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
Counts assertions = m_totals.assertions - endInfo.prevAssertions;
bool missingAssertions = testForMissingAssertions(assertions);
if (!m_activeSections.empty()) {
m_activeSections.back()->close();
m_activeSec... | subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rsi
movq %rsi, 0x10(%rsp)
addq $0xf0, %rsi
addq $0x8, %rsi
movq 0xc8(%rsp), %rdx
addq $0x50, %rdx
leaq 0xb0(%rsp), %rdi
callq 0x154f80
movq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x154d30
movq 0x10(%rsp), %rdi
andb $0x1, %al
movb %al, ... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::RunContext::handleFatalErrorCondition(Catch::StringRef) | void RunContext::handleFatalErrorCondition( StringRef message ) {
// First notify reporter that bad things happened
m_reporter->fatalErrorEncountered(message);
// Don't rebuild the result -- the stringification itself can cause more fatal errors
// Instead, fake a result data.
A... | subq $0x4f8, %rsp # imm = 0x4F8
movq %rsi, 0x4e8(%rsp)
movq %rdx, 0x4f0(%rsp)
movq %rdi, 0x4e0(%rsp)
movq 0x4e0(%rsp), %rdi
movq %rdi, 0x70(%rsp)
addq $0x128, %rdi # imm = 0x128
callq 0x1836c0
movq %rax, %rdi
movups 0x4e8(%rsp), %xmm0
movaps %xmm0, 0x4d0(%rsp)
movq 0x4d0(%rsp), %rsi
movq 0x4d8(%rs... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::RunContext::handleUnfinishedSections() | void RunContext::handleUnfinishedSections() {
// If sections ended prematurely due to an exception we stored their
// infos here so we can tear them down outside the unwind process.
for (auto it = m_unfinishedSections.rbegin(),
itEnd = m_unfinishedSections.rend();
it !=... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x198, %rsi # imm = 0x198
leaq 0x18(%rsp), %rdi
callq 0x184100
movq 0x8(%rsp), %rsi
addq $0x198, %rsi # imm = 0x198
leaq 0x10(%rsp), %rdi
callq 0x184150
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1841a... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::XmlReporter::testCaseEnded(Catch::TestCaseStats const&) | void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
StreamingReporterBase::testCaseEnded( testCaseStats );
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
if ( m_config->show... | subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq 0x1c0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movq 0x1b8(%rsp), %rsi
callq 0x18ac20
movq 0x50(%rsp), %rax
addq $0x170, %rax # imm = 0x170
movq %rax, 0x58(%rsp)
leaq 0x187(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x142ca0
m... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::(anonymous namespace)::createReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<Catch::IConfig const> const&) | IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
return... | subq $0x98, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movb $0x0, 0x7f(%rsp)
callq 0x14f4f0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x88(%rsp), %rdx
movq 0x80(%rsp), %rcx
movq (... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::Detail::(anonymous namespace)::StreamBufImpl<Catch::Detail::(anonymous namespace)::OutputDebugWriter, 256ul>::overflow(int) | int overflow( int c ) override {
sync();
if( c != EOF ) {
if( pbase() == epptr() )
m_writer( std::string( 1, static_cast<char>( c ) ) );
else
sputc( static_cast<char>( c ) );
}
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $-0x1, 0x6c(%rsp)
je 0x170282
movq 0x28(%rsp), %rdi
callq 0x142200
movq 0x28(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x142940
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx,... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::clara::detail::ParserRefImpl<Catch::clara::detail::Arg>::ParserRefImpl<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::cha... | ParserRefImpl( T &ref, std::string const &hint )
: m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint )
{} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1934c0
movq 0x10(%rsp), %rax
leaq 0xdf3ca(%rip), %rcx # 0x272438
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp),... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::clara::TextFlow::Column::iterator::indent() const | auto indent() const -> size_t {
auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
return initial == std::string::npos ? m_column.m_indent : initial;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, 0x10(%rax)
jne 0x196465
movq -0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x196465
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x196473
movq $-0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x196473
movq -0x2... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::clara::TextFlow::Column::iterator::isBoundary(unsigned long) const | auto isBoundary(size_t at) const -> bool {
assert(at > 0);
assert(at <= line().size());
return at == line().size() ||
(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
isBreakableBefore(line()[at]) ||
isBreakableAfter(line()[at - 1]);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x1964b0
movq %rax, %rdi
callq 0x142500
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, 0x17(%rsp)
je 0x1965bb
movq (%rsp), %rdi
callq 0x196... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::clara::TextFlow::Columns::iterator::operator++() | auto operator ++() -> iterator& {
for (size_t i = 0; i < m_columns.size(); ++i) {
if (m_iterators[i] != m_columns[i].end())
++m_iterators[i];
}
return *this;
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x10(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
callq 0x197ac0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x19794d
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x48(%rs... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::clara::detail::Parser::getHelpColumns() const | auto getHelpColumns() const -> std::vector<HelpColumns> {
std::vector<HelpColumns> cols;
for (auto const &o : m_options) {
auto childCols = o.getHelpColumns();
cols.insert( cols.end(), childCols.begin(), childCols.end() );
}
return cols;
... | subq $0xb8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0x19d0d0
movq 0x28(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x194ec0
movq %rax, 0x90(%rsp... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
Catch::clara::detail::Opt::getHelpColumns() const | auto getHelpColumns() const -> std::vector<HelpColumns> {
std::ostringstream oss;
bool first = true;
for( auto const &opt : m_optNames ) {
if (first)
first = false;
else
oss << ", ";
oss << opt;
... | subq $0x298, %rsp # imm = 0x298
movq %rdi, 0x60(%rsp)
movq %rdi, %rax
movq %rax, 0x68(%rsp)
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq 0x288(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x110(%rsp), %rdi
callq 0x1429f0
movq 0x70(%rsp), %rax
movb $0x1, 0x10f(%rsp)
addq $0x60, %rax
movq %rax, 0x100(%rsp)
mov... | /alecthomas[P]entityx/entityx/3rdparty/catch.hpp |
msgpack::v2::detail::create_object_visitor::visit_bin(char const*, unsigned int) | bool visit_bin(const char* v, uint32_t size) {
MSGPACK_ASSERT(v || size == 0);
if (size > m_limit.bin()) throw msgpack::bin_size_overflow("bin size overflow");
msgpack::object* obj = m_stack.back();
obj->type = msgpack::type::BIN;
if (m_func && m_func(obj->type, size, m_user_data... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r15d
cmpq %r15, 0x28(%rdi)
jb 0x5d58b
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
movq 0x60(%rdi), %rax
movq -0x8(%rax), %r13
movl $0x6, (%r13)
movq (%rdi), %rax
testq %rax, %rax
je 0x5d545
movq 0x8(%r12), %rdx
pushq $0x6
popq %rdi
movq %r15, %rsi
c... | /qicosmos[P]rest_rpc/examples/../thirdparty/msgpack-c/include/msgpack/v2/create_object_visitor.hpp |
msgpack::v2::parse_return msgpack::v2::detail::context<msgpack::v2::detail::parse_helper<msgpack::v2::detail::create_object_visitor>>::start_aggregate<unsigned short, msgpack::v2::detail::context<msgpack::v2::detail::parse_helper<msgpack::v2::detail::create_object_visitor>>::array_sv, msgpack::v2::detail::context<msgpa... | parse_return start_aggregate(
StartVisitor const& sv,
EndVisitor const& ev,
const char* load_pos,
std::size_t& off) {
typename value<T>::type size;
load<T>(size, load_pos);
++m_current;
if (size == 0) {
if (!sv(size)) {
off = st... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdi, %r14
movzwl (%rcx), %eax
incq 0x8(%rdi)
testw %ax, %ax
je 0x5d60e
rolw $0x8, %ax
movzwl %ax, %ebp
movq %rsi, %rdi
movl %ebp, %esi
callq 0x5d9ea
testb %al, %al
je 0x5d647
leaq 0x20(%r14), %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebp, %ecx... | /qicosmos[P]rest_rpc/examples/../thirdparty/msgpack-c/include/msgpack/v2/parse.hpp |
msgpack::v2::parse_return msgpack::v2::detail::context<msgpack::v2::detail::parse_helper<msgpack::v2::detail::create_object_visitor>>::start_aggregate<unsigned int, msgpack::v2::detail::context<msgpack::v2::detail::parse_helper<msgpack::v2::detail::create_object_visitor>>::array_sv, msgpack::v2::detail::context<msgpack... | parse_return start_aggregate(
StartVisitor const& sv,
EndVisitor const& ev,
const char* load_pos,
std::size_t& off) {
typename value<T>::type size;
load<T>(size, load_pos);
++m_current;
if (size == 0) {
if (!sv(size)) {
off = st... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdi, %r14
movl (%rcx), %ebp
incq 0x8(%rdi)
testl %ebp, %ebp
je 0x5d6a1
bswapl %ebp
movq %rsi, %rdi
movl %ebp, %esi
callq 0x5d9ea
testb %al, %al
je 0x5d6da
leaq 0x20(%r14), %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x5d9f6
jmp 0... | /qicosmos[P]rest_rpc/examples/../thirdparty/msgpack-c/include/msgpack/v2/parse.hpp |
cfgfile::format_t<int, cfgfile::string_trait_t>::to_string[abi:cxx11](int const&) | static string_trait_t::string_t to_string( const int & value )
{
return std::to_string( value );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %r15d
movl %r15d, %ebp
negl %ebp
cmovsl %r15d, %ebp
movl $0x1, %r14d
cmpl $0xa, %ebp
jb 0xa528
movl $0x4, %r14d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0xa51f
cmpl $0x3e7, %ecx # i... | /igormironchik[P]cfgfile/example/generator/../../cfgfile/format.hpp |
cfgfile::tag_scalar_t<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cfgfile::string_trait_t>::set_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
set_value( const typename Trait::string_t & v )
{
if( m_constraint )
{
if( !m_constraint->check( v ) )
throw exception_t< Trait >(
Trait::from_ascii( "Invalid value: \"" ) +
format_t< typename Trait::string_t, Trait >::to_string( v ) +
Trait::from_ascii( "\". Value must match t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %r15
movq %rdi, %r14
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0xa6a2
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
testb %al, %al
je 0xa6c5
leaq 0x60(%r14), %rdi
movq %r15, %rsi
callq 0x30d0
mo... | /igormironchik[P]cfgfile/example/generator/../../cfgfile/tag_scalar.hpp |
QPDFObject::getDescription[abi:cxx11]() (.cold.1) | std::string
QPDFObject::getDescription()
{
qpdf_offset_t shift = (getTypeCode() == ::ot_dictionary) ? 2
: (getTypeCode() == ::ot_array) ? 1
: 0;
if (object_description) {
switch (object_description->index()) {
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq 0x1d6b15(%rip), %rax # 0x1f0f80
cmpb $0x0, (%rax)
je 0x1a47b
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x1a483
pushq $-0x1
popq %rax
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x1a48e
movq (%rdi), %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFObject.cc |
BitStream::reset() | void
BitStream::reset()
{
p = start;
bit_offset = 7;
if (QIntC::to_uint(nbytes) > static_cast<unsigned int>(-1) / 8) {
throw std::runtime_error("array too large for bitstream");
}
bits_available = 8 * nbytes;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq %rax, 0x10(%rbx)
movq $0x7, 0x18(%rbx)
movq %rdi, %rax
shrq $0x20, %rax
je 0x1e000
callq 0x1e600
movq 0x8(%rbx), %rdi
testl $0xe0000000, %edi # imm = 0xE0000000
jne 0x1e018
shlq $0x3, %rdi
movq %rdi, 0x20(%rbx)
addq $0x8,... | /jberkenbilt[P]qpdf/libqpdf/BitStream.cc |
BitStream::skipToNextByte() | void
BitStream::skipToNextByte()
{
if (bit_offset != 7) {
size_t bits_to_skip = bit_offset + 1;
if (bits_available < bits_to_skip) {
throw std::logic_error("INTERNAL ERROR: overflow skipping to next byte in bitstream");
}
bit_offset = 7;
++p;
bits_availabl... | pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
cmpq $0x7, %rax
je 0x1e390
incq %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
jb 0x1e398
movq $0x7, 0x18(%rdi)
incq 0x10(%rdi)
movq %rcx, 0x20(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x13fec0(%rip), %rsi # ... | /jberkenbilt[P]qpdf/libqpdf/BitStream.cc |
BufferInputSource::seek(long long, int) | void
BufferInputSource::seek(qpdf_offset_t offset, int whence)
{
switch (whence) {
case SEEK_SET:
this->cur_offset = offset;
break;
case SEEK_END:
QIntC::range_check(this->max_offset, offset);
this->cur_offset = this->max_offset + offset;
break;
case SEEK_CUR:
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, (%rsp)
cmpl $0x2, %edx
je 0x1f183
cmpl $0x1, %edx
je 0x1f149
testl %edx, %edx
je 0x1f1b8
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x13f34f(%rip), %rsi # 0x15e47a
movq %rax, %rdi
callq 0x19970
movq 0x1d1eae(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/BufferInputSource.cc |
QIntC::IntConverter<long long, unsigned long, true, false>::error(long long) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte unsigned type";
throw s... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x19b00
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x19130
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x195d0
movq %rsp, %rdi
callq 0x19b50
leaq ... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
ClosedFileInputSource::after() | void
ClosedFileInputSource::after()
{
this->last_offset = this->fis->getLastOffset();
this->offset = this->fis->tell();
if (this->stay_open) {
return;
}
this->fis = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0xd0(%rdi), %rdi
callq 0x21006
movq %rax, 0x8(%rbx)
movq 0xd0(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0xc8(%rbx)
cmpb $0x0, 0xe0(%rbx)
jne 0x1faff
xorps %xmm0, %xmm0
movq 0xd8(%rbx), %rdi
movups %xmm0, 0xd0(%rbx)
testq %rdi, %rdi
je 0x1faff
popq %rbx
jmp 0x1fc74
popq %... | /jberkenbilt[P]qpdf/libqpdf/ClosedFileInputSource.cc |
FileInputSource::~FileInputSource() | FileInputSource::~FileInputSource()
{
// Must be explicit and not inline -- see QPDF_DLL_CLASS in README-maintainer
if (this->file && this->close_file) {
fclose(this->file);
}
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1cab19(%rip), %rax # 0x1ead60
movq %rax, (%rdi)
movq 0xd0(%rdi), %rdi
testq %rdi, %rdi
je 0x20264
cmpb $0x1, 0xa8(%rbx)
jne 0x20264
callq 0x19460
movq 0xb0(%rbx), %rdi
addq $0xc0, %rbx
cmpq %rbx, %rdi
je 0x20283
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x190e0
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/FileInputSource.cc |
QPDFExc::~QPDFExc() | ~QPDFExc() noexcept override = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x1c9f3d(%rip), %rax # 0x1eade8
movq %rax, (%rdi)
movq 0x60(%rdi), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x20ec6
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq 0x38(%rbx), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x20ede
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq 0x18... | /jberkenbilt[P]qpdf/include/qpdf/QPDFExc.hh |
JSON::writeNext(Pipeline*, bool&, unsigned long) | void
JSON::writeNext(Pipeline* p, bool& first, size_t depth)
{
if (first) {
first = false;
std::string s{"\n"};
s.append(2 * depth, ' ');
*p << s;
} else {
std::string s{",\n"};
s.append(2 * depth, ' ');
*p << s;
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x217d3
movb $0x0, (%rsi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x15a728(%rip), %rsi # 0x17bec5
leaq 0x15a722(%rip), %rdx # 0x17bec6
movq %rsp, %rdi
callq 0x1df30
addq %r14, %r14
movq %rsp, %rdi
mov... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
JSON::JSON_number::JSON_number(long long) | JSON::JSON_number::JSON_number(long long value) :
JSON_value(vt_number),
encoded(std::to_string(value))
{
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, 0x8(%rdi)
leaq 0x1c8e28(%rip), %rax # 0x1eae78
movq %rax, (%rdi)
movq %rsi, %r15
negq %r15
cmovsq %rsi, %r15
movl $0x1, %r12d
cmpq $0xa, %r15
jb 0x220bd
movl $0x4, %r12d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
JSON::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | JSON
JSON::parse(std::string const& s)
{
BufferInputSource bis("json input", s);
JSONParser jp(bis, nullptr);
return jp.parse();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x41a8, %rsp # imm = 0x41A8
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x100(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x138197(%rip), %rsi # 0x15ec4f
leaq 0x13819a(%rip), %rdx # 0x15ec59
leaq 0xf0(%rsp), %rdi
callq 0x1df30
leaq 0x8(%rsp), %r14
leaq 0xf0(%rsp), ... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
MD5::getDataChecksum[abi:cxx11](char const*, unsigned long) | std::string
MD5::getDataChecksum(char const* buf, size_t len)
{
MD5 m;
m.encodeDataIncrementally(buf, len);
return m.unparse();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2a8f8
movq (%r15), %r15
movq %r12, %rdi
callq 0x13ed53
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq *0x20(%rcx)
leaq 0x8(%rsp), %rsi
movq %... | /jberkenbilt[P]qpdf/libqpdf/MD5.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.