name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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) {
std::vector<uint32_t> histogram_literal(256, 0);
std::vector<uint32_t> histogram_cmd(kNumCommandPrefixes, 0);
std::vector<uint32_t> histogram_dist(kNumDistancePrefixes, 0);
size_t pos = position - last_insert_len;
for (size_t i = 0; i < num_commands; i++) {
size_t inslength = commands[i].insert_len_;
size_t copylength = commands[i].copy_len_;
size_t distcode = commands[i].dist_prefix_;
size_t cmdcode = commands[i].cmd_prefix_;
histogram_cmd[cmdcode]++;
if (cmdcode >= 128) histogram_dist[distcode]++;
for (size_t j = 0; j < inslength; j++) {
histogram_literal[ringbuffer[(pos + j) & ringbuffer_mask]]++;
}
pos += inslength + copylength;
}
std::vector<double> cost_literal;
Set(histogram_literal, &cost_literal);
Set(histogram_cmd, &cost_cmd_);
Set(histogram_dist, &cost_dist_);
for (uint32_t i = 0; i < kNumCommandPrefixes; ++i) {
min_cost_cmd_ = std::min(min_cost_cmd_, cost_cmd_[i]);
}
literal_costs_.resize(num_bytes + 1);
literal_costs_[0] = 0.0;
for (size_t i = 0; i < num_bytes; ++i) {
literal_costs_[i + 1] = literal_costs_[i] +
cost_literal[ringbuffer[(position + i) & ringbuffer_mask]];
}
} | 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)
leaq -0x4d(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xc22b0
movq -0x108(%rbp), %rcx
leaq -0x48(%rbp), %rdi
movl $0x100, %esi # imm = 0x100
leaq -0x4c(%rbp), %rdx
callq 0xc7dc0
jmp 0xc2c38
leaq -0x4d(%rbp), %rdi
callq 0xc2340
movl $0x0, -0x7c(%rbp)
leaq -0x7d(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0xc22b0
movq -0x118(%rbp), %rcx
leaq -0x78(%rbp), %rdi
movl $0x2c0, %esi # imm = 0x2C0
leaq -0x7c(%rbp), %rdx
callq 0xc7dc0
jmp 0xc2c73
leaq -0x7d(%rbp), %rdi
callq 0xc2340
movl $0x0, -0x9c(%rbp)
leaq -0x9d(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xc22b0
movq -0x120(%rbp), %rcx
leaq -0x98(%rbp), %rdi
movl $0x208, %esi # imm = 0x208
leaq -0x9c(%rbp), %rdx
callq 0xc7dc0
jmp 0xc2cba
leaq -0x9d(%rbp), %rdi
callq 0xc2340
movq -0x18(%rbp), %rax
subq 0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq $0x0, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
cmpq 0x10(%rbp), %rax
jae 0xc2e75
movq -0x30(%rbp), %rax
imulq $0x18, -0xb0(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
movq %rax, -0xb8(%rbp)
movq -0x30(%rbp), %rax
imulq $0x18, -0xb0(%rbp), %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq %rax, -0xc0(%rbp)
movq -0x30(%rbp), %rax
imulq $0x18, -0xb0(%rbp), %rcx
addq %rcx, %rax
movzwl 0x16(%rax), %eax
movq %rax, -0xc8(%rbp)
movq -0x30(%rbp), %rax
imulq $0x18, -0xb0(%rbp), %rcx
addq %rcx, %rax
movzwl 0x14(%rax), %eax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xc1fc0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpq $0x80, -0xd0(%rbp)
jb 0xc2de7
movq -0xc8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0xc1fc0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xc2de7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x4d(%rbp), %rdi
callq 0xc2340
jmp 0xc30a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x7d(%rbp), %rdi
callq 0xc2340
jmp 0xc309d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x9d(%rbp), %rdi
callq 0xc2340
jmp 0xc3094
movq $0x0, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
cmpq -0xb8(%rbp), %rax
jae 0xc2e42
movq -0x20(%rbp), %rax
movq -0xa8(%rbp), %rcx
addq -0xd8(%rbp), %rcx
andq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
leaq -0x48(%rbp), %rdi
callq 0xc1fc0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0xd8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
jmp 0xc2df2
movq -0xb8(%rbp), %rax
addq -0xc0(%rbp), %rax
addq -0xa8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xb0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb0(%rbp)
jmp 0xc2ce0
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0xc8540
movq -0x110(%rbp), %rdi
movq -0x128(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0xc9950
jmp 0xc2ea1
movq -0x110(%rbp), %rdx
leaq -0x78(%rbp), %rsi
movq %rdx, %rdi
callq 0xc9950
jmp 0xc2eb6
movq -0x110(%rbp), %rdi
movq %rdi, %rdx
addq $0x18, %rdx
leaq -0x98(%rbp), %rsi
callq 0xc9950
jmp 0xc2ed2
movl $0x0, -0xf4(%rbp)
cmpl $0x2c0, -0xf4(%rbp) # imm = 0x2C0
jae 0xc2f77
movq -0x110(%rbp), %rdi
movq %rdi, %rax
addq $0x48, %rax
movq %rax, -0x138(%rbp)
movl -0xf4(%rbp), %eax
movl %eax, %esi
callq 0xc8770
movq -0x138(%rbp), %rdi
movq %rax, %rsi
callq 0xc9ae0
movq %rax, -0x130(%rbp)
jmp 0xc2f26
movq -0x110(%rbp), %rax
movq -0x130(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x48(%rax)
movl -0xf4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf4(%rbp)
jmp 0xc2edc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0xc9b20
leaq -0x98(%rbp), %rdi
callq 0xc2070
jmp 0xc3094
movq -0x110(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
incq %rsi
callq 0xc86e0
jmp 0xc2f90
movq -0x110(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc8770
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq $0x0, -0x100(%rbp)
movq -0x100(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xc3061
movq -0x110(%rbp), %rdi
addq $0x30, %rdi
movq -0x100(%rbp), %rsi
callq 0xc8770
movsd (%rax), %xmm0
movsd %xmm0, -0x148(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
addq -0x100(%rbp), %rcx
andq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
leaq -0xf0(%rbp), %rdi
callq 0xc8770
movsd -0x148(%rbp), %xmm0
movq -0x110(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, -0x140(%rbp)
addq $0x30, %rdi
movq -0x100(%rbp), %rsi
addq $0x1, %rsi
callq 0xc8770
movsd -0x140(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x100(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x100(%rbp)
jmp 0xc2fb6
leaq -0xf0(%rbp), %rdi
callq 0xc9b20
leaq -0x98(%rbp), %rdi
callq 0xc2070
leaq -0x78(%rbp), %rdi
callq 0xc2070
leaq -0x48(%rbp), %rdi
callq 0xc2070
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
leaq -0x78(%rbp), %rdi
callq 0xc2070
leaq -0x48(%rbp), %rdi
callq 0xc2070
movq -0x58(%rbp), %rdi
callq 0x3fc20
nop
| /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,
const int lgwin,
Hasher* hasher,
int* dist_cache,
size_t* last_insert_len,
Command* commands,
size_t* num_commands,
size_t* num_literals) {
// Set maximum distance, see section 9.1. of the spec.
const size_t max_backward_limit = (1 << lgwin) - 16;
// Choose which init method is faster.
// memset is about 100 times faster than hasher->InitForData().
const size_t kMaxBytesForPartialHashInit = Hasher::kHashMapSize >> 7;
if (position == 0 && is_last && num_bytes <= kMaxBytesForPartialHashInit) {
hasher->InitForData(ringbuffer, num_bytes);
} else {
hasher->Init();
}
if (num_bytes >= 3 && position >= 3) {
// Prepare the hashes for three last bytes of the last write.
// These could not be calculated before, since they require knowledge
// of both the previous and the current block.
hasher->Store(&ringbuffer[(position - 3) & ringbuffer_mask],
static_cast<uint32_t>(position - 3));
hasher->Store(&ringbuffer[(position - 2) & ringbuffer_mask],
static_cast<uint32_t>(position - 2));
hasher->Store(&ringbuffer[(position - 1) & ringbuffer_mask],
static_cast<uint32_t>(position - 1));
}
const Command * const orig_commands = commands;
size_t insert_length = *last_insert_len;
size_t i = position & ringbuffer_mask;
const size_t i_diff = position - i;
const size_t i_end = i + num_bytes;
// For speed up heuristics for random data.
const size_t random_heuristics_window_size = quality < 9 ? 64 : 512;
size_t apply_random_heuristics = i + random_heuristics_window_size;
// Minimum score to accept a backward reference.
const int kMinScore = 4.0;
while (i + Hasher::kHashTypeLength - 1 < i_end) {
size_t max_length = i_end - i;
size_t max_distance = std::min(i + i_diff, max_backward_limit);
size_t best_len = 0;
size_t best_len_code = 0;
size_t best_dist = 0;
double best_score = kMinScore;
bool match_found = hasher->FindLongestMatch(
ringbuffer, ringbuffer_mask,
dist_cache, static_cast<uint32_t>(i + i_diff), max_length, max_distance,
&best_len, &best_len_code, &best_dist, &best_score);
if (match_found) {
// Found a match. Let's look for something even better ahead.
int delayed_backward_references_in_row = 0;
for (;;) {
--max_length;
size_t best_len_2 =
quality < 5 ? std::min(best_len - 1, max_length) : 0;
size_t best_len_code_2 = 0;
size_t best_dist_2 = 0;
double best_score_2 = kMinScore;
max_distance = std::min(i + i_diff + 1, max_backward_limit);
match_found = hasher->FindLongestMatch(
ringbuffer, ringbuffer_mask,
dist_cache, static_cast<uint32_t>(i + i_diff + 1),
max_length, max_distance,
&best_len_2, &best_len_code_2, &best_dist_2, &best_score_2);
double cost_diff_lazy = 7.0;
if (match_found && best_score_2 >= best_score + cost_diff_lazy) {
// Ok, let's just write one byte for now and start a match from the
// next byte.
++i;
++insert_length;
best_len = best_len_2;
best_len_code = best_len_code_2;
best_dist = best_dist_2;
best_score = best_score_2;
if (++delayed_backward_references_in_row < 4) {
continue;
}
}
break;
}
apply_random_heuristics =
i + 2 * best_len + random_heuristics_window_size;
max_distance = std::min(i + i_diff, max_backward_limit);
// The first 16 codes are special shortcodes, and the minimum offset is 1.
size_t distance_code =
ComputeDistanceCode(best_dist, max_distance, quality, dist_cache);
if (best_dist <= max_distance && distance_code > 0) {
dist_cache[3] = dist_cache[2];
dist_cache[2] = dist_cache[1];
dist_cache[1] = dist_cache[0];
dist_cache[0] = static_cast<int>(best_dist);
}
Command cmd(insert_length, best_len, best_len_code, distance_code);
*commands++ = cmd;
*num_literals += insert_length;
insert_length = 0;
// Put the hash keys into the table, if there are enough
// bytes left.
for (size_t j = 2; j < best_len; ++j) {
hasher->Store(&ringbuffer[i + j],
static_cast<uint32_t>(i + i_diff + j));
}
i += best_len;
} else {
++insert_length;
++i;
// If we have not seen matches for a long time, we can skip some
// match lookups. Unsuccessful match lookups are very very expensive
// and this kind of a heuristic speeds up compression quite
// a lot.
if (i > apply_random_heuristics) {
// Going through uncompressible data, jump.
if (i > apply_random_heuristics + 4 * random_heuristics_window_size) {
// It is quite a long time since we saw a copy, so we assume
// that this data is not compressible, and store hashes less
// often. Hashes of non compressible data are less likely to
// turn out to be useful in the future, too, so we store less of
// them to not to flood out the hash table of good compressible
// data.
size_t i_jump = std::min(i + 16, i_end - 4);
for (; i < i_jump; i += 4) {
hasher->Store(ringbuffer + i, static_cast<uint32_t>(i + i_diff));
insert_length += 4;
}
} else {
size_t i_jump = std::min(i + 8, i_end - 3);
for (; i < i_jump; i += 2) {
hasher->Store(ringbuffer + i, static_cast<uint32_t>(i + i_diff));
insert_length += 2;
}
}
}
}
}
insert_length += i_end - i;
*last_insert_len = insert_length;
*num_commands += static_cast<size_t>(commands - orig_commands);
} | 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
movb %al, -0x21(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
movl 0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x10, %eax
cltq
movq %rax, -0x48(%rbp)
movq $0x800, -0x50(%rbp) # imm = 0x800
cmpq $0x0, -0x20(%rbp)
jne 0xc3959
testb $0x1, -0x21(%rbp)
je 0xc3959
cmpq $0x800, -0x18(%rbp) # imm = 0x800
ja 0xc3959
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xcc190
jmp 0xc3962
movq 0x18(%rbp), %rdi
callq 0xcc210
cmpq $0x3, -0x18(%rbp)
jb 0xc39e2
cmpq $0x3, -0x20(%rbp)
jb 0xc39e2
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
subq $0x3, %rax
andq -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
subq $0x3, %rax
movl %eax, %edx
callq 0xcc250
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
subq $0x2, %rax
andq -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
subq $0x2, %rax
movl %eax, %edx
callq 0xcc250
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
subq $0x1, %rax
andq -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
subq $0x1, %rax
movl %eax, %edx
callq 0xcc250
movq 0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
andq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x3c(%rbp), %edx
movl $0x200, %eax # imm = 0x200
movl $0x40, %ecx
cmpl $0x9, %edx
cmovll %ecx, %eax
cltq
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rax
addq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x4, -0x8c(%rbp)
movq -0x68(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
cmpq -0x78(%rbp), %rax
jae 0xc3ff8
movq -0x78(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0xb0(%rbp)
movq $0x0, -0xb8(%rbp)
movq $0x0, -0xc0(%rbp)
movsd 0x810fe(%rip), %xmm0 # 0x144bc0
movsd %xmm0, -0xc8(%rbp)
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movl %eax, %eax
movl %eax, %r8d
movq -0x98(%rbp), %r9
movq -0xa0(%rbp), %r14
leaq -0xb0(%rbp), %rbx
leaq -0xb8(%rbp), %r11
leaq -0xc0(%rbp), %r10
leaq -0xc8(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0xcc2a0
andb $0x1, %al
movb %al, -0xc9(%rbp)
testb $0x1, -0xc9(%rbp)
je 0xc3ead
movl $0x0, -0xd0(%rbp)
movq -0x98(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x98(%rbp)
cmpl $0x5, -0x3c(%rbp)
jge 0xc3b96
movq -0xb0(%rbp), %rax
subq $0x1, %rax
movq %rax, -0xe0(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0x170(%rbp)
jmp 0xc3ba1
xorl %eax, %eax
movq %rax, -0x170(%rbp)
jmp 0xc3ba1
movq -0x170(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq $0x0, -0xe8(%rbp)
movq $0x0, -0xf0(%rbp)
movsd 0x80ff3(%rip), %xmm0 # 0x144bc0
movsd %xmm0, -0xf8(%rbp)
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x100(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
addq $0x1, %rax
movl %eax, %eax
movl %eax, %r8d
movq -0x98(%rbp), %r9
movq -0xa0(%rbp), %r14
leaq -0xd8(%rbp), %rbx
leaq -0xe8(%rbp), %r11
leaq -0xf0(%rbp), %r10
leaq -0xf8(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0xcc2a0
andb $0x1, %al
movb %al, -0xc9(%rbp)
movsd 0x80f4e(%rip), %xmm0 # 0x144bc8
movsd %xmm0, -0x108(%rbp)
testb $0x1, -0xc9(%rbp)
je 0xc3d1a
movsd -0xf8(%rbp), %xmm0
movsd -0xc8(%rbp), %xmm1
addsd -0x108(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0xc3d1a
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movsd -0xf8(%rbp), %xmm0
movsd %xmm0, -0xc8(%rbp)
movl -0xd0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd0(%rbp)
cmpl $0x4, %eax
jge 0xc3d18
jmp 0xc3b4d
jmp 0xc3d1a
jmp 0xc3d1c
movq -0x68(%rbp), %rax
movq -0xb0(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
addq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x110(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0xc0(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq 0x20(%rbp), %rcx
callq 0xcbee0
movq %rax, -0x118(%rbp)
movq -0xc0(%rbp), %rax
cmpq -0xa0(%rbp), %rax
ja 0xc3dd4
cmpq $0x0, -0x118(%rbp)
jbe 0xc3dd4
movq 0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq 0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rbp), %rax
movl (%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0xc0(%rbp), %rax
movl %eax, %ecx
movq 0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x60(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq -0xb8(%rbp), %rcx
movq -0x118(%rbp), %r8
leaq -0x130(%rbp), %rdi
callq 0xc1fe0
movq 0x30(%rbp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x30(%rbp)
movq -0x130(%rbp), %rcx
movq %rcx, (%rax)
movq -0x128(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x60(%rbp), %rcx
movq 0x40(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x60(%rbp)
movq $0x2, -0x138(%rbp)
movq -0x138(%rbp), %rax
cmpq -0xb0(%rbp), %rax
jae 0xc3e99
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x68(%rbp), %rax
addq -0x138(%rbp), %rax
addq %rax, %rsi
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
addq -0x138(%rbp), %rax
movl %eax, %edx
callq 0xcc250
movq -0x138(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x138(%rbp)
jmp 0xc3e49
movq -0xb0(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xc3ff3
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x88(%rbp), %rax
jbe 0xc3ff1
movq -0x68(%rbp), %rax
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0xc3f70
movq -0x68(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x148(%rbp)
movq -0x78(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x150(%rbp)
leaq -0x148(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0x140(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x140(%rbp), %rax
jae 0xc3f6e
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq -0x68(%rbp), %rsi
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movl %eax, %edx
callq 0xcc250
movq -0x60(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x68(%rbp)
jmp 0xc3f2c
jmp 0xc3fef
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x160(%rbp)
movq -0x78(%rbp), %rax
subq $0x3, %rax
movq %rax, -0x168(%rbp)
leaq -0x160(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0x158(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x158(%rbp), %rax
jae 0xc3fed
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq -0x68(%rbp), %rsi
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movl %eax, %edx
callq 0xcc250
movq -0x60(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x68(%rbp)
jmp 0xc3fab
jmp 0xc3fef
jmp 0xc3ff1
jmp 0xc3ff3
jmp 0xc3a4b
movq -0x78(%rbp), %rax
subq -0x68(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movq 0x30(%rbp), %rax
movq -0x58(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq 0x38(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /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,
const int lgwin,
Hasher* hasher,
int* dist_cache,
size_t* last_insert_len,
Command* commands,
size_t* num_commands,
size_t* num_literals) {
// Set maximum distance, see section 9.1. of the spec.
const size_t max_backward_limit = (1 << lgwin) - 16;
// Choose which init method is faster.
// memset is about 100 times faster than hasher->InitForData().
const size_t kMaxBytesForPartialHashInit = Hasher::kHashMapSize >> 7;
if (position == 0 && is_last && num_bytes <= kMaxBytesForPartialHashInit) {
hasher->InitForData(ringbuffer, num_bytes);
} else {
hasher->Init();
}
if (num_bytes >= 3 && position >= 3) {
// Prepare the hashes for three last bytes of the last write.
// These could not be calculated before, since they require knowledge
// of both the previous and the current block.
hasher->Store(&ringbuffer[(position - 3) & ringbuffer_mask],
static_cast<uint32_t>(position - 3));
hasher->Store(&ringbuffer[(position - 2) & ringbuffer_mask],
static_cast<uint32_t>(position - 2));
hasher->Store(&ringbuffer[(position - 1) & ringbuffer_mask],
static_cast<uint32_t>(position - 1));
}
const Command * const orig_commands = commands;
size_t insert_length = *last_insert_len;
size_t i = position & ringbuffer_mask;
const size_t i_diff = position - i;
const size_t i_end = i + num_bytes;
// For speed up heuristics for random data.
const size_t random_heuristics_window_size = quality < 9 ? 64 : 512;
size_t apply_random_heuristics = i + random_heuristics_window_size;
// Minimum score to accept a backward reference.
const int kMinScore = 4.0;
while (i + Hasher::kHashTypeLength - 1 < i_end) {
size_t max_length = i_end - i;
size_t max_distance = std::min(i + i_diff, max_backward_limit);
size_t best_len = 0;
size_t best_len_code = 0;
size_t best_dist = 0;
double best_score = kMinScore;
bool match_found = hasher->FindLongestMatch(
ringbuffer, ringbuffer_mask,
dist_cache, static_cast<uint32_t>(i + i_diff), max_length, max_distance,
&best_len, &best_len_code, &best_dist, &best_score);
if (match_found) {
// Found a match. Let's look for something even better ahead.
int delayed_backward_references_in_row = 0;
for (;;) {
--max_length;
size_t best_len_2 =
quality < 5 ? std::min(best_len - 1, max_length) : 0;
size_t best_len_code_2 = 0;
size_t best_dist_2 = 0;
double best_score_2 = kMinScore;
max_distance = std::min(i + i_diff + 1, max_backward_limit);
match_found = hasher->FindLongestMatch(
ringbuffer, ringbuffer_mask,
dist_cache, static_cast<uint32_t>(i + i_diff + 1),
max_length, max_distance,
&best_len_2, &best_len_code_2, &best_dist_2, &best_score_2);
double cost_diff_lazy = 7.0;
if (match_found && best_score_2 >= best_score + cost_diff_lazy) {
// Ok, let's just write one byte for now and start a match from the
// next byte.
++i;
++insert_length;
best_len = best_len_2;
best_len_code = best_len_code_2;
best_dist = best_dist_2;
best_score = best_score_2;
if (++delayed_backward_references_in_row < 4) {
continue;
}
}
break;
}
apply_random_heuristics =
i + 2 * best_len + random_heuristics_window_size;
max_distance = std::min(i + i_diff, max_backward_limit);
// The first 16 codes are special shortcodes, and the minimum offset is 1.
size_t distance_code =
ComputeDistanceCode(best_dist, max_distance, quality, dist_cache);
if (best_dist <= max_distance && distance_code > 0) {
dist_cache[3] = dist_cache[2];
dist_cache[2] = dist_cache[1];
dist_cache[1] = dist_cache[0];
dist_cache[0] = static_cast<int>(best_dist);
}
Command cmd(insert_length, best_len, best_len_code, distance_code);
*commands++ = cmd;
*num_literals += insert_length;
insert_length = 0;
// Put the hash keys into the table, if there are enough
// bytes left.
for (size_t j = 2; j < best_len; ++j) {
hasher->Store(&ringbuffer[i + j],
static_cast<uint32_t>(i + i_diff + j));
}
i += best_len;
} else {
++insert_length;
++i;
// If we have not seen matches for a long time, we can skip some
// match lookups. Unsuccessful match lookups are very very expensive
// and this kind of a heuristic speeds up compression quite
// a lot.
if (i > apply_random_heuristics) {
// Going through uncompressible data, jump.
if (i > apply_random_heuristics + 4 * random_heuristics_window_size) {
// It is quite a long time since we saw a copy, so we assume
// that this data is not compressible, and store hashes less
// often. Hashes of non compressible data are less likely to
// turn out to be useful in the future, too, so we store less of
// them to not to flood out the hash table of good compressible
// data.
size_t i_jump = std::min(i + 16, i_end - 4);
for (; i < i_jump; i += 4) {
hasher->Store(ringbuffer + i, static_cast<uint32_t>(i + i_diff));
insert_length += 4;
}
} else {
size_t i_jump = std::min(i + 8, i_end - 3);
for (; i < i_jump; i += 2) {
hasher->Store(ringbuffer + i, static_cast<uint32_t>(i + i_diff));
insert_length += 2;
}
}
}
}
}
insert_length += i_end - i;
*last_insert_len = insert_length;
*num_commands += static_cast<size_t>(commands - orig_commands);
} | 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
movb %al, -0x21(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
movl 0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x10, %eax
cltq
movq %rax, -0x48(%rbp)
movq $0x100, -0x50(%rbp) # imm = 0x100
cmpq $0x0, -0x20(%rbp)
jne 0xc4fd9
testb $0x1, -0x21(%rbp)
je 0xc4fd9
cmpq $0x100, -0x18(%rbp) # imm = 0x100
ja 0xc4fd9
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xcd550
jmp 0xc4fe2
movq 0x18(%rbp), %rdi
callq 0xcd5c0
cmpq $0x3, -0x18(%rbp)
jb 0xc5062
cmpq $0x3, -0x20(%rbp)
jb 0xc5062
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
subq $0x3, %rax
andq -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
subq $0x3, %rax
movl %eax, %edx
callq 0xcd600
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
subq $0x2, %rax
andq -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
subq $0x2, %rax
movl %eax, %edx
callq 0xcd600
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
subq $0x1, %rax
andq -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
subq $0x1, %rax
movl %eax, %edx
callq 0xcd600
movq 0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
andq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x3c(%rbp), %edx
movl $0x200, %eax # imm = 0x200
movl $0x40, %ecx
cmpl $0x9, %edx
cmovll %ecx, %eax
cltq
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rax
addq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x4, -0x8c(%rbp)
movq -0x68(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
cmpq -0x78(%rbp), %rax
jae 0xc5678
movq -0x78(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0xb0(%rbp)
movq $0x0, -0xb8(%rbp)
movq $0x0, -0xc0(%rbp)
movsd 0x7fa7e(%rip), %xmm0 # 0x144bc0
movsd %xmm0, -0xc8(%rbp)
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movl %eax, %eax
movl %eax, %r8d
movq -0x98(%rbp), %r9
movq -0xa0(%rbp), %r14
leaq -0xb0(%rbp), %rbx
leaq -0xb8(%rbp), %r11
leaq -0xc0(%rbp), %r10
leaq -0xc8(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0xcd670
andb $0x1, %al
movb %al, -0xc9(%rbp)
testb $0x1, -0xc9(%rbp)
je 0xc552d
movl $0x0, -0xd0(%rbp)
movq -0x98(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x98(%rbp)
cmpl $0x5, -0x3c(%rbp)
jge 0xc5216
movq -0xb0(%rbp), %rax
subq $0x1, %rax
movq %rax, -0xe0(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0x170(%rbp)
jmp 0xc5221
xorl %eax, %eax
movq %rax, -0x170(%rbp)
jmp 0xc5221
movq -0x170(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq $0x0, -0xe8(%rbp)
movq $0x0, -0xf0(%rbp)
movsd 0x7f973(%rip), %xmm0 # 0x144bc0
movsd %xmm0, -0xf8(%rbp)
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x100(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
addq $0x1, %rax
movl %eax, %eax
movl %eax, %r8d
movq -0x98(%rbp), %r9
movq -0xa0(%rbp), %r14
leaq -0xd8(%rbp), %rbx
leaq -0xe8(%rbp), %r11
leaq -0xf0(%rbp), %r10
leaq -0xf8(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0xcd670
andb $0x1, %al
movb %al, -0xc9(%rbp)
movsd 0x7f8ce(%rip), %xmm0 # 0x144bc8
movsd %xmm0, -0x108(%rbp)
testb $0x1, -0xc9(%rbp)
je 0xc539a
movsd -0xf8(%rbp), %xmm0
movsd -0xc8(%rbp), %xmm1
addsd -0x108(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0xc539a
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movsd -0xf8(%rbp), %xmm0
movsd %xmm0, -0xc8(%rbp)
movl -0xd0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd0(%rbp)
cmpl $0x4, %eax
jge 0xc5398
jmp 0xc51cd
jmp 0xc539a
jmp 0xc539c
movq -0x68(%rbp), %rax
movq -0xb0(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
addq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x110(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0xc0(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq 0x20(%rbp), %rcx
callq 0xcbee0
movq %rax, -0x118(%rbp)
movq -0xc0(%rbp), %rax
cmpq -0xa0(%rbp), %rax
ja 0xc5454
cmpq $0x0, -0x118(%rbp)
jbe 0xc5454
movq 0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq 0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rbp), %rax
movl (%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0xc0(%rbp), %rax
movl %eax, %ecx
movq 0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x60(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq -0xb8(%rbp), %rcx
movq -0x118(%rbp), %r8
leaq -0x130(%rbp), %rdi
callq 0xc1fe0
movq 0x30(%rbp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x30(%rbp)
movq -0x130(%rbp), %rcx
movq %rcx, (%rax)
movq -0x128(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x60(%rbp), %rcx
movq 0x40(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x60(%rbp)
movq $0x2, -0x138(%rbp)
movq -0x138(%rbp), %rax
cmpq -0xb0(%rbp), %rax
jae 0xc5519
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x68(%rbp), %rax
addq -0x138(%rbp), %rax
addq %rax, %rsi
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
addq -0x138(%rbp), %rax
movl %eax, %edx
callq 0xcd600
movq -0x138(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x138(%rbp)
jmp 0xc54c9
movq -0xb0(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xc5673
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x88(%rbp), %rax
jbe 0xc5671
movq -0x68(%rbp), %rax
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0xc55f0
movq -0x68(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x148(%rbp)
movq -0x78(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x150(%rbp)
leaq -0x148(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0x140(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x140(%rbp), %rax
jae 0xc55ee
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq -0x68(%rbp), %rsi
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movl %eax, %edx
callq 0xcd600
movq -0x60(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x68(%rbp)
jmp 0xc55ac
jmp 0xc566f
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x160(%rbp)
movq -0x78(%rbp), %rax
subq $0x3, %rax
movq %rax, -0x168(%rbp)
leaq -0x160(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0x158(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x158(%rbp), %rax
jae 0xc566d
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq -0x68(%rbp), %rsi
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movl %eax, %edx
callq 0xcd600
movq -0x60(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x68(%rbp)
jmp 0xc562b
jmp 0xc566f
jmp 0xc5671
jmp 0xc5673
jmp 0xc50cb
movq -0x78(%rbp), %rax
subq -0x68(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movq 0x30(%rbp), %rax
movq -0x58(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq 0x38(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /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,
const int lgwin,
Hasher* hasher,
int* dist_cache,
size_t* last_insert_len,
Command* commands,
size_t* num_commands,
size_t* num_literals) {
// Set maximum distance, see section 9.1. of the spec.
const size_t max_backward_limit = (1 << lgwin) - 16;
// Choose which init method is faster.
// memset is about 100 times faster than hasher->InitForData().
const size_t kMaxBytesForPartialHashInit = Hasher::kHashMapSize >> 7;
if (position == 0 && is_last && num_bytes <= kMaxBytesForPartialHashInit) {
hasher->InitForData(ringbuffer, num_bytes);
} else {
hasher->Init();
}
if (num_bytes >= 3 && position >= 3) {
// Prepare the hashes for three last bytes of the last write.
// These could not be calculated before, since they require knowledge
// of both the previous and the current block.
hasher->Store(&ringbuffer[(position - 3) & ringbuffer_mask],
static_cast<uint32_t>(position - 3));
hasher->Store(&ringbuffer[(position - 2) & ringbuffer_mask],
static_cast<uint32_t>(position - 2));
hasher->Store(&ringbuffer[(position - 1) & ringbuffer_mask],
static_cast<uint32_t>(position - 1));
}
const Command * const orig_commands = commands;
size_t insert_length = *last_insert_len;
size_t i = position & ringbuffer_mask;
const size_t i_diff = position - i;
const size_t i_end = i + num_bytes;
// For speed up heuristics for random data.
const size_t random_heuristics_window_size = quality < 9 ? 64 : 512;
size_t apply_random_heuristics = i + random_heuristics_window_size;
// Minimum score to accept a backward reference.
const int kMinScore = 4.0;
while (i + Hasher::kHashTypeLength - 1 < i_end) {
size_t max_length = i_end - i;
size_t max_distance = std::min(i + i_diff, max_backward_limit);
size_t best_len = 0;
size_t best_len_code = 0;
size_t best_dist = 0;
double best_score = kMinScore;
bool match_found = hasher->FindLongestMatch(
ringbuffer, ringbuffer_mask,
dist_cache, static_cast<uint32_t>(i + i_diff), max_length, max_distance,
&best_len, &best_len_code, &best_dist, &best_score);
if (match_found) {
// Found a match. Let's look for something even better ahead.
int delayed_backward_references_in_row = 0;
for (;;) {
--max_length;
size_t best_len_2 =
quality < 5 ? std::min(best_len - 1, max_length) : 0;
size_t best_len_code_2 = 0;
size_t best_dist_2 = 0;
double best_score_2 = kMinScore;
max_distance = std::min(i + i_diff + 1, max_backward_limit);
match_found = hasher->FindLongestMatch(
ringbuffer, ringbuffer_mask,
dist_cache, static_cast<uint32_t>(i + i_diff + 1),
max_length, max_distance,
&best_len_2, &best_len_code_2, &best_dist_2, &best_score_2);
double cost_diff_lazy = 7.0;
if (match_found && best_score_2 >= best_score + cost_diff_lazy) {
// Ok, let's just write one byte for now and start a match from the
// next byte.
++i;
++insert_length;
best_len = best_len_2;
best_len_code = best_len_code_2;
best_dist = best_dist_2;
best_score = best_score_2;
if (++delayed_backward_references_in_row < 4) {
continue;
}
}
break;
}
apply_random_heuristics =
i + 2 * best_len + random_heuristics_window_size;
max_distance = std::min(i + i_diff, max_backward_limit);
// The first 16 codes are special shortcodes, and the minimum offset is 1.
size_t distance_code =
ComputeDistanceCode(best_dist, max_distance, quality, dist_cache);
if (best_dist <= max_distance && distance_code > 0) {
dist_cache[3] = dist_cache[2];
dist_cache[2] = dist_cache[1];
dist_cache[1] = dist_cache[0];
dist_cache[0] = static_cast<int>(best_dist);
}
Command cmd(insert_length, best_len, best_len_code, distance_code);
*commands++ = cmd;
*num_literals += insert_length;
insert_length = 0;
// Put the hash keys into the table, if there are enough
// bytes left.
for (size_t j = 2; j < best_len; ++j) {
hasher->Store(&ringbuffer[i + j],
static_cast<uint32_t>(i + i_diff + j));
}
i += best_len;
} else {
++insert_length;
++i;
// If we have not seen matches for a long time, we can skip some
// match lookups. Unsuccessful match lookups are very very expensive
// and this kind of a heuristic speeds up compression quite
// a lot.
if (i > apply_random_heuristics) {
// Going through uncompressible data, jump.
if (i > apply_random_heuristics + 4 * random_heuristics_window_size) {
// It is quite a long time since we saw a copy, so we assume
// that this data is not compressible, and store hashes less
// often. Hashes of non compressible data are less likely to
// turn out to be useful in the future, too, so we store less of
// them to not to flood out the hash table of good compressible
// data.
size_t i_jump = std::min(i + 16, i_end - 4);
for (; i < i_jump; i += 4) {
hasher->Store(ringbuffer + i, static_cast<uint32_t>(i + i_diff));
insert_length += 4;
}
} else {
size_t i_jump = std::min(i + 8, i_end - 3);
for (; i < i_jump; i += 2) {
hasher->Store(ringbuffer + i, static_cast<uint32_t>(i + i_diff));
insert_length += 2;
}
}
}
}
}
insert_length += i_end - i;
*last_insert_len = insert_length;
*num_commands += static_cast<size_t>(commands - orig_commands);
} | 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
movb %al, -0x21(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
movl 0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x10, %eax
cltq
movq %rax, -0x48(%rbp)
movq $0x200, -0x50(%rbp) # imm = 0x200
cmpq $0x0, -0x20(%rbp)
jne 0xc5759
testb $0x1, -0x21(%rbp)
je 0xc5759
cmpq $0x200, -0x18(%rbp) # imm = 0x200
ja 0xc5759
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xcdd90
jmp 0xc5762
movq 0x18(%rbp), %rdi
callq 0xcde00
cmpq $0x3, -0x18(%rbp)
jb 0xc57e2
cmpq $0x3, -0x20(%rbp)
jb 0xc57e2
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
subq $0x3, %rax
andq -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
subq $0x3, %rax
movl %eax, %edx
callq 0xcde40
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
subq $0x2, %rax
andq -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
subq $0x2, %rax
movl %eax, %edx
callq 0xcde40
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
subq $0x1, %rax
andq -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
subq $0x1, %rax
movl %eax, %edx
callq 0xcde40
movq 0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
andq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x3c(%rbp), %edx
movl $0x200, %eax # imm = 0x200
movl $0x40, %ecx
cmpl $0x9, %edx
cmovll %ecx, %eax
cltq
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rax
addq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x4, -0x8c(%rbp)
movq -0x68(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
cmpq -0x78(%rbp), %rax
jae 0xc5df8
movq -0x78(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0xb0(%rbp)
movq $0x0, -0xb8(%rbp)
movq $0x0, -0xc0(%rbp)
movsd 0x7f2fe(%rip), %xmm0 # 0x144bc0
movsd %xmm0, -0xc8(%rbp)
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movl %eax, %eax
movl %eax, %r8d
movq -0x98(%rbp), %r9
movq -0xa0(%rbp), %r14
leaq -0xb0(%rbp), %rbx
leaq -0xb8(%rbp), %r11
leaq -0xc0(%rbp), %r10
leaq -0xc8(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0xcdeb0
andb $0x1, %al
movb %al, -0xc9(%rbp)
testb $0x1, -0xc9(%rbp)
je 0xc5cad
movl $0x0, -0xd0(%rbp)
movq -0x98(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x98(%rbp)
cmpl $0x5, -0x3c(%rbp)
jge 0xc5996
movq -0xb0(%rbp), %rax
subq $0x1, %rax
movq %rax, -0xe0(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0x170(%rbp)
jmp 0xc59a1
xorl %eax, %eax
movq %rax, -0x170(%rbp)
jmp 0xc59a1
movq -0x170(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq $0x0, -0xe8(%rbp)
movq $0x0, -0xf0(%rbp)
movsd 0x7f1f3(%rip), %xmm0 # 0x144bc0
movsd %xmm0, -0xf8(%rbp)
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x100(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
addq $0x1, %rax
movl %eax, %eax
movl %eax, %r8d
movq -0x98(%rbp), %r9
movq -0xa0(%rbp), %r14
leaq -0xd8(%rbp), %rbx
leaq -0xe8(%rbp), %r11
leaq -0xf0(%rbp), %r10
leaq -0xf8(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0xcdeb0
andb $0x1, %al
movb %al, -0xc9(%rbp)
movsd 0x7f14e(%rip), %xmm0 # 0x144bc8
movsd %xmm0, -0x108(%rbp)
testb $0x1, -0xc9(%rbp)
je 0xc5b1a
movsd -0xf8(%rbp), %xmm0
movsd -0xc8(%rbp), %xmm1
addsd -0x108(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0xc5b1a
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movsd -0xf8(%rbp), %xmm0
movsd %xmm0, -0xc8(%rbp)
movl -0xd0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd0(%rbp)
cmpl $0x4, %eax
jge 0xc5b18
jmp 0xc594d
jmp 0xc5b1a
jmp 0xc5b1c
movq -0x68(%rbp), %rax
movq -0xb0(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
addq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x110(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0xc0(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq 0x20(%rbp), %rcx
callq 0xcbee0
movq %rax, -0x118(%rbp)
movq -0xc0(%rbp), %rax
cmpq -0xa0(%rbp), %rax
ja 0xc5bd4
cmpq $0x0, -0x118(%rbp)
jbe 0xc5bd4
movq 0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq 0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rbp), %rax
movl (%rax), %ecx
movq 0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0xc0(%rbp), %rax
movl %eax, %ecx
movq 0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x60(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq -0xb8(%rbp), %rcx
movq -0x118(%rbp), %r8
leaq -0x130(%rbp), %rdi
callq 0xc1fe0
movq 0x30(%rbp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x30(%rbp)
movq -0x130(%rbp), %rcx
movq %rcx, (%rax)
movq -0x128(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x60(%rbp), %rcx
movq 0x40(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x60(%rbp)
movq $0x2, -0x138(%rbp)
movq -0x138(%rbp), %rax
cmpq -0xb0(%rbp), %rax
jae 0xc5c99
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x68(%rbp), %rax
addq -0x138(%rbp), %rax
addq %rax, %rsi
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
addq -0x138(%rbp), %rax
movl %eax, %edx
callq 0xcde40
movq -0x138(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x138(%rbp)
jmp 0xc5c49
movq -0xb0(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xc5df3
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x88(%rbp), %rax
jbe 0xc5df1
movq -0x68(%rbp), %rax
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0xc5d70
movq -0x68(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x148(%rbp)
movq -0x78(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x150(%rbp)
leaq -0x148(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0x140(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x140(%rbp), %rax
jae 0xc5d6e
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq -0x68(%rbp), %rsi
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movl %eax, %edx
callq 0xcde40
movq -0x60(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x68(%rbp)
jmp 0xc5d2c
jmp 0xc5def
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x160(%rbp)
movq -0x78(%rbp), %rax
subq $0x3, %rax
movq %rax, -0x168(%rbp)
leaq -0x160(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0x158(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x158(%rbp), %rax
jae 0xc5ded
movq 0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq -0x68(%rbp), %rsi
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movl %eax, %edx
callq 0xcde40
movq -0x60(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x68(%rbp)
jmp 0xc5dab
jmp 0xc5def
jmp 0xc5df1
jmp 0xc5df3
jmp 0xc584b
movq -0x78(%rbp), %rax
subq -0x68(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movq 0x30(%rbp), %rax
movq -0x58(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq 0x38(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /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,
const size_t max_backward,
size_t * __restrict best_len_out,
size_t * __restrict best_len_code_out,
size_t * __restrict best_distance_out,
double* __restrict best_score_out) {
const size_t best_len_in = *best_len_out;
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
const uint32_t key = HashBytes(&ring_buffer[cur_ix_masked]);
int compare_char = ring_buffer[cur_ix_masked + best_len_in];
double best_score = *best_score_out;
size_t best_len = best_len_in;
size_t cached_backward = static_cast<size_t>(distance_cache[0]);
size_t prev_ix = cur_ix - cached_backward;
bool match_found = false;
if (prev_ix < cur_ix) {
prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
if (compare_char == ring_buffer[prev_ix + best_len]) {
size_t len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
&ring_buffer[cur_ix_masked],
max_length);
if (len >= 4) {
best_score = BackwardReferenceScoreUsingLastDistance(len, 0);
best_len = len;
*best_len_out = len;
*best_len_code_out = len;
*best_distance_out = cached_backward;
*best_score_out = best_score;
compare_char = ring_buffer[cur_ix_masked + best_len];
if (kBucketSweep == 1) {
buckets_[key] = static_cast<uint32_t>(cur_ix);
return true;
} else {
match_found = true;
}
}
}
}
if (kBucketSweep == 1) {
// Only one to look for, don't bother to prepare for a loop.
prev_ix = buckets_[key];
buckets_[key] = static_cast<uint32_t>(cur_ix);
size_t backward = cur_ix - prev_ix;
prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
if (compare_char != ring_buffer[prev_ix + best_len_in]) {
return false;
}
if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
return false;
}
const size_t len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
&ring_buffer[cur_ix_masked],
max_length);
if (len >= 4) {
*best_len_out = len;
*best_len_code_out = len;
*best_distance_out = backward;
*best_score_out = BackwardReferenceScore(len, backward);
return true;
}
} else {
uint32_t *bucket = buckets_ + key;
prev_ix = *bucket++;
for (int i = 0; i < kBucketSweep; ++i, prev_ix = *bucket++) {
const size_t backward = cur_ix - prev_ix;
prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
if (compare_char != ring_buffer[prev_ix + best_len]) {
continue;
}
if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
&ring_buffer[cur_ix_masked],
max_length);
if (len >= 4) {
const double score = BackwardReferenceScore(len, backward);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = score;
compare_char = ring_buffer[cur_ix_masked + best_len];
match_found = true;
}
}
}
}
if (kUseDictionary && !match_found &&
num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
++num_dict_lookups_;
const uint32_t dict_key = Hash<14>(&ring_buffer[cur_ix_masked]) << 1;
const uint16_t v = kStaticDictionaryHash[dict_key];
if (v > 0) {
const uint32_t len = v & 31;
const uint32_t dist = v >> 5;
const size_t offset =
kBrotliDictionaryOffsetsByLength[len] + len * dist;
if (len <= max_length) {
const size_t matchlen =
FindMatchLengthWithLimit(&ring_buffer[cur_ix_masked],
&kBrotliDictionary[offset], len);
if (matchlen + kCutoffTransformsCount > len && matchlen > 0) {
const size_t transform_id = kCutoffTransforms[len - matchlen];
const size_t word_id =
transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
dist;
const size_t backward = max_backward + word_id + 1;
const double score = BackwardReferenceScore(matchlen, backward);
if (best_score < score) {
++num_dict_matches_;
best_score = score;
best_len = matchlen;
*best_len_out = best_len;
*best_len_code_out = len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
}
}
const uint32_t off = (cur_ix >> 3) % kBucketSweep;
buckets_[key + off] = static_cast<uint32_t>(cur_ix);
return match_found;
} | 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 %rax, -0xe0(%rbp)
movq 0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
andq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq -0x48(%rbp), %rdi
callq 0xcc020
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
addq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x50(%rbp)
movq 0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x71(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xcbb42
movq -0x20(%rbp), %rax
movl %eax, %eax
andq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x50(%rbp), %eax
movq -0x18(%rbp), %rcx
movq -0x70(%rbp), %rdx
addq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xcbb40
movq -0x18(%rbp), %rdi
addq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xc0710
movq %rax, -0x80(%rbp)
cmpq $0x4, -0x80(%rbp)
jb 0xcbb3e
movq -0x80(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xcc060
movq -0xe0(%rbp), %rax
movsd %xmm0, -0x58(%rbp)
movq -0x80(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq -0x80(%rbp), %rdx
movq 0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x80(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x68(%rbp), %rdx
movq 0x28(%rbp), %rcx
movq %rdx, (%rcx)
movsd -0x58(%rbp), %xmm0
movq 0x30(%rbp), %rcx
movsd %xmm0, (%rcx)
movq -0x18(%rbp), %rcx
movq -0x48(%rbp), %rdx
addq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movl %ecx, -0x50(%rbp)
movq -0x30(%rbp), %rcx
movl %ecx, %edx
movl -0x4c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movb $0x1, -0x1(%rbp)
jmp 0xcbec5
jmp 0xcbb40
jmp 0xcbb42
movq -0xe0(%rbp), %rax
movl -0x4c(%rbp), %ecx
movl (%rax,%rcx,4), %ecx
movq %rcx, -0x70(%rbp)
movq -0x30(%rbp), %rcx
movl %ecx, %edx
movl -0x4c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
subq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %eax
andq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x50(%rbp), %eax
movq -0x18(%rbp), %rcx
movq -0x70(%rbp), %rdx
addq -0x40(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xcbb9c
movb $0x0, -0x1(%rbp)
jmp 0xcbec5
movb $0x1, %al
cmpq $0x0, -0x88(%rbp)
movb %al, -0xe1(%rbp)
je 0xcbbc2
movq -0x88(%rbp), %rax
cmpq 0x10(%rbp), %rax
seta %al
movb %al, -0xe1(%rbp)
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0xcbbce
jmp 0xcbbd7
movb $0x0, -0x1(%rbp)
jmp 0xcbec5
movq -0x18(%rbp), %rdi
addq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xc0710
movq %rax, -0x90(%rbp)
cmpq $0x4, -0x90(%rbp)
jb 0xcbc4f
movq -0x90(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x90(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x88(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0xcc0d0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0xcbec5
testb $0x1, -0x71(%rbp)
jne 0xcbe90
movq -0xe0(%rbp), %rcx
movq 0x40010(%rcx), %rax
movq 0x40008(%rcx), %rcx
shrq $0x7, %rcx
cmpq %rcx, %rax
jb 0xcbe90
movq -0xe0(%rbp), %rax
movq 0x40008(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40008(%rax)
movq -0x18(%rbp), %rdi
addq -0x48(%rbp), %rdi
callq 0xcc160
shll %eax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, %ecx
leaq 0x79408(%rip), %rax # 0x1450c0
movw (%rax,%rcx,2), %ax
movw %ax, -0x96(%rbp)
movzwl -0x96(%rbp), %eax
cmpl $0x0, %eax
jle 0xcbe8e
movzwl -0x96(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x9c(%rbp)
movzwl -0x96(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0xa0(%rbp)
movl -0x9c(%rbp), %eax
movl %eax, %ecx
leaq 0x893be(%rip), %rax # 0x1550c0
movl (%rax,%rcx,4), %eax
movl -0x9c(%rbp), %ecx
imull -0xa0(%rbp), %ecx
addl %ecx, %eax
movl %eax, %eax
movq %rax, -0xa8(%rbp)
movl -0x9c(%rbp), %eax
cmpq -0x38(%rbp), %rax
ja 0xcbe8c
movq -0x18(%rbp), %rdi
addq -0x48(%rbp), %rdi
leaq 0x90574(%rip), %rsi # 0x15c2b0
addq -0xa8(%rbp), %rsi
movl -0x9c(%rbp), %eax
movl %eax, %edx
callq 0xc0710
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
addq $0xa, %rax
movl -0x9c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0xcbe8a
cmpq $0x0, -0xb0(%rbp)
jbe 0xcbe8a
movl -0x9c(%rbp), %eax
movl %eax, %ecx
subq -0xb0(%rbp), %rcx
leaq 0x8938f(%rip), %rax # 0x155124
movzbl (%rax,%rcx), %eax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movl -0x9c(%rbp), %ecx
movl %ecx, %edx
leaq 0x8937a(%rip), %rcx # 0x155130
movzbl (%rcx,%rdx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
imulq %rcx, %rax
movl -0xa0(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0xc0(%rbp)
movq 0x10(%rbp), %rax
addq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0xd0(%rbp)
movsd -0x58(%rbp), %xmm1
movsd -0xd0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcbe88
movq -0xe0(%rbp), %rax
movq 0x40010(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40010(%rax)
movsd -0xd0(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x9c(%rbp), %eax
movl %eax, %ecx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0xc8(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x58(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x71(%rbp)
jmp 0xcbe8a
jmp 0xcbe8c
jmp 0xcbe8e
jmp 0xcbe90
movq -0xe0(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x3, %rcx
andq $0x0, %rcx
movl %ecx, -0xd4(%rbp)
movq -0x30(%rbp), %rcx
movl %ecx, %edx
movl -0x4c(%rbp), %ecx
addl -0xd4(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movb -0x71(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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;
} else if (distance == static_cast<size_t>(dist_cache[1])) {
return 1;
} else if (distance == static_cast<size_t>(dist_cache[2])) {
return 2;
} else if (distance == static_cast<size_t>(dist_cache[3])) {
return 3;
} else if (quality > 3 && distance >= 6) {
for (size_t k = 4; k < kNumDistanceShortCodes; ++k) {
size_t idx = kDistanceCacheIndex[k];
size_t candidate =
static_cast<size_t>(dist_cache[idx] + kDistanceCacheOffset[k]);
static const size_t kLimits[16] = { 0, 0, 0, 0,
6, 6, 11, 11,
11, 11, 11, 11,
12, 12, 12, 12 };
if (distance == candidate && distance >= kLimits[k]) {
return k;
}
}
}
}
return distance + 15;
} | 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), %rax
movq -0x28(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpq %rcx, %rax
jne 0xcbf3c
movq $0x1, -0x8(%rbp)
jmp 0xcc01a
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
jne 0xcbf5a
movq $0x2, -0x8(%rbp)
jmp 0xcc01a
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq 0xc(%rcx), %rcx
cmpq %rcx, %rax
jne 0xcbf78
movq $0x3, -0x8(%rbp)
jmp 0xcc01a
cmpl $0x3, -0x1c(%rbp)
jle 0xcc004
cmpq $0x6, -0x10(%rbp)
jb 0xcc004
movq $0x4, -0x30(%rbp)
cmpq $0x10, -0x30(%rbp)
jae 0xcc002
movq -0x30(%rbp), %rcx
leaq 0x78c5d(%rip), %rax # 0x144c00
movl (%rax,%rcx,4), %eax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x30(%rbp), %rdx
leaq 0x78c80(%rip), %rcx # 0x144c40
addl (%rcx,%rdx,4), %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0xcbff2
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rdx
leaq 0x893ee(%rip), %rcx # 0x1553d0
cmpq (%rcx,%rdx,8), %rax
jb 0xcbff2
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc01a
jmp 0xcbff4
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xcbf91
jmp 0xcc004
jmp 0xcc006
jmp 0xcc008
jmp 0xcc00a
jmp 0xcc00c
jmp 0xcc00e
movq -0x10(%rbp), %rax
addq $0xf, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
| /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 multiplication,
// so we take our results from there.
return static_cast<uint32_t>(h >> (64 - kBucketBits));
} | 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,
const size_t max_backward,
size_t * __restrict best_len_out,
size_t * __restrict best_len_code_out,
size_t * __restrict best_distance_out,
double* __restrict best_score_out) {
const size_t best_len_in = *best_len_out;
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
const uint32_t key = HashBytes(&ring_buffer[cur_ix_masked]);
int compare_char = ring_buffer[cur_ix_masked + best_len_in];
double best_score = *best_score_out;
size_t best_len = best_len_in;
size_t cached_backward = static_cast<size_t>(distance_cache[0]);
size_t prev_ix = cur_ix - cached_backward;
bool match_found = false;
if (prev_ix < cur_ix) {
prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
if (compare_char == ring_buffer[prev_ix + best_len]) {
size_t len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
&ring_buffer[cur_ix_masked],
max_length);
if (len >= 4) {
best_score = BackwardReferenceScoreUsingLastDistance(len, 0);
best_len = len;
*best_len_out = len;
*best_len_code_out = len;
*best_distance_out = cached_backward;
*best_score_out = best_score;
compare_char = ring_buffer[cur_ix_masked + best_len];
if (kBucketSweep == 1) {
buckets_[key] = static_cast<uint32_t>(cur_ix);
return true;
} else {
match_found = true;
}
}
}
}
if (kBucketSweep == 1) {
// Only one to look for, don't bother to prepare for a loop.
prev_ix = buckets_[key];
buckets_[key] = static_cast<uint32_t>(cur_ix);
size_t backward = cur_ix - prev_ix;
prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
if (compare_char != ring_buffer[prev_ix + best_len_in]) {
return false;
}
if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
return false;
}
const size_t len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
&ring_buffer[cur_ix_masked],
max_length);
if (len >= 4) {
*best_len_out = len;
*best_len_code_out = len;
*best_distance_out = backward;
*best_score_out = BackwardReferenceScore(len, backward);
return true;
}
} else {
uint32_t *bucket = buckets_ + key;
prev_ix = *bucket++;
for (int i = 0; i < kBucketSweep; ++i, prev_ix = *bucket++) {
const size_t backward = cur_ix - prev_ix;
prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
if (compare_char != ring_buffer[prev_ix + best_len]) {
continue;
}
if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
&ring_buffer[cur_ix_masked],
max_length);
if (len >= 4) {
const double score = BackwardReferenceScore(len, backward);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = score;
compare_char = ring_buffer[cur_ix_masked + best_len];
match_found = true;
}
}
}
}
if (kUseDictionary && !match_found &&
num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
++num_dict_lookups_;
const uint32_t dict_key = Hash<14>(&ring_buffer[cur_ix_masked]) << 1;
const uint16_t v = kStaticDictionaryHash[dict_key];
if (v > 0) {
const uint32_t len = v & 31;
const uint32_t dist = v >> 5;
const size_t offset =
kBrotliDictionaryOffsetsByLength[len] + len * dist;
if (len <= max_length) {
const size_t matchlen =
FindMatchLengthWithLimit(&ring_buffer[cur_ix_masked],
&kBrotliDictionary[offset], len);
if (matchlen + kCutoffTransformsCount > len && matchlen > 0) {
const size_t transform_id = kCutoffTransforms[len - matchlen];
const size_t word_id =
transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
dist;
const size_t backward = max_backward + word_id + 1;
const double score = BackwardReferenceScore(matchlen, backward);
if (best_score < score) {
++num_dict_matches_;
best_score = score;
best_len = matchlen;
*best_len_out = best_len;
*best_len_code_out = len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
}
}
const uint32_t off = (cur_ix >> 3) % kBucketSweep;
buckets_[key + off] = static_cast<uint32_t>(cur_ix);
return match_found;
} | 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, -0xb0(%rbp)
movq 0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
andq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq -0x40(%rbp), %rdi
callq 0xcc5f0
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
addq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
movq 0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
subq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x69(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xcc40a
movq -0x18(%rbp), %rax
movl %eax, %eax
andq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x48(%rbp), %eax
movq -0x10(%rbp), %rcx
movq -0x68(%rbp), %rdx
addq -0x58(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xcc408
movq -0x10(%rbp), %rdi
addq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0x78(%rbp)
cmpq $0x4, -0x78(%rbp)
jb 0xcc406
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xcc060
movsd %xmm0, -0x50(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x78(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x50(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
addq -0x58(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
movb $0x1, -0x69(%rbp)
jmp 0xcc408
jmp 0xcc40a
movq -0xb0(%rbp), %rax
movl -0x44(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x80(%rbp)
movl (%rax), %eax
movq %rax, -0x68(%rbp)
movl $0x0, -0x84(%rbp)
cmpl $0x2, -0x84(%rbp)
jge 0xcc5a7
movq -0x28(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %eax
andq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x48(%rbp), %eax
movq -0x10(%rbp), %rcx
movq -0x68(%rbp), %rdx
addq -0x58(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xcc484
jmp 0xcc57e
movb $0x1, %al
cmpq $0x0, -0x90(%rbp)
movb %al, -0xb1(%rbp)
je 0xcc4aa
movq -0x90(%rbp), %rax
cmpq 0x10(%rbp), %rax
seta %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xcc4b6
jmp 0xcc4bb
jmp 0xcc57e
movq -0x10(%rbp), %rdi
addq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0x98(%rbp)
cmpq $0x4, -0x98(%rbp)
jb 0xcc57c
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0xa0(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0xa0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcc57a
movsd -0xa0(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x90(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0xa0(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
addq -0x58(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
movb $0x1, -0x69(%rbp)
jmp 0xcc57c
jmp 0xcc57e
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x80(%rbp)
movl (%rax), %eax
movq %rax, -0x68(%rbp)
jmp 0xcc43e
movq -0xb0(%rbp), %rax
movq -0x28(%rbp), %rcx
shrq $0x3, %rcx
andq $0x1, %rcx
movl %ecx, -0xa4(%rbp)
movq -0x28(%rbp), %rcx
movl %ecx, %edx
movl -0x44(%rbp), %ecx
addl -0xa4(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movb -0x69(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%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,
const size_t max_backward,
size_t * __restrict best_len_out,
size_t * __restrict best_len_code_out,
size_t * __restrict best_distance_out,
double* __restrict best_score_out) {
const size_t best_len_in = *best_len_out;
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
const uint32_t key = HashBytes(&ring_buffer[cur_ix_masked]);
int compare_char = ring_buffer[cur_ix_masked + best_len_in];
double best_score = *best_score_out;
size_t best_len = best_len_in;
size_t cached_backward = static_cast<size_t>(distance_cache[0]);
size_t prev_ix = cur_ix - cached_backward;
bool match_found = false;
if (prev_ix < cur_ix) {
prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
if (compare_char == ring_buffer[prev_ix + best_len]) {
size_t len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
&ring_buffer[cur_ix_masked],
max_length);
if (len >= 4) {
best_score = BackwardReferenceScoreUsingLastDistance(len, 0);
best_len = len;
*best_len_out = len;
*best_len_code_out = len;
*best_distance_out = cached_backward;
*best_score_out = best_score;
compare_char = ring_buffer[cur_ix_masked + best_len];
if (kBucketSweep == 1) {
buckets_[key] = static_cast<uint32_t>(cur_ix);
return true;
} else {
match_found = true;
}
}
}
}
if (kBucketSweep == 1) {
// Only one to look for, don't bother to prepare for a loop.
prev_ix = buckets_[key];
buckets_[key] = static_cast<uint32_t>(cur_ix);
size_t backward = cur_ix - prev_ix;
prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
if (compare_char != ring_buffer[prev_ix + best_len_in]) {
return false;
}
if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
return false;
}
const size_t len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
&ring_buffer[cur_ix_masked],
max_length);
if (len >= 4) {
*best_len_out = len;
*best_len_code_out = len;
*best_distance_out = backward;
*best_score_out = BackwardReferenceScore(len, backward);
return true;
}
} else {
uint32_t *bucket = buckets_ + key;
prev_ix = *bucket++;
for (int i = 0; i < kBucketSweep; ++i, prev_ix = *bucket++) {
const size_t backward = cur_ix - prev_ix;
prev_ix &= static_cast<uint32_t>(ring_buffer_mask);
if (compare_char != ring_buffer[prev_ix + best_len]) {
continue;
}
if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&ring_buffer[prev_ix],
&ring_buffer[cur_ix_masked],
max_length);
if (len >= 4) {
const double score = BackwardReferenceScore(len, backward);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = score;
compare_char = ring_buffer[cur_ix_masked + best_len];
match_found = true;
}
}
}
}
if (kUseDictionary && !match_found &&
num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
++num_dict_lookups_;
const uint32_t dict_key = Hash<14>(&ring_buffer[cur_ix_masked]) << 1;
const uint16_t v = kStaticDictionaryHash[dict_key];
if (v > 0) {
const uint32_t len = v & 31;
const uint32_t dist = v >> 5;
const size_t offset =
kBrotliDictionaryOffsetsByLength[len] + len * dist;
if (len <= max_length) {
const size_t matchlen =
FindMatchLengthWithLimit(&ring_buffer[cur_ix_masked],
&kBrotliDictionary[offset], len);
if (matchlen + kCutoffTransformsCount > len && matchlen > 0) {
const size_t transform_id = kCutoffTransforms[len - matchlen];
const size_t word_id =
transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
dist;
const size_t backward = max_backward + word_id + 1;
const double score = BackwardReferenceScore(matchlen, backward);
if (best_score < score) {
++num_dict_matches_;
best_score = score;
best_len = matchlen;
*best_len_out = best_len;
*best_len_code_out = len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
}
}
const uint32_t off = (cur_ix >> 3) % kBucketSweep;
buckets_[key + off] = static_cast<uint32_t>(cur_ix);
return match_found;
} | 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 -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq 0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
andq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq -0x40(%rbp), %rdi
callq 0xcccd0
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
addq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
movq 0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
subq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x69(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xcc8aa
movq -0x18(%rbp), %rax
movl %eax, %eax
andq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x48(%rbp), %eax
movq -0x10(%rbp), %rcx
movq -0x68(%rbp), %rdx
addq -0x58(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xcc8a8
movq -0x10(%rbp), %rdi
addq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0x78(%rbp)
cmpq $0x4, -0x78(%rbp)
jb 0xcc8a6
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xcc060
movsd %xmm0, -0x50(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x78(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x50(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
addq -0x58(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
movb $0x1, -0x69(%rbp)
jmp 0xcc8a8
jmp 0xcc8aa
movq -0xf0(%rbp), %rax
movl -0x44(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x80(%rbp)
movl (%rax), %eax
movq %rax, -0x68(%rbp)
movl $0x0, -0x84(%rbp)
cmpl $0x4, -0x84(%rbp)
jge 0xcca47
movq -0x28(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %eax
andq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x48(%rbp), %eax
movq -0x10(%rbp), %rcx
movq -0x68(%rbp), %rdx
addq -0x58(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xcc924
jmp 0xcca1e
movb $0x1, %al
cmpq $0x0, -0x90(%rbp)
movb %al, -0xf1(%rbp)
je 0xcc94a
movq -0x90(%rbp), %rax
cmpq 0x10(%rbp), %rax
seta %al
movb %al, -0xf1(%rbp)
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0xcc956
jmp 0xcc95b
jmp 0xcca1e
movq -0x10(%rbp), %rdi
addq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0x98(%rbp)
cmpq $0x4, -0x98(%rbp)
jb 0xcca1c
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0xa0(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0xa0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcca1a
movsd -0xa0(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x90(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0xa0(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
addq -0x58(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
movb $0x1, -0x69(%rbp)
jmp 0xcca1c
jmp 0xcca1e
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x80(%rbp)
movl (%rax), %eax
movq %rax, -0x68(%rbp)
jmp 0xcc8de
testb $0x1, -0x69(%rbp)
jne 0xccc88
movq -0xf0(%rbp), %rcx
movq 0x80020(%rcx), %rax
movq 0x80018(%rcx), %rcx
shrq $0x7, %rcx
cmpq %rcx, %rax
jb 0xccc88
movq -0xf0(%rbp), %rax
movq 0x80018(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x80018(%rax)
movq -0x10(%rbp), %rdi
addq -0x40(%rbp), %rdi
callq 0xcc160
shll %eax
movl %eax, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
movl %eax, %ecx
leaq 0x78610(%rip), %rax # 0x1450c0
movw (%rax,%rcx,2), %ax
movw %ax, -0xa6(%rbp)
movzwl -0xa6(%rbp), %eax
cmpl $0x0, %eax
jle 0xccc86
movzwl -0xa6(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0xac(%rbp)
movzwl -0xa6(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0xb0(%rbp)
movl -0xac(%rbp), %eax
movl %eax, %ecx
leaq 0x885c6(%rip), %rax # 0x1550c0
movl (%rax,%rcx,4), %eax
movl -0xac(%rbp), %ecx
imull -0xb0(%rbp), %ecx
addl %ecx, %eax
movl %eax, %eax
movq %rax, -0xb8(%rbp)
movl -0xac(%rbp), %eax
cmpq -0x30(%rbp), %rax
ja 0xccc84
movq -0x10(%rbp), %rdi
addq -0x40(%rbp), %rdi
leaq 0x8f77c(%rip), %rsi # 0x15c2b0
addq -0xb8(%rbp), %rsi
movl -0xac(%rbp), %eax
movl %eax, %edx
callq 0xc0710
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
addq $0xa, %rax
movl -0xac(%rbp), %ecx
cmpq %rcx, %rax
jbe 0xccc82
cmpq $0x0, -0xc0(%rbp)
jbe 0xccc82
movl -0xac(%rbp), %eax
movl %eax, %ecx
subq -0xc0(%rbp), %rcx
leaq 0x88597(%rip), %rax # 0x155124
movzbl (%rax,%rcx), %eax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movl -0xac(%rbp), %ecx
movl %ecx, %edx
leaq 0x88582(%rip), %rcx # 0x155130
movzbl (%rcx,%rdx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
imulq %rcx, %rax
movl -0xb0(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0xd0(%rbp)
movq 0x10(%rbp), %rax
addq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
movq -0xc0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0xe0(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0xe0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xccc80
movq -0xf0(%rbp), %rax
movq 0x80020(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x80020(%rax)
movsd -0xe0(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xac(%rbp), %eax
movl %eax, %ecx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0xd8(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x50(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x69(%rbp)
jmp 0xccc82
jmp 0xccc84
jmp 0xccc86
jmp 0xccc88
movq -0xf0(%rbp), %rax
movq -0x28(%rbp), %rcx
shrq $0x3, %rcx
andq $0x3, %rcx
movl %ecx, -0xe4(%rbp)
movq -0x28(%rbp), %rcx
movl %ecx, %edx
movl -0x44(%rbp), %ecx
addl -0xe4(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movb -0x69(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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,
size_t * __restrict best_len_out,
size_t * __restrict best_len_code_out,
size_t * __restrict best_distance_out,
double * __restrict best_score_out) {
*best_len_code_out = 0;
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
bool match_found = false;
// Don't accept a short copy from far away.
double best_score = *best_score_out;
size_t best_len = *best_len_out;
*best_len_out = 0;
// Try last distance first.
for (size_t i = 0; i < kNumLastDistancesToCheck; ++i) {
const size_t idx = kDistanceCacheIndex[i];
const size_t backward =
static_cast<size_t>(distance_cache[idx] + kDistanceCacheOffset[i]);
size_t prev_ix = static_cast<size_t>(cur_ix - backward);
if (prev_ix >= cur_ix) {
continue;
}
if (PREDICT_FALSE(backward > max_backward)) {
continue;
}
prev_ix &= ring_buffer_mask;
if (cur_ix_masked + best_len > ring_buffer_mask ||
prev_ix + best_len > ring_buffer_mask ||
data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
&data[cur_ix_masked],
max_length);
if (len >= 3 || (len == 2 && i < 2)) {
// Comparing for >= 2 does not change the semantics, but just saves for
// a few unnecessary binary logarithms in backward reference score,
// since we are not interested in such short matches.
double score = BackwardReferenceScoreUsingLastDistance(len, i);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
const uint32_t key = HashBytes(&data[cur_ix_masked]);
const uint32_t * __restrict const bucket = &buckets_[key][0];
const size_t down = (num_[key] > kBlockSize) ? (num_[key] - kBlockSize) : 0;
for (size_t i = num_[key]; i > down;) {
--i;
size_t prev_ix = bucket[i & kBlockMask];
const size_t backward = cur_ix - prev_ix;
if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
break;
}
prev_ix &= ring_buffer_mask;
if (cur_ix_masked + best_len > ring_buffer_mask ||
prev_ix + best_len > ring_buffer_mask ||
data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
&data[cur_ix_masked],
max_length);
if (len >= 4) {
// Comparing for >= 3 does not change the semantics, but just saves
// for a few unnecessary binary logarithms in backward reference
// score, since we are not interested in such short matches.
double score = BackwardReferenceScore(len, backward);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
buckets_[key][num_[key] & kBlockMask] = static_cast<uint32_t>(cur_ix);
++num_[key];
if (!match_found && num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
size_t dict_key = Hash<14>(&data[cur_ix_masked]) << 1;
for (int k = 0; k < 2; ++k, ++dict_key) {
++num_dict_lookups_;
const uint16_t v = kStaticDictionaryHash[dict_key];
if (v > 0) {
const size_t len = v & 31;
const size_t dist = v >> 5;
const size_t offset =
kBrotliDictionaryOffsetsByLength[len] + len * dist;
if (len <= max_length) {
const size_t matchlen =
FindMatchLengthWithLimit(&data[cur_ix_masked],
&kBrotliDictionary[offset], len);
if (matchlen + kCutoffTransformsCount > len && matchlen > 0) {
const size_t transform_id = kCutoffTransforms[len - matchlen];
const size_t word_id =
transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
dist;
const size_t backward = max_backward + word_id + 1;
double score = BackwardReferenceScore(matchlen, backward);
if (best_score < score) {
++num_dict_matches_;
best_score = score;
best_len = matchlen;
*best_len_out = best_len;
*best_len_code_out = len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
}
}
}
return match_found;
} | 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 -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq 0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
andq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq 0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq 0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq 0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x58(%rbp)
cmpq $0x4, -0x58(%rbp)
jae 0xcd01c
movq -0x58(%rbp), %rcx
leaq 0x77d32(%rip), %rax # 0x144c00
movl (%rax,%rcx,4), %eax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq -0x60(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x58(%rbp), %rdx
leaq 0x77d55(%rip), %rcx # 0x144c40
addl (%rcx,%rdx,4), %eax
cltq
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0xccf0f
jmp 0xcd00b
movq -0x68(%rbp), %rax
cmpq 0x10(%rbp), %rax
jbe 0xccf1e
jmp 0xcd00b
movq -0x18(%rbp), %rax
andq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xccf6a
movq -0x70(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xccf6a
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x70(%rbp), %rdx
addq -0x50(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xccf6f
jmp 0xcd00b
movq -0x10(%rbp), %rdi
addq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0x78(%rbp)
cmpq $0x3, -0x78(%rbp)
jae 0xccfa1
cmpq $0x2, -0x78(%rbp)
jne 0xcd009
cmpq $0x2, -0x58(%rbp)
jae 0xcd009
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xcc060
movsd %xmm0, -0x80(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x80(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcd007
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xcd009
jmp 0xcd00b
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xcceb8
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
callq 0xcd520
movl %eax, %ecx
movq -0x118(%rbp), %rax
movl %ecx, -0x84(%rbp)
movq %rax, %rcx
addq $0x8000, %rcx # imm = 0x8000
movl -0x84(%rbp), %edx
shlq $0x6, %rdx
addq %rdx, %rcx
movq %rcx, -0x90(%rbp)
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl $0x10, %eax
jbe 0xcd081
movq -0x118(%rbp), %rax
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
subl $0x10, %eax
movl %eax, -0x11c(%rbp)
jmp 0xcd08b
xorl %eax, %eax
movl %eax, -0x11c(%rbp)
jmp 0xcd08b
movq -0x118(%rbp), %rax
movl -0x11c(%rbp), %ecx
movl %ecx, %ecx
movq %rcx, -0x98(%rbp)
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
cmpq -0x98(%rbp), %rax
jbe 0xcd249
movq -0xa0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xa0(%rbp)
movq -0x90(%rbp), %rax
movq -0xa0(%rbp), %rcx
andq $0xf, %rcx
movl (%rax,%rcx,4), %eax
movq %rax, -0xa8(%rbp)
movq -0x28(%rbp), %rax
subq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movb $0x1, %al
cmpq $0x0, -0xb0(%rbp)
movb %al, -0x11d(%rbp)
je 0xcd12c
movq -0xb0(%rbp), %rax
cmpq 0x10(%rbp), %rax
seta %al
movb %al, -0x11d(%rbp)
movb -0x11d(%rbp), %al
testb $0x1, %al
jne 0xcd138
jmp 0xcd13d
jmp 0xcd249
movq -0x18(%rbp), %rax
andq -0xa8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcd195
movq -0xa8(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcd195
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0xa8(%rbp), %rdx
addq -0x50(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xcd19a
jmp 0xcd0b2
movq -0x10(%rbp), %rdi
addq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0xb8(%rbp)
cmpq $0x4, -0xb8(%rbp)
jb 0xcd244
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0xc0(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0xc0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcd242
movsd -0xc0(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0xb0(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xcd244
jmp 0xcd0b2
movq -0x118(%rbp), %rax
movq -0x28(%rbp), %rcx
movl %ecx, %esi
movq %rax, %rcx
addq $0x8000, %rcx # imm = 0x8000
movl -0x84(%rbp), %edx
shlq $0x6, %rdx
addq %rdx, %rcx
movl -0x84(%rbp), %edx
movzwl (%rax,%rdx,2), %edx
andl $0xf, %edx
movl %edx, %edx
movl %esi, (%rcx,%rdx,4)
movl -0x84(%rbp), %ecx
movw (%rax,%rcx,2), %dx
addw $0x1, %dx
movw %dx, (%rax,%rcx,2)
testb $0x1, -0x39(%rbp)
jne 0xcd512
movq -0x118(%rbp), %rcx
movq 0x108010(%rcx), %rax
movq 0x108008(%rcx), %rcx
shrq $0x7, %rcx
cmpq %rcx, %rax
jb 0xcd512
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
callq 0xcc160
shll %eax
movl %eax, %eax
movq %rax, -0xc8(%rbp)
movl $0x0, -0xcc(%rbp)
cmpl $0x2, -0xcc(%rbp)
jge 0xcd510
movq -0x118(%rbp), %rax
movq 0x108008(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x108008(%rax)
movq -0xc8(%rbp), %rcx
leaq 0x77dad(%rip), %rax # 0x1450c0
movw (%rax,%rcx,2), %ax
movw %ax, -0xce(%rbp)
movzwl -0xce(%rbp), %eax
cmpl $0x0, %eax
jle 0xcd4e8
movzwl -0xce(%rbp), %eax
andl $0x1f, %eax
cltq
movq %rax, -0xd8(%rbp)
movzwl -0xce(%rbp), %eax
sarl $0x5, %eax
cltq
movq %rax, -0xe0(%rbp)
movq -0xd8(%rbp), %rcx
leaq 0x87d5e(%rip), %rax # 0x1550c0
movl (%rax,%rcx,4), %eax
movq -0xd8(%rbp), %rcx
imulq -0xe0(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xe8(%rbp)
movq -0xd8(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0xcd4e6
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
leaq 0x8ef12(%rip), %rsi # 0x15c2b0
addq -0xe8(%rbp), %rsi
movq -0xd8(%rbp), %rdx
callq 0xc0710
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rax
addq $0xa, %rax
cmpq -0xd8(%rbp), %rax
jbe 0xcd4e4
cmpq $0x0, -0xf0(%rbp)
jbe 0xcd4e4
movq -0xd8(%rbp), %rcx
subq -0xf0(%rbp), %rcx
leaq 0x87d31(%rip), %rax # 0x155124
movzbl (%rax,%rcx), %eax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq -0xd8(%rbp), %rdx
leaq 0x87d1d(%rip), %rcx # 0x155130
movzbl (%rcx,%rdx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
imulq %rcx, %rax
addq -0xe0(%rbp), %rax
movq %rax, -0x100(%rbp)
movq 0x10(%rbp), %rax
addq -0x100(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x108(%rbp)
movq -0xf0(%rbp), %rdi
movq -0x108(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0x110(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x110(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcd4e2
movq -0x118(%rbp), %rax
movq 0x108010(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x108010(%rax)
movsd -0x110(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0xd8(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x108(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xcd4e4
jmp 0xcd4e6
jmp 0xcd4e8
jmp 0xcd4ea
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
jmp 0xcd2df
jmp 0xcd512
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
| /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,
size_t * __restrict best_len_out,
size_t * __restrict best_len_code_out,
size_t * __restrict best_distance_out,
double * __restrict best_score_out) {
*best_len_code_out = 0;
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
bool match_found = false;
// Don't accept a short copy from far away.
double best_score = *best_score_out;
size_t best_len = *best_len_out;
*best_len_out = 0;
// Try last distance first.
for (size_t i = 0; i < kNumLastDistancesToCheck; ++i) {
const size_t idx = kDistanceCacheIndex[i];
const size_t backward =
static_cast<size_t>(distance_cache[idx] + kDistanceCacheOffset[i]);
size_t prev_ix = static_cast<size_t>(cur_ix - backward);
if (prev_ix >= cur_ix) {
continue;
}
if (PREDICT_FALSE(backward > max_backward)) {
continue;
}
prev_ix &= ring_buffer_mask;
if (cur_ix_masked + best_len > ring_buffer_mask ||
prev_ix + best_len > ring_buffer_mask ||
data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
&data[cur_ix_masked],
max_length);
if (len >= 3 || (len == 2 && i < 2)) {
// Comparing for >= 2 does not change the semantics, but just saves for
// a few unnecessary binary logarithms in backward reference score,
// since we are not interested in such short matches.
double score = BackwardReferenceScoreUsingLastDistance(len, i);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
const uint32_t key = HashBytes(&data[cur_ix_masked]);
const uint32_t * __restrict const bucket = &buckets_[key][0];
const size_t down = (num_[key] > kBlockSize) ? (num_[key] - kBlockSize) : 0;
for (size_t i = num_[key]; i > down;) {
--i;
size_t prev_ix = bucket[i & kBlockMask];
const size_t backward = cur_ix - prev_ix;
if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
break;
}
prev_ix &= ring_buffer_mask;
if (cur_ix_masked + best_len > ring_buffer_mask ||
prev_ix + best_len > ring_buffer_mask ||
data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
&data[cur_ix_masked],
max_length);
if (len >= 4) {
// Comparing for >= 3 does not change the semantics, but just saves
// for a few unnecessary binary logarithms in backward reference
// score, since we are not interested in such short matches.
double score = BackwardReferenceScore(len, backward);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
buckets_[key][num_[key] & kBlockMask] = static_cast<uint32_t>(cur_ix);
++num_[key];
if (!match_found && num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
size_t dict_key = Hash<14>(&data[cur_ix_masked]) << 1;
for (int k = 0; k < 2; ++k, ++dict_key) {
++num_dict_lookups_;
const uint16_t v = kStaticDictionaryHash[dict_key];
if (v > 0) {
const size_t len = v & 31;
const size_t dist = v >> 5;
const size_t offset =
kBrotliDictionaryOffsetsByLength[len] + len * dist;
if (len <= max_length) {
const size_t matchlen =
FindMatchLengthWithLimit(&data[cur_ix_masked],
&kBrotliDictionary[offset], len);
if (matchlen + kCutoffTransformsCount > len && matchlen > 0) {
const size_t transform_id = kCutoffTransforms[len - matchlen];
const size_t word_id =
transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
dist;
const size_t backward = max_backward + word_id + 1;
double score = BackwardReferenceScore(matchlen, backward);
if (best_score < score) {
++num_dict_matches_;
best_score = score;
best_len = matchlen;
*best_len_out = best_len;
*best_len_code_out = len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
}
}
}
return match_found;
} | 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 -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq 0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
andq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq 0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq 0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq 0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x58(%rbp)
cmpq $0x4, -0x58(%rbp)
jae 0xcd85c
movq -0x58(%rbp), %rcx
leaq 0x774f2(%rip), %rax # 0x144c00
movl (%rax,%rcx,4), %eax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq -0x60(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x58(%rbp), %rdx
leaq 0x77515(%rip), %rcx # 0x144c40
addl (%rcx,%rdx,4), %eax
cltq
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0xcd74f
jmp 0xcd84b
movq -0x68(%rbp), %rax
cmpq 0x10(%rbp), %rax
jbe 0xcd75e
jmp 0xcd84b
movq -0x18(%rbp), %rax
andq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcd7aa
movq -0x70(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcd7aa
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x70(%rbp), %rdx
addq -0x50(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xcd7af
jmp 0xcd84b
movq -0x10(%rbp), %rdi
addq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0x78(%rbp)
cmpq $0x3, -0x78(%rbp)
jae 0xcd7e1
cmpq $0x2, -0x78(%rbp)
jne 0xcd849
cmpq $0x2, -0x58(%rbp)
jae 0xcd849
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xcc060
movsd %xmm0, -0x80(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x80(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcd847
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xcd849
jmp 0xcd84b
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xcd6f8
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
callq 0xcdd60
movl %eax, %ecx
movq -0x118(%rbp), %rax
movl %ecx, -0x84(%rbp)
movq %rax, %rcx
addq $0x8000, %rcx # imm = 0x8000
movl -0x84(%rbp), %edx
shlq $0x7, %rdx
addq %rdx, %rcx
movq %rcx, -0x90(%rbp)
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl $0x20, %eax
jbe 0xcd8c1
movq -0x118(%rbp), %rax
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
subl $0x20, %eax
movl %eax, -0x11c(%rbp)
jmp 0xcd8cb
xorl %eax, %eax
movl %eax, -0x11c(%rbp)
jmp 0xcd8cb
movq -0x118(%rbp), %rax
movl -0x11c(%rbp), %ecx
movl %ecx, %ecx
movq %rcx, -0x98(%rbp)
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
cmpq -0x98(%rbp), %rax
jbe 0xcda89
movq -0xa0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xa0(%rbp)
movq -0x90(%rbp), %rax
movq -0xa0(%rbp), %rcx
andq $0x1f, %rcx
movl (%rax,%rcx,4), %eax
movq %rax, -0xa8(%rbp)
movq -0x28(%rbp), %rax
subq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movb $0x1, %al
cmpq $0x0, -0xb0(%rbp)
movb %al, -0x11d(%rbp)
je 0xcd96c
movq -0xb0(%rbp), %rax
cmpq 0x10(%rbp), %rax
seta %al
movb %al, -0x11d(%rbp)
movb -0x11d(%rbp), %al
testb $0x1, %al
jne 0xcd978
jmp 0xcd97d
jmp 0xcda89
movq -0x18(%rbp), %rax
andq -0xa8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcd9d5
movq -0xa8(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcd9d5
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0xa8(%rbp), %rdx
addq -0x50(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xcd9da
jmp 0xcd8f2
movq -0x10(%rbp), %rdi
addq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0xb8(%rbp)
cmpq $0x4, -0xb8(%rbp)
jb 0xcda84
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0xc0(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0xc0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcda82
movsd -0xc0(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0xb0(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xcda84
jmp 0xcd8f2
movq -0x118(%rbp), %rax
movq -0x28(%rbp), %rcx
movl %ecx, %esi
movq %rax, %rcx
addq $0x8000, %rcx # imm = 0x8000
movl -0x84(%rbp), %edx
shlq $0x7, %rdx
addq %rdx, %rcx
movl -0x84(%rbp), %edx
movzwl (%rax,%rdx,2), %edx
andl $0x1f, %edx
movl %edx, %edx
movl %esi, (%rcx,%rdx,4)
movl -0x84(%rbp), %ecx
movw (%rax,%rcx,2), %dx
addw $0x1, %dx
movw %dx, (%rax,%rcx,2)
testb $0x1, -0x39(%rbp)
jne 0xcdd52
movq -0x118(%rbp), %rcx
movq 0x208010(%rcx), %rax
movq 0x208008(%rcx), %rcx
shrq $0x7, %rcx
cmpq %rcx, %rax
jb 0xcdd52
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
callq 0xcc160
shll %eax
movl %eax, %eax
movq %rax, -0xc8(%rbp)
movl $0x0, -0xcc(%rbp)
cmpl $0x2, -0xcc(%rbp)
jge 0xcdd50
movq -0x118(%rbp), %rax
movq 0x208008(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x208008(%rax)
movq -0xc8(%rbp), %rcx
leaq 0x7756d(%rip), %rax # 0x1450c0
movw (%rax,%rcx,2), %ax
movw %ax, -0xce(%rbp)
movzwl -0xce(%rbp), %eax
cmpl $0x0, %eax
jle 0xcdd28
movzwl -0xce(%rbp), %eax
andl $0x1f, %eax
cltq
movq %rax, -0xd8(%rbp)
movzwl -0xce(%rbp), %eax
sarl $0x5, %eax
cltq
movq %rax, -0xe0(%rbp)
movq -0xd8(%rbp), %rcx
leaq 0x8751e(%rip), %rax # 0x1550c0
movl (%rax,%rcx,4), %eax
movq -0xd8(%rbp), %rcx
imulq -0xe0(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xe8(%rbp)
movq -0xd8(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0xcdd26
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
leaq 0x8e6d2(%rip), %rsi # 0x15c2b0
addq -0xe8(%rbp), %rsi
movq -0xd8(%rbp), %rdx
callq 0xc0710
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rax
addq $0xa, %rax
cmpq -0xd8(%rbp), %rax
jbe 0xcdd24
cmpq $0x0, -0xf0(%rbp)
jbe 0xcdd24
movq -0xd8(%rbp), %rcx
subq -0xf0(%rbp), %rcx
leaq 0x874f1(%rip), %rax # 0x155124
movzbl (%rax,%rcx), %eax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq -0xd8(%rbp), %rdx
leaq 0x874dd(%rip), %rcx # 0x155130
movzbl (%rcx,%rdx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
imulq %rcx, %rax
addq -0xe0(%rbp), %rax
movq %rax, -0x100(%rbp)
movq 0x10(%rbp), %rax
addq -0x100(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x108(%rbp)
movq -0xf0(%rbp), %rdi
movq -0x108(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0x110(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x110(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcdd22
movq -0x118(%rbp), %rax
movq 0x208010(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x208010(%rax)
movsd -0x110(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0xd8(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x108(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xcdd24
jmp 0xcdd26
jmp 0xcdd28
jmp 0xcdd2a
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
jmp 0xcdb1f
jmp 0xcdd52
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
| /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,
size_t * __restrict best_len_out,
size_t * __restrict best_len_code_out,
size_t * __restrict best_distance_out,
double * __restrict best_score_out) {
*best_len_code_out = 0;
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
bool match_found = false;
// Don't accept a short copy from far away.
double best_score = *best_score_out;
size_t best_len = *best_len_out;
*best_len_out = 0;
// Try last distance first.
for (size_t i = 0; i < kNumLastDistancesToCheck; ++i) {
const size_t idx = kDistanceCacheIndex[i];
const size_t backward =
static_cast<size_t>(distance_cache[idx] + kDistanceCacheOffset[i]);
size_t prev_ix = static_cast<size_t>(cur_ix - backward);
if (prev_ix >= cur_ix) {
continue;
}
if (PREDICT_FALSE(backward > max_backward)) {
continue;
}
prev_ix &= ring_buffer_mask;
if (cur_ix_masked + best_len > ring_buffer_mask ||
prev_ix + best_len > ring_buffer_mask ||
data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
&data[cur_ix_masked],
max_length);
if (len >= 3 || (len == 2 && i < 2)) {
// Comparing for >= 2 does not change the semantics, but just saves for
// a few unnecessary binary logarithms in backward reference score,
// since we are not interested in such short matches.
double score = BackwardReferenceScoreUsingLastDistance(len, i);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
const uint32_t key = HashBytes(&data[cur_ix_masked]);
const uint32_t * __restrict const bucket = &buckets_[key][0];
const size_t down = (num_[key] > kBlockSize) ? (num_[key] - kBlockSize) : 0;
for (size_t i = num_[key]; i > down;) {
--i;
size_t prev_ix = bucket[i & kBlockMask];
const size_t backward = cur_ix - prev_ix;
if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
break;
}
prev_ix &= ring_buffer_mask;
if (cur_ix_masked + best_len > ring_buffer_mask ||
prev_ix + best_len > ring_buffer_mask ||
data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
&data[cur_ix_masked],
max_length);
if (len >= 4) {
// Comparing for >= 3 does not change the semantics, but just saves
// for a few unnecessary binary logarithms in backward reference
// score, since we are not interested in such short matches.
double score = BackwardReferenceScore(len, backward);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
buckets_[key][num_[key] & kBlockMask] = static_cast<uint32_t>(cur_ix);
++num_[key];
if (!match_found && num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
size_t dict_key = Hash<14>(&data[cur_ix_masked]) << 1;
for (int k = 0; k < 2; ++k, ++dict_key) {
++num_dict_lookups_;
const uint16_t v = kStaticDictionaryHash[dict_key];
if (v > 0) {
const size_t len = v & 31;
const size_t dist = v >> 5;
const size_t offset =
kBrotliDictionaryOffsetsByLength[len] + len * dist;
if (len <= max_length) {
const size_t matchlen =
FindMatchLengthWithLimit(&data[cur_ix_masked],
&kBrotliDictionary[offset], len);
if (matchlen + kCutoffTransformsCount > len && matchlen > 0) {
const size_t transform_id = kCutoffTransforms[len - matchlen];
const size_t word_id =
transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
dist;
const size_t backward = max_backward + word_id + 1;
double score = BackwardReferenceScore(matchlen, backward);
if (best_score < score) {
++num_dict_matches_;
best_score = score;
best_len = matchlen;
*best_len_out = best_len;
*best_len_code_out = len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
}
}
}
return match_found;
} | 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 -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq 0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
andq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq 0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq 0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq 0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x58(%rbp)
cmpq $0xa, -0x58(%rbp)
jae 0xce09c
movq -0x58(%rbp), %rcx
leaq 0x76cb2(%rip), %rax # 0x144c00
movl (%rax,%rcx,4), %eax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq -0x60(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x58(%rbp), %rdx
leaq 0x76cd5(%rip), %rcx # 0x144c40
addl (%rcx,%rdx,4), %eax
cltq
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0xcdf8f
jmp 0xce08b
movq -0x68(%rbp), %rax
cmpq 0x10(%rbp), %rax
jbe 0xcdf9e
jmp 0xce08b
movq -0x18(%rbp), %rax
andq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcdfea
movq -0x70(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcdfea
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x70(%rbp), %rdx
addq -0x50(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xcdfef
jmp 0xce08b
movq -0x10(%rbp), %rdi
addq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0x78(%rbp)
cmpq $0x3, -0x78(%rbp)
jae 0xce021
cmpq $0x2, -0x78(%rbp)
jne 0xce089
cmpq $0x2, -0x58(%rbp)
jae 0xce089
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xcc060
movsd %xmm0, -0x80(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x80(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xce087
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xce089
jmp 0xce08b
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xcdf38
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
callq 0xce5a0
movl %eax, %ecx
movq -0x118(%rbp), %rax
movl %ecx, -0x84(%rbp)
movq %rax, %rcx
addq $0x10000, %rcx # imm = 0x10000
movl -0x84(%rbp), %edx
shlq $0x8, %rdx
addq %rdx, %rcx
movq %rcx, -0x90(%rbp)
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl $0x40, %eax
jbe 0xce101
movq -0x118(%rbp), %rax
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
subl $0x40, %eax
movl %eax, -0x11c(%rbp)
jmp 0xce10b
xorl %eax, %eax
movl %eax, -0x11c(%rbp)
jmp 0xce10b
movq -0x118(%rbp), %rax
movl -0x11c(%rbp), %ecx
movl %ecx, %ecx
movq %rcx, -0x98(%rbp)
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
cmpq -0x98(%rbp), %rax
jbe 0xce2c9
movq -0xa0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xa0(%rbp)
movq -0x90(%rbp), %rax
movq -0xa0(%rbp), %rcx
andq $0x3f, %rcx
movl (%rax,%rcx,4), %eax
movq %rax, -0xa8(%rbp)
movq -0x28(%rbp), %rax
subq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movb $0x1, %al
cmpq $0x0, -0xb0(%rbp)
movb %al, -0x11d(%rbp)
je 0xce1ac
movq -0xb0(%rbp), %rax
cmpq 0x10(%rbp), %rax
seta %al
movb %al, -0x11d(%rbp)
movb -0x11d(%rbp), %al
testb $0x1, %al
jne 0xce1b8
jmp 0xce1bd
jmp 0xce2c9
movq -0x18(%rbp), %rax
andq -0xa8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xce215
movq -0xa8(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xce215
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0xa8(%rbp), %rdx
addq -0x50(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xce21a
jmp 0xce132
movq -0x10(%rbp), %rdi
addq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0xb8(%rbp)
cmpq $0x4, -0xb8(%rbp)
jb 0xce2c4
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0xc0(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0xc0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xce2c2
movsd -0xc0(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0xb0(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xce2c4
jmp 0xce132
movq -0x118(%rbp), %rax
movq -0x28(%rbp), %rcx
movl %ecx, %esi
movq %rax, %rcx
addq $0x10000, %rcx # imm = 0x10000
movl -0x84(%rbp), %edx
shlq $0x8, %rdx
addq %rdx, %rcx
movl -0x84(%rbp), %edx
movzwl (%rax,%rdx,2), %edx
andl $0x3f, %edx
movl %edx, %edx
movl %esi, (%rcx,%rdx,4)
movl -0x84(%rbp), %ecx
movw (%rax,%rcx,2), %dx
addw $0x1, %dx
movw %dx, (%rax,%rcx,2)
testb $0x1, -0x39(%rbp)
jne 0xce592
movq -0x118(%rbp), %rcx
movq 0x810010(%rcx), %rax
movq 0x810008(%rcx), %rcx
shrq $0x7, %rcx
cmpq %rcx, %rax
jb 0xce592
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
callq 0xcc160
shll %eax
movl %eax, %eax
movq %rax, -0xc8(%rbp)
movl $0x0, -0xcc(%rbp)
cmpl $0x2, -0xcc(%rbp)
jge 0xce590
movq -0x118(%rbp), %rax
movq 0x810008(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x810008(%rax)
movq -0xc8(%rbp), %rcx
leaq 0x76d2d(%rip), %rax # 0x1450c0
movw (%rax,%rcx,2), %ax
movw %ax, -0xce(%rbp)
movzwl -0xce(%rbp), %eax
cmpl $0x0, %eax
jle 0xce568
movzwl -0xce(%rbp), %eax
andl $0x1f, %eax
cltq
movq %rax, -0xd8(%rbp)
movzwl -0xce(%rbp), %eax
sarl $0x5, %eax
cltq
movq %rax, -0xe0(%rbp)
movq -0xd8(%rbp), %rcx
leaq 0x86cde(%rip), %rax # 0x1550c0
movl (%rax,%rcx,4), %eax
movq -0xd8(%rbp), %rcx
imulq -0xe0(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xe8(%rbp)
movq -0xd8(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0xce566
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
leaq 0x8de92(%rip), %rsi # 0x15c2b0
addq -0xe8(%rbp), %rsi
movq -0xd8(%rbp), %rdx
callq 0xc0710
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rax
addq $0xa, %rax
cmpq -0xd8(%rbp), %rax
jbe 0xce564
cmpq $0x0, -0xf0(%rbp)
jbe 0xce564
movq -0xd8(%rbp), %rcx
subq -0xf0(%rbp), %rcx
leaq 0x86cb1(%rip), %rax # 0x155124
movzbl (%rax,%rcx), %eax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq -0xd8(%rbp), %rdx
leaq 0x86c9d(%rip), %rcx # 0x155130
movzbl (%rcx,%rdx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
imulq %rcx, %rax
addq -0xe0(%rbp), %rax
movq %rax, -0x100(%rbp)
movq 0x10(%rbp), %rax
addq -0x100(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x108(%rbp)
movq -0xf0(%rbp), %rdi
movq -0x108(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0x110(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x110(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xce562
movq -0x118(%rbp), %rax
movq 0x810010(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x810010(%rax)
movsd -0x110(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0xd8(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x108(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xce564
jmp 0xce566
jmp 0xce568
jmp 0xce56a
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
jmp 0xce35f
jmp 0xce592
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
| /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,
size_t * __restrict best_len_out,
size_t * __restrict best_len_code_out,
size_t * __restrict best_distance_out,
double * __restrict best_score_out) {
*best_len_code_out = 0;
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
bool match_found = false;
// Don't accept a short copy from far away.
double best_score = *best_score_out;
size_t best_len = *best_len_out;
*best_len_out = 0;
// Try last distance first.
for (size_t i = 0; i < kNumLastDistancesToCheck; ++i) {
const size_t idx = kDistanceCacheIndex[i];
const size_t backward =
static_cast<size_t>(distance_cache[idx] + kDistanceCacheOffset[i]);
size_t prev_ix = static_cast<size_t>(cur_ix - backward);
if (prev_ix >= cur_ix) {
continue;
}
if (PREDICT_FALSE(backward > max_backward)) {
continue;
}
prev_ix &= ring_buffer_mask;
if (cur_ix_masked + best_len > ring_buffer_mask ||
prev_ix + best_len > ring_buffer_mask ||
data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
&data[cur_ix_masked],
max_length);
if (len >= 3 || (len == 2 && i < 2)) {
// Comparing for >= 2 does not change the semantics, but just saves for
// a few unnecessary binary logarithms in backward reference score,
// since we are not interested in such short matches.
double score = BackwardReferenceScoreUsingLastDistance(len, i);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
const uint32_t key = HashBytes(&data[cur_ix_masked]);
const uint32_t * __restrict const bucket = &buckets_[key][0];
const size_t down = (num_[key] > kBlockSize) ? (num_[key] - kBlockSize) : 0;
for (size_t i = num_[key]; i > down;) {
--i;
size_t prev_ix = bucket[i & kBlockMask];
const size_t backward = cur_ix - prev_ix;
if (PREDICT_FALSE(backward == 0 || backward > max_backward)) {
break;
}
prev_ix &= ring_buffer_mask;
if (cur_ix_masked + best_len > ring_buffer_mask ||
prev_ix + best_len > ring_buffer_mask ||
data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
continue;
}
const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
&data[cur_ix_masked],
max_length);
if (len >= 4) {
// Comparing for >= 3 does not change the semantics, but just saves
// for a few unnecessary binary logarithms in backward reference
// score, since we are not interested in such short matches.
double score = BackwardReferenceScore(len, backward);
if (best_score < score) {
best_score = score;
best_len = len;
*best_len_out = best_len;
*best_len_code_out = best_len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
buckets_[key][num_[key] & kBlockMask] = static_cast<uint32_t>(cur_ix);
++num_[key];
if (!match_found && num_dict_matches_ >= (num_dict_lookups_ >> 7)) {
size_t dict_key = Hash<14>(&data[cur_ix_masked]) << 1;
for (int k = 0; k < 2; ++k, ++dict_key) {
++num_dict_lookups_;
const uint16_t v = kStaticDictionaryHash[dict_key];
if (v > 0) {
const size_t len = v & 31;
const size_t dist = v >> 5;
const size_t offset =
kBrotliDictionaryOffsetsByLength[len] + len * dist;
if (len <= max_length) {
const size_t matchlen =
FindMatchLengthWithLimit(&data[cur_ix_masked],
&kBrotliDictionary[offset], len);
if (matchlen + kCutoffTransformsCount > len && matchlen > 0) {
const size_t transform_id = kCutoffTransforms[len - matchlen];
const size_t word_id =
transform_id * (1 << kBrotliDictionarySizeBitsByLength[len]) +
dist;
const size_t backward = max_backward + word_id + 1;
double score = BackwardReferenceScore(matchlen, backward);
if (best_score < score) {
++num_dict_matches_;
best_score = score;
best_len = matchlen;
*best_len_out = best_len;
*best_len_code_out = len;
*best_distance_out = backward;
*best_score_out = best_score;
match_found = true;
}
}
}
}
}
}
return match_found;
} | 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 -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq 0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
andq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq 0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq 0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq 0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x58(%rbp)
cmpq $0xa, -0x58(%rbp)
jae 0xce8dc
movq -0x58(%rbp), %rcx
leaq 0x76472(%rip), %rax # 0x144c00
movl (%rax,%rcx,4), %eax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq -0x60(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x58(%rbp), %rdx
leaq 0x76495(%rip), %rcx # 0x144c40
addl (%rcx,%rdx,4), %eax
cltq
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0xce7cf
jmp 0xce8cb
movq -0x68(%rbp), %rax
cmpq 0x10(%rbp), %rax
jbe 0xce7de
jmp 0xce8cb
movq -0x18(%rbp), %rax
andq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xce82a
movq -0x70(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xce82a
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x70(%rbp), %rdx
addq -0x50(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xce82f
jmp 0xce8cb
movq -0x10(%rbp), %rdi
addq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0x78(%rbp)
cmpq $0x3, -0x78(%rbp)
jae 0xce861
cmpq $0x2, -0x78(%rbp)
jne 0xce8c9
cmpq $0x2, -0x58(%rbp)
jae 0xce8c9
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xcc060
movsd %xmm0, -0x80(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x80(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xce8c7
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xce8c9
jmp 0xce8cb
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xce778
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
callq 0xcedf0
movl %eax, %ecx
movq -0x118(%rbp), %rax
movl %ecx, -0x84(%rbp)
movq %rax, %rcx
addq $0x10000, %rcx # imm = 0x10000
movl -0x84(%rbp), %edx
shlq $0x9, %rdx
addq %rdx, %rcx
movq %rcx, -0x90(%rbp)
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl $0x80, %eax
jbe 0xce945
movq -0x118(%rbp), %rax
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
subl $0x80, %eax
movl %eax, -0x11c(%rbp)
jmp 0xce94f
xorl %eax, %eax
movl %eax, -0x11c(%rbp)
jmp 0xce94f
movq -0x118(%rbp), %rax
movl -0x11c(%rbp), %ecx
movl %ecx, %ecx
movq %rcx, -0x98(%rbp)
movl -0x84(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
cmpq -0x98(%rbp), %rax
jbe 0xceb0d
movq -0xa0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xa0(%rbp)
movq -0x90(%rbp), %rax
movq -0xa0(%rbp), %rcx
andq $0x7f, %rcx
movl (%rax,%rcx,4), %eax
movq %rax, -0xa8(%rbp)
movq -0x28(%rbp), %rax
subq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movb $0x1, %al
cmpq $0x0, -0xb0(%rbp)
movb %al, -0x11d(%rbp)
je 0xce9f0
movq -0xb0(%rbp), %rax
cmpq 0x10(%rbp), %rax
seta %al
movb %al, -0x11d(%rbp)
movb -0x11d(%rbp), %al
testb $0x1, %al
jne 0xce9fc
jmp 0xcea01
jmp 0xceb0d
movq -0x18(%rbp), %rax
andq -0xa8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcea59
movq -0xa8(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xcea59
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0xa8(%rbp), %rdx
addq -0x50(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xcea5e
jmp 0xce976
movq -0x10(%rbp), %rdi
addq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc0710
movq %rax, -0xb8(%rbp)
cmpq $0x4, -0xb8(%rbp)
jb 0xceb08
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0xc0(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0xc0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xceb06
movsd -0xc0(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0xb0(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xceb08
jmp 0xce976
movq -0x118(%rbp), %rax
movq -0x28(%rbp), %rcx
movl %ecx, %esi
movq %rax, %rcx
addq $0x10000, %rcx # imm = 0x10000
movl -0x84(%rbp), %edx
shlq $0x9, %rdx
addq %rdx, %rcx
movl -0x84(%rbp), %edx
movzwl (%rax,%rdx,2), %edx
andl $0x7f, %edx
movl %edx, %edx
movl %esi, (%rcx,%rdx,4)
movl -0x84(%rbp), %ecx
movw (%rax,%rcx,2), %dx
addw $0x1, %dx
movw %dx, (%rax,%rcx,2)
testb $0x1, -0x39(%rbp)
jne 0xcedd6
movq -0x118(%rbp), %rcx
movq 0x1010010(%rcx), %rax
movq 0x1010008(%rcx), %rcx
shrq $0x7, %rcx
cmpq %rcx, %rax
jb 0xcedd6
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
callq 0xcc160
shll %eax
movl %eax, %eax
movq %rax, -0xc8(%rbp)
movl $0x0, -0xcc(%rbp)
cmpl $0x2, -0xcc(%rbp)
jge 0xcedd4
movq -0x118(%rbp), %rax
movq 0x1010008(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1010008(%rax)
movq -0xc8(%rbp), %rcx
leaq 0x764e9(%rip), %rax # 0x1450c0
movw (%rax,%rcx,2), %ax
movw %ax, -0xce(%rbp)
movzwl -0xce(%rbp), %eax
cmpl $0x0, %eax
jle 0xcedac
movzwl -0xce(%rbp), %eax
andl $0x1f, %eax
cltq
movq %rax, -0xd8(%rbp)
movzwl -0xce(%rbp), %eax
sarl $0x5, %eax
cltq
movq %rax, -0xe0(%rbp)
movq -0xd8(%rbp), %rcx
leaq 0x8649a(%rip), %rax # 0x1550c0
movl (%rax,%rcx,4), %eax
movq -0xd8(%rbp), %rcx
imulq -0xe0(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xe8(%rbp)
movq -0xd8(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0xcedaa
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
leaq 0x8d64e(%rip), %rsi # 0x15c2b0
addq -0xe8(%rbp), %rsi
movq -0xd8(%rbp), %rdx
callq 0xc0710
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rax
addq $0xa, %rax
cmpq -0xd8(%rbp), %rax
jbe 0xceda8
cmpq $0x0, -0xf0(%rbp)
jbe 0xceda8
movq -0xd8(%rbp), %rcx
subq -0xf0(%rbp), %rcx
leaq 0x8646d(%rip), %rax # 0x155124
movzbl (%rax,%rcx), %eax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq -0xd8(%rbp), %rdx
leaq 0x86459(%rip), %rcx # 0x155130
movzbl (%rcx,%rdx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
imulq %rcx, %rax
addq -0xe0(%rbp), %rax
movq %rax, -0x100(%rbp)
movq 0x10(%rbp), %rax
addq -0x100(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x108(%rbp)
movq -0xf0(%rbp), %rdi
movq -0x108(%rbp), %rsi
callq 0xcc0d0
movsd %xmm0, -0x110(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x110(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xceda6
movq -0x118(%rbp), %rax
movq 0x1010010(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1010010(%rax)
movsd -0x110(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0xd8(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x108(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movsd -0x48(%rbp), %xmm0
movq 0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
jmp 0xceda8
jmp 0xcedaa
jmp 0xcedac
jmp 0xcedae
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
jmp 0xceba3
jmp 0xcedd6
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| /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) {
// Count how many we have.
size_t total_length = 0;
for (size_t i = 0; i < num_commands; ++i) {
total_length += cmds[i].insert_len_;
}
if (total_length == 0) {
return;
}
// Allocate.
literals->resize(total_length);
// Loop again, and copy this time.
size_t pos = 0;
size_t from_pos = offset & mask;
for (size_t i = 0; i < num_commands && pos < total_length; ++i) {
size_t insert_len = cmds[i].insert_len_;
if (from_pos + insert_len > mask) {
size_t head_size = mask + 1 - from_pos;
memcpy(&(*literals)[pos], data + from_pos, head_size);
from_pos = 0;
pos += head_size;
insert_len -= head_size;
}
if (insert_len > 0) {
memcpy(&(*literals)[pos], data + from_pos, insert_len);
pos += insert_len;
}
from_pos = (from_pos + insert_len + cmds[i].copy_len_) & mask;
}
} | 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, -0x40(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xcf6a0
cmpq $0x0, -0x38(%rbp)
jne 0xcf6da
jmp 0xcf807
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xcfff0
movq $0x0, -0x48(%rbp)
movq -0x20(%rbp), %rax
andq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x69(%rbp)
jae 0xcf720
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
setb %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xcf72c
jmp 0xcf807
movq -0x8(%rbp), %rax
imulq $0x18, -0x58(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %eax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rax
addq -0x60(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0xcf7a0
movq -0x28(%rbp), %rax
addq $0x1, %rax
subq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xd0080
movq %rax, %rdi
movq -0x18(%rbp), %rsi
addq -0x50(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x3f180
movq $0x0, -0x50(%rbp)
movq -0x68(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jbe 0xcf7d4
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xd0080
movq %rax, %rdi
movq -0x18(%rbp), %rsi
addq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x3f180
movq -0x60(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
addq -0x60(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq $0x18, -0x58(%rbp), %rdx
addq %rdx, %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
andq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xcf703
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
| /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 = 0; i < length; ++i) {
block_ids[i] = new_id[block_ids[i]];
}
return next_id;
} | 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 0xd0160
movq %rax, -0x80(%rbp)
jmp 0xcf8f4
movq -0x80(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd0190
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xd0130
testb $0x1, %al
jne 0xcf91c
jmp 0xcf979
movb -0x48(%rbp), %al
movb %al, -0x89(%rbp)
movq -0x8(%rbp), %rsi
movq -0x50(%rbp), %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xd01c0
movq %rax, -0x88(%rbp)
jmp 0xcf942
movq -0x88(%rbp), %rax
movb -0x89(%rbp), %cl
movb %cl, (%rax)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xcf979
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd02a0
jmp 0xcfa01
jmp 0xcf97b
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0xcf8cc
movq $0x0, -0x78(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xcf9dd
movq -0x8(%rbp), %rsi
movq -0x78(%rbp), %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xd01c0
movq %rax, -0x98(%rbp)
jmp 0xcf9bb
movq -0x98(%rbp), %rax
movb (%rax), %dl
movq -0x8(%rbp), %rax
movq -0x78(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0xcf994
movq -0x48(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd02a0
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3fc20
nopw (%rax,%rax)
| /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);
split->lengths.push_back(cur_length);
max_type = std::max(max_type, next_id);
cur_id = next_id;
cur_length = 0;
}
++cur_length;
}
split->types.push_back(cur_id);
split->lengths.push_back(cur_length);
split->num_types = static_cast<size_t>(max_type) + 1;
} | 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, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd02e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xcfadd
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd02c0
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
movzbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0xcfac3
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x11(%rbp), %rsi
callq 0xd0300
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq -0x18(%rbp), %rsi
callq 0xc1f50
leaq -0x12(%rbp), %rdi
leaq -0x21(%rbp), %rsi
callq 0xd0370
movb (%rax), %al
movb %al, -0x12(%rbp)
movb -0x21(%rbp), %al
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xcfa47
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x11(%rbp), %rsi
callq 0xd0300
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq -0x18(%rbp), %rsi
callq 0xc1f50
movzbl -0x12(%rbp), %eax
movl %eax, %ecx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%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) {
// Create a continuous array of literals.
std::vector<uint8_t> literals;
CopyLiteralsToByteArray(cmds, num_commands, data, pos, mask, &literals);
// Compute prefix codes for commands.
std::vector<uint16_t> insert_and_copy_codes;
std::vector<uint16_t> distance_prefixes;
CopyCommandsToByteArray(cmds, num_commands,
&insert_and_copy_codes,
&distance_prefixes);
SplitByteVector<HistogramLiteral>(
literals,
kSymbolsPerLiteralHistogram, kMaxLiteralHistograms,
kLiteralStrideLength, kLiteralBlockSwitchCost,
literal_split);
SplitByteVector<HistogramCommand>(
insert_and_copy_codes,
kSymbolsPerCommandHistogram, kMaxCommandHistograms,
kCommandStrideLength, kCommandBlockSwitchCost,
insert_and_copy_split);
SplitByteVector<HistogramDistance>(
distance_prefixes,
kSymbolsPerDistanceHistogram, kMaxCommandHistograms,
kCommandStrideLength, kDistanceBlockSwitchCost,
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), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xcf670
jmp 0xcfb7d
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xd03d0
leaq -0x88(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xd03d0
movq -0xa0(%rbp), %rdx
movq -0x98(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcf810
jmp 0xcfbbd
movq -0x30(%rbp), %r8
leaq -0x48(%rbp), %rdi
movl $0x220, %esi # imm = 0x220
movl $0x64, %edx
movl $0x46, %ecx
movsd 0x85874(%rip), %xmm0 # 0x155450
callq 0xd03f0
jmp 0xcfbe3
movq 0x10(%rbp), %r8
leaq -0x70(%rbp), %rdi
movl $0x212, %esi # imm = 0x212
movl $0x32, %edx
movl $0x28, %ecx
movsd 0x85856(%rip), %xmm0 # 0x155458
callq 0xd0730
jmp 0xcfc09
movq 0x18(%rbp), %r8
leaq -0x88(%rbp), %rdi
movl $0x220, %esi # imm = 0x220
movl $0x32, %edx
movl $0x28, %ecx
movsd 0x85835(%rip), %xmm0 # 0x155460
callq 0xd0a70
jmp 0xcfc32
leaq -0x88(%rbp), %rdi
callq 0xd0db0
leaq -0x70(%rbp), %rdi
callq 0xd0db0
leaq -0x48(%rbp), %rdi
callq 0xd0e10
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xcfc88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xd0db0
leaq -0x70(%rbp), %rdi
callq 0xd0db0
leaq -0x48(%rbp), %rdi
callq 0xd0e10
movq -0x50(%rbp), %rdi
callq 0x3fc20
nopw (%rax,%rax)
| /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 = 1.4426950408889634f;
return log(static_cast<double>(v)) * kLog2Inv;
#else
return log2(static_cast<double>(v));
#endif
} | 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 -0x10(%rbp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x64327(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x3ffe0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /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 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x6427d(%rip), %xmm2 # 0x134040
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcfe04
movaps 0x64251(%rip), %xmm1 # 0x134030
movq -0x18(%rbp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x64250(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
| /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 < population_end) {
p = *population++;
sum += p;
retval -= static_cast<double>(p) * FastLog2(p);
odd_number_of_elements_left:
p = *population++;
sum += p;
retval -= static_cast<double>(p) * FastLog2(p);
}
if (sum) retval += static_cast<double>(sum) * FastLog2(sum);
*total = sum;
return retval;
} | 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
cmpq $0x0, %rax
je 0xcfe5a
jmp 0xcfef4
jmp 0xcfe5c
movq -0x8(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xcff83
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rbp)
movl (%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movaps 0x6419b(%rip), %xmm1 # 0x134030
movq -0x38(%rbp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x6419a(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xcfcd0
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rbp)
movl (%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movaps 0x64111(%rip), %xmm1 # 0x134030
movq -0x38(%rbp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x64110(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0xcfcd0
movaps %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0xcfe5c
cmpq $0x0, -0x20(%rbp)
je 0xcffd9
movaps 0x6409f(%rip), %xmm1 # 0x134030
movq -0x20(%rbp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x6409e(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0xcfcd0
movaps %xmm0, %xmm2
movsd -0x50(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movsd -0x28(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
| /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) {
if (data.empty()) {
split->num_types = 1;
return;
} else if (data.size() < kMinLengthForBlockSplitting) {
split->num_types = 1;
split->types.push_back(0);
split->lengths.push_back(static_cast<uint32_t>(data.size()));
return;
}
std::vector<HistogramType> histograms;
// Find good entropy codes.
InitialEntropyCodes(&data[0], data.size(),
literals_per_histogram,
max_histograms,
sampling_stride_length,
&histograms);
RefineEntropyCodes(&data[0], data.size(),
sampling_stride_length,
&histograms);
// Find a good path through literals with the good entropy codes.
std::vector<uint8_t> block_ids(data.size());
for (size_t i = 0; i < 10; ++i) {
FindBlocks(&data[0], data.size(),
block_switch_cost,
histograms,
&block_ids[0]);
BuildBlockHistograms(&data[0], data.size(), &block_ids[0], &histograms);
}
ClusterBlocks<HistogramType>(&data[0], data.size(), &block_ids[0]);
BuildBlockSplit(block_ids, split);
} | 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, (%rax)
jmp 0xd0a4a
movq -0x8(%rbp), %rdi
callq 0xd22a0
cmpq $0x80, %rax
jae 0xd07d4
movq -0x30(%rbp), %rax
movq $0x1, (%rax)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movb $0x0, -0x31(%rbp)
leaq -0x31(%rbp), %rsi
callq 0xd3930
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd22a0
movq -0x90(%rbp), %rdi
movl %eax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xc1f00
jmp 0xd0a4a
jmp 0xd07d6
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xdc3b0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdc4f0
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd22a0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %r9
movq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xdc3d0
jmp 0xd0827
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdc4f0
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd22a0
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0xdc510
jmp 0xd085d
movq -0x8(%rbp), %rdi
callq 0xd22a0
movq %rax, -0xb8(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xd3be0
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0xd3c00
jmp 0xd0896
leaq -0x79(%rbp), %rdi
callq 0xd3c70
movq $0x0, -0x88(%rbp)
cmpq $0xa, -0x88(%rbp)
jae 0xd09d6
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xd8(%rbp)
callq 0xdc4f0
movq %rax, -0xd0(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd22a0
movq -0xd8(%rbp), %rsi
movq %rax, -0xc8(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xd0080
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movsd -0xc0(%rbp), %xmm0
movq %rax, %rcx
leaq -0x50(%rbp), %rdx
callq 0xdc650
jmp 0xd0924
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xf0(%rbp)
callq 0xdc4f0
movq %rax, -0xe8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd22a0
movq -0xf0(%rbp), %rsi
movq %rax, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xd0080
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movq %rax, %rdx
leaq -0x50(%rbp), %rcx
callq 0xdcb90
jmp 0xd097b
jmp 0xd097d
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0xd08aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xd0a53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x79(%rbp), %rdi
callq 0xd3c70
jmp 0xd0a53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xd0e10
jmp 0xd0a53
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x108(%rbp)
callq 0xdc4f0
movq %rax, -0x100(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd22a0
movq -0x108(%rbp), %rsi
movq %rax, -0xf8(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xd0080
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movq %rax, %rdx
callq 0xdcc50
jmp 0xd0a29
movq -0x30(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xcfa10
jmp 0xd0a38
leaq -0x78(%rbp), %rdi
callq 0xd0e10
leaq -0x50(%rbp), %rdi
callq 0xdcf20
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0xdcf20
movq -0x58(%rbp), %rdi
callq 0x3fc20
nopw %cs:(%rax,%rax)
nop
| /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_histogram + 1;
if (total_histograms > max_histograms) {
total_histograms = max_histograms;
}
unsigned int seed = 7;
size_t block_length = length / total_histograms;
for (size_t i = 0; i < total_histograms; ++i) {
size_t pos = length * i / total_histograms;
if (i != 0) {
pos += MyRand(&seed) % block_length;
}
if (pos + stride >= length) {
pos = length - stride - 1;
}
HistogramType histo;
histo.Add(data + pos, stride);
vec->push_back(histo);
}
} | 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 -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xd39c9
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x7, -0x3c(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x38(%rbp)
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xd3a90
movq -0x10(%rbp), %rax
imulq -0x50(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x38(%rbp)
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xd3a2d
leaq -0x3c(%rbp), %rdi
callq 0xcfca0
movl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x48(%rbp)
addq -0x58(%rbp), %rdx
movq %rdx, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0xd3a4b
movq -0x10(%rbp), %rax
subq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x58(%rbp)
leaq -0x468(%rbp), %rdi
callq 0xd4a20
movq -0x8(%rbp), %rsi
addq -0x58(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x468(%rbp), %rdi
callq 0xd4a40
movq -0x30(%rbp), %rdi
leaq -0x468(%rbp), %rsi
callq 0xd4ab0
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0xd39e8
addq $0x470, %rsp # imm = 0x470
popq %rbp
retq
nopl (%rax)
| /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()) * vec->size();
for (size_t iter = 0; iter < iters; ++iter) {
HistogramType sample;
RandomSample(&seed, data, length, stride, &sample);
size_t ix = iter % vec->size();
(*vec)[ix].AddHistogram(sample);
}
} | 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(%rbp), %rax
movq %rax, -0x468(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd5020
movq %rax, %rcx
movq -0x468(%rbp), %rax
addq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x460(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd5020
movq %rax, %rcx
movq -0x460(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x458(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd5020
movq %rax, %rcx
movq -0x458(%rbp), %rax
imulq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xd3bd7
leaq -0x448(%rbp), %rdi
callq 0xd4a20
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x2c(%rbp), %rdi
leaq -0x448(%rbp), %r8
callq 0xd5410
movq -0x38(%rbp), %rax
movq %rax, -0x470(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd5020
movq %rax, %rcx
movq -0x470(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x450(%rbp)
movq -0x20(%rbp), %rdi
movq -0x450(%rbp), %rsi
callq 0xd5490
movq %rax, %rdi
leaq -0x448(%rbp), %rsi
callq 0xd54b0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xd3b47
addq $0x470, %rsp # imm = 0x470
popq %rbp
retq
| /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;
}
size_t vecsize = vec.size();
assert(vecsize <= 256);
double* insert_cost = new double[kSize * vecsize];
memset(insert_cost, 0, sizeof(insert_cost[0]) * kSize * vecsize);
for (size_t j = 0; j < vecsize; ++j) {
insert_cost[j] = FastLog2(static_cast<uint32_t>(vec[j].total_count_));
}
for (size_t i = kSize; i != 0;) {
--i;
for (size_t j = 0; j < vecsize; ++j) {
insert_cost[i * vecsize + j] = insert_cost[j] - BitCost(vec[j].data_[i]);
}
}
double *cost = new double[vecsize];
memset(cost, 0, sizeof(cost[0]) * vecsize);
bool* switch_signal = new bool[length * vecsize];
memset(switch_signal, 0, sizeof(switch_signal[0]) * length * vecsize);
// After each iteration of this loop, cost[k] will contain the difference
// between the minimum cost of arriving at the current byte position using
// entropy code k, and the minimum cost of arriving at the current byte
// position. This difference is capped at the block switch cost, and if it
// reaches block switch cost, it means that when we trace back from the last
// position, we need to switch here.
for (size_t byte_ix = 0; byte_ix < length; ++byte_ix) {
size_t ix = byte_ix * vecsize;
size_t insert_cost_ix = data[byte_ix] * vecsize;
double min_cost = 1e99;
for (size_t k = 0; k < vecsize; ++k) {
// We are coding the symbol in data[byte_ix] with entropy code k.
cost[k] += insert_cost[insert_cost_ix + k];
if (cost[k] < min_cost) {
min_cost = cost[k];
block_id[byte_ix] = static_cast<uint8_t>(k);
}
}
double block_switch_cost = block_switch_bitcost;
// More blocks for the beginning.
if (byte_ix < 2000) {
block_switch_cost *= 0.77 + 0.07 * static_cast<double>(byte_ix) / 2000;
}
for (size_t k = 0; k < vecsize; ++k) {
cost[k] -= min_cost;
if (cost[k] >= block_switch_cost) {
cost[k] = block_switch_cost;
switch_signal[ix + k] = true;
}
}
}
// Now trace back from the last position and switch at the marked places.
size_t byte_ix = length - 1;
size_t ix = byte_ix * vecsize;
uint8_t cur_id = block_id[byte_ix];
while (byte_ix > 0) {
--byte_ix;
ix -= vecsize;
if (switch_signal[ix + cur_id]) {
cur_id = block_id[byte_ix];
}
block_id[byte_ix] = cur_id;
}
delete[] insert_cost;
delete[] cost;
delete[] switch_signal;
} | 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), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xd3cc7
jmp 0xd41c0
movq -0x20(%rbp), %rdi
callq 0xd5020
movq %rax, -0x38(%rbp)
cmpq $0x100, -0x38(%rbp) # imm = 0x100
ja 0xd3d09
jmp 0xd3d28
leaq 0x81798(%rip), %rdi # 0x1554a8
leaq 0x817a0(%rip), %rsi # 0x1554b7
movl $0xac, %edx
leaq 0x817f9(%rip), %rcx # 0x15551c
callq 0x3f2e0
movq -0x38(%rbp), %rax
shlq $0x8, %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3f930
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
shlq $0xb, %rdx
xorl %esi, %esi
callq 0x3f5b0
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xd3db2
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xd56f0
movq 0x400(%rax), %rax
movl %eax, %eax
movl %eax, %edi
callq 0xcfcd0
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xd3d70
movq $0x100, -0x50(%rbp) # imm = 0x100
cmpq $0x0, -0x50(%rbp)
je 0xd3e4b
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xd3e46
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0xc0(%rbp)
movq -0x20(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xd56f0
movq -0x50(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %edi
callq 0xcfd40
movaps %xmm0, %xmm1
movsd -0xc0(%rbp), %xmm0
subsd %xmm1, %xmm0
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
imulq -0x38(%rbp), %rcx
addq -0x58(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xd3dd9
jmp 0xd3dba
movq -0x38(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3f930
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x3f5b0
movq -0x10(%rbp), %rdi
imulq -0x38(%rbp), %rdi
callq 0x3f930
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rdx
shlq $0x0, %rdx
imulq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x3f5b0
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xd40bd
movq -0x70(%rbp), %rax
imulq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq -0x70(%rbp), %rcx
movzbl (%rax,%rcx), %eax
imulq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movsd 0x81577(%rip), %xmm0 # 0x155468
movsd %xmm0, -0x88(%rbp)
movq $0x0, -0x90(%rbp)
movq -0x90(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xd3fa1
movq -0x40(%rbp), %rax
movq -0x80(%rbp), %rcx
addq -0x90(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x60(%rbp), %rax
movq -0x90(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x60(%rbp), %rax
movq -0x90(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x88(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd3f88
movq -0x60(%rbp), %rax
movq -0x90(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x90(%rbp), %rax
movb %al, %dl
movq -0x28(%rbp), %rax
movq -0x70(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xd3f8a
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0xd3f04
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
cmpq $0x7d0, -0x70(%rbp) # imm = 0x7D0
jae 0xd4013
movaps 0x60071(%rip), %xmm1 # 0x134030
movq -0x70(%rbp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x60070(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x81491(%rip), %xmm1 # 0x155478
mulsd %xmm0, %xmm1
movsd 0x8147d(%rip), %xmm0 # 0x155470
divsd %xmm0, %xmm1
movsd 0x607f1(%rip), %xmm0 # 0x1347f0
addsd %xmm1, %xmm0
mulsd -0x98(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movq $0x0, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xd40aa
movsd -0x88(%rbp), %xmm1
movq -0x60(%rbp), %rax
movq -0xa0(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x60(%rbp), %rax
movq -0xa0(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x98(%rbp), %xmm0
jb 0xd4091
movsd -0x98(%rbp), %xmm0
movq -0x60(%rbp), %rax
movq -0xa0(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x68(%rbp), %rax
movq -0x78(%rbp), %rcx
addq -0xa0(%rbp), %rcx
movb $0x1, (%rax,%rcx)
jmp 0xd4093
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0xd401e
jmp 0xd40ac
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xd3eb9
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
imulq -0x38(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x28(%rbp), %rax
movq -0xa8(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xb1(%rbp)
cmpq $0x0, -0xa8(%rbp)
jbe 0xd4169
movq -0xa8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rcx
movq -0xb0(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x68(%rbp), %rax
movq -0xb0(%rbp), %rcx
movzbl -0xb1(%rbp), %edx
addq %rdx, %rcx
testb $0x1, (%rax,%rcx)
je 0xd4153
movq -0x28(%rbp), %rax
movq -0xa8(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %dl
movq -0x28(%rbp), %rax
movq -0xa8(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xd40f3
movq -0x40(%rbp), %rax
movq %rax, -0xc8(%rbp)
cmpq $0x0, %rax
je 0xd4186
movq -0xc8(%rbp), %rdi
callq 0x3f6f0
movq -0x60(%rbp), %rax
movq %rax, -0xd0(%rbp)
cmpq $0x0, %rax
je 0xd41a3
movq -0xd0(%rbp), %rdi
callq 0x3f6f0
movq -0x68(%rbp), %rax
movq %rax, -0xd8(%rbp)
cmpq $0x0, %rax
je 0xd41c0
movq -0xd8(%rbp), %rdi
callq 0x3f6f0
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
| /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);
for (size_t i = 0; i < length; ++i) {
(*histograms)[block_ids[i]].Add(data[i]);
}
} | 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 # 0x1555bc
leaq 0x812a4(%rip), %rsi # 0x1554b7
movl $0x100, %edx # imm = 0x100
leaq 0x813ae(%rip), %rcx # 0x1555cd
callq 0x3f2e0
movq -0x20(%rbp), %rdi
callq 0xd5710
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xd5730
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xd4287
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
callq 0xd5490
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
callq 0xd57c0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xd4242
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| /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 == length || block_ids[i] != block_ids[i + 1]);
block_index[i] = cur_idx;
cur_histogram.Add(data[i]);
if (block_boundary) {
histograms.push_back(cur_histogram);
cur_histogram.Clear();
++cur_idx;
}
}
std::vector<HistogramType> clustered_histograms;
std::vector<uint32_t> histogram_symbols;
// Block ids need to fit in one byte.
static const size_t kMaxNumberOfBlockTypes = 256;
ClusterHistograms(histograms, 1, histograms.size(),
kMaxNumberOfBlockTypes,
&clustered_histograms,
&histogram_symbols);
for (size_t i = 0; i < length; ++i) {
block_ids[i] = static_cast<uint8_t>(histogram_symbols[block_index[i]]);
}
} | 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(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0xc22d0
jmp 0xd42e4
leaq -0x49(%rbp), %rdi
callq 0xc2340
movl $0x0, -0x60(%rbp)
leaq -0x470(%rbp), %rdi
callq 0xd4a20
jmp 0xd4302
movq $0x0, -0x478(%rbp)
movq -0x478(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xd4423
movq -0x478(%rbp), %rcx
addq $0x1, %rcx
movb $0x1, %al
cmpq -0x10(%rbp), %rcx
movb %al, -0x4c9(%rbp)
je 0xd4361
movq -0x18(%rbp), %rax
movq -0x478(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x478(%rbp), %rdx
movzbl 0x1(%rcx,%rdx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x4c9(%rbp)
movb -0x4c9(%rbp), %al
andb $0x1, %al
movb %al, -0x479(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x4d0(%rbp)
movq -0x478(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xc1fc0
movl -0x4d0(%rbp), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq -0x478(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
leaq -0x470(%rbp), %rdi
callq 0xd57c0
testb $0x1, -0x479(%rbp)
je 0xd440a
leaq -0x30(%rbp), %rdi
leaq -0x470(%rbp), %rsi
callq 0xd4ab0
jmp 0xd43c8
leaq -0x470(%rbp), %rdi
callq 0xd4b20
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0xd440a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0xc2340
jmp 0xd4542
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xd4539
jmp 0xd440c
movq -0x478(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x478(%rbp)
jmp 0xd430d
leaq -0x498(%rbp), %rdi
movq %rdi, -0x4e0(%rbp)
callq 0xd3960
leaq -0x4b0(%rbp), %rdi
movq %rdi, -0x4d8(%rbp)
callq 0xc1ee0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x4e8(%rbp)
callq 0xd5020
movq -0x4e8(%rbp), %rdi
movq -0x4e0(%rbp), %r8
movq -0x4d8(%rbp), %r9
movq %rax, %rdx
movl $0x1, %esi
movl $0x100, %ecx # imm = 0x100
callq 0xd5c60
jmp 0xd4482
movq $0x0, -0x4b8(%rbp)
movq -0x4b8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xd4506
movq -0x4b8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xc1fc0
movl (%rax), %eax
movl %eax, %esi
leaq -0x4b0(%rbp), %rdi
callq 0xc1fc0
movl (%rax), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x4b8(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x4b8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x4b8(%rbp)
jmp 0xd448d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x4b0(%rbp), %rdi
callq 0xc2070
leaq -0x498(%rbp), %rdi
callq 0xd4560
jmp 0xd4539
leaq -0x4b0(%rbp), %rdi
callq 0xc2070
leaq -0x498(%rbp), %rdi
callq 0xd4560
leaq -0x48(%rbp), %rdi
callq 0xc2070
leaq -0x30(%rbp), %rdi
callq 0xd4560
addq $0x4f0, %rsp # imm = 0x4F0
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0xc2070
leaq -0x30(%rbp), %rdi
callq 0xd4560
movq -0x58(%rbp), %rdi
callq 0x3fc20
nopw %cs:(%rax,%rax)
nop
| /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 + histogram.total_count_);
}
double bits = 0;
uint8_t depth_array[kSize] = { 0 };
if (count <= 4) {
// For very low symbol count we build the Huffman tree.
CreateHuffmanTree(&histogram.data_[0], kSize, 15, depth_array);
for (int i = 0; i < kSize; ++i) {
bits += histogram.data_[i] * depth_array[i];
}
return count == 3 ? bits + 28 : bits + 37;
}
// In this loop we compute the entropy of the histogram and simultaneously
// build a simplified histogram of the code length codes where we use the
// zero repeat code 17, but we don't use the non-zero repeat code 16.
size_t max_depth = 1;
uint32_t depth_histo[kCodeLengthCodes] = { 0 };
const double log2total = FastLog2(histogram.total_count_);
for (size_t i = 0; i < kSize;) {
if (histogram.data_[i] > 0) {
// Compute -log2(P(symbol)) = -log2(count(symbol)/total_count) =
// = log2(total_count) - log2(count(symbol))
double log2p = log2total - FastLog2(histogram.data_[i]);
// Approximate the bit depth by round(-log2(P(symbol)))
size_t depth = static_cast<size_t>(log2p + 0.5);
bits += histogram.data_[i] * log2p;
if (depth > 15) {
depth = 15;
}
if (depth > max_depth) {
max_depth = depth;
}
++depth_histo[depth];
++i;
} else {
// Compute the run length of zeros and add the appropriate number of 0 and
// 17 code length codes to the code length code histogram.
uint32_t reps = 1;
for (size_t k = i + 1; k < kSize && histogram.data_[k] == 0; ++k) {
++reps;
}
i += reps;
if (i == kSize) {
// Don't add any cost for the last zero run, since these are encoded
// only implicitly.
break;
}
if (reps < 3) {
depth_histo[0] += reps;
} else {
reps -= 2;
while (reps > 0) {
++depth_histo[17];
// Add the 3 extra bits for the 17 code length code.
bits += 3;
reps >>= 3;
}
}
}
}
// Add the estimated encoding cost of the code length code histogram.
bits += static_cast<double>(18 + 2 * max_depth);
// Add the entropy of the code length code histogram.
bits += BitsEntropy(depth_histo, kCodeLengthCodes);
return bits;
} | 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 0xd60da
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jbe 0xd60cd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd60cf
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd60ad
cmpl $0x1, -0x14(%rbp)
jne 0xd60f2
movsd 0x7f3b8(%rip), %xmm0 # 0x1554a0
movsd %xmm0, -0x8(%rbp)
jmp 0xd64ea
cmpl $0x2, -0x14(%rbp)
jne 0xd6138
movq -0x10(%rbp), %rax
movq 0x400(%rax), %rax
addq $0x14, %rax
movq %rax, %xmm0
movaps 0x5df1d(%rip), %xmm1 # 0x134030
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x5df21(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xd64ea
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx # imm = 0x100
callq 0x3f5b0
cmpl $0x4, -0x14(%rbp)
jg 0xd620a
movq -0x10(%rbp), %rdi
leaq -0x120(%rbp), %rcx
movl $0x100, %esi # imm = 0x100
movl $0xf, %edx
callq 0xf39d0
movl $0x0, -0x124(%rbp)
cmpl $0x100, -0x124(%rbp) # imm = 0x100
jge 0xd61c6
movq -0x10(%rbp), %rax
movslq -0x124(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movzbl -0x120(%rbp,%rcx), %ecx
imull %ecx, %eax
cvtsi2sd %rax, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0xd6181
cmpl $0x3, -0x14(%rbp)
jne 0xd61e3
movsd 0x7f2c4(%rip), %xmm0 # 0x155498
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x1b8(%rbp)
jmp 0xd61f8
movsd 0x7f2a5(%rip), %xmm0 # 0x155490
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x1b8(%rbp)
movsd -0x1b8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xd64ea
movq $0x1, -0x130(%rbp)
leaq -0x180(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x3f5b0
movq -0x10(%rbp), %rax
movq 0x400(%rax), %rdi
callq 0xcfcd0
movsd %xmm0, -0x188(%rbp)
movq $0x0, -0x190(%rbp)
cmpq $0x100, -0x190(%rbp) # imm = 0x100
jae 0xd6488
movq -0x10(%rbp), %rax
movq -0x190(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jbe 0xd637d
movsd -0x188(%rbp), %xmm0
movsd %xmm0, -0x1c0(%rbp)
movq -0x10(%rbp), %rax
movq -0x190(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %edi
callq 0xcfcd0
movaps %xmm0, %xmm1
movsd -0x1c0(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x198(%rbp)
movsd -0x198(%rbp), %xmm0
movsd 0x5dd63(%rip), %xmm1 # 0x134020
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x5dd38(%rip), %xmm1 # 0x134010
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x1a0(%rbp)
movq -0x10(%rbp), %rax
movq -0x190(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cvtsi2sd %rax, %xmm0
movsd -0x198(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpq $0xf, -0x1a0(%rbp)
jbe 0xd6330
movq $0xf, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rax
cmpq -0x130(%rbp), %rax
jbe 0xd634e
movq -0x1a0(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x1a0(%rbp), %rax
movl -0x180(%rbp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, -0x180(%rbp,%rax,4)
movq -0x190(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x190(%rbp)
jmp 0xd6483
movl $0x1, -0x1a4(%rbp)
movq -0x190(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1b0(%rbp)
xorl %eax, %eax
cmpq $0x100, -0x1b0(%rbp) # imm = 0x100
movb %al, -0x1c1(%rbp)
jae 0xd63c6
movq -0x10(%rbp), %rax
movq -0x1b0(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
sete %al
movb %al, -0x1c1(%rbp)
movb -0x1c1(%rbp), %al
testb $0x1, %al
jne 0xd63d2
jmp 0xd63f5
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
movq -0x1b0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1b0(%rbp)
jmp 0xd6399
movl -0x1a4(%rbp), %eax
addq -0x190(%rbp), %rax
movq %rax, -0x190(%rbp)
cmpq $0x100, -0x190(%rbp) # imm = 0x100
jne 0xd6418
jmp 0xd6488
cmpl $0x3, -0x1a4(%rbp)
jae 0xd6435
movl -0x1a4(%rbp), %eax
addl -0x180(%rbp), %eax
movl %eax, -0x180(%rbp)
jmp 0xd6481
movl -0x1a4(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x1a4(%rbp)
cmpl $0x0, -0x1a4(%rbp)
jbe 0xd647f
movl -0x13c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x13c(%rbp)
movsd 0x7f024(%rip), %xmm0 # 0x155488
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x1a4(%rbp), %eax
shrl $0x3, %eax
movl %eax, -0x1a4(%rbp)
jmp 0xd6444
jmp 0xd6481
jmp 0xd6483
jmp 0xd624b
movq -0x130(%rbp), %rax
leaq 0x12(%rax,%rax), %rax
movq %rax, %xmm0
movaps 0x5db90(%rip), %xmm1 # 0x134030
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x5db94(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x180(%rbp), %rdi
movl $0x12, %esi
callq 0xcfd80
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbp
retq
nopl (%rax,%rax)
| /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[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x5abc1(%rip), %xmm1 # 0x134040
movaps %xmm1, -0x40(%rbp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0xcfcd0
movaps -0x50(%rbp), %xmm2
movaps -0x40(%rbp), %xmm1
movsd %xmm0, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, %xmm0
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
callq 0xcfcd0
movsd -0x60(%rbp), %xmm3
movsd -0x58(%rbp), %xmm4
movaps -0x50(%rbp), %xmm2
movaps -0x40(%rbp), %xmm1
movaps %xmm0, %xmm5
movsd -0x30(%rbp), %xmm0
mulsd %xmm5, %xmm3
mulsd %xmm4, %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %xmm0
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xcfcd0
movsd -0x28(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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_histogram + 1;
if (total_histograms > max_histograms) {
total_histograms = max_histograms;
}
unsigned int seed = 7;
size_t block_length = length / total_histograms;
for (size_t i = 0; i < total_histograms; ++i) {
size_t pos = length * i / total_histograms;
if (i != 0) {
pos += MyRand(&seed) % block_length;
}
if (pos + stride >= length) {
pos = length - stride - 1;
}
HistogramType histo;
histo.Add(data + pos, stride);
vec->push_back(histo);
}
} | 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 -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xdc419
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x7, -0x3c(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x38(%rbp)
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xdc4e6
movq -0x10(%rbp), %rax
imulq -0x50(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x38(%rbp)
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xdc47d
leaq -0x3c(%rbp), %rdi
callq 0xcfca0
movl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x48(%rbp)
addq -0x58(%rbp), %rdx
movq %rdx, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0xdc49b
movq -0x10(%rbp), %rax
subq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x58(%rbp)
leaq -0xb68(%rbp), %rdi
callq 0xdd100
movq -0x8(%rbp), %rsi
movq -0x58(%rbp), %rax
shlq %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
leaq -0xb68(%rbp), %rdi
callq 0xdd120
movq -0x30(%rbp), %rdi
leaq -0xb68(%rbp), %rsi
callq 0xdd190
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0xdc438
addq $0xb70, %rsp # imm = 0xB70
popq %rbp
retq
nop
| /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);
for (size_t i = 0; i < length; ++i) {
(*histograms)[block_ids[i]].Add(data[i]);
}
} | 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 # 0x1555bc
leaq 0x788e4(%rip), %rsi # 0x1554b7
movl $0x100, %edx # imm = 0x100
leaq 0x78c6c(%rip), %rcx # 0x15584b
callq 0x3f2e0
movq -0x20(%rbp), %rdi
callq 0xddc20
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xddc40
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xdcc47
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
callq 0xddb70
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, %esi
callq 0xddcd0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xdcc02
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| /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 == length || block_ids[i] != block_ids[i + 1]);
block_index[i] = cur_idx;
cur_histogram.Add(data[i]);
if (block_boundary) {
histograms.push_back(cur_histogram);
cur_histogram.Clear();
++cur_idx;
}
}
std::vector<HistogramType> clustered_histograms;
std::vector<uint32_t> histogram_symbols;
// Block ids need to fit in one byte.
static const size_t kMaxNumberOfBlockTypes = 256;
ClusterHistograms(histograms, 1, histograms.size(),
kMaxNumberOfBlockTypes,
&clustered_histograms,
&histogram_symbols);
for (size_t i = 0; i < length; ++i) {
block_ids[i] = static_cast<uint8_t>(histogram_symbols[block_index[i]]);
}
} | 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(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0xc22d0
jmp 0xdcca4
leaq -0x49(%rbp), %rdi
callq 0xc2340
movl $0x0, -0x60(%rbp)
leaq -0xb70(%rbp), %rdi
callq 0xdd100
jmp 0xdccc2
movq $0x0, -0xb78(%rbp)
movq -0xb78(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xdcde3
movq -0xb78(%rbp), %rcx
addq $0x1, %rcx
movb $0x1, %al
cmpq -0x10(%rbp), %rcx
movb %al, -0xbc9(%rbp)
je 0xdcd21
movq -0x18(%rbp), %rax
movq -0xb78(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0xb78(%rbp), %rdx
movzbl 0x1(%rcx,%rdx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0xbc9(%rbp)
movb -0xbc9(%rbp), %al
andb $0x1, %al
movb %al, -0xb79(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0xbd0(%rbp)
movq -0xb78(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xc1fc0
movl -0xbd0(%rbp), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq -0xb78(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, %esi
leaq -0xb70(%rbp), %rdi
callq 0xddcd0
testb $0x1, -0xb79(%rbp)
je 0xdcdca
leaq -0x30(%rbp), %rdi
leaq -0xb70(%rbp), %rsi
callq 0xdd190
jmp 0xdcd88
leaq -0xb70(%rbp), %rdi
callq 0xdd200
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0xdcdca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0xc2340
jmp 0xdcf02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xdcef9
jmp 0xdcdcc
movq -0xb78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb78(%rbp)
jmp 0xdcccd
leaq -0xb98(%rbp), %rdi
movq %rdi, -0xbe0(%rbp)
callq 0xdc3b0
leaq -0xbb0(%rbp), %rdi
movq %rdi, -0xbd8(%rbp)
callq 0xc1ee0
leaq -0x30(%rbp), %rdi
movq %rdi, -0xbe8(%rbp)
callq 0xdd6f0
movq -0xbe8(%rbp), %rdi
movq -0xbe0(%rbp), %r8
movq -0xbd8(%rbp), %r9
movq %rax, %rdx
movl $0x1, %esi
movl $0x100, %ecx # imm = 0x100
callq 0xde170
jmp 0xdce42
movq $0x0, -0xbb8(%rbp)
movq -0xbb8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xdcec6
movq -0xbb8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xc1fc0
movl (%rax), %eax
movl %eax, %esi
leaq -0xbb0(%rbp), %rdi
callq 0xc1fc0
movl (%rax), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0xbb8(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0xbb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xbb8(%rbp)
jmp 0xdce4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xbb0(%rbp), %rdi
callq 0xc2070
leaq -0xb98(%rbp), %rdi
callq 0xdcf20
jmp 0xdcef9
leaq -0xbb0(%rbp), %rdi
callq 0xc2070
leaq -0xb98(%rbp), %rdi
callq 0xdcf20
leaq -0x48(%rbp), %rdi
callq 0xc2070
leaq -0x30(%rbp), %rdi
callq 0xdcf20
addq $0xbf0, %rsp # imm = 0xBF0
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0xc2070
leaq -0x30(%rbp), %rdi
callq 0xdcf20
movq -0x58(%rbp), %rdi
callq 0x3fc20
nopw %cs:(%rax,%rax)
nop
| /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 + 1);
}
sample->Add(data + pos, 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
movq -0x8(%rbp), %rdi
callq 0xcfca0
movl %eax, %eax
movq -0x18(%rbp), %rcx
subq -0x20(%rbp), %rcx
addq $0x1, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rax
shlq %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0xdd120
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /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 = num_contexts * num_blocks;
assert(in_size == in.size());
std::vector<uint32_t> cluster_size(in_size, 1);
out->resize(in_size);
histogram_symbols->resize(in_size);
for (size_t i = 0; i < in_size; ++i) {
(*out)[i] = in[i];
(*out)[i].bit_cost_ = PopulationCost(in[i]);
(*histogram_symbols)[i] = static_cast<uint32_t>(i);
}
const size_t max_input_histograms = 64;
for (size_t i = 0; i < in_size; i += max_input_histograms) {
size_t num_to_combine = std::min(in_size - i, max_input_histograms);
HistogramCombine(&(*out)[0], &cluster_size[0],
&(*histogram_symbols)[i], num_to_combine,
max_histograms);
}
// Collapse similar histograms.
HistogramCombine(&(*out)[0], &cluster_size[0],
&(*histogram_symbols)[0], in_size,
max_histograms);
// Find the optimal map from original histograms to the final ones.
HistogramRemap(&in[0], in_size, &(*out)[0], &(*histogram_symbols)[0]);
// Convert the context map to a canonical form.
HistogramReindex(out, histogram_symbols);
} | 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)
movq -0x8(%rbp), %rdi
callq 0xdd6f0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jne 0xde1c5
jmp 0xde1e4
leaq 0x774af(%rip), %rdi # 0x15567b
leaq 0x774bd(%rip), %rsi # 0x155690
movl $0x106, %edx # imm = 0x106
leaq 0x7771b(%rip), %rcx # 0x1558fa
callq 0x3f2e0
movq -0x38(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x1, -0x54(%rbp)
leaq -0x55(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xc22b0
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rcx
leaq -0x50(%rbp), %rdi
leaq -0x54(%rbp), %rdx
callq 0xc7dc0
jmp 0xde223
leaq -0x55(%rbp), %rdi
callq 0xc2340
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xddc40
jmp 0xde23b
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xd5fe0
jmp 0xde24a
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xde335
movq -0x8(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xddc00
movq %rax, -0xb8(%rbp)
movq -0x28(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xddb70
movq -0xb8(%rbp), %rsi
movq %rax, %rdi
movl $0xb10, %edx # imm = 0xB10
callq 0x3f180
movq -0x8(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xddc00
movq %rax, %rdi
callq 0xde4f0
movsd %xmm0, -0xb0(%rbp)
jmp 0xde2b4
movq -0x28(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xddb70
movsd -0xb0(%rbp), %xmm0
movsd %xmm0, 0xb08(%rax)
movq -0x70(%rbp), %rax
movl %eax, -0xbc(%rbp)
movq -0x30(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xc1fc0
movl -0xbc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xde252
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x55(%rbp), %rdi
callq 0xc2340
jmp 0xde4e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc2070
jmp 0xde4e3
movq $0x40, -0x78(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xde3f4
movq -0x38(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xc1a70
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xd8(%rbp)
callq 0xddb70
movq -0xd8(%rbp), %rsi
movq %rax, -0xd0(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc1fc0
movq %rax, -0xc8(%rbp)
movq -0x30(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0xc1fc0
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movq %rax, %rdx
movq -0x88(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xde980
jmp 0xde3e1
jmp 0xde3e3
movq -0x80(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x80(%rbp)
jmp 0xde345
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xf0(%rbp)
callq 0xddb70
movq -0xf0(%rbp), %rsi
movq %rax, -0xe8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc1fc0
movq -0xf0(%rbp), %rsi
movq %rax, -0xe0(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc1fc0
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movq %rax, %rdx
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xde980
jmp 0xde456
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x110(%rbp)
callq 0xddc00
movq -0x110(%rbp), %rsi
movq %rax, -0x108(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x28(%rbp), %rdi
callq 0xddb70
movq -0x110(%rbp), %rsi
movq %rax, -0xf8(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc1fc0
movq -0x108(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdx
movq %rax, %rcx
callq 0xdf0c0
jmp 0xde4c2
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xdf4f0
jmp 0xde4d1
leaq -0x50(%rbp), %rdi
callq 0xc2070
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3fc20
nopl (%rax)
| /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 + histogram.total_count_);
}
double bits = 0;
uint8_t depth_array[kSize] = { 0 };
if (count <= 4) {
// For very low symbol count we build the Huffman tree.
CreateHuffmanTree(&histogram.data_[0], kSize, 15, depth_array);
for (int i = 0; i < kSize; ++i) {
bits += histogram.data_[i] * depth_array[i];
}
return count == 3 ? bits + 28 : bits + 37;
}
// In this loop we compute the entropy of the histogram and simultaneously
// build a simplified histogram of the code length codes where we use the
// zero repeat code 17, but we don't use the non-zero repeat code 16.
size_t max_depth = 1;
uint32_t depth_histo[kCodeLengthCodes] = { 0 };
const double log2total = FastLog2(histogram.total_count_);
for (size_t i = 0; i < kSize;) {
if (histogram.data_[i] > 0) {
// Compute -log2(P(symbol)) = -log2(count(symbol)/total_count) =
// = log2(total_count) - log2(count(symbol))
double log2p = log2total - FastLog2(histogram.data_[i]);
// Approximate the bit depth by round(-log2(P(symbol)))
size_t depth = static_cast<size_t>(log2p + 0.5);
bits += histogram.data_[i] * log2p;
if (depth > 15) {
depth = 15;
}
if (depth > max_depth) {
max_depth = depth;
}
++depth_histo[depth];
++i;
} else {
// Compute the run length of zeros and add the appropriate number of 0 and
// 17 code length codes to the code length code histogram.
uint32_t reps = 1;
for (size_t k = i + 1; k < kSize && histogram.data_[k] == 0; ++k) {
++reps;
}
i += reps;
if (i == kSize) {
// Don't add any cost for the last zero run, since these are encoded
// only implicitly.
break;
}
if (reps < 3) {
depth_histo[0] += reps;
} else {
reps -= 2;
while (reps > 0) {
++depth_histo[17];
// Add the 3 extra bits for the 17 code length code.
bits += 3;
reps >>= 3;
}
}
}
}
// Add the estimated encoding cost of the code length code histogram.
bits += static_cast<double>(18 + 2 * max_depth);
// Add the entropy of the code length code histogram.
bits += BitsEntropy(depth_histo, kCodeLengthCodes);
return bits;
} | 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 0xde55a
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jbe 0xde54d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xde54f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xde52d
cmpl $0x1, -0x14(%rbp)
jne 0xde572
movsd 0x76f38(%rip), %xmm0 # 0x1554a0
movsd %xmm0, -0x8(%rbp)
jmp 0xde96a
cmpl $0x2, -0x14(%rbp)
jne 0xde5b8
movq -0x10(%rbp), %rax
movq 0xb00(%rax), %rax
addq $0x14, %rax
movq %rax, %xmm0
movaps 0x55a9d(%rip), %xmm1 # 0x134030
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x55aa1(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xde96a
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x2e0(%rbp), %rdi
xorl %esi, %esi
movl $0x2c0, %edx # imm = 0x2C0
callq 0x3f5b0
cmpl $0x4, -0x14(%rbp)
jg 0xde68a
movq -0x10(%rbp), %rdi
leaq -0x2e0(%rbp), %rcx
movl $0x2c0, %esi # imm = 0x2C0
movl $0xf, %edx
callq 0xf39d0
movl $0x0, -0x2e4(%rbp)
cmpl $0x2c0, -0x2e4(%rbp) # imm = 0x2C0
jge 0xde646
movq -0x10(%rbp), %rax
movslq -0x2e4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movzbl -0x2e0(%rbp,%rcx), %ecx
imull %ecx, %eax
cvtsi2sd %rax, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x2e4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2e4(%rbp)
jmp 0xde601
cmpl $0x3, -0x14(%rbp)
jne 0xde663
movsd 0x76e44(%rip), %xmm0 # 0x155498
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x378(%rbp)
jmp 0xde678
movsd 0x76e25(%rip), %xmm0 # 0x155490
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x378(%rbp)
movsd -0x378(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xde96a
movq $0x1, -0x2f0(%rbp)
leaq -0x340(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x3f5b0
movq -0x10(%rbp), %rax
movq 0xb00(%rax), %rdi
callq 0xcfcd0
movsd %xmm0, -0x348(%rbp)
movq $0x0, -0x350(%rbp)
cmpq $0x2c0, -0x350(%rbp) # imm = 0x2C0
jae 0xde908
movq -0x10(%rbp), %rax
movq -0x350(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jbe 0xde7fd
movsd -0x348(%rbp), %xmm0
movsd %xmm0, -0x380(%rbp)
movq -0x10(%rbp), %rax
movq -0x350(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %edi
callq 0xcfcd0
movaps %xmm0, %xmm1
movsd -0x380(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x358(%rbp)
movsd -0x358(%rbp), %xmm0
movsd 0x558e3(%rip), %xmm1 # 0x134020
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x558b8(%rip), %xmm1 # 0x134010
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x360(%rbp)
movq -0x10(%rbp), %rax
movq -0x350(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cvtsi2sd %rax, %xmm0
movsd -0x358(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpq $0xf, -0x360(%rbp)
jbe 0xde7b0
movq $0xf, -0x360(%rbp)
movq -0x360(%rbp), %rax
cmpq -0x2f0(%rbp), %rax
jbe 0xde7ce
movq -0x360(%rbp), %rax
movq %rax, -0x2f0(%rbp)
movq -0x360(%rbp), %rax
movl -0x340(%rbp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, -0x340(%rbp,%rax,4)
movq -0x350(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x350(%rbp)
jmp 0xde903
movl $0x1, -0x364(%rbp)
movq -0x350(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x370(%rbp)
xorl %eax, %eax
cmpq $0x2c0, -0x370(%rbp) # imm = 0x2C0
movb %al, -0x381(%rbp)
jae 0xde846
movq -0x10(%rbp), %rax
movq -0x370(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
sete %al
movb %al, -0x381(%rbp)
movb -0x381(%rbp), %al
testb $0x1, %al
jne 0xde852
jmp 0xde875
movl -0x364(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x364(%rbp)
movq -0x370(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x370(%rbp)
jmp 0xde819
movl -0x364(%rbp), %eax
addq -0x350(%rbp), %rax
movq %rax, -0x350(%rbp)
cmpq $0x2c0, -0x350(%rbp) # imm = 0x2C0
jne 0xde898
jmp 0xde908
cmpl $0x3, -0x364(%rbp)
jae 0xde8b5
movl -0x364(%rbp), %eax
addl -0x340(%rbp), %eax
movl %eax, -0x340(%rbp)
jmp 0xde901
movl -0x364(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x364(%rbp)
cmpl $0x0, -0x364(%rbp)
jbe 0xde8ff
movl -0x2fc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2fc(%rbp)
movsd 0x76ba4(%rip), %xmm0 # 0x155488
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x364(%rbp), %eax
shrl $0x3, %eax
movl %eax, -0x364(%rbp)
jmp 0xde8c4
jmp 0xde901
jmp 0xde903
jmp 0xde6cb
movq -0x2f0(%rbp), %rax
leaq 0x12(%rax,%rax), %rax
movq %rax, %xmm0
movaps 0x55710(%rip), %xmm1 # 0x134030
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x55714(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x340(%rbp), %rdi
movl $0x12, %esi
callq 0xcfd80
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x390, %rsp # imm = 0x390
popq %rbp
retq
nopl (%rax,%rax)
| /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.
std::vector<uint32_t> clusters(symbols, symbols + symbols_size);
std::sort(clusters.begin(), clusters.end());
std::vector<uint32_t>::iterator last =
std::unique(clusters.begin(), clusters.end());
clusters.resize(static_cast<size_t>(last - clusters.begin()));
// We maintain a heap of histogram pairs, ordered by the bit cost reduction.
std::vector<HistogramPair> pairs;
for (size_t idx1 = 0; idx1 < clusters.size(); ++idx1) {
for (size_t idx2 = idx1 + 1; idx2 < clusters.size(); ++idx2) {
CompareAndPushToQueue(out, cluster_size, clusters[idx1], clusters[idx2],
&pairs);
}
}
while (clusters.size() > min_cluster_size) {
if (pairs[0].cost_diff >= cost_diff_threshold) {
cost_diff_threshold = 1e99;
min_cluster_size = max_clusters;
continue;
}
// Take the best pair from the top of heap.
uint32_t best_idx1 = pairs[0].idx1;
uint32_t best_idx2 = pairs[0].idx2;
out[best_idx1].AddHistogram(out[best_idx2]);
out[best_idx1].bit_cost_ = pairs[0].cost_combo;
cluster_size[best_idx1] += cluster_size[best_idx2];
for (size_t i = 0; i < symbols_size; ++i) {
if (symbols[i] == best_idx2) {
symbols[i] = best_idx1;
}
}
for (std::vector<uint32_t>::iterator cluster = clusters.begin();
cluster != clusters.end(); ++cluster) {
if (*cluster >= best_idx2) {
clusters.erase(cluster);
break;
}
}
// Remove pairs intersecting the just combined best pair.
size_t copy_to_idx = 0;
for (size_t i = 0; i < pairs.size(); ++i) {
HistogramPair& p = pairs[i];
if (p.idx1 == best_idx1 || p.idx2 == best_idx1 ||
p.idx1 == best_idx2 || p.idx2 == best_idx2) {
// Remove invalid pair from the queue.
continue;
}
if (pairs.front() < p) {
// Replace the top of the queue if needed.
HistogramPair front = pairs.front();
pairs.front() = p;
pairs[copy_to_idx] = front;
} else {
pairs[copy_to_idx] = p;
}
++copy_to_idx;
}
pairs.resize(copy_to_idx);
// Push new pairs formed with the combined histogram to the heap.
for (size_t i = 0; i < clusters.size(); ++i) {
CompareAndPushToQueue(out, cluster_size, best_idx1, clusters[i], &pairs);
}
}
} | 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), %rax
movq %rax, -0x138(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0xc22b0
movq -0x140(%rbp), %rsi
movq -0x138(%rbp), %rdx
movq -0x130(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0xd7570
jmp 0xde9f9
leaq -0x51(%rbp), %rdi
callq 0xc2340
leaq -0x50(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0xca700
movq -0x148(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0xca550
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xd75f0
jmp 0xdea35
leaq -0x50(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0xca700
movq -0x158(%rbp), %rdi
movq %rax, -0x88(%rbp)
callq 0xca550
movq %rax, -0x90(%rbp)
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xd7630
movq %rax, -0x150(%rbp)
jmp 0xdea7b
movq -0x150(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0xca700
movq %rax, -0x98(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xca6c0
movq -0x160(%rbp), %rdi
movq %rax, %rsi
callq 0xd5fe0
jmp 0xdeabe
leaq -0xb0(%rbp), %rdi
callq 0xd7670
movq $0x0, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x168(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc1f30
movq %rax, %rcx
movq -0x168(%rbp), %rax
cmpq %rcx, %rax
jae 0xdec21
movq -0xb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc1f30
movq %rax, %rcx
movq -0x170(%rbp), %rax
cmpq %rcx, %rax
jae 0xdec08
movq -0x8(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0xb8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0xc1fc0
movq -0x190(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x174(%rbp)
movq -0xc0(%rbp), %rsi
callq 0xc1fc0
movq -0x188(%rbp), %rdi
movq -0x180(%rbp), %rsi
movl -0x174(%rbp), %edx
movl (%rax), %ecx
leaq -0xb0(%rbp), %r8
callq 0xdf730
jmp 0xdeba7
jmp 0xdeba9
movq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
jmp 0xdeb11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0xc2340
jmp 0xdf0b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xdf0ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xd7c00
jmp 0xdf0ae
jmp 0xdec0a
movq -0xb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb8(%rbp)
jmp 0xdead5
jmp 0xdec23
leaq -0x50(%rbp), %rdi
callq 0xc1f30
cmpq -0x38(%rbp), %rax
jbe 0xdf090
leaq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd7970
movsd 0x10(%rax), %xmm0
ucomisd -0x30(%rbp), %xmm0
jb 0xdec69
movsd 0x7680e(%rip), %xmm0 # 0x155468
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xdec23
leaq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd7970
movl (%rax), %eax
movl %eax, -0xc4(%rbp)
leaq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd7970
movl 0x4(%rax), %eax
movl %eax, -0xc8(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc4(%rbp), %eax
imulq $0xb10, %rax, %rax # imm = 0xB10
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl -0xc8(%rbp), %eax
imulq $0xb10, %rax, %rax # imm = 0xB10
addq %rax, %rsi
callq 0xddb90
leaq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd7970
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movl -0xc4(%rbp), %ecx
imulq $0xb10, %rcx, %rcx # imm = 0xB10
addq %rcx, %rax
movsd %xmm0, 0xb08(%rax)
movq -0x10(%rbp), %rax
movl -0xc8(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movl -0xc4(%rbp), %ecx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq $0x0, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xded6d
movq -0x18(%rbp), %rax
movq -0xd0(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0xc8(%rbp), %eax
jne 0xded57
movl -0xc4(%rbp), %edx
movq -0x18(%rbp), %rax
movq -0xd0(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xded59
movq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd0(%rbp)
jmp 0xded20
leaq -0x50(%rbp), %rdi
callq 0xca700
movq %rax, -0xd8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xca550
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0xd7990
testb $0x1, %al
jne 0xdeda6
jmp 0xdee0b
leaq -0xd8(%rbp), %rdi
callq 0xca930
movl (%rax), %eax
cmpl -0xc8(%rbp), %eax
jb 0xdedf8
leaq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xd7a40
movq -0xe8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xd79d0
movq %rax, -0x198(%rbp)
jmp 0xdede8
movq -0x198(%rbp), %rax
movq %rax, -0xf0(%rbp)
jmp 0xdee0b
jmp 0xdedfa
leaq -0xd8(%rbp), %rdi
callq 0xd7a80
jmp 0xded7d
movq $0x0, -0xf8(%rbp)
movq $0x0, -0x100(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0x1a0(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xd7aa0
movq %rax, %rcx
movq -0x1a0(%rbp), %rax
cmpq %rcx, %rax
jae 0xdefd6
movq -0x100(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0xd7970
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movl (%rax), %eax
cmpl -0xc4(%rbp), %eax
je 0xdeeae
movq -0x108(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc4(%rbp), %eax
je 0xdeeae
movq -0x108(%rbp), %rax
movl (%rax), %eax
cmpl -0xc8(%rbp), %eax
je 0xdeeae
movq -0x108(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc8(%rbp), %eax
jne 0xdeeb3
jmp 0xdefbf
leaq -0xb0(%rbp), %rdi
callq 0xd7b40
movq %rax, %rdi
movq -0x108(%rbp), %rsi
callq 0xd7ad0
testb $0x1, %al
jne 0xdeed7
jmp 0xdef6f
leaq -0xb0(%rbp), %rdi
callq 0xd7b40
movq (%rax), %rcx
movq %rcx, -0x120(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x118(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x110(%rbp)
movq -0x108(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xd7b40
movq -0x1a8(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0xf8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0xd7970
movq -0x120(%rbp), %rcx
movq %rcx, (%rax)
movq -0x118(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xdefad
movq -0x108(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movq -0xf8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0xd7970
movq -0x1b0(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0xf8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xf8(%rbp)
movq -0x100(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x100(%rbp)
jmp 0xdee21
movq -0xf8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0xd7b70
jmp 0xdefeb
movq $0x0, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc1f30
movq %rax, %rcx
movq -0x1b8(%rbp), %rax
cmpq %rcx, %rax
jae 0xdf08b
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movl -0xc4(%rbp), %eax
movl %eax, -0x1bc(%rbp)
movq -0x128(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xc1fc0
movq -0x1d0(%rbp), %rdi
movq -0x1c8(%rbp), %rsi
movl -0x1bc(%rbp), %edx
movl (%rax), %ecx
leaq -0xb0(%rbp), %r8
callq 0xdf730
jmp 0xdf072
jmp 0xdf074
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
jmp 0xdeff6
jmp 0xdec23
leaq -0xb0(%rbp), %rdi
callq 0xd7c00
leaq -0x50(%rbp), %rdi
callq 0xc2070
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0xc2070
movq -0x60(%rbp), %rdi
callq 0x3fc20
| /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 =
std::unique(all_symbols.begin(), all_symbols.end());
all_symbols.resize(static_cast<size_t>(last - all_symbols.begin()));
for (size_t i = 0; i < in_size; ++i) {
uint32_t best_out = i == 0 ? symbols[0] : symbols[i - 1];
double best_bits = HistogramBitCostDistance(in[i], out[best_out]);
for (std::vector<uint32_t>::const_iterator k = all_symbols.begin();
k != all_symbols.end(); ++k) {
const double cur_bits = HistogramBitCostDistance(in[i], out[*k]);
if (cur_bits < best_bits) {
best_bits = cur_bits;
best_out = *k;
}
}
symbols[i] = best_out;
}
// Recompute each out based on raw and symbols.
for (std::vector<uint32_t>::const_iterator k = all_symbols.begin();
k != all_symbols.end(); ++k) {
out[*k].Clear();
}
for (size_t i = 0; i < in_size; ++i) {
out[symbols[i]].AddHistogram(in[i]);
}
} | 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(%rbp)
callq 0xc22b0
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
movq -0xe0(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0xd7570
jmp 0xdf125
leaq -0x39(%rbp), %rdi
callq 0xc2340
leaq -0x38(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0xca700
movq -0xf8(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0xca550
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xd75f0
jmp 0xdf161
leaq -0x38(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xca700
movq -0x108(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0xca550
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xd7630
movq %rax, -0x100(%rbp)
jmp 0xdf19b
movq -0x100(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0xca700
movq %rax, -0x80(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xca6c0
movq -0x110(%rbp), %rdi
movq %rax, %rsi
callq 0xd5fe0
jmp 0xdf1d8
movq $0x0, -0x88(%rbp)
movq -0x88(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xdf3e1
cmpq $0x0, -0x88(%rbp)
jne 0xdf20c
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x114(%rbp)
jmp 0xdf224
movq -0x20(%rbp), %rax
movq -0x88(%rbp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x88(%rbp), %rax
imulq $0xb10, %rax, %rax # imm = 0xB10
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x8c(%rbp), %eax
imulq $0xb10, %rax, %rax # imm = 0xB10
addq %rax, %rsi
callq 0xdfa10
movsd %xmm0, -0x120(%rbp)
jmp 0xdf268
movsd -0x120(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xca700
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xd7a40
leaq -0x38(%rbp), %rdi
callq 0xca550
movq %rax, -0xb0(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0xda880
testb $0x1, %al
jne 0xdf2c7
jmp 0xdf3b6
movq -0x8(%rbp), %rax
movq -0x88(%rbp), %rcx
imulq $0xb10, %rcx, %rcx # imm = 0xB10
addq %rcx, %rax
movq %rax, -0x130(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x138(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xda8c0
movq -0x138(%rbp), %rsi
movq -0x130(%rbp), %rdi
movl (%rax), %eax
imulq $0xb10, %rax, %rax # imm = 0xB10
addq %rax, %rsi
callq 0xdfa10
movsd %xmm0, -0x128(%rbp)
jmp 0xdf323
movsd -0x128(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movsd -0xb8(%rbp), %xmm1
movsd -0x98(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xdf3a3
movsd -0xb8(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xda8c0
movl (%rax), %eax
movl %eax, -0x8c(%rbp)
jmp 0xdf3a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xc2340
jmp 0xdf4db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc2070
jmp 0xdf4db
jmp 0xdf3a5
leaq -0xa0(%rbp), %rdi
callq 0xda8e0
jmp 0xdf29b
movl -0x8c(%rbp), %edx
movq -0x20(%rbp), %rax
movq -0x88(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0xdf1e3
leaq -0x38(%rbp), %rdi
callq 0xca700
movq %rax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xd7a40
leaq -0x38(%rbp), %rdi
callq 0xca550
movq %rax, -0xd0(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xda880
testb $0x1, %al
jne 0xdf42d
jmp 0xdf46a
movq -0x18(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xda8c0
movq -0x140(%rbp), %rdi
movl (%rax), %eax
imulq $0xb10, %rax, %rax # imm = 0xB10
addq %rax, %rdi
callq 0xdd200
leaq -0xc0(%rbp), %rdi
callq 0xda8e0
jmp 0xdf404
movq $0x0, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xdf4c9
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0xd8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
imulq $0xb10, %rax, %rax # imm = 0xB10
addq %rax, %rdi
movq -0x8(%rbp), %rsi
imulq $0xb10, -0xd8(%rbp), %rax # imm = 0xB10
addq %rax, %rsi
callq 0xddb90
movq -0xd8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
jmp 0xdf475
leaq -0x38(%rbp), %rdi
callq 0xc2070
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3fc20
nopw %cs:(%rax,%rax)
nop
| /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.end()) {
new_index[(*symbols)[i]] = next_index;
(*out)[next_index] = tmp[(*symbols)[i]];
++next_index;
}
}
out->resize(next_index);
for (size_t i = 0; i < symbols->size(); ++i) {
(*symbols)[i] = new_index[(*symbols)[i]];
}
} | 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 %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0xdf663
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xc1fc0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xdaa40
movq %rax, -0xa0(%rbp)
jmp 0xdf571
movq -0xa0(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xdaa70
movq %rax, -0x88(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xdaa10
testb $0x1, %al
jne 0xdf5a5
jmp 0xdf650
movl -0x5c(%rbp), %eax
movl %eax, -0xac(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xc1fc0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xdaaa0
movq %rax, -0xa8(%rbp)
jmp 0xdf5d0
movq -0xa8(%rbp), %rax
movl -0xac(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xc1fc0
movl (%rax), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0xddb70
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0xddb70
movq -0xb8(%rbp), %rsi
movq %rax, %rdi
movl $0xb10, %edx # imm = 0xB10
callq 0x3f180
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0xdf650
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xdab80
leaq -0x28(%rbp), %rdi
callq 0xdcf20
jmp 0xdf722
jmp 0xdf652
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0xdf528
movq -0x8(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0xddc40
jmp 0xdf673
movq $0x0, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc1f30
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jae 0xdf707
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xc1fc0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xdaaa0
movq %rax, -0xc8(%rbp)
jmp 0xdf6c9
movq -0xc8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xcc(%rbp)
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xc1fc0
movl -0xcc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0xdf67e
leaq -0x58(%rbp), %rdi
callq 0xdab80
leaq -0x28(%rbp), %rdi
callq 0xdcf20
addq $0xd0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3fc20
nopl (%rax,%rax)
| /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;
idx2 = idx1;
idx1 = t;
}
bool store_pair = false;
HistogramPair p;
p.idx1 = idx1;
p.idx2 = idx2;
p.cost_diff = 0.5 * ClusterCostDiff(cluster_size[idx1], cluster_size[idx2]);
p.cost_diff -= out[idx1].bit_cost_;
p.cost_diff -= out[idx2].bit_cost_;
if (out[idx1].total_count_ == 0) {
p.cost_combo = out[idx2].bit_cost_;
store_pair = true;
} else if (out[idx2].total_count_ == 0) {
p.cost_combo = out[idx1].bit_cost_;
store_pair = true;
} else {
double threshold = pairs->empty() ? 1e99 :
std::max(0.0, (*pairs)[0].cost_diff);
HistogramType combo = out[idx1];
combo.AddHistogram(out[idx2]);
double cost_combo = PopulationCost(combo);
if (cost_combo < threshold - p.cost_diff) {
p.cost_combo = cost_combo;
store_pair = true;
}
}
if (store_pair) {
p.cost_diff += p.cost_combo;
if (!pairs->empty() && (pairs->front() < p)) {
// Replace the top of the queue if needed.
pairs->push_back(pairs->front());
pairs->front() = p;
} else {
pairs->push_back(p);
}
}
} | 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 -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movb $0x0, -0x25(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, %edi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
callq 0xd9440
movaps %xmm0, %xmm1
movsd 0x54874(%rip), %xmm0 # 0x134020
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
imulq $0xb10, %rcx, %rcx # imm = 0xB10
addq %rcx, %rax
movsd 0xb08(%rax), %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
imulq $0xb10, %rcx, %rcx # imm = 0xB10
addq %rcx, %rax
movsd 0xb08(%rax), %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
imulq $0xb10, %rcx, %rcx # imm = 0xB10
addq %rcx, %rax
cmpq $0x0, 0xb00(%rax)
jne 0xdf845
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
imulq $0xb10, %rcx, %rcx # imm = 0xB10
addq %rcx, %rax
movsd 0xb08(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movb $0x1, -0x25(%rbp)
jmp 0xdf966
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
imulq $0xb10, %rcx, %rcx # imm = 0xB10
addq %rcx, %rax
cmpq $0x0, 0xb00(%rax)
jne 0xdf887
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
imulq $0xb10, %rcx, %rcx # imm = 0xB10
addq %rcx, %rax
movsd 0xb08(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movb $0x1, -0x25(%rbp)
jmp 0xdf964
movq -0x20(%rbp), %rdi
callq 0xd9560
testb $0x1, %al
jne 0xdf896
jmp 0xdf8a8
movsd 0x75bca(%rip), %xmm0 # 0x155468
movsd %xmm0, -0xb70(%rbp)
jmp 0xdf8d9
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd7970
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x50(%rbp), %rdi
callq 0xd95a0
movsd (%rax), %xmm0
movsd %xmm0, -0xb70(%rbp)
movsd -0xb70(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
imulq $0xb10, %rax, %rax # imm = 0xB10
addq %rax, %rsi
leaq -0xb60(%rbp), %rdi
movl $0xb10, %edx # imm = 0xB10
callq 0x3f180
movq -0x8(%rbp), %rsi
movl -0x18(%rbp), %eax
imulq $0xb10, %rax, %rax # imm = 0xB10
addq %rax, %rsi
leaq -0xb60(%rbp), %rdi
callq 0xddb90
leaq -0xb60(%rbp), %rdi
callq 0xde4f0
movsd %xmm0, -0xb68(%rbp)
movsd -0xb68(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xdf962
movsd -0xb68(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movb $0x1, -0x25(%rbp)
jmp 0xdf964
jmp 0xdf966
testb $0x1, -0x25(%rbp)
je 0xdf9fb
movsd -0x38(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd9560
testb $0x1, %al
jne 0xdf9ec
movq -0x20(%rbp), %rdi
callq 0xd7b40
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
callq 0xd7ad0
testb $0x1, %al
jne 0xdf9a7
jmp 0xdf9ec
movq -0x20(%rbp), %rax
movq %rax, -0xb78(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd7b40
movq -0xb78(%rbp), %rdi
movq %rax, %rsi
callq 0xd95e0
movq -0x20(%rbp), %rdi
callq 0xd7b40
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xdf9f9
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd95e0
jmp 0xdf9fb
addq $0xb80, %rsp # imm = 0xB80
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| /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()) * vec->size();
for (size_t iter = 0; iter < iters; ++iter) {
HistogramType sample;
RandomSample(&seed, data, length, stride, &sample);
size_t ix = iter % vec->size();
(*vec)[ix].AddHistogram(sample);
}
} | 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(%rbp), %rax
movq %rax, -0x888(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe1280
movq %rax, %rcx
movq -0x888(%rbp), %rax
addq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x880(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe1280
movq %rax, %rcx
movq -0x880(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x878(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe1280
movq %rax, %rcx
movq -0x878(%rbp), %rax
imulq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xe02a7
leaq -0x868(%rbp), %rdi
callq 0xe0c90
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x2c(%rbp), %rdi
leaq -0x868(%rbp), %r8
callq 0xe1670
movq -0x38(%rbp), %rax
movq %rax, -0x890(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe1280
movq %rax, %rcx
movq -0x890(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x870(%rbp)
movq -0x20(%rbp), %rdi
movq -0x870(%rbp), %rsi
callq 0xe1700
movq %rax, %rdi
leaq -0x868(%rbp), %rsi
callq 0xe1720
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xe0217
addq $0x890, %rsp # imm = 0x890
popq %rbp
retq
| /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;
}
size_t vecsize = vec.size();
assert(vecsize <= 256);
double* insert_cost = new double[kSize * vecsize];
memset(insert_cost, 0, sizeof(insert_cost[0]) * kSize * vecsize);
for (size_t j = 0; j < vecsize; ++j) {
insert_cost[j] = FastLog2(static_cast<uint32_t>(vec[j].total_count_));
}
for (size_t i = kSize; i != 0;) {
--i;
for (size_t j = 0; j < vecsize; ++j) {
insert_cost[i * vecsize + j] = insert_cost[j] - BitCost(vec[j].data_[i]);
}
}
double *cost = new double[vecsize];
memset(cost, 0, sizeof(cost[0]) * vecsize);
bool* switch_signal = new bool[length * vecsize];
memset(switch_signal, 0, sizeof(switch_signal[0]) * length * vecsize);
// After each iteration of this loop, cost[k] will contain the difference
// between the minimum cost of arriving at the current byte position using
// entropy code k, and the minimum cost of arriving at the current byte
// position. This difference is capped at the block switch cost, and if it
// reaches block switch cost, it means that when we trace back from the last
// position, we need to switch here.
for (size_t byte_ix = 0; byte_ix < length; ++byte_ix) {
size_t ix = byte_ix * vecsize;
size_t insert_cost_ix = data[byte_ix] * vecsize;
double min_cost = 1e99;
for (size_t k = 0; k < vecsize; ++k) {
// We are coding the symbol in data[byte_ix] with entropy code k.
cost[k] += insert_cost[insert_cost_ix + k];
if (cost[k] < min_cost) {
min_cost = cost[k];
block_id[byte_ix] = static_cast<uint8_t>(k);
}
}
double block_switch_cost = block_switch_bitcost;
// More blocks for the beginning.
if (byte_ix < 2000) {
block_switch_cost *= 0.77 + 0.07 * static_cast<double>(byte_ix) / 2000;
}
for (size_t k = 0; k < vecsize; ++k) {
cost[k] -= min_cost;
if (cost[k] >= block_switch_cost) {
cost[k] = block_switch_cost;
switch_signal[ix + k] = true;
}
}
}
// Now trace back from the last position and switch at the marked places.
size_t byte_ix = length - 1;
size_t ix = byte_ix * vecsize;
uint8_t cur_id = block_id[byte_ix];
while (byte_ix > 0) {
--byte_ix;
ix -= vecsize;
if (switch_signal[ix + cur_id]) {
cur_id = block_id[byte_ix];
}
block_id[byte_ix] = cur_id;
}
delete[] insert_cost;
delete[] cost;
delete[] switch_signal;
} | 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), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe02e7
jmp 0xe07e0
movq -0x20(%rbp), %rdi
callq 0xe1280
movq %rax, -0x38(%rbp)
cmpq $0x100, -0x38(%rbp) # imm = 0x100
ja 0xe0329
jmp 0xe0348
leaq 0x75178(%rip), %rdi # 0x1554a8
leaq 0x75180(%rip), %rsi # 0x1554b7
movl $0xac, %edx
leaq 0x75672(%rip), %rcx # 0x1559b5
callq 0x3f2e0
imulq $0x208, -0x38(%rbp), %rax # imm = 0x208
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3f930
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
imulq $0x1040, -0x38(%rbp), %rdx # imm = 0x1040
xorl %esi, %esi
callq 0x3f5b0
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xe03d2
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xe1790
movq 0x820(%rax), %rax
movl %eax, %eax
movl %eax, %edi
callq 0xcfcd0
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xe0390
movq $0x208, -0x50(%rbp) # imm = 0x208
cmpq $0x0, -0x50(%rbp)
je 0xe046b
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xe0466
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0xc0(%rbp)
movq -0x20(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xe1790
movq -0x50(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %edi
callq 0xcfd40
movaps %xmm0, %xmm1
movsd -0xc0(%rbp), %xmm0
subsd %xmm1, %xmm0
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
imulq -0x38(%rbp), %rcx
addq -0x58(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xe03f9
jmp 0xe03da
movq -0x38(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3f930
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x3f5b0
movq -0x10(%rbp), %rdi
imulq -0x38(%rbp), %rdi
callq 0x3f930
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rdx
shlq $0x0, %rdx
imulq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x3f5b0
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xe06dd
movq -0x70(%rbp), %rax
imulq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq -0x70(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
imulq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movsd 0x74f57(%rip), %xmm0 # 0x155468
movsd %xmm0, -0x88(%rbp)
movq $0x0, -0x90(%rbp)
movq -0x90(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xe05c1
movq -0x40(%rbp), %rax
movq -0x80(%rbp), %rcx
addq -0x90(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x60(%rbp), %rax
movq -0x90(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x60(%rbp), %rax
movq -0x90(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x88(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xe05a8
movq -0x60(%rbp), %rax
movq -0x90(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x90(%rbp), %rax
movb %al, %dl
movq -0x28(%rbp), %rax
movq -0x70(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xe05aa
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0xe0524
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
cmpq $0x7d0, -0x70(%rbp) # imm = 0x7D0
jae 0xe0633
movaps 0x53a51(%rip), %xmm1 # 0x134030
movq -0x70(%rbp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x53a50(%rip), %xmm1 # 0x134040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x74e71(%rip), %xmm1 # 0x155478
mulsd %xmm0, %xmm1
movsd 0x74e5d(%rip), %xmm0 # 0x155470
divsd %xmm0, %xmm1
movsd 0x541d1(%rip), %xmm0 # 0x1347f0
addsd %xmm1, %xmm0
mulsd -0x98(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movq $0x0, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xe06ca
movsd -0x88(%rbp), %xmm1
movq -0x60(%rbp), %rax
movq -0xa0(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x60(%rbp), %rax
movq -0xa0(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x98(%rbp), %xmm0
jb 0xe06b1
movsd -0x98(%rbp), %xmm0
movq -0x60(%rbp), %rax
movq -0xa0(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x68(%rbp), %rax
movq -0x78(%rbp), %rcx
addq -0xa0(%rbp), %rcx
movb $0x1, (%rax,%rcx)
jmp 0xe06b3
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0xe063e
jmp 0xe06cc
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xe04d9
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
imulq -0x38(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x28(%rbp), %rax
movq -0xa8(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xb1(%rbp)
cmpq $0x0, -0xa8(%rbp)
jbe 0xe0789
movq -0xa8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rcx
movq -0xb0(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x68(%rbp), %rax
movq -0xb0(%rbp), %rcx
movzbl -0xb1(%rbp), %edx
addq %rdx, %rcx
testb $0x1, (%rax,%rcx)
je 0xe0773
movq -0x28(%rbp), %rax
movq -0xa8(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %dl
movq -0x28(%rbp), %rax
movq -0xa8(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xe0713
movq -0x40(%rbp), %rax
movq %rax, -0xc8(%rbp)
cmpq $0x0, %rax
je 0xe07a6
movq -0xc8(%rbp), %rdi
callq 0x3f6f0
movq -0x60(%rbp), %rax
movq %rax, -0xd0(%rbp)
cmpq $0x0, %rax
je 0xe07c3
movq -0xd0(%rbp), %rdi
callq 0x3f6f0
movq -0x68(%rbp), %rax
movq %rax, -0xd8(%rbp)
cmpq $0x0, %rax
je 0xe07e0
movq -0xd8(%rbp), %rdi
callq 0x3f6f0
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
| /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_t* storage_ix,
uint8_t* storage) {
size_t count = 0;
size_t symbols[4] = { 0 };
size_t length = 0;
size_t total = histogram_total;
while (total != 0) {
if (histogram[length]) {
if (count < 4) {
symbols[count] = length;
}
++count;
total -= histogram[length];
}
++length;
}
if (count <= 1) {
WriteBits(4, 1, storage_ix, storage);
WriteBits(max_bits, symbols[0], storage_ix, storage);
return;
}
const size_t max_tree_size = 2 * length + 1;
HuffmanTree* const tree =
static_cast<HuffmanTree*>(malloc(max_tree_size * sizeof(HuffmanTree)));
for (uint32_t count_limit = 1; ; count_limit *= 2) {
HuffmanTree* node = tree;
for (size_t i = length; i != 0;) {
--i;
if (histogram[i]) {
if (PREDICT_TRUE(histogram[i] >= count_limit)) {
*node = HuffmanTree(histogram[i], -1, static_cast<int16_t>(i));
} else {
*node = HuffmanTree(count_limit, -1, static_cast<int16_t>(i));
}
++node;
}
}
const int n = static_cast<int>(node - tree);
std::sort(tree, node, SortHuffmanTree);
// The nodes are:
// [0, n): the sorted leaf nodes that we start with.
// [n]: we add a sentinel here.
// [n + 1, 2n): new parent nodes are added here, starting from
// (n+1). These are naturally in ascending order.
// [2n]: we add a sentinel at the end as well.
// There will be (2n+1) elements at the end.
const HuffmanTree sentinel(std::numeric_limits<int>::max(), -1, -1);
*node++ = sentinel;
*node++ = sentinel;
int i = 0; // Points to the next leaf node.
int j = n + 1; // Points to the next non-leaf node.
for (int k = n - 1; k > 0; --k) {
int left, right;
if (tree[i].total_count_ <= tree[j].total_count_) {
left = i;
++i;
} else {
left = j;
++j;
}
if (tree[i].total_count_ <= tree[j].total_count_) {
right = i;
++i;
} else {
right = j;
++j;
}
// The sentinel node becomes the parent node.
node[-1].total_count_ =
tree[left].total_count_ + tree[right].total_count_;
node[-1].index_left_ = static_cast<int16_t>(left);
node[-1].index_right_or_value_ = static_cast<int16_t>(right);
// Add back the last sentinel node.
*node++ = sentinel;
}
SetDepth(tree[2 * n - 1], &tree[0], depth, 0);
// We need to pack the Huffman tree in 14 bits.
// If this was not successful, add fake entities to the lowest values
// and retry.
if (PREDICT_TRUE(*std::max_element(&depth[0], &depth[length]) <= 14)) {
break;
}
}
free(tree);
ConvertBitDepthsToSymbols(depth, length, bits);
if (count <= 4) {
// value of 1 indicates a simple Huffman code
WriteBits(2, 1, storage_ix, storage);
WriteBits(2, count - 1, storage_ix, storage); // NSYM - 1
// Sort
for (size_t i = 0; i < count; i++) {
for (size_t j = i + 1; j < count; j++) {
if (depth[symbols[j]] < depth[symbols[i]]) {
std::swap(symbols[j], symbols[i]);
}
}
}
if (count == 2) {
WriteBits(max_bits, symbols[0], storage_ix, storage);
WriteBits(max_bits, symbols[1], storage_ix, storage);
} else if (count == 3) {
WriteBits(max_bits, symbols[0], storage_ix, storage);
WriteBits(max_bits, symbols[1], storage_ix, storage);
WriteBits(max_bits, symbols[2], storage_ix, storage);
} else {
WriteBits(max_bits, symbols[0], storage_ix, storage);
WriteBits(max_bits, symbols[1], storage_ix, storage);
WriteBits(max_bits, symbols[2], storage_ix, storage);
WriteBits(max_bits, symbols[3], storage_ix, storage);
// tree-select
WriteBits(1, depth[symbols[0]] == 1 ? 1 : 0, storage_ix, storage);
}
} else {
// Complex Huffman Tree
StoreStaticCodeLengthCode(storage_ix, storage);
// Actual rle coding.
uint8_t previous_value = 8;
for (size_t i = 0; i < length;) {
const uint8_t value = depth[i];
size_t reps = 1;
for (size_t k = i + 1; k < length && depth[k] == value; ++k) {
++reps;
}
i += reps;
if (value == 0) {
WriteBits(kZeroRepsDepth[reps], kZeroRepsBits[reps],
storage_ix, storage);
} else {
if (previous_value != value) {
WriteBits(kCodeLengthDepth[value], kCodeLengthBits[value],
storage_ix, storage);
--reps;
}
if (reps < 3) {
while (reps != 0) {
reps--;
WriteBits(kCodeLengthDepth[value], kCodeLengthBits[value],
storage_ix, storage);
}
} else {
reps -= 3;
WriteBits(kNonZeroRepsDepth[reps], kNonZeroRepsBits[reps],
storage_ix, storage);
}
previous_value = value;
}
}
}
} | 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
movq $0x0, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
je 0xe487a
movq -0x8(%rbp), %rax
movq -0x68(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xe486c
cmpq $0x4, -0x38(%rbp)
jae 0xe4848
movq -0x68(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x60(%rbp,%rax,8)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq -0x68(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
movq -0x70(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0xe481f
cmpq $0x1, -0x38(%rbp)
ja 0xe48b2
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
movl $0x4, %edi
movl $0x1, %esi
callq 0xe8010
movq -0x18(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
jmp 0xe506f
movq -0x68(%rbp), %rax
shlq %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
shlq $0x3, %rdi
callq 0x40240
movq %rax, -0x80(%rbp)
movl $0x1, -0x84(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0xe49cd
movq -0x98(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rax
movq -0x98(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xe49c8
movq -0x8(%rbp), %rax
movq -0x98(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x84(%rbp), %eax
setae %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe4948
jmp 0xe4984
movq -0x8(%rbp), %rax
movq -0x98(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq -0x98(%rbp), %rax
leaq -0xa0(%rbp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movswl %ax, %ecx
callq 0xe8250
movq -0x90(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xe49b6
movl -0x84(%rbp), %esi
movq -0x98(%rbp), %rax
leaq -0xa8(%rbp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movswl %ax, %ecx
callq 0xe8250
movq -0x90(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, (%rax)
movq -0x90(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x90(%rbp)
jmp 0xe48f2
movq -0x90(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0xac(%rbp)
movq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rsi
leaq 0x38e9(%rip), %rdx # 0xe82e0
callq 0xe8290
callq 0xe8300
movl %eax, %esi
leaq -0xb4(%rbp), %rdi
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl %ecx, %edx
callq 0xe8250
movq -0x90(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x90(%rbp)
movq -0xb4(%rbp), %rcx
movq %rcx, (%rax)
movq -0x90(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x90(%rbp)
movq -0xb4(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0xb8(%rbp)
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xbc(%rbp)
movl -0xac(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc0(%rbp)
cmpl $0x0, -0xc0(%rbp)
jle 0xe4bb6
movq -0x80(%rbp), %rax
movslq -0xb8(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x80(%rbp), %rcx
movslq -0xbc(%rbp), %rdx
cmpl (%rcx,%rdx,8), %eax
ja 0xe4ac4
movl -0xb8(%rbp), %eax
movl %eax, -0xc4(%rbp)
movl -0xb8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb8(%rbp)
jmp 0xe4adf
movl -0xbc(%rbp), %eax
movl %eax, -0xc4(%rbp)
movl -0xbc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xbc(%rbp)
movq -0x80(%rbp), %rax
movslq -0xb8(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x80(%rbp), %rcx
movslq -0xbc(%rbp), %rdx
cmpl (%rcx,%rdx,8), %eax
ja 0xe4b1a
movl -0xb8(%rbp), %eax
movl %eax, -0xc8(%rbp)
movl -0xb8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb8(%rbp)
jmp 0xe4b35
movl -0xbc(%rbp), %eax
movl %eax, -0xc8(%rbp)
movl -0xbc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xbc(%rbp)
movq -0x80(%rbp), %rax
movslq -0xc4(%rbp), %rcx
movl (%rax,%rcx,8), %ecx
movq -0x80(%rbp), %rax
movslq -0xc8(%rbp), %rdx
addl (%rax,%rdx,8), %ecx
movq -0x90(%rbp), %rax
movl %ecx, -0x8(%rax)
movl -0xc4(%rbp), %eax
movw %ax, %cx
movq -0x90(%rbp), %rax
movw %cx, -0x4(%rax)
movl -0xc8(%rbp), %eax
movw %ax, %cx
movq -0x90(%rbp), %rax
movw %cx, -0x2(%rax)
movq -0x90(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x90(%rbp)
movq -0xb4(%rbp), %rcx
movq %rcx, (%rax)
movl -0xc0(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc0(%rbp)
jmp 0xe4a7c
movq -0x80(%rbp), %rdi
movl -0xac(%rbp), %eax
shll %eax
subl $0x1, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdi
movq -0x80(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0xf3930
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq -0x68(%rbp), %rsi
callq 0xe8310
movzbl (%rax), %eax
cmpl $0xe, %eax
setle %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe4c01
jmp 0xe4c03
jmp 0xe4c18
jmp 0xe4c05
movl -0x84(%rbp), %eax
shll %eax
movl %eax, -0x84(%rbp)
jmp 0xe48dc
movq -0x80(%rbp), %rdi
callq 0x3f330
movq -0x20(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xf4a80
cmpq $0x4, -0x38(%rbp)
ja 0xe4e37
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
movl $0x2, %edi
movl $0x1, %esi
callq 0xe8010
movq -0x38(%rbp), %rsi
subq $0x1, %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
movl $0x2, %edi
callq 0xe8010
movq $0x0, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xe4d2d
movq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xe4d14
movq -0x20(%rbp), %rax
movq -0xd8(%rbp), %rcx
movq -0x60(%rbp,%rcx,8), %rcx
movzbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movq -0xd0(%rbp), %rdx
movq -0x60(%rbp,%rdx,8), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0xe4cfe
movq -0xd8(%rbp), %rax
leaq -0x60(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
movq -0xd0(%rbp), %rax
leaq -0x60(%rbp), %rsi
shlq $0x3, %rax
addq %rax, %rsi
callq 0xc75c0
jmp 0xe4d00
movq -0xd8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
jmp 0xe4c9c
jmp 0xe4d16
movq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd0(%rbp)
jmp 0xe4c79
cmpq $0x2, -0x38(%rbp)
jne 0xe4d63
movq -0x18(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
movq -0x18(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
jmp 0xe4e32
cmpq $0x3, -0x38(%rbp)
jne 0xe4dae
movq -0x18(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
movq -0x18(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
movq -0x18(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
jmp 0xe4e30
movq -0x18(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
movq -0x18(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
movq -0x18(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
movq -0x20(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movslq %eax, %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
movl $0x1, %edi
callq 0xe8010
jmp 0xe4e32
jmp 0xe506f
movq -0x30(%rbp), %rdi
movq 0x10(%rbp), %rsi
callq 0xe8350
movb $0x8, -0xd9(%rbp)
movq $0x0, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0xe506d
movq -0x20(%rbp), %rax
movq -0xe8(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xe9(%rbp)
movq $0x1, -0xf8(%rbp)
movq -0xe8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rcx
xorl %eax, %eax
cmpq -0x68(%rbp), %rcx
movb %al, -0x101(%rbp)
jae 0xe4ece
movq -0x20(%rbp), %rax
movq -0x100(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movzbl -0xe9(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x101(%rbp)
movb -0x101(%rbp), %al
testb $0x1, %al
jne 0xe4eda
jmp 0xe4f00
movq -0xf8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xf8(%rbp)
movq -0x100(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x100(%rbp)
jmp 0xe4e98
movq -0xf8(%rbp), %rax
addq -0xe8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movzbl -0xe9(%rbp), %eax
cmpl $0x0, %eax
jne 0xe4f58
movq -0xf8(%rbp), %rcx
leaq 0x710f1(%rip), %rax # 0x156020
movl (%rax,%rcx,4), %eax
movl %eax, %edi
movq -0xf8(%rbp), %rcx
leaq 0x71bde(%rip), %rax # 0x156b20
movq (%rax,%rcx,8), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
jmp 0xe5068
movzbl -0xd9(%rbp), %eax
movzbl -0xe9(%rbp), %ecx
cmpl %ecx, %eax
je 0xe4fb4
movzbl -0xe9(%rbp), %eax
movl %eax, %ecx
leaq 0x731a6(%rip), %rax # 0x158120
movzbl (%rax,%rcx), %eax
movl %eax, %edi
movzbl -0xe9(%rbp), %eax
movl %eax, %ecx
leaq 0x731b0(%rip), %rax # 0x158140
movl (%rax,%rcx,4), %eax
movl %eax, %esi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
movq -0xf8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xf8(%rbp)
cmpq $0x3, -0xf8(%rbp)
jae 0xe5018
jmp 0xe4fc0
cmpq $0x0, -0xf8(%rbp)
je 0xe5016
movq -0xf8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xf8(%rbp)
movzbl -0xe9(%rbp), %eax
movl %eax, %ecx
leaq 0x73134(%rip), %rax # 0x158120
movzbl (%rax,%rcx), %eax
movl %eax, %edi
movzbl -0xe9(%rbp), %eax
movl %eax, %ecx
leaq 0x7313e(%rip), %rax # 0x158140
movl (%rax,%rcx,4), %eax
movl %eax, %esi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
jmp 0xe4fc0
jmp 0xe505c
movq -0xf8(%rbp), %rax
subq $0x3, %rax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rcx
leaq 0x73158(%rip), %rax # 0x158190
movl (%rax,%rcx,4), %eax
movl %eax, %edi
movq -0xf8(%rbp), %rcx
leaq 0x73c45(%rip), %rax # 0x158c90
movq (%rax,%rcx,8), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0xe8010
movb -0xe9(%rbp), %al
movb %al, -0xd9(%rbp)
jmp 0xe4e56
jmp 0xe506f
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
nopl (%rax,%rax)
| /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_t i = 0; i < v.size(); ++i) {
size_t index = IndexOf(mtf, v[i]);
assert(index < mtf.size());
result[i] = static_cast<uint32_t>(index);
MoveToFront(&mtf, index);
}
return result;
} | 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), %rdi
callq 0xe8500
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe8530
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xe84c0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xda8c0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
incl %eax
movq %rax, -0x98(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xc22b0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0xc22d0
jmp 0xe5243
leaq -0x49(%rbp), %rdi
callq 0xc2340
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0xe529f
movl -0x60(%rbp), %eax
movl %eax, -0x9c(%rbp)
movl -0x60(%rbp), %eax
movl %eax, %esi
leaq -0x48(%rbp), %rdi
callq 0xc1fc0
movl -0x9c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0xe5253
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0xc2340
jmp 0xe5403
movb $0x0, -0x61(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc1f30
movq %rax, -0xb0(%rbp)
leaq -0x62(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xc22b0
movq -0x88(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
callq 0xc22d0
jmp 0xe52df
leaq -0x62(%rbp), %rdi
callq 0xc2340
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc1f30
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
jae 0xe53d7
movq -0x10(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xc1e10
movl (%rax), %esi
leaq -0x48(%rbp), %rdi
callq 0xe5080
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc1f30
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jae 0xe5358
jmp 0xe5397
leaq 0x75c01(%rip), %rdi # 0x15af60
leaq 0x75c0d(%rip), %rsi # 0x15af73
movl $0x1ed, %edx # imm = 0x1ED
leaq 0x75c69(%rip), %rcx # 0x15afdb
callq 0x3f2e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x62(%rbp), %rdi
callq 0xc2340
leaq -0x48(%rbp), %rdi
callq 0xc2070
jmp 0xe5403
movq -0x88(%rbp), %rdi
movq -0x78(%rbp), %rax
movl %eax, -0xc4(%rbp)
movq -0x70(%rbp), %rsi
callq 0xc1fc0
movl -0xc4(%rbp), %ecx
movl %ecx, (%rax)
movq -0x78(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xe5100
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xe52f0
movb $0x1, -0x61(%rbp)
testb $0x1, -0x61(%rbp)
jne 0xe53ed
movq -0x88(%rbp), %rdi
callq 0xc2070
leaq -0x48(%rbp), %rdi
callq 0xc2070
movq -0x80(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3fc20
nopl (%rax)
| /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.size() && v_in[i] != 0; ++i) ;
uint32_t reps = 0;
for (; i < v_in.size() && v_in[i] == 0; ++i) {
++reps;
}
max_reps = std::max(reps, max_reps);
}
uint32_t max_prefix = max_reps > 0 ? Log2FloorNonZero(max_reps) : 0;
max_prefix = std::min(max_prefix, *max_run_length_prefix);
*max_run_length_prefix = max_prefix;
for (size_t i = 0; i < v_in.size();) {
if (v_in[i] != 0) {
v_out->push_back(v_in[i] + *max_run_length_prefix);
extra_bits->push_back(0);
++i;
} else {
uint32_t reps = 1;
for (size_t k = i + 1; k < v_in.size() && v_in[k] == 0; ++k) {
++reps;
}
i += reps;
while (reps != 0) {
if (reps < (2u << max_prefix)) {
uint32_t run_length_prefix = Log2FloorNonZero(reps);
v_out->push_back(run_length_prefix);
extra_bits->push_back(reps - (1u << run_length_prefix));
break;
} else {
v_out->push_back(max_prefix);
extra_bits->push_back((1u << max_prefix) - 1u);
reps -= (2u << max_prefix) - 1u;
}
}
}
}
} | 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
jae 0xe5533
jmp 0xe545d
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc1f30
movq -0x80(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x71(%rbp)
jae 0xe5495
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xc1e10
cmpl $0x0, (%rax)
setne %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xe549e
jmp 0xe54ae
jmp 0xe54a0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe545d
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc1f30
movq -0x90(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x81(%rbp)
jae 0xe54f9
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xc1e10
cmpl $0x0, (%rax)
sete %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0xe5505
jmp 0xe551c
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe54b5
leaq -0x34(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xe8560
movl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0xe543a
cmpl $0x0, -0x24(%rbp)
jbe 0xe554b
movl -0x24(%rbp), %eax
movl %eax, %edi
callq 0xe3c60
movl %eax, -0x94(%rbp)
jmp 0xe5555
xorl %eax, %eax
movl %eax, -0x94(%rbp)
jmp 0xe5555
movl -0x94(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xe85a0
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc1f30
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0xe573e
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xc1e10
cmpl $0x0, (%rax)
je 0xe5612
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xc1e10
movq -0xa8(%rbp), %rdi
movl (%rax), %eax
movq -0x10(%rbp), %rcx
addl (%rcx), %eax
movl %eax, -0x44(%rbp)
leaq -0x44(%rbp), %rsi
callq 0xc1f00
movq -0x20(%rbp), %rdi
movl $0x0, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0xc1f00
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xe5739
movl $0x1, -0x4c(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc1f30
movq -0xb8(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0xa9(%rbp)
jae 0xe5669
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xc1e10
cmpl $0x0, (%rax)
sete %al
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0xe5675
jmp 0xe568c
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xe5625
movl -0x4c(%rbp), %eax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0xe5737
movl -0x4c(%rbp), %eax
movl -0x38(%rbp), %ecx
movl $0x2, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jae 0xe56f1
movl -0x4c(%rbp), %eax
movl %eax, %edi
callq 0xe3c60
movl %eax, -0x5c(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0xc1f50
movq -0x20(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl -0x5c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl %ecx, %eax
movl %eax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0xc1f00
jmp 0xe5737
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc1f50
movq -0x20(%rbp), %rdi
movl -0x38(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x64(%rbp)
leaq -0x64(%rbp), %rsi
callq 0xc1f00
movl -0x38(%rbp), %ecx
movl $0x2, %eax
shll %cl, %eax
movl %eax, %ecx
subl $0x1, %ecx
movl -0x4c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4c(%rbp)
jmp 0xe5697
jmp 0xe5739
jmp 0xe5581
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /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 * alphabet_size_;
BuildAndStoreHuffmanTree(&histograms[i].data_[0], alphabet_size_,
&depths_[ix], &bits_[ix],
storage_ix, storage);
}
} | 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
imulq (%rax), %rsi
callq 0xcfff0
movq -0x38(%rbp), %rax
addq $0x110, %rax # imm = 0x110
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe1280
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x38(%rbp), %rax
imulq (%rax), %rsi
callq 0xe8640
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe1280
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0xe8bfc
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
imulq (%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xe1790
movq -0x38(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq (%rdi), %rax
movq %rax, -0x60(%rbp)
addq $0xf8, %rdi
movq -0x30(%rbp), %rsi
callq 0xd0080
movq -0x38(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x110, %rdi # imm = 0x110
movq -0x30(%rbp), %rsi
callq 0xe8230
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
callq 0xe4660
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xe8b5a
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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_len_;
size_t ix = entropy_ix_ + symbol;
WriteBits(depths_[ix], bits_[ix], storage_ix, storage);
} | 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
movq 0xe0(%rax), %rsi
callq 0xc1e10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
movq %rcx, 0xe8(%rax)
movq 0x10(%rax), %rdi
movq 0xe0(%rax), %rsi
callq 0xd02c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movzbl (%rcx), %ecx
imulq (%rax), %rcx
movq %rcx, 0xf0(%rax)
movq %rax, %rdi
addq $0x20, %rdi
movq 0xe0(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xe5ab0
movq -0x30(%rbp), %rdi
movq 0xe8(%rdi), %rax
addq $-0x1, %rax
movq %rax, 0xe8(%rdi)
movq 0xf0(%rdi), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0xf8, %rdi
movq -0x28(%rbp), %rsi
callq 0xd0080
movq -0x30(%rbp), %rdi
movzbl (%rax), %eax
movq %rax, -0x38(%rbp)
addq $0x110, %rdi # imm = 0x110
movq -0x28(%rbp), %rsi
callq 0xe8230
movq -0x38(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xe8010
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| /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 = block_types_[block_ix_];
entropy_ix_ = block_type << kContextBits;
StoreBlockSwitch(block_split_code_, block_ix_, storage_ix, storage);
}
--block_len_;
size_t histo_ix = context_map[entropy_ix_ + context];
size_t ix = histo_ix * alphabet_size_ + symbol;
WriteBits(depths_[ix], bits_[ix], storage_ix, storage);
} | 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
movq %rcx, 0xe0(%rax)
movq 0x18(%rax), %rdi
movq 0xe0(%rax), %rsi
callq 0xc1e10
movq %rax, %rcx
movq -0x50(%rbp), %rax
movl (%rcx), %ecx
movq %rcx, 0xe8(%rax)
movq 0x10(%rax), %rdi
movq 0xe0(%rax), %rsi
callq 0xd02c0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movzbl (%rcx), %ecx
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
shlq $0x6, %rcx
movq %rcx, 0xf0(%rax)
movq %rax, %rdi
addq $0x20, %rdi
movq 0xe0(%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xe5ab0
movq -0x50(%rbp), %rax
movq 0xe8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xe8(%rax)
movq -0x20(%rbp), %rdi
movq 0xf0(%rax), %rsi
addq -0x18(%rbp), %rsi
callq 0xc1e10
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
imulq (%rdi), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0xf8, %rdi
movq -0x48(%rbp), %rsi
callq 0xd0080
movq -0x50(%rbp), %rdi
movzbl (%rax), %eax
movq %rax, -0x58(%rbp)
addq $0x110, %rdi # imm = 0x110
movq -0x48(%rbp), %rsi
callq 0xe8230
movq -0x58(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, %esi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xe8010
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /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 (!yaml_parser_parse(parser, &event))
return NULL;
if (!(event.type == YAML_STREAM_START_EVENT || event.type == YAML_DOCUMENT_START_EVENT))
break;
yaml_event_delete(&event);
}
switch (event.type) {
case YAML_ALIAS_EVENT:
node = yoml__new_node(parse_args->filename, YOML__TYPE_UNRESOLVED_ALIAS, sizeof(*node), NULL, NULL, &event);
node->data.alias = yoml__strdup(event.data.alias.anchor);
break;
case YAML_SCALAR_EVENT:
node = yoml__new_node(parse_args->filename, YOML_TYPE_SCALAR, sizeof(*node), event.data.scalar.anchor, event.data.scalar.tag, &event);
node->data.scalar = yoml__strdup(event.data.scalar.value);
if (parse_args->mem_set != NULL)
parse_args->mem_set(event.data.scalar.value, 'A', strlen(node->data.scalar));
break;
case YAML_SEQUENCE_START_EVENT:
node = yoml__parse_sequence(parser, &event, parse_args);
break;
case YAML_MAPPING_START_EVENT:
node = yoml__parse_mapping(parser, &event, parse_args);
break;
default:
node = NULL;
if (unhandled != NULL)
*unhandled = event.type;
break;
}
yaml_event_delete(&event);
return node;
} | 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 0x10e573
cmpl $0x1, -0x90(%rbp)
je 0x10e400
cmpl $0x3, -0x90(%rbp)
je 0x10e400
jmp 0x10e40e
leaq -0x90(%rbp), %rdi
callq 0x989f0
jmp 0x10e3ca
movl -0x90(%rbp), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x98(%rbp)
subl $0x4, %eax
ja 0x10e542
movq -0x98(%rbp), %rax
leaq 0xaf001(%rip), %rcx # 0x1bd438
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0x3, %esi
movl $0x50, %edx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x90(%rbp), %r9
movq %r8, %rcx
callq 0x10ed00
movq %rax, -0x28(%rbp)
movq -0x88(%rbp), %rdi
callq 0x10ee20
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x10e55f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %r8
xorl %esi, %esi
movl $0x50, %edx
leaq -0x90(%rbp), %r9
callq 0x10ed00
movq %rax, -0x28(%rbp)
movq -0x78(%rbp), %rdi
callq 0x10ee20
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x10e50c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3f780
movq -0xa8(%rbp), %rdi
movq %rax, %rdx
movq -0xa0(%rbp), %rax
movl $0x41, %esi
callq *%rax
jmp 0x10e55f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rsi
callq 0x10ee40
movq %rax, -0x28(%rbp)
jmp 0x10e55f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rsi
callq 0x10ef20
movq %rax, -0x28(%rbp)
jmp 0x10e55f
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10e55d
movl -0x90(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x10e55f
leaq -0x90(%rbp), %rdi
callq 0x989f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
| /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__resolve_merge((*target)->data.sequence.elements + i, parser, parse_args) != 0)
return -1;
}
break;
case YOML_TYPE_MAPPING:
if ((*target)->data.mapping.size != 0) {
i = (*target)->data.mapping.size;
do {
--i;
if (yoml__resolve_merge(&(*target)->data.mapping.elements[i].key, parser, parse_args) != 0)
return -1;
if (yoml__resolve_merge(&(*target)->data.mapping.elements[i].value, parser, parse_args) != 0)
return -1;
if ((*target)->data.mapping.elements[i].key->type == YOML_TYPE_SCALAR &&
strcmp((*target)->data.mapping.elements[i].key->data.scalar, "<<") == 0) {
/* erase the slot (as well as preserving the values) */
yoml_mapping_element_t src = (*target)->data.mapping.elements[i];
memmove((*target)->data.mapping.elements + i, (*target)->data.mapping.elements + i + 1,
((*target)->data.mapping.size - i - 1) * sizeof((*target)->data.mapping.elements[0]));
--(*target)->data.mapping.size;
/* merge */
if (src.value->type == YOML_TYPE_SEQUENCE) {
for (j = 0; j != src.value->data.sequence.size; ++j)
if (yoml__merge(target, i, src.value->data.sequence.elements[j]) != 0) {
MergeError:
if (parser != NULL) {
parser->problem = "value of the merge key MUST be a mapping or a sequence of mappings";
parser->problem_mark.line = src.key->line;
parser->problem_mark.column = src.key->column;
}
return -1;
}
} else {
if (yoml__merge(target, i, src.value) != 0)
goto MergeError;
}
/* cleanup */
yoml_free(src.key, parse_args->mem_set);
yoml_free(src.value, parse_args->mem_set);
}
} while (i != 0);
}
break;
case YOML__TYPE_UNRESOLVED_ALIAS:
assert(!"unreachable");
break;
}
return 0;
} | 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 %rcx, %rax
jmpq *%rax
jmp 0x10ecee
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x38(%rcx), %rax
je 0x10ea55
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10e9b0
cmpl $0x0, %eax
je 0x10ea45
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10ecf5
jmp 0x10ea47
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x10e9fc
jmp 0x10ecee
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x10eccd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10e9b0
cmpl $0x0, %eax
je 0x10eabf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10ecf5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10e9b0
cmpl $0x0, %eax
je 0x10eafb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10ecf5
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x38, %rax
addq $0x8, %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
jne 0x10ecbe
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x38, %rax
addq $0x8, %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq 0x38(%rax), %rdi
leaq 0xae6d9(%rip), %rsi # 0x1bd222
callq 0x40030
cmpl $0x0, %eax
jne 0x10ecbe
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x38, %rax
addq $0x8, %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x38, %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdx
subq -0x28(%rbp), %rdx
subq $0x1, %rdx
shlq $0x4, %rdx
callq 0x3f2d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x38(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x10ec82
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq 0x38(%rcx), %rax
je 0x10ec80
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rdx
callq 0x10f1d0
cmpl $0x0, %eax
je 0x10ec6d
jmp 0x10ec2b
cmpq $0x0, -0x18(%rbp)
je 0x10ec61
movq -0x18(%rbp), %rax
leaq 0xae5e8(%rip), %rcx # 0x1bd225
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10ecf5
jmp 0x10ec6f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x10ebfc
jmp 0x10ec9c
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x10f1d0
cmpl $0x0, %eax
je 0x10ec9a
jmp 0x10ec2b
jmp 0x10ec9c
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10e200
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10e200
jmp 0x10ecc0
cmpq $0x0, -0x28(%rbp)
jne 0x10ea7b
jmp 0x10eccd
jmp 0x10ecee
leaq 0x284ce(%rip), %rdi # 0x1371a4
leaq 0xae58b(%rip), %rsi # 0x1bd268
movl $0x10c, %edx # imm = 0x10C
leaq 0xae5da(%rip), %rcx # 0x1bd2c3
callq 0x3f2e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| /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_start.tag, event);
map->data.mapping.size = 0;
while (1) {
yoml_t *key, *value;
yaml_event_type_t unhandled;
if ((key = yoml__parse_node(parser, &unhandled, parse_args)) == NULL) {
if (unhandled == YAML_MAPPING_END_EVENT) {
break;
} else {
yoml_free(map, parse_args->mem_set);
map = NULL;
break;
}
}
if ((value = yoml__parse_node(parser, NULL, parse_args)) == NULL) {
yoml_free(map, parse_args->mem_set);
map = NULL;
break;
}
map = realloc(map, offsetof(yoml_t, data.mapping.elements) + sizeof(yoml_mapping_element_t) * (map->data.mapping.size + 1));
map->data.mapping.elements[map->data.mapping.size].key = key;
map->data.mapping.elements[map->data.mapping.size].value = value;
++map->data.mapping.size;
}
return map;
} | 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, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x34(%rbp), %rsi
callq 0x10e3a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x10efb2
cmpl $0xa, -0x34(%rbp)
jne 0x10ef94
jmp 0x10f063
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10e200
movq $0x0, -0x20(%rbp)
jmp 0x10f063
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x10e3a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x10efe8
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10e200
movq $0x0, -0x20(%rbp)
jmp 0x10f063
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rsi
addq $0x1, %rsi
shlq $0x4, %rsi
addq $0x40, %rsi
callq 0x3f1e0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
addq $0x38, %rax
addq $0x8, %rax
movq -0x20(%rbp), %rdx
movq 0x38(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
addq $0x38, %rax
addq $0x8, %rax
movq -0x20(%rbp), %rdx
movq 0x38(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
jmp 0x10ef6e
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%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);
if (!g_rng_function) {
return 0;
}
for (tries = 0; tries < uECC_RNG_MAX_TRIES; ++tries) {
if (!g_rng_function((uint8_t *)random, num_words * uECC_WORD_SIZE)) {
return 0;
}
random[num_words - 1] &= mask >> ((bitcount_t)(num_words * uECC_WORD_SIZE * 8 - num_bits));
if (!uECC_vli_isZero(random, num_words) &&
uECC_vli_cmp(top, random, num_words) == 1) {
return 1;
}
}
return 0;
} | 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 0x1102fd
movq $0x0, -0x30(%rbp)
cmpq $0x40, -0x30(%rbp)
jae 0x1102f6
movq 0xdf45a(%rip), %rax # 0x1ef6b8
movq -0x10(%rbp), %rdi
movsbl -0x19(%rbp), %esi
shll $0x3, %esi
callq *%rax
cmpl $0x0, %eax
jne 0x11027c
movl $0x0, -0x4(%rbp)
jmp 0x1102fd
movq -0x28(%rbp), %rdx
movsbl -0x19(%rbp), %eax
shll $0x3, %eax
shll $0x3, %eax
movswl -0x32(%rbp), %ecx
subl %ecx, %eax
cwtl
movl %eax, %eax
movl %eax, %ecx
shrq %cl, %rdx
movq -0x10(%rbp), %rax
movsbl -0x19(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x110b70
cmpq $0x0, %rax
jne 0x1102e3
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsbl -0x19(%rbp), %edx
callq 0x111190
movsbl %al, %eax
cmpl $0x1, %eax
jne 0x1102e3
movl $0x1, -0x4(%rbp)
jmp 0x1102fd
jmp 0x1102e5
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x11024c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /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_bytes);
uECC_vli_bytesToNative(
_public + curve->num_words, public_key + curve->num_bytes, curve->num_bytes);
#endif
return uECC_valid_point(_public, curve);
} | 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
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cltq
addq %rax, %rsi
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %edx
callq 0x110610
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x110df0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /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) {
digit >>= 1;
}
return (((bitcount_t)(num_digits - 1) << uECC_WORD_BITS_SHIFT) + 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), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1129c1
movq -0x28(%rbp), %rax
shrq %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1129a1
movsbl -0x29(%rbp), %eax
subl $0x1, %eax
cwtl
shll $0x6, %eax
cltq
addq -0x20(%rbp), %rax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
| /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;
/* Compute each digit of result in sequence, maintaining the carries. */
for (k = 0; k < num_words; ++k) {
for (i = 0; i <= k; ++i) {
muladd(left[i], right[k - i], &r0, &r1, &r2);
}
result[k] = r0;
r0 = r1;
r1 = r2;
r2 = 0;
}
for (k = num_words; k < num_words * 2 - 1; ++k) {
for (i = (k + 1) - num_words; i < num_words; ++i) {
muladd(left[i], right[k - i], &r0, &r1, &r2);
}
result[k] = r0;
r0 = r1;
r1 = r2;
r2 = 0;
}
result[num_words * 2 - 1] = r0;
} | 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
movb $0x0, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
movsbl -0x3a(%rbp), %ecx
cmpl %ecx, %eax
jg 0x114a62
movq -0x10(%rbp), %rax
movsbq -0x39(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movsbl -0x3a(%rbp), %ecx
movsbl -0x39(%rbp), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x114560
movb -0x39(%rbp), %al
addb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x114a19
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movsbq -0x3a(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movb -0x3a(%rbp), %al
addb $0x1, %al
movb %al, -0x3a(%rbp)
jmp 0x114a05
movb -0x19(%rbp), %al
movb %al, -0x3a(%rbp)
movsbl -0x3a(%rbp), %eax
movsbl -0x19(%rbp), %ecx
shll %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x114b42
movsbl -0x3a(%rbp), %eax
addl $0x1, %eax
movsbl -0x19(%rbp), %ecx
subl %ecx, %eax
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jge 0x114b0c
movq -0x10(%rbp), %rax
movsbq -0x39(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movsbl -0x3a(%rbp), %ecx
movsbl -0x39(%rbp), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x114560
movb -0x39(%rbp), %al
addb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x114ac3
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movsbq -0x3a(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movb -0x3a(%rbp), %al
addb $0x1, %al
movb %al, -0x3a(%rbp)
jmp 0x114a9e
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movsbl -0x19(%rbp), %ecx
shll %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
| /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_word_t *v[2] = {tmp, product};
uECC_word_t index;
/* Shift mod so its highest set bit is at the maximum position. */
bitcount_t shift = (num_words * 2 * uECC_WORD_BITS) - uECC_vli_numBits(mod, num_words);
wordcount_t word_shift = shift / uECC_WORD_BITS;
wordcount_t bit_shift = shift % uECC_WORD_BITS;
uECC_word_t carry = 0;
uECC_vli_clear(mod_multiple, word_shift);
if (bit_shift > 0) {
for(index = 0; index < (uECC_word_t)num_words; ++index) {
mod_multiple[word_shift + index] = (mod[index] << bit_shift) | carry;
carry = mod[index] >> (uECC_WORD_BITS - bit_shift);
}
} else {
uECC_vli_set(mod_multiple + word_shift, mod, num_words);
}
for (index = 1; shift >= 0; --shift) {
uECC_word_t borrow = 0;
wordcount_t i;
for (i = 0; i < num_words * 2; ++i) {
uECC_word_t diff = v[index][i] - mod_multiple[i] - borrow;
if (diff != v[index][i]) {
borrow = (diff > v[index][i]);
}
v[1 - index][i] = diff;
}
index = !(index ^ borrow); /* Swap the index if there was no borrow */
uECC_vli_rshift1(mod_multiple, num_words);
mod_multiple[num_words - 1] |= mod_multiple[num_words] << (uECC_WORD_BITS - 1);
uECC_vli_rshift1(mod_multiple + num_words, num_words);
}
uECC_vli_set(result, v[index], num_words);
} | 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 -0x18(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x112950
movw %ax, %cx
movl -0xe4(%rbp), %eax
movswl %cx, %ecx
subl %ecx, %eax
movw %ax, -0xba(%rbp)
movswl -0xba(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movb %al, -0xbb(%rbp)
movswl -0xba(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0xbc(%rbp)
movq $0x0, -0xc8(%rbp)
leaq -0x60(%rbp), %rdi
movsbl -0xbb(%rbp), %esi
callq 0x112a20
movsbl -0xbc(%rbp), %eax
cmpl $0x0, %eax
jle 0x114cb4
movq $0x0, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movsbq -0x19(%rbp), %rcx
cmpq %rcx, %rax
jae 0x114cb2
movq -0x18(%rbp), %rax
movq -0xb8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl -0xbc(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
orq -0xc8(%rbp), %rcx
movsbq -0xbb(%rbp), %rax
addq -0xb8(%rbp), %rax
movq %rcx, -0x60(%rbp,%rax,8)
movq -0x18(%rbp), %rax
movq -0xb8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl -0xbc(%rbp), %edx
movl $0x40, %ecx
subl %edx, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0xc8(%rbp)
movq -0xb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb8(%rbp)
jmp 0x114c28
jmp 0x114cd5
leaq -0x60(%rbp), %rdi
movsbl -0xbb(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movsbl -0x19(%rbp), %edx
callq 0x112660
movq $0x1, -0xb8(%rbp)
movswl -0xba(%rbp), %eax
cmpl $0x0, %eax
jl 0x114e62
movq $0x0, -0xd0(%rbp)
movb $0x0, -0xd1(%rbp)
movsbl -0xd1(%rbp), %eax
movsbl -0x19(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x114dde
movq -0xb8(%rbp), %rax
movq -0xb0(%rbp,%rax,8), %rax
movsbq -0xd1(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0xd1(%rbp), %rcx
subq -0x60(%rbp,%rcx,8), %rax
subq -0xd0(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rax
movq -0xb8(%rbp), %rcx
movq -0xb0(%rbp,%rcx,8), %rcx
movsbq -0xd1(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x114da4
movq -0xe0(%rbp), %rax
movq -0xb8(%rbp), %rcx
movq -0xb0(%rbp,%rcx,8), %rcx
movsbq -0xd1(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0xd0(%rbp)
movq -0xe0(%rbp), %rdx
movl $0x1, %eax
subq -0xb8(%rbp), %rax
movq -0xb0(%rbp,%rax,8), %rax
movsbq -0xd1(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movb -0xd1(%rbp), %al
addb $0x1, %al
movb %al, -0xd1(%rbp)
jmp 0x114d02
movq -0xb8(%rbp), %rax
xorq -0xd0(%rbp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0xb8(%rbp)
leaq -0x60(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x113220
movsbq -0x19(%rbp), %rax
movq -0x60(%rbp,%rax,8), %rcx
shlq $0x3f, %rcx
movsbl -0x19(%rbp), %eax
subl $0x1, %eax
cltq
orq -0x60(%rbp,%rax,8), %rcx
movq %rcx, -0x60(%rbp,%rax,8)
leaq -0x60(%rbp), %rdi
movsbl -0x19(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdi
movsbl -0x19(%rbp), %esi
callq 0x113220
movw -0xba(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0xba(%rbp)
jmp 0x114ce0
movq -0x8(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq -0xb0(%rbp,%rax,8), %rsi
movsbl -0x19(%rbp), %edx
callq 0x112660
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /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
return word4(a, b, c, d);
} | 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)
movl -0x4(%rbp), %eax
shrl $0x0, %eax
andl $0xff, %eax
movb %al, -0x14(%rbp)
movq -0x10(%rbp), %r8
leaq -0x11(%rbp), %rdi
leaq -0x12(%rbp), %rsi
leaq -0x13(%rbp), %rdx
leaq -0x14(%rbp), %rcx
movl $0x100, %r9d # imm = 0x100
callq 0x115b30
movzbl -0x11(%rbp), %eax
shll $0x18, %eax
movzbl -0x12(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl -0x13(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl -0x14(%rbp), %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /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(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
shrq $0x28, %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 $0x20, %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 $0x18, %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 $0x10, %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 $0x8, %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
andq $0xff, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
| /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. */
uint32_t negative_mask = mask_u32(xsub[16] & 0x80, 0x80);
uint32_t positive_mask = negative_mask ^ 0xffffffff;
for (i = 0; i < 17; i++)
x[i] = (x[i] & negative_mask) | (xsub[i] & positive_mask);
} | 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 0x11a864
leaq -0x50(%rbp), %rdi
leaq 0xa38c9(%rip), %rsi # 0x1be160
callq 0x11a910
movl -0x10(%rbp), %edi
andl $0x80, %edi
movl $0x80, %esi
callq 0x11abd0
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
cmpq $0x11, -0x58(%rbp)
jae 0x11a8fe
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movl (%rax,%rcx,4), %edx
andl -0x5c(%rbp), %edx
movq -0x58(%rbp), %rax
movl -0x50(%rbp,%rax,4), %eax
andl -0x60(%rbp), %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x11a8c3
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /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->H[7],
Wt;
for (size_t t = 0; t < 80; t++)
{
if (t < 16)
{
W[t] = Wt = read64_be(inp);
inp += 8;
} else {
Wt = SSIG1(W[(t - 2) % 16]) +
W[(t - 7) % 16] +
SSIG0(W[(t - 15) % 16]) +
W[(t - 16) % 16];
W[t % 16] = Wt;
}
uint64_t T1 = h + BSIG1(e) + CH(e, f, g) + K[t] + Wt;
uint64_t T2 = BSIG0(a) + MAJ(a, b, c);
h = g;
g = f;
f = e;
e = d + T1;
d = c;
c = b;
b = a;
a = T1 + T2;
}
ctx->H[0] += a;
ctx->H[1] += b;
ctx->H[2] += c;
ctx->H[3] += d;
ctx->H[4] += e;
ctx->H[5] += f;
ctx->H[6] += g;
ctx->H[7] += h;
ctx->blocks++;
} | 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 0x10(%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xd8(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0xe0(%rbp)
movq $0x0, -0xf0(%rbp)
cmpq $0x50, -0xf0(%rbp)
jae 0x11bb53
cmpq $0x10, -0xf0(%rbp)
jae 0x11b828
movq -0x10(%rbp), %rdi
callq 0x11bfd0
movq %rax, %rcx
movq %rcx, -0xe8(%rbp)
movq -0xf0(%rbp), %rax
movq %rcx, -0xa0(%rbp,%rax,8)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x11b970
movq -0xf0(%rbp), %rax
subq $0x2, %rax
andq $0xf, %rax
movq -0xa0(%rbp,%rax,8), %rdi
movl $0x13, %esi
callq 0x11c010
movq %rax, -0x118(%rbp)
movq -0xf0(%rbp), %rax
subq $0x2, %rax
andq $0xf, %rax
movq -0xa0(%rbp,%rax,8), %rdi
movl $0x3d, %esi
callq 0x11c010
movq %rax, %rcx
movq -0x118(%rbp), %rax
xorq %rcx, %rax
movq -0xf0(%rbp), %rcx
subq $0x2, %rcx
andq $0xf, %rcx
movq -0xa0(%rbp,%rcx,8), %rcx
shrq $0x6, %rcx
xorq %rcx, %rax
movq -0xf0(%rbp), %rcx
subq $0x7, %rcx
andq $0xf, %rcx
addq -0xa0(%rbp,%rcx,8), %rax
movq %rax, -0x108(%rbp)
movq -0xf0(%rbp), %rax
subq $0xf, %rax
andq $0xf, %rax
movq -0xa0(%rbp,%rax,8), %rdi
movl $0x1, %esi
callq 0x11c010
movq %rax, -0x110(%rbp)
movq -0xf0(%rbp), %rax
subq $0xf, %rax
andq $0xf, %rax
movq -0xa0(%rbp,%rax,8), %rdi
movl $0x8, %esi
callq 0x11c010
movq -0x110(%rbp), %rcx
movq %rax, %rdx
movq -0x108(%rbp), %rax
xorq %rdx, %rcx
movq -0xf0(%rbp), %rdx
subq $0xf, %rdx
andq $0xf, %rdx
movq -0xa0(%rbp,%rdx,8), %rdx
shrq $0x7, %rdx
xorq %rdx, %rcx
addq %rcx, %rax
movq -0xf0(%rbp), %rcx
subq $0x10, %rcx
andq $0xf, %rcx
addq -0xa0(%rbp,%rcx,8), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rcx
movq -0xf0(%rbp), %rax
andq $0xf, %rax
movq %rcx, -0xa0(%rbp,%rax,8)
movq -0xe0(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0xc8(%rbp), %rdi
movl $0xe, %esi
callq 0x11c010
movq %rax, -0x140(%rbp)
movq -0xc8(%rbp), %rdi
movl $0x12, %esi
callq 0x11c010
movq %rax, %rcx
movq -0x140(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x138(%rbp)
movq -0xc8(%rbp), %rdi
movl $0x29, %esi
callq 0x11c010
movq -0x138(%rbp), %rcx
movq %rax, %rdx
movq -0x130(%rbp), %rax
xorq %rdx, %rcx
addq %rcx, %rax
movq -0xc8(%rbp), %rcx
andq -0xd0(%rbp), %rcx
movq -0xc8(%rbp), %rdx
xorq $-0x1, %rdx
andq -0xd8(%rbp), %rdx
xorq %rdx, %rcx
addq %rcx, %rax
movq -0xf0(%rbp), %rdx
leaq 0xa2899(%rip), %rcx # 0x1be2b0
addq (%rcx,%rdx,8), %rax
addq -0xe8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0xa8(%rbp), %rdi
movl $0x1c, %esi
callq 0x11c010
movq %rax, -0x128(%rbp)
movq -0xa8(%rbp), %rdi
movl $0x22, %esi
callq 0x11c010
movq %rax, %rcx
movq -0x128(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x120(%rbp)
movq -0xa8(%rbp), %rdi
movl $0x27, %esi
callq 0x11c010
movq %rax, %rcx
movq -0x120(%rbp), %rax
xorq %rcx, %rax
movq -0xa8(%rbp), %rcx
andq -0xb0(%rbp), %rcx
movq -0xa8(%rbp), %rdx
andq -0xb8(%rbp), %rdx
xorq %rdx, %rcx
movq -0xb0(%rbp), %rdx
andq -0xb8(%rbp), %rdx
xorq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x100(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
addq -0xf8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xf8(%rbp), %rax
addq -0x100(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xf0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xf0(%rbp)
jmp 0x11b7dd
movq -0xa8(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0xb0(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0xb8(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0xc0(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0xc8(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0xd0(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0xd8(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0xe0(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movl 0xc0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc0(%rax)
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /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_size);
free(slot);
} | 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)
cmpq $0x0, -0x18(%rbp)
jne 0x11cff6
jmp 0x11d048
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x11d003
jmp 0x11d022
leaq 0xa1984(%rip), %rdi # 0x1be98e
leaq 0xa171e(%rip), %rsi # 0x1be72f
movl $0x360, %edx # imm = 0x360
leaq 0xa198b(%rip), %rcx # 0x1be9a8
callq 0x3f2e0
movq 0xd26a7(%rip), %rax # 0x1ef6d0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq 0x50(%rcx), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq -0x18(%rbp), %rdi
callq 0x3f330
addq $0x20, %rsp
popq %rbp
retq
nop
| /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)) != 0)
return ret;
assert(rec.fragment != NULL);
/* decrypt the record */
if (rec.type == PTLS_CONTENT_TYPE_CHANGE_CIPHER_SPEC) {
if (tls->state < PTLS_STATE_POST_HANDSHAKE_MIN) {
if (!(rec.length == 1 && rec.fragment[0] == 0x01))
return PTLS_ALERT_ILLEGAL_PARAMETER;
} else {
return PTLS_ALERT_HANDSHAKE_FAILURE;
}
ret = PTLS_ERROR_IN_PROGRESS;
goto NextRecord;
}
if (tls->traffic_protection.dec.aead != NULL && rec.type != PTLS_CONTENT_TYPE_ALERT) {
if (rec.type != PTLS_CONTENT_TYPE_APPDATA)
return PTLS_ALERT_HANDSHAKE_FAILURE;
if ((ret = ptls_buffer_reserve(decryptbuf, 5 + rec.length)) != 0)
return ret;
if ((ret = aead_decrypt(&tls->traffic_protection.dec, decryptbuf->base + decryptbuf->off, &rec.length, rec.fragment,
rec.length)) != 0) {
if (tls->skip_early_data) {
ret = PTLS_ERROR_IN_PROGRESS;
goto NextRecord;
}
return ret;
}
rec.fragment = decryptbuf->base + decryptbuf->off;
/* skip padding */
for (; rec.length != 0; --rec.length)
if (rec.fragment[rec.length - 1] != 0)
break;
if (rec.length == 0)
return PTLS_ALERT_UNEXPECTED_MESSAGE;
rec.type = rec.fragment[--rec.length];
} else if (rec.type == PTLS_CONTENT_TYPE_APPDATA && tls->skip_early_data) {
ret = PTLS_ERROR_IN_PROGRESS;
goto NextRecord;
}
if (tls->recvbuf.mess.base != NULL || rec.type == PTLS_CONTENT_TYPE_HANDSHAKE) {
/* handshake record */
ret = handle_handshake_record(tls, handle_handshake_message, sendbuf, &rec, properties);
} else {
/* handling of an alert or an application record */
switch (rec.type) {
case PTLS_CONTENT_TYPE_APPDATA:
if (tls->state >= PTLS_STATE_POST_HANDSHAKE_MIN) {
decryptbuf->off += rec.length;
ret = 0;
} else if (tls->state == PTLS_STATE_SERVER_EXPECT_END_OF_EARLY_DATA) {
if (tls->traffic_protection.dec.aead != NULL)
decryptbuf->off += rec.length;
ret = 0;
} else {
ret = PTLS_ALERT_UNEXPECTED_MESSAGE;
}
break;
case PTLS_CONTENT_TYPE_ALERT:
ret = handle_alert(tls, rec.fragment, rec.length);
break;
default:
ret = PTLS_ALERT_UNEXPECTED_MESSAGE;
break;
}
}
NextRecord:
ptls_buffer_dispose(&tls->recvbuf.rec);
return ret;
} | 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, %eax
je 0x11fcb8
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11ff67
cmpq $0x0, -0x40(%rbp)
je 0x11fcc1
jmp 0x11fce0
leaq 0x9ed99(%rip), %rdi # 0x1bea61
leaq 0x9ea60(%rip), %rsi # 0x1be72f
movl $0xce7, %edx # imm = 0xCE7
leaq 0x9ed9b(%rip), %rcx # 0x1bea76
callq 0x3f2e0
movzbl -0x50(%rbp), %eax
cmpl $0x14, %eax
jne 0x11fd2c
movq -0x10(%rbp), %rax
cmpl $0xb, 0x8(%rax)
jae 0x11fd14
cmpq $0x1, -0x48(%rbp)
jne 0x11fd06
movq -0x40(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x11fd12
movl $0x2f, -0x4(%rbp)
jmp 0x11ff67
jmp 0x11fd20
movl $0x28, -0x4(%rbp)
jmp 0x11ff67
movl $0x202, -0x54(%rbp) # imm = 0x202
jmp 0x11ff54
movq -0x10(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x11fe56
movzbl -0x50(%rbp), %eax
cmpl $0x15, %eax
je 0x11fe56
movzbl -0x50(%rbp), %eax
cmpl $0x17, %eax
je 0x11fd60
movl $0x28, -0x4(%rbp)
jmp 0x11ff67
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x5, %rsi
callq 0x11c0c0
movl %eax, -0x54(%rbp)
cmpl $0x0, %eax
je 0x11fd84
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11ff67
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
addq 0x10(%rax), %rsi
leaq -0x50(%rbp), %rdx
addq $0x8, %rdx
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
callq 0x123640
movl %eax, -0x54(%rbp)
cmpl $0x0, %eax
je 0x11fde6
movq -0x10(%rbp), %rax
movb 0x138(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x11fddb
movl $0x202, -0x54(%rbp) # imm = 0x202
jmp 0x11ff54
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11ff67
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x11fe27
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x11fe17
jmp 0x11fe27
jmp 0x11fe19
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x11fdf9
cmpq $0x0, -0x48(%rbp)
jne 0x11fe3a
movl $0xa, -0x4(%rbp)
jmp 0x11ff67
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x48(%rbp)
movb -0x1(%rax,%rcx), %al
movb %al, -0x50(%rbp)
jmp 0x11fe84
movzbl -0x50(%rbp), %eax
cmpl $0x17, %eax
jne 0x11fe82
movq -0x10(%rbp), %rax
movb 0x138(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x11fe82
movl $0x202, -0x54(%rbp) # imm = 0x202
jmp 0x11ff54
jmp 0x11fe84
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x11fe98
movzbl -0x50(%rbp), %eax
cmpl $0x16, %eax
jne 0x11febc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %r8
leaq 0x3ae5(%rip), %rsi # 0x123990
leaq -0x50(%rbp), %rcx
callq 0x1236d0
movl %eax, -0x54(%rbp)
jmp 0x11ff52
movzbl -0x50(%rbp), %eax
movl %eax, -0x58(%rbp)
subl $0x15, %eax
je 0x11ff33
jmp 0x11feca
movl -0x58(%rbp), %eax
subl $0x17, %eax
jne 0x11ff49
jmp 0x11fed4
movq -0x10(%rbp), %rax
cmpl $0xb, 0x8(%rax)
jb 0x11fef7
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x54(%rbp)
jmp 0x11ff31
movq -0x10(%rbp), %rax
cmpl $0x9, 0x8(%rax)
jne 0x11ff28
movq -0x10(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x11ff1f
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x54(%rbp)
jmp 0x11ff2f
movl $0xa, -0x54(%rbp)
jmp 0x11ff31
jmp 0x11ff50
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x123bc0
movl %eax, -0x54(%rbp)
jmp 0x11ff50
movl $0xa, -0x54(%rbp)
jmp 0x11ff52
jmp 0x11ff54
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x11cf50
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
| /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_label_buf, sizeof(hkdf_label_buf));
ptls_buffer_push16(&hkdf_label, (uint16_t)outlen);
ptls_buffer_push_block(&hkdf_label, 1, {
if (base_label == NULL)
base_label = "tls13 ";
ptls_buffer_pushv(&hkdf_label, base_label, strlen(base_label));
ptls_buffer_pushv(&hkdf_label, label, strlen(label));
});
ptls_buffer_push_block(&hkdf_label, 1, { ptls_buffer_pushv(&hkdf_label, hash_value.base, hash_value.len); });
ret = ptls_hkdf_expand(algo, output, outlen, secret, ptls_iovec_init(hkdf_label.base, hkdf_label.off));
Exit:
ptls_buffer_dispose(&hkdf_label);
return ret;
} | 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
movl $0x200, %edx # imm = 0x200
callq 0x11fc00
movq -0x28(%rbp), %rax
movw %ax, -0x256(%rbp)
movzwl -0x256(%rbp), %eax
sarl $0x8, %eax
movb %al, -0x258(%rbp)
movw -0x256(%rbp), %ax
movb %al, -0x257(%rbp)
leaq -0x258(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x2, %edx
callq 0x11c1c0
movl %eax, -0x254(%rbp)
cmpl $0x0, %eax
je 0x120984
jmp 0x120c06
jmp 0x120986
jmp 0x120988
jmp 0x12098a
movq $0x1, -0x260(%rbp)
movq -0x260(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq 0x9e94a(%rip), %rsi # 0x1bf2f1
callq 0x11c1c0
movl %eax, -0x254(%rbp)
cmpl $0x0, %eax
je 0x1209bc
jmp 0x120c06
jmp 0x1209be
movq -0x40(%rbp), %rax
movq %rax, -0x268(%rbp)
cmpq $0x0, 0x20(%rbp)
jne 0x1209db
leaq 0x9dfb0(%rip), %rax # 0x1be987
movq %rax, 0x20(%rbp)
jmp 0x1209dd
movq 0x20(%rbp), %rax
movq %rax, -0x2a8(%rbp)
movq 0x20(%rbp), %rdi
callq 0x3f780
movq -0x2a8(%rbp), %rsi
movq %rax, %rdx
leaq -0x50(%rbp), %rdi
callq 0x11c1c0
movl %eax, -0x254(%rbp)
cmpl $0x0, %eax
je 0x120a14
jmp 0x120c06
jmp 0x120a16
jmp 0x120a18
movq -0x30(%rbp), %rax
movq %rax, -0x2b0(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3f780
movq -0x2b0(%rbp), %rsi
movq %rax, %rdx
leaq -0x50(%rbp), %rdi
callq 0x11c1c0
movl %eax, -0x254(%rbp)
cmpl $0x0, %eax
je 0x120a4f
jmp 0x120c06
jmp 0x120a51
jmp 0x120a53
movq -0x40(%rbp), %rax
subq -0x268(%rbp), %rax
movq %rax, -0x270(%rbp)
cmpq $0x0, -0x260(%rbp)
je 0x120ab3
movq -0x270(%rbp), %rax
movq -0x260(%rbp), %rcx
subq $0x1, %rcx
shlq $0x3, %rcx
shrq %cl, %rax
movb %al, %dl
movq -0x50(%rbp), %rax
movq -0x268(%rbp), %rcx
subq -0x260(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x260(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x260(%rbp)
jmp 0x120a65
jmp 0x120ab5
jmp 0x120ab7
movq $0x1, -0x278(%rbp)
movq -0x278(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq 0x9e81d(%rip), %rsi # 0x1bf2f1
callq 0x11c1c0
movl %eax, -0x254(%rbp)
cmpl $0x0, %eax
je 0x120ae9
jmp 0x120c06
jmp 0x120aeb
movq -0x40(%rbp), %rax
movq %rax, -0x280(%rbp)
jmp 0x120af8
movq -0x2a0(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rdi
callq 0x11c1c0
movl %eax, -0x254(%rbp)
cmpl $0x0, %eax
je 0x120b1f
jmp 0x120c06
jmp 0x120b21
jmp 0x120b23
movq -0x40(%rbp), %rax
subq -0x280(%rbp), %rax
movq %rax, -0x288(%rbp)
cmpq $0x0, -0x278(%rbp)
je 0x120b83
movq -0x288(%rbp), %rax
movq -0x278(%rbp), %rcx
subq $0x1, %rcx
shlq $0x3, %rcx
shrq %cl, %rax
movb %al, %dl
movq -0x50(%rbp), %rax
movq -0x280(%rbp), %rcx
subq -0x278(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x278(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x278(%rbp)
jmp 0x120b35
jmp 0x120b85
movq -0x18(%rbp), %rax
movq %rax, -0x2c8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x2c0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x2b8(%rbp)
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x11cb60
movq -0x2c8(%rbp), %rdi
movq -0x2c0(%rbp), %rsi
movq %rax, %rcx
movq %rdx, %rax
movq -0x2b8(%rbp), %rdx
movq %rcx, -0x298(%rbp)
movq %rax, -0x290(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %r8
leaq -0x298(%rbp), %rax
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x121010
movl %eax, -0x254(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x11cf50
movl -0x254(%rbp), %eax
addq $0x2e0, %rsp # imm = 0x2E0
popq %rbp
retq
nop
| /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_update, hmac_final}, algo};
if ((ctx->hash = algo->create()) == NULL) {
free(ctx);
return NULL;
}
memset(ctx->key, 0, algo->block_size);
memcpy(ctx->key, key, key_size);
hmac_apply_key(ctx, 0x36);
return &ctx->super;
} | 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)
leaq 0xc6(%rip), %rax # 0x120d30
movq %rax, -0x58(%rbp)
leaq 0xfb(%rip), %rax # 0x120d70
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x58(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x3f5b0
movq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x30, %edx
callq 0x3f180
movq -0x10(%rbp), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x120cdf
movq -0x28(%rbp), %rdi
callq 0x3f330
movq $0x0, -0x8(%rbp)
jmp 0x120d20
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
xorl %esi, %esi
callq 0x3f5b0
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3f180
movq -0x28(%rbp), %rdi
movl $0x36, %esi
callq 0x120ea0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /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_HASH_FINAL_MODE_RESET);
hmac_apply_key(ctx, 0x5c);
ctx->hash->update(ctx->hash, md, ctx->algo->digest_size);
}
ctx->hash->final(ctx->hash, md, mode);
switch (mode) {
case PTLS_HASH_FINAL_MODE_FREE:
ptls_clear_memory(ctx->key, ctx->algo->block_size);
free(ctx);
break;
case PTLS_HASH_FINAL_MODE_RESET:
hmac_apply_key(ctx, 0x36);
break;
default:
assert(!"FIXME");
break;
}
} | 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 = 0xDDC
leaq 0x9e4fd(%rip), %rcx # 0x1bf2aa
callq 0x3f2e0
cmpq $0x0, -0x10(%rbp)
je 0x120e0b
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movq -0x20(%rbp), %rdi
movl $0x5c, %esi
callq 0x120ea0
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rdi), %rax
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x120e36
jmp 0x120e2c
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x120e5d
jmp 0x120e6d
movq 0xce893(%rip), %rax # 0x1ef6d0
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rsi
callq *%rax
movq -0x20(%rbp), %rdi
callq 0x3f330
jmp 0x120e8c
movq -0x20(%rbp), %rdi
movl $0x36, %esi
callq 0x120ea0
jmp 0x120e8c
leaq 0x14311(%rip), %rdi # 0x135185
leaq 0x9d8b4(%rip), %rsi # 0x1be72f
movl $0xdee, %edx # imm = 0xDEE
leaq 0x9e423(%rip), %rcx # 0x1bf2aa
callq 0x3f2e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /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 = ptls_hmac_create(algo, prk.base, prk.len)) == NULL)
return PTLS_ERROR_NO_MEMORY;
} else {
hmac->update(hmac, digest, algo->digest_size);
}
hmac->update(hmac, info.base, info.len);
uint8_t gen = (uint8_t)(i + 1);
hmac->update(hmac, &gen, 1);
hmac->final(hmac, digest, 1);
size_t off_start = i * algo->digest_size, off_end = off_start + algo->digest_size;
if (off_end > outlen)
off_end = outlen;
memcpy((uint8_t *)output + off_start, digest, off_end - off_start);
}
if (hmac != NULL)
hmac->final(hmac, NULL, PTLS_HASH_FINAL_MODE_FREE);
ptls_clear_memory(digest, algo->digest_size);
return 0;
} | 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
cmpq -0x30(%rbp), %rax
jae 0x121178
cmpq $0x0, -0x38(%rbp)
jne 0x121091
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x120c20
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x12108f
movl $0x201, -0x4(%rbp) # imm = 0x201
jmp 0x1211af
jmp 0x1210aa
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
movq -0xa0(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rdi
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
callq *%rax
movq -0x40(%rbp), %rax
addq $0x1, %rax
movb %al, -0x81(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rdi
leaq -0x81(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
imulq 0x8(%rcx), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq -0x20(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x121145
movq -0x30(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x28(%rbp), %rdi
addq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq -0x98(%rbp), %rdx
subq -0x90(%rbp), %rdx
callq 0x3f180
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x12104a
cmpq $0x0, -0x38(%rbp)
je 0x121193
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
callq *%rax
movq 0xce536(%rip), %rax # 0x1ef6d0
leaq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /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((double)poller->size));
for (size_t i = 0; (i < poller->size); ++i) {
green_future_t f = poller->futures[i];
if (i == 0) {
fprintf(stderr, " --busy--\n");
}
if (i == poller->busy) {
fprintf(stderr, " --done--\n");
}
if (i == poller->used) {
fprintf(stderr, " --free--\n");
}
if (f) {
fprintf(stderr, " %*zu => (%*d) %p (%s)\n",
w, i, w, f->slot, f, states[f->state]);
}
else {
fprintf(stderr, " %*zu => null\n", w, i);
}
}
fprintf(stderr, " --------\n");
} | 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
unpcklps 0x10a1(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x10a9(%rip), %xmm1 # 0x4160
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x2080
callq 0x20e0
cvttsd2si %xmm0, %ebp
pushq $0x1
popq %r12
xorl %r13d, %r13d
cmpq 0x20(%rbx), %r13
jae 0x3191
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %r15
testq %r13, %r13
jne 0x3104
movq (%r14), %rcx
leaq 0x1496(%rip), %rdi # 0x458f
pushq $0xb
popq %rsi
movq %r12, %rdx
callq 0x20c0
cmpq 0x28(%rbx), %r13
jne 0x311f
movq (%r14), %rcx
leaq 0x1487(%rip), %rdi # 0x459b
pushq $0xb
popq %rsi
movq %r12, %rdx
callq 0x20c0
cmpq 0x18(%rbx), %r13
jne 0x313a
movq (%r14), %rcx
leaq 0x1478(%rip), %rdi # 0x45a7
pushq $0xb
popq %rsi
movq %r12, %rdx
callq 0x20c0
movq (%r14), %rdi
testq %r15, %r15
jne 0x3157
leaq 0x1483(%rip), %rsi # 0x45cc
movl %ebp, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2090
jmp 0x3189
movl 0x20(%r15), %eax
movl 0x30(%r15), %r9d
leaq 0x14ba(%rip), %rcx # 0x4620
movslq (%rcx,%rax,4), %r10
addq %rcx, %r10
leaq 0x143f(%rip), %rsi # 0x45b3
movl %ebp, %edx
movq %r13, %rcx
movl %ebp, %r8d
xorl %eax, %eax
pushq %r10
pushq %r15
callq 0x2090
popq %rcx
popq %rdx
incq %r13
jmp 0x30d8
movq (%r14), %rcx
leaq 0x1441(%rip), %rdi # 0x45dc
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
| /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 GREEN_EBADFD;
}
// Store result.
future->result.i = i;
future->result.p = p;
// Mark as complete.
future->state = green_future_complete;
// Restore poller invariant.
if (future->poller) {
green_poller_swap(future->poller,
future->slot, --future->poller->busy);
// TODO: resume coroutine blocked on poller, if any.
}
return GREEN_SUCCESS;
} | 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(%rdi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x35ce
movl 0x30(%rdi), %esi
movq 0x28(%rax), %rdx
decq %rdx
movq %rdx, 0x28(%rax)
movq %rax, %rdi
callq 0x3206
jmp 0x35ce
movq 0x29ee(%rip), %rbx # 0x5ff8
movq (%rbx), %rdi
leaq 0xb5c(%rip), %rsi # 0x4170
leaq 0xdd7(%rip), %rdx # 0x43f2
leaq 0xb70(%rip), %rcx # 0x4192
movl $0x25d, %r8d # imm = 0x25D
xorl %eax, %eax
callq 0x2090
movq (%rbx), %rdi
callq 0x20b0
callq 0x2040
| /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 0x158830
movq 0x18(%rsp), %rdi
leaq 0xcfe9d(%rip), %rsi # 0x21392d
callq 0x17f350
movq %rax, 0x20(%rsp)
jmp 0x143a9c
movq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x17f2a0
movq %rax, 0x10(%rsp)
jmp 0x143ab2
movq 0x10(%rsp), %rdi
movb $0x2e, 0x33(%rsp)
leaq 0x33(%rsp), %rsi
callq 0x17f2e0
movq %rax, 0x8(%rsp)
jmp 0x143acd
movq 0x8(%rsp), %rdi
leaq 0xcfe6e(%rip), %rsi # 0x213947
callq 0x17f380
movq %rax, (%rsp)
jmp 0x143ae4
movq (%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x143760
jmp 0x143af4
leaq 0x58(%rsp), %rdi
callq 0x1439e0
jmp 0x143b00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x143b28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x142e28
leaq 0x40(%rsp), %rdi
callq 0x1588f0
jmp 0x143b4d
jmp 0x143b36
movq 0x28(%rsp), %rax
movsd 0x78(%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x142c90
nopw (%rax,%rax)
| /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 += m_info.macroName;
expr += "( ";
expr += m_info.capturedExpression;
expr += " )";
}
return 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
leaq 0x30(%rsp), %rdi
callq 0x17f5c0
jmp 0x1447d4
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1428c0
leaq 0x30(%rsp), %rdi
callq 0x142e28
jmp 0x144891
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x142e28
jmp 0x1448b1
movq 0x18(%rsp), %rdi
callq 0x17f590
movq 0x18(%rsp), %rdi
movq %rax, (%rsp)
addq $0x20, %rdi
callq 0x17f590
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
leaq 0x4(%rax,%rcx), %rsi
callq 0x142b00
jmp 0x144843
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x144730
jmp 0x144854
movq 0x8(%rsp), %rdi
leaq 0xcf086(%rip), %rsi # 0x2138e6
callq 0x1426f0
jmp 0x144867
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x20, %rsi
callq 0x144730
jmp 0x14487c
movq 0x8(%rsp), %rdi
leaq 0xcf061(%rip), %rsi # 0x2138e9
callq 0x1426f0
jmp 0x14488f
jmp 0x144891
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x1448a7
movq 0x8(%rsp), %rdi
callq 0x142e28
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x142c90
nopl (%rax,%rax)
| /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( start, 1+end-start ) : std::string();
} | 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 $-0x1, %rdx
callq 0x142cd0
movq %rax, 0x18(%rsp)
cmpq $-0x1, 0x20(%rsp)
je 0x14a9de
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
addq $0x1, %rcx
subq 0x20(%rsp), %rcx
callq 0x1427a0
jmp 0x14a9e8
movq 0x8(%rsp), %rdi
callq 0x142a20
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| /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_activeSections.push_back(§ionTracker);
m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
m_reporter->sectionStarting(sectionInfo);
assertions = m_totals.assertions;
return true;
} | 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), %rdi
movq 0x18(%rsp), %rsi
callq 0x154040
movq %rax, 0x20(%rsp)
jmp 0x154b08
leaq 0x40(%rsp), %rdi
callq 0x183880
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x154b55
movb $0x0, 0x97(%rsp)
jmp 0x154be7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x183880
jmp 0x154bf8
movq 0x8(%rsp), %rdi
addq $0x1b0, %rdi # imm = 0x1B0
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x183930
movq 0x8(%rsp), %rdi
movq 0x80(%rsp), %rax
movq 0x40(%rax), %rcx
movq %rcx, 0x170(%rdi)
movq 0x48(%rax), %rax
movq %rax, 0x178(%rdi)
addq $0x128, %rdi # imm = 0x128
callq 0x1836c0
movq %rax, %rdi
movq 0x80(%rsp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x8(%rsp), %rcx
movq 0x78(%rsp), %rax
movq 0xf8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x100(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x108(%rcx), %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x97(%rsp)
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x142c90
nopw %cs:(%rax,%rax)
| /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::NameAndLocation( static_cast<std::string>(generatorName), lineInfo ) );
m_lastAssertionInfo.lineInfo = lineInfo;
return tracker;
} | 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 0x88(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x15b510
jmp 0x154c7f
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x183960
movq %rax, (%rsp)
jmp 0x154c94
leaq 0x50(%rsp), %rdi
callq 0x183880
leaq 0x30(%rsp), %rdi
callq 0x142e28
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x80(%rsp)
movq 0x88(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x170(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x178(%rax)
movq 0x80(%rsp), %rax
addq $0x68, %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x154d12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x183880
leaq 0x30(%rsp), %rdi
callq 0x142e28
movq 0x28(%rsp), %rdi
callq 0x142c90
nopw %cs:(%rax,%rax)
| /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_activeSections.pop_back();
}
m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
m_messages.clear();
m_messageScopes.clear();
} | 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, 0xaf(%rsp)
addq $0x1b0, %rdi # imm = 0x1B0
callq 0x183c50
testb $0x1, %al
jne 0x154ec3
movq 0x10(%rsp), %rdi
addq $0x1b0, %rdi # imm = 0x1B0
callq 0x183ca0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x10(%rsp), %rdi
addq $0x1b0, %rdi # imm = 0x1B0
callq 0x183ce0
movq 0x10(%rsp), %rdi
addq $0x128, %rdi # imm = 0x128
callq 0x1836c0
movq %rax, (%rsp)
movq 0xc8(%rsp), %rsi
movsd 0x68(%rsi), %xmm0
movzbl 0xaf(%rsp), %ecx
andl $0x1, %ecx
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0xb0(%rsp), %rdx
callq 0x14d1b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
jmp 0x154f1b
leaq 0x28(%rsp), %rdi
callq 0x14d240
movq 0x10(%rsp), %rdi
addq $0x130, %rdi # imm = 0x130
callq 0x183d00
movq 0x10(%rsp), %rdi
addq $0x148, %rdi # imm = 0x148
callq 0x1838c0
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x14d240
movq 0x20(%rsp), %rdi
callq 0x142c90
nopw %cs:(%rax,%rax)
| /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.
AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
tempResult.message = static_cast<std::string>(message);
AssertionResult result(m_lastAssertionInfo, tempResult);
assertionEnded(result);
handleUnfinishedSections();
// Recreate section for test case (as we will lose the one that was in scope)
auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
Counts assertions;
assertions.failed = 1;
SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
m_reporter->sectionEnded(testCaseSectionStats);
auto const& testInfo = m_activeTestCase->getTestCaseInfo();
Totals deltaTotals;
deltaTotals.testCases.failed = 1;
deltaTotals.assertions.failed = 1;
m_reporter->testCaseEnded(TestCaseStats(testInfo,
deltaTotals,
std::string(),
std::string(),
false));
m_totals.testCases.failed++;
testGroupEnded(std::string(), m_totals, 1, 1);
m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
} | 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(%rsp), %rdx
movq (%rdi), %rax
movq 0x80(%rax), %rax
callq *%rax
leaq 0x468(%rsp), %rdi
movq %rdi, 0x78(%rsp)
xorl %esi, %esi
callq 0x143bf0
movq 0x78(%rsp), %rdx
leaq 0x478(%rsp), %rdi
movl $0x210, %esi # imm = 0x210
callq 0x144340
leaq 0x448(%rsp), %rdi
leaq 0x4e8(%rsp), %rsi
callq 0x17f5c0
jmp 0x1552e9
leaq 0x478(%rsp), %rdi
movq %rdi, 0x68(%rsp)
leaq 0x448(%rsp), %rsi
movq %rsi, 0x60(%rsp)
callq 0x1428c0
movq 0x60(%rsp), %rdi
callq 0x142e28
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
addq $0x160, %rsi # imm = 0x160
leaq 0x3a8(%rsp), %rdi
callq 0x1444c0
jmp 0x155332
movq 0x70(%rsp), %rdi
leaq 0x3a8(%rsp), %rsi
callq 0x154850
jmp 0x155346
movq 0x70(%rsp), %rdi
callq 0x155730
jmp 0x155352
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x14f090
movq %rax, 0x58(%rsp)
jmp 0x155367
movq 0x58(%rsp), %rax
movq %rax, 0x3a0(%rsp)
movq 0x3a0(%rsp), %rdx
movq %rdx, %rsi
addq $0x90, %rsi
leaq 0x350(%rsp), %rdi
callq 0x156580
jmp 0x155395
leaq 0x338(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x184000
movq 0x50(%rsp), %rdx
movq $0x1, 0x340(%rsp)
leaq 0x2b8(%rsp), %rdi
leaq 0x350(%rsp), %rsi
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x14d1b0
jmp 0x1553d4
movq 0x70(%rsp), %rdi
addq $0x128, %rdi # imm = 0x128
callq 0x1836c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x58(%rax), %rax
leaq 0x2b8(%rsp), %rsi
callq *%rax
jmp 0x1553fb
movq 0x70(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x14f090
movq %rax, 0x48(%rsp)
jmp 0x155410
movq 0x48(%rsp), %rax
movq %rax, 0x2b0(%rsp)
leaq 0x278(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x1818a0
movq 0x70(%rsp), %rdi
movq $0x1, 0x2a0(%rsp)
movq $0x1, 0x288(%rsp)
addq $0x128, %rdi # imm = 0x128
callq 0x1836c0
movq %rax, 0x20(%rsp)
movq 0x2b0(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x128(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x142a20
leaq 0x108(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x142a20
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %r8
leaq 0x148(%rsp), %rdi
xorl %r9d, %r9d
callq 0x14d2a0
jmp 0x1554b4
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq 0x60(%rax), %rax
leaq 0x148(%rsp), %rsi
callq *%rax
jmp 0x1554cc
leaq 0x148(%rsp), %rdi
callq 0x14d3b0
leaq 0x108(%rsp), %rdi
callq 0x142e28
leaq 0x128(%rsp), %rdi
callq 0x142e28
movq 0x70(%rsp), %rax
movq %rax, %rcx
addq $0xf0, %rcx
movq %rcx, 0x18(%rsp)
movq 0x118(%rax), %rcx
incq %rcx
movq %rcx, 0x118(%rax)
leaq 0xe8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x142a20
movq 0x70(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl $0x1, %r8d
movq %r8, %rcx
callq 0x1538a0
jmp 0x155549
leaq 0xe8(%rsp), %rdi
callq 0x142e28
movq 0x70(%rsp), %rdi
addq $0x128, %rdi # imm = 0x128
callq 0x1836c0
movq 0x70(%rsp), %rdx
movq %rax, 0x8(%rsp)
movq %rdx, %rsi
addq $0x10, %rsi
addq $0xf0, %rdx
leaq 0x80(%rsp), %rdi
xorl %ecx, %ecx
callq 0x14d560
jmp 0x155590
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x70(%rax), %rax
leaq 0x80(%rsp), %rsi
callq *%rax
jmp 0x1555a8
leaq 0x80(%rsp), %rdi
callq 0x14d5d0
leaq 0x2b8(%rsp), %rdi
callq 0x14d240
leaq 0x350(%rsp), %rdi
callq 0x181680
leaq 0x3a8(%rsp), %rdi
callq 0x1815d0
leaq 0x478(%rsp), %rdi
callq 0x184030
addq $0x4f8, %rsp # imm = 0x4F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x440(%rsp)
movl %eax, 0x43c(%rsp)
jmp 0x155713
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x440(%rsp)
movl %eax, 0x43c(%rsp)
jmp 0x155706
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x440(%rsp)
movl %eax, 0x43c(%rsp)
jmp 0x1556f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x440(%rsp)
movl %eax, 0x43c(%rsp)
jmp 0x1556ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x440(%rsp)
movl %eax, 0x43c(%rsp)
jmp 0x15568c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x440(%rsp)
movl %eax, 0x43c(%rsp)
leaq 0x148(%rsp), %rdi
callq 0x14d3b0
leaq 0x108(%rsp), %rdi
callq 0x142e28
leaq 0x128(%rsp), %rdi
callq 0x142e28
jmp 0x1556ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x440(%rsp)
movl %eax, 0x43c(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x142e28
jmp 0x1556ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x440(%rsp)
movl %eax, 0x43c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x14d5d0
leaq 0x2b8(%rsp), %rdi
callq 0x14d240
leaq 0x350(%rsp), %rdi
callq 0x181680
leaq 0x3a8(%rsp), %rdi
callq 0x1815d0
leaq 0x478(%rsp), %rdi
callq 0x184030
movq 0x440(%rsp), %rdi
callq 0x142c90
nopl (%rax)
| /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 != itEnd;
++it)
sectionEnded(*it);
m_unfinishedSections.clear();
} | 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 0x1841a0
testb $0x1, %al
jne 0x15577f
jmp 0x1557a3
leaq 0x18(%rsp), %rdi
callq 0x1841d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x18(%rsp), %rdi
callq 0x184200
jmp 0x15576a
movq 0x8(%rsp), %rdi
addq $0x198, %rdi # imm = 0x198
callq 0x184230
addq $0x28, %rsp
retq
nopl (%rax)
| /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->showDurations() == ShowDurations::Always )
e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
if( !testCaseStats.stdOut.empty() )
m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
if( !testCaseStats.stdErr.empty() )
m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
m_xml.endElement();
} | 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
movq 0x60(%rsp), %rdx
leaq 0xa8594(%rip), %rsi # 0x214c33
leaq 0x188(%rsp), %rdi
callq 0x142a10
jmp 0x16c6ae
movl $0x2, %edi
movl $0x1, %esi
callq 0x15f4d0
movq 0x58(%rsp), %rsi
movl %eax, %ecx
leaq 0x1a8(%rsp), %rdi
leaq 0x188(%rsp), %rdx
callq 0x160340
jmp 0x16c6db
leaq 0x188(%rsp), %rdi
callq 0x142e28
leaq 0x187(%rsp), %rdi
callq 0x1427f0
leaq 0x14f(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x142ca0
movq 0x48(%rsp), %rdx
leaq 0xa72e9(%rip), %rsi # 0x2139fc
leaq 0x150(%rsp), %rdi
callq 0x142a10
jmp 0x16c722
movq 0x1b8(%rsp), %rdi
addq $0xb8, %rdi
callq 0x15f170
movb %al, 0x14e(%rsp)
leaq 0x1a8(%rsp), %rdi
leaq 0x150(%rsp), %rsi
leaq 0x14e(%rsp), %rdx
callq 0x18ac50
jmp 0x16c75c
leaq 0x150(%rsp), %rdi
callq 0x142e28
leaq 0x14f(%rsp), %rdi
callq 0x1427f0
movq 0x50(%rsp), %rdi
addq $0x8, %rdi
callq 0x17f470
movq %rax, %rdi
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
movl %eax, 0x44(%rsp)
jmp 0x16c796
movl 0x44(%rsp), %eax
cmpl $0x1, %eax
jne 0x16c92a
leaq 0x127(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x142ca0
movq 0x38(%rsp), %rdx
leaq 0xa8460(%rip), %rsi # 0x214c21
leaq 0x128(%rsp), %rdi
callq 0x142a10
jmp 0x16c7d0
movq 0x50(%rsp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x155950
movsd %xmm0, 0x30(%rsp)
jmp 0x16c7e9
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x118(%rsp)
leaq 0x1a8(%rsp), %rdi
leaq 0x128(%rsp), %rsi
leaq 0x118(%rsp), %rdx
callq 0x18abe0
jmp 0x16c817
leaq 0x128(%rsp), %rdi
callq 0x142e28
leaq 0x127(%rsp), %rdi
callq 0x1427f0
jmp 0x16c92a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
jmp 0x16c86d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
leaq 0x188(%rsp), %rdi
callq 0x142e28
leaq 0x187(%rsp), %rdi
callq 0x1427f0
jmp 0x16cc7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
jmp 0x16c8b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
leaq 0x150(%rsp), %rdi
callq 0x142e28
leaq 0x14f(%rsp), %rdi
callq 0x1427f0
jmp 0x16cc6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
jmp 0x16cc6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
jmp 0x16c918
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
leaq 0x128(%rsp), %rdi
callq 0x142e28
leaq 0x127(%rsp), %rdi
callq 0x1427f0
jmp 0x16cc6d
movq 0x1b8(%rsp), %rdi
addq $0xe8, %rdi
callq 0x142bc0
testb $0x1, %al
jne 0x16cab2
movq 0x50(%rsp), %rax
addq $0x170, %rax # imm = 0x170
movq %rax, 0x20(%rsp)
leaq 0xe7(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x142ca0
movq 0x28(%rsp), %rdx
leaq 0xa82cd(%rip), %rsi # 0x214c41
leaq 0xe8(%rsp), %rdi
callq 0x142a10
jmp 0x16c983
movl $0x2, %edi
movl $0x1, %esi
callq 0x15f4d0
movq 0x20(%rsp), %rsi
movl %eax, %ecx
leaq 0x108(%rsp), %rdi
leaq 0xe8(%rsp), %rdx
callq 0x160340
jmp 0x16c9b0
movq 0x1b8(%rsp), %rsi
addq $0xe8, %rsi
leaq 0xc0(%rsp), %rdi
callq 0x14a960
jmp 0x16c9ce
leaq 0x108(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movl $0x2, %edx
callq 0x15ff30
jmp 0x16c9ea
leaq 0xc0(%rsp), %rdi
callq 0x142e28
leaq 0x108(%rsp), %rdi
callq 0x15fef0
leaq 0xe8(%rsp), %rdi
callq 0x142e28
leaq 0xe7(%rsp), %rdi
callq 0x1427f0
jmp 0x16cab2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
jmp 0x16caa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
jmp 0x16ca93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
jmp 0x16ca86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x142e28
leaq 0x108(%rsp), %rdi
callq 0x15fef0
leaq 0xe8(%rsp), %rdi
callq 0x142e28
leaq 0xe7(%rsp), %rdi
callq 0x1427f0
jmp 0x16cc6d
movq 0x1b8(%rsp), %rdi
addq $0x108, %rdi # imm = 0x108
callq 0x142bc0
testb $0x1, %al
jne 0x16cc2b
movq 0x50(%rsp), %rax
addq $0x170, %rax # imm = 0x170
movq %rax, 0x10(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x142ca0
movq 0x18(%rsp), %rdx
leaq 0xa814c(%rip), %rsi # 0x214c48
leaq 0x90(%rsp), %rdi
callq 0x142a10
jmp 0x16cb0b
movl $0x2, %edi
movl $0x1, %esi
callq 0x15f4d0
movq 0x10(%rsp), %rsi
movl %eax, %ecx
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x160340
jmp 0x16cb38
movq 0x1b8(%rsp), %rsi
addq $0x108, %rsi # imm = 0x108
leaq 0x68(%rsp), %rdi
callq 0x14a960
jmp 0x16cb53
leaq 0xb0(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movl $0x2, %edx
callq 0x15ff30
jmp 0x16cb6c
leaq 0x68(%rsp), %rdi
callq 0x142e28
leaq 0xb0(%rsp), %rdi
callq 0x15fef0
leaq 0x90(%rsp), %rdi
callq 0x142e28
leaq 0x8f(%rsp), %rdi
callq 0x1427f0
jmp 0x16cc2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
jmp 0x16cc1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
jmp 0x16cc0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
jmp 0x16cc02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x178(%rsp)
movl %eax, 0x174(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x142e28
leaq 0xb0(%rsp), %rdi
callq 0x15fef0
leaq 0x90(%rsp), %rdi
callq 0x142e28
leaq 0x8f(%rsp), %rdi
callq 0x1427f0
jmp 0x16cc6d
movq 0x50(%rsp), %rax
addq $0x170, %rax # imm = 0x170
movq %rax, 0x8(%rsp)
movl $0x2, %edi
movl $0x1, %esi
callq 0x15f4d0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x15fdb0
jmp 0x16cc58
leaq 0x1a8(%rsp), %rdi
callq 0x15fef0
addq $0x1c8, %rsp # imm = 0x1C8
retq
leaq 0x1a8(%rsp), %rdi
callq 0x15fef0
movq 0x178(%rsp), %rdi
callq 0x142c90
nopw (%rax,%rax)
| /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 reporter;
} | 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 (%rsi), %rax
callq *0x10(%rax)
movq 0x28(%rsp), %rdi
callq 0x1a3c80
testb $0x1, %al
jne 0x16fd45
leaq 0x40(%rsp), %rdi
callq 0x158830
jmp 0x16fc9b
leaq 0xa53a3(%rip), %rsi # 0x215045
leaq 0x40(%rsp), %rdi
callq 0x1a3ca0
movq %rax, 0x18(%rsp)
jmp 0x16fcb3
movq 0x18(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x17f1a0
movq %rax, 0x10(%rsp)
jmp 0x16fccc
movq 0x10(%rsp), %rdi
leaq 0xa4ae9(%rip), %rsi # 0x2147c1
callq 0x184f40
movq %rax, 0x8(%rsp)
jmp 0x16fce4
movq 0x8(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x143760
jmp 0x16fcf5
leaq 0x58(%rsp), %rdi
callq 0x1439e0
jmp 0x16fd01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x16fd6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x16fd39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x142e28
leaq 0x40(%rsp), %rdi
callq 0x1588f0
jmp 0x16fd6c
jmp 0x16fd47
jmp 0x16fd49
movb $0x1, 0x7f(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0x16fd5f
movq 0x28(%rsp), %rdi
callq 0x183800
movq 0x20(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x183800
movq 0x38(%rsp), %rdi
callq 0x142c90
| /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 ) );
}
return 0;
} | 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, %rax
jne 0x17026f
movq 0x28(%rsp), %rax
addq $0x140, %rax # imm = 0x140
movq %rax, 0x8(%rsp)
movsbl 0x6c(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x142ca0
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rcx
leaq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x1424c0
jmp 0x170214
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1702a0
jmp 0x170225
leaq 0x48(%rsp), %rdi
callq 0x142e28
leaq 0x47(%rsp), %rdi
callq 0x1427f0
jmp 0x170280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x170263
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x142e28
leaq 0x47(%rsp), %rdi
callq 0x1427f0
jmp 0x170289
movq 0x28(%rsp), %rdi
movl 0x6c(%rsp), %eax
movsbl %al, %esi
callq 0x1422c0
jmp 0x170282
xorl %eax, %eax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x142c90
nopw %cs:(%rax,%rax)
| /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::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 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), %rdi
callq 0x1934f0
jmp 0x193092
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x193570
movq 0x8(%rsp), %rdi
callq 0x1935a0
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq 0x40(%rsp), %rsi
callq 0x142300
jmp 0x1930c5
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
callq 0x142a20
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x193100
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x18f960
movq 0x10(%rsp), %rdi
callq 0x193620
movq 0x28(%rsp), %rdi
callq 0x142c90
nopw %cs:(%rax,%rax)
nop
| /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 -0x20(%rsp), %rax
movq %rax, -0x10(%rsp)
cmpq $-0x1, -0x10(%rsp)
jne 0x196498
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x1964a2
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
retq
nopl (%rax,%rax)
| /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 0x1964b0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x142810
movsbl (%rax), %edi
callq 0x1965d0
testb $0x1, %al
jne 0x196539
jmp 0x19656a
movq (%rsp), %rdi
callq 0x1964b0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
subq $0x1, %rsi
callq 0x142810
movsbl (%rax), %edi
callq 0x1965d0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x19656a
jmp 0x1965bb
movq (%rsp), %rdi
callq 0x1964b0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x142810
movsbl (%rax), %edi
callq 0x1966a0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x1965bb
movq (%rsp), %rdi
callq 0x1964b0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
subq $0x1, %rsi
callq 0x142810
movsbl (%rax), %edi
callq 0x196770
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| /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(%rsp), %rsi
callq 0x198cc0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rsp)
movq (%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0x198be0
movq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x195f50
movq (%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x195f90
testb $0x1, %al
jne 0x19791d
jmp 0x197938
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x48(%rsp), %rsi
callq 0x198cc0
movq %rax, %rdi
callq 0x196060
jmp 0x19793a
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x1978ac
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
| /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)
movq 0x98(%rsp), %rdi
callq 0x194ef0
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x194f20
testb $0x1, %al
jne 0x19cce7
jmp 0x19cdc1
leaq 0x90(%rsp), %rdi
callq 0x194f60
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x19d0e0
jmp 0x19cd10
movq 0x18(%rsp), %rdi
callq 0x19ce30
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x19d500
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x19ce00
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0x19ce30
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x19d440
movq %rax, 0x10(%rsp)
jmp 0x19cd71
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x19d030
leaq 0x90(%rsp), %rdi
callq 0x194f70
jmp 0x19ccc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x19cdea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x19d030
jmp 0x19cdea
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x19cddd
movq 0x18(%rsp), %rdi
callq 0x19d030
movq 0x20(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x19d030
movq 0x60(%rsp), %rdi
callq 0x142c90
nop
| /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;
}
if( !m_hint.empty() )
oss << " <" << m_hint << ">";
return { { oss.str(), m_description } };
} | 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)
movq 0x100(%rsp), %rdi
callq 0x181de0
movq %rax, 0xf8(%rsp)
movq 0x100(%rsp), %rdi
callq 0x181e10
movq %rax, 0xf0(%rsp)
leaq 0xf8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x181e40
testb $0x1, %al
jne 0x19d17f
jmp 0x19d204
leaq 0xf8(%rsp), %rdi
callq 0x181e80
movq %rax, 0xe8(%rsp)
testb $0x1, 0x10f(%rsp)
je 0x19d1a8
movb $0x0, 0x10f(%rsp)
jmp 0x19d1d9
leaq 0x7710e(%rip), %rsi # 0x2142bd
leaq 0x110(%rsp), %rdi
callq 0x142730
jmp 0x19d1be
jmp 0x19d1d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
jmp 0x19d41e
movq 0xe8(%rsp), %rsi
leaq 0x110(%rsp), %rdi
callq 0x142660
jmp 0x19d1f0
jmp 0x19d1f2
leaq 0xf8(%rsp), %rdi
callq 0x182030
jmp 0x19d161
movq 0x70(%rsp), %rdi
addq $0x20, %rdi
callq 0x142bc0
testb $0x1, %al
jne 0x19d260
leaq 0x77ddc(%rip), %rsi # 0x214ff9
leaq 0x110(%rsp), %rdi
callq 0x142730
movq %rax, 0x58(%rsp)
jmp 0x19d231
movq 0x58(%rsp), %rdi
movq 0x70(%rsp), %rsi
addq $0x20, %rsi
callq 0x142660
movq %rax, 0x50(%rsp)
jmp 0x19d24b
movq 0x50(%rsp), %rdi
leaq 0x775a7(%rip), %rsi # 0x2147fe
callq 0x142730
jmp 0x19d25e
jmp 0x19d260
leaq 0x88(%rsp), %rdi
movq %rdi, 0x48(%rsp)
movq %rdi, 0x80(%rsp)
leaq 0x110(%rsp), %rsi
callq 0x142780
jmp 0x19d284
movq 0x70(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
addq $0x40, %rsi
callq 0x142300
jmp 0x19d29c
leaq 0x88(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq $0x1, 0xd0(%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x19d5f0
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rcx
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0x19d600
jmp 0x19d2e8
leaq 0x7f(%rsp), %rdi
callq 0x19d690
leaq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x40, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
addq $-0x40, %rdi
movq %rdi, 0x28(%rsp)
callq 0x19d5c0
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x38(%rsp)
jne 0x19d308
leaq 0x110(%rsp), %rdi
callq 0x142180
movq 0x68(%rsp), %rax
addq $0x298, %rsp # imm = 0x298
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
jmp 0x19d37d
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
callq 0x142e28
movq 0x80(%rsp), %rax
leaq 0x88(%rsp), %rcx
cmpq %rax, %rcx
movq %rax, 0x20(%rsp)
je 0x19d3c1
movq 0x20(%rsp), %rdi
addq $-0x40, %rdi
movq %rdi, 0x18(%rsp)
callq 0x19d5c0
movq 0x18(%rsp), %rax
leaq 0x88(%rsp), %rcx
cmpq %rcx, %rax
movq %rax, 0x20(%rsp)
jne 0x19d397
jmp 0x19d41e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0x7f(%rsp), %rdi
callq 0x19d690
leaq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x40, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $-0x40, %rdi
movq %rdi, (%rsp)
callq 0x19d5c0
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0x19d3f7
jmp 0x19d41e
leaq 0x110(%rsp), %rdi
callq 0x142180
movq 0xe0(%rsp), %rdi
callq 0x142c90
nopl (%rax,%rax)
| /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)) {
obj->via.bin.ptr = v;
obj->via.bin.size = size;
set_referenced(true);
}
else {
if (v) {
char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
std::memcpy(tmp, v, size);
obj->via.bin.ptr = tmp;
obj->via.bin.size = size;
}
else {
obj->via.bin.ptr = MSGPACK_NULLPTR;
obj->via.bin.size = 0;
}
}
return true;
} | 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
callq *%rax
testb %al, %al
je 0x5d545
movq %r14, 0x10(%r13)
movl %ebx, 0x8(%r13)
movb $0x1, 0x78(%r12)
jmp 0x5d57f
testq %r14, %r14
je 0x5d575
movq 0x70(%r12), %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
callq 0x5d8b8
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4d3c0
movq %r12, 0x10(%r13)
movl %ebx, 0x8(%r13)
jmp 0x5d57f
andq $0x0, 0x10(%r13)
andl $0x0, 0x8(%r13)
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x4d290
movq %rax, %rbx
leaq 0xa0f3(%rip), %rsi # 0x67690
movq %rax, %rdi
callq 0x5de98
leaq 0x203f4(%rip), %rsi # 0x7d9a0
movq 0x209a5(%rip), %rdx # 0x7df58
movq %rbx, %rdi
callq 0x4d7a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4d360
movq %r14, %rdi
callq 0x4d7d0
| /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<msgpack::v2::detail::parse_helper<msgpack::v2::detail::create_object_visitor>>::array_ev>(msgpack::v2::detail::context<msgpack::v2::detail::parse_helper<msgpack::v2::detail::create_object_visitor>>::array_sv const&, msgpack::v2::detail::context<msgpack::v2::detail::parse_helper<msgpack::v2::detail::create_object_visitor>>::array_ev const&, char const*, unsigned long&) | 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 = static_cast<std::size_t>(m_current - m_start);
return PARSE_STOP_VISITOR;
}
if (!ev()) {
off = static_cast<std::size_t>(m_current - m_start);
return PARSE_STOP_VISITOR;
}
parse_return ret = m_stack.consume(holder());
if (ret != PARSE_CONTINUE) {
off = static_cast<std::size_t>(m_current - m_start);
return ret;
}
}
else {
if (!sv(size)) {
off = static_cast<std::size_t>(m_current - m_start);
return PARSE_STOP_VISITOR;
}
parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
if (ret != PARSE_CONTINUE) {
off = static_cast<std::size_t>(m_current - m_start);
return ret;
}
}
m_cs = MSGPACK_CS_HEADER;
return PARSE_CONTINUE;
} | 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
callq 0x5d9f6
jmp 0x5d637
movq %rdx, %r15
movq %rsi, %rdi
xorl %esi, %esi
callq 0x5d9ea
testb %al, %al
je 0x5d647
movq (%r15), %rax
movq 0x38(%rax), %rax
addq $-0x8, 0x60(%rax)
leaq 0x20(%r14), %rdi
movq %r14, %rsi
callq 0x5d82c
testl %eax, %eax
je 0x5d656
movq 0x8(%r14), %rcx
subq (%r14), %rcx
movq %rcx, (%rbx)
jmp 0x5d65d
movq 0x8(%r14), %rax
subq (%r14), %rax
movq %rax, (%rbx)
pushq $-0x2
popq %rax
jmp 0x5d65d
andl $0x0, 0x18(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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::v2::detail::parse_helper<msgpack::v2::detail::create_object_visitor>>::array_ev>(msgpack::v2::detail::context<msgpack::v2::detail::parse_helper<msgpack::v2::detail::create_object_visitor>>::array_sv const&, msgpack::v2::detail::context<msgpack::v2::detail::parse_helper<msgpack::v2::detail::create_object_visitor>>::array_ev const&, char const*, unsigned long&) | 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 = static_cast<std::size_t>(m_current - m_start);
return PARSE_STOP_VISITOR;
}
if (!ev()) {
off = static_cast<std::size_t>(m_current - m_start);
return PARSE_STOP_VISITOR;
}
parse_return ret = m_stack.consume(holder());
if (ret != PARSE_CONTINUE) {
off = static_cast<std::size_t>(m_current - m_start);
return ret;
}
}
else {
if (!sv(size)) {
off = static_cast<std::size_t>(m_current - m_start);
return PARSE_STOP_VISITOR;
}
parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
if (ret != PARSE_CONTINUE) {
off = static_cast<std::size_t>(m_current - m_start);
return ret;
}
}
m_cs = MSGPACK_CS_HEADER;
return PARSE_CONTINUE;
} | 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 0x5d6ca
movq %rdx, %r15
movq %rsi, %rdi
xorl %esi, %esi
callq 0x5d9ea
testb %al, %al
je 0x5d6da
movq (%r15), %rax
movq 0x38(%rax), %rax
addq $-0x8, 0x60(%rax)
leaq 0x20(%r14), %rdi
movq %r14, %rsi
callq 0x5d82c
testl %eax, %eax
je 0x5d6e9
movq 0x8(%r14), %rcx
subq (%r14), %rcx
movq %rcx, (%rbx)
jmp 0x5d6f0
movq 0x8(%r14), %rax
subq (%r14), %rax
movq %rax, (%rbx)
pushq $-0x2
popq %rax
jmp 0x5d6f0
andl $0x0, 0x18(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 # imm = 0x3E7
jbe 0xa525
cmpl $0x2710, %ecx # imm = 0x2710
jb 0xa528
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r14d
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %edx, %ecx
ja 0xa4ec
addl $-0x3, %r14d
jmp 0xa528
addl $-0x2, %r14d
jmp 0xa528
decl %r14d
shrl $0x1f, %r15d
movl %r15d, %esi
addl %r14d, %esi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x3200
movq (%rbx), %rdi
addq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0xa564
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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 to the "
"constraint in tag \"" ) +
this->name() + Trait::from_ascii( "\"." ) );
}
m_value = v;
this->set_defined();
} | 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
movb $0x1, 0x29(%r14)
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x30b0
movq %rax, %rbx
leaq 0x98(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a7d(%rip), %rsi # 0xc163
leaq 0x1a86(%rip), %rdx # 0xc173
leaq 0x88(%rsp), %rdi
callq 0x4724
leaq 0xd8(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
addq %rsi, %rdx
leaq 0xc8(%rsp), %rdi
callq 0x460e
leaq 0xb8(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0xa8(%rsp), %rdi
callq 0x460e
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0x6d86
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x19fe(%rip), %rsi # 0xc174
leaq 0x1a25(%rip), %rdx # 0xc1a2
leaq 0x28(%rsp), %rdi
callq 0x4724
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0x460e
leaq 0x108(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x6d86
addq $0x8, %r14
leaq 0x128(%rsp), %rdi
leaq 0x108(%rsp), %rsi
movq %r14, %rdx
callq 0x6e2e
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1922(%rip), %rsi # 0xc10f
leaq 0x191d(%rip), %rdx # 0xc111
leaq 0x8(%rsp), %rdi
callq 0x4724
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x460e
leaq 0x148(%rsp), %rdi
leaq 0x128(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x6d86
movb $0x1, %r15b
leaq 0x148(%rsp), %rsi
movq %rbx, %rdi
callq 0x6e88
xorl %r15d, %r15d
leaq 0x51bb(%rip), %rsi # 0xfa10
leaq -0x3974(%rip), %rdx # 0x6ee8
movq %rbx, %rdi
callq 0x32c0
movq %rax, %r14
leaq 0x158(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa890
movq 0x158(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xa890
movq %rax, %r14
movb $0x1, %r15b
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xa8b4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xa8b4
movq %rax, %r14
movb $0x1, %r15b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa8d8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xa8d8
movq %rax, %r14
movb $0x1, %r15b
leaq 0x138(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa901
movq 0x138(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xa901
movq %rax, %r14
movb $0x1, %r15b
leaq 0x118(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa92a
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xa92a
movq %rax, %r14
movb $0x1, %r15b
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0xa94e
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xa94e
movq %rax, %r14
movb $0x1, %r15b
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xa972
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xa972
movq %rax, %r14
movb $0x1, %r15b
leaq 0xf8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa99b
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xa99b
movq %rax, %r14
movb $0x1, %r15b
movq 0xa8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa9c0
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xa9c0
movq %rax, %r14
movb $0x1, %r15b
movq 0xc8(%rsp), %rdi
cmpq %r13, %rdi
je 0xa9e5
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xa9e5
movq %rax, %r14
movb $0x1, %r15b
movq 0x88(%rsp), %rdi
cmpq %r12, %rdi
je 0xaa0a
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x31a0
jmp 0xaa0a
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xaa17
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x32e0
nop
| /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()) {
case 0:
{
// Simple template string
auto description = std::get<0>(*object_description);
if (auto pos = description.find("$OG"); pos != std::string::npos) {
description.replace(pos, 3, og.unparse(' '));
}
if (auto pos = description.find("$PO"); pos != std::string::npos) {
description.replace(pos, 3, std::to_string(parsed_offset + shift));
}
return description;
}
case 1:
{
// QPDF::JSONReactor generated description
auto j_descr = std::get<1>(*object_description);
return (
*j_descr.input + (j_descr.object.empty() ? "" : ", " + j_descr.object) +
" at offset " + std::to_string(parsed_offset));
}
case 2:
{
// Child object description
auto j_descr = std::get<2>(*object_description);
std::string result;
if (auto p = j_descr.parent.lock()) {
result = p->getDescription();
}
result += j_descr.static_descr;
if (auto pos = result.find("$VD"); pos != std::string::npos) {
result.replace(pos, 3, j_descr.var_descr);
}
return result;
}
case 3:
auto [stream_id, obj_id] = std::get<3>(*object_description);
std::string result = qpdf ? qpdf->getFilename() : "";
result += " object stream " + std::to_string(stream_id) + ", object " +
std::to_string(obj_id) + " 0 at offset " + std::to_string(parsed_offset + shift);
return result;
}
} else if (og.isIndirect()) {
return "object " + og.unparse(' ');
}
return {};
} | 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
callq *0x18(%rax)
movq %r14, (%rbx)
movl %ebp, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
| /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, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x140222(%rip), %rsi # 0x15e24e
movq %rax, %rdi
callq 0x192b0
movq 0x1d2f65(%rip), %rsi # 0x1f0fa0
movq 0x1d2f2e(%rip), %rdx # 0x1f0f70
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a40
movq %r14, %rdi
callq 0x19710
nop
| /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_available -= bits_to_skip;
}
} | 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 # 0x15e26c
movq %rax, %rdi
callq 0x19970
movq 0x1d2c2d(%rip), %rsi # 0x1f0fe8
movq 0x1d2bfe(%rip), %rdx # 0x1f0fc0
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a40
movq %r14, %rdi
callq 0x19710
| /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:
QIntC::range_check(this->cur_offset, offset);
this->cur_offset += offset;
break;
default:
throw std::logic_error("INTERNAL ERROR: invalid argument to BufferInputSource::seek");
break;
}
if (this->cur_offset < 0) {
throw std::runtime_error(this->description + ": seek before beginning of buffer");
}
} | 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 # 0x1f0fe8
movq 0x1d1e7f(%rip), %rdx # 0x1f0fc0
movq %r14, %rdi
callq 0x196e0
leaq 0xd8(%rbx), %r14
testq %rsi, %rsi
setg %cl
movq 0xd8(%rbx), %rax
testq %rax, %rax
setle %dl
cmpb %dl, %cl
je 0x1f17b
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f59c
movq (%r15), %rsi
movq (%r14), %rax
addq %rax, %rsi
movq %rsi, (%r14)
jmp 0x1f1bf
testq %rsi, %rsi
setg %cl
movq 0xe0(%rbx), %rax
testq %rax, %rax
setle %dl
cmpb %dl, %cl
je 0x1f1b5
leaq 0xe0(%rbx), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f59c
movq (%r14), %rax
movq (%r15), %rsi
addq %rax, %rsi
movq %rsi, 0xd8(%rbx)
testq %rsi, %rsi
js 0x1f1cf
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
addq $0xb0, %rbx
leaq 0x13f2cc(%rip), %rdx # 0x15e4b6
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1f34f
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1d1d90(%rip), %rsi # 0x1f0fa0
movq 0x1d1d59(%rip), %rdx # 0x1f0f70
movq %r14, %rdi
callq 0x196e0
jmp 0x1f246
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f23f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x1f249
jmp 0x1f251
movq %rax, %rbx
movq %r14, %rdi
callq 0x19a40
movq %rbx, %rdi
callq 0x19710
nop
| /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 std::range_error(msg.str());
} | 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 0x13eab6(%rip), %rsi # 0x15e301
leaq 0x28(%rsp), %rdi
movl $0x20, %edx
callq 0x19b40
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x19e00
movq %rax, %rbx
leaq 0x13eab1(%rip), %rsi # 0x15e322
movl $0x8, %edx
movq %rax, %rdi
callq 0x19b40
movl $0x8, %esi
movq %rbx, %rdi
callq 0x195b0
movq %rax, %rbx
leaq 0x13eca0(%rip), %rsi # 0x15e535
movl $0x17, %edx
movq %rax, %rdi
callq 0x19b40
movl $0x8, %esi
movq %rbx, %rdi
callq 0x195b0
leaq 0x13ea8f(%rip), %rsi # 0x15e345
movl $0x13, %edx
movq %rax, %rdi
callq 0x19b40
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x19410
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19e10
xorl %ebp, %ebp
movq 0x1d16e8(%rip), %rsi # 0x1f0fe0
movq 0x1d1609(%rip), %rdx # 0x1f0f08
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f925
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x1f92f
jmp 0x1f93c
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a40
jmp 0x1f93c
movq %rax, %r14
movq 0x1d161d(%rip), %rsi # 0x1f0f60
leaq 0x28(%rsp), %rdi
callq 0x197e0
leaq 0x98(%rsp), %rdi
callq 0x197a0
movq %r14, %rdi
callq 0x19710
nop
| /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 %rbx
retq
nop
| /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(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x20ef6
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
popq %rbx
jmp 0x19e30
| /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
movq 0x8(%rdi), %rsi
xorl %edx, %edx
movq %r14, %rcx
movl $0x20, %r8d
callq 0x19640
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x31a68
jmp 0x21817
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x14a29b(%rip), %rsi # 0x16ba7e
leaq 0x14a296(%rip), %rdx # 0x16ba80
movq %rsp, %rdi
callq 0x1df30
addq %r14, %r14
movq %rsp, %rdi
movq 0x8(%rdi), %rsi
xorl %edx, %edx
movq %r14, %rcx
movl $0x20, %r8d
callq 0x19640
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x31a68
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2182d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x21839
movq %rax, %rbx
jmp 0x21859
jmp 0x21840
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x21859
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
nop
| /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 = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x220b4
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x220ba
cmpq $0x2710, %rcx # imm = 0x2710
jb 0x220bd
movq %rcx, %rax
mulq %rsi
shrq $0xb, %rdx
addl $0x4, %r12d
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0x2207c
addl $-0x3, %r12d
jmp 0x220bd
addl $-0x2, %r12d
jmp 0x220bd
decl %r12d
leaq 0x10(%r14), %rdi
shrq $0x3f, %rbx
leal (%rbx,%r12), %esi
leaq 0x20(%r14), %rax
movq %rax, 0x10(%r14)
movl $0x2d, %edx
callq 0x19670
addq 0x10(%r14), %rbx
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20eff
| /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), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x1ee80
movq 0xf0(%rsp), %rdi
cmpq %r12, %rdi
je 0x26b01
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x104(%rsp), %rax
movq %r14, -0x14(%rax)
xorl %ecx, %ecx
movq %rcx, -0xc(%rax)
movl %ecx, -0x4(%rax)
movq %rcx, 0x4004(%rax)
movq %rax, 0x400c(%rax)
leaq 0x4148(%rsp), %r15
xorps %xmm0, %xmm0
movups %xmm0, -0x30(%r15)
movups %xmm0, -0x27(%r15)
movq %r15, -0x10(%r15)
movq %rcx, -0x8(%r15)
movb %cl, (%r15)
movq %rcx, 0x10(%r15)
movl %ecx, 0x18(%r15)
movups %xmm0, 0x20(%r15)
movq %rcx, 0x30(%r15)
leaq 0x4190(%rsp), %r14
movq %r14, -0x10(%r14)
movq %rcx, -0x8(%r14)
movb %cl, (%r14)
movq %rcx, 0x10(%r14)
leaq 0xf0(%rsp), %rsi
movq %rbx, %rdi
callq 0x2461c
movq 0x4180(%rsp), %rdi
cmpq %r14, %rdi
je 0x26b99
movq 0x4190(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x4168(%rsp), %r14
movq 0x4170(%rsp), %r12
cmpq %r12, %r14
je 0x26bcd
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x26bbc
callq 0x1fc74
addq $0x18, %r14
cmpq %r12, %r14
jne 0x26bae
movq 0x4168(%rsp), %r14
testq %r14, %r14
je 0x26be5
movq 0x4178(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x190e0
movq 0x4138(%rsp), %rdi
cmpq %r15, %rdi
je 0x26c02
movq 0x4148(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x8(%rsp), %rdi
callq 0x1ef82
movq %rbx, %rax
addq $0x41a8, %rsp # imm = 0x41A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x269f8
leaq 0x8(%rsp), %rdi
callq 0x1ef82
jmp 0x26c5f
movq %rax, %rbx
movq 0xf0(%rsp), %rdi
cmpq %r12, %rdi
je 0x26c5f
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x26c5f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x19710
nop
| /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 %rbx, %rdi
callq 0x2acb4
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2addd
callq 0x1fc74
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2adfe
callq 0x1fc74
movq %rbx, %rdi
callq 0x19710
| /jberkenbilt[P]qpdf/libqpdf/MD5.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.