Dataset Viewer (First 5GB)
name
string | code
string | asm
string | file
string | addresses
string | bin
string |
|---|---|---|---|---|---|
bool duckdb::BitpackingState<int, int>::Update<duckdb::EmptyBitpackingWriter>(int, bool)
|
bool Update(T value, bool is_valid) {
compression_buffer_validity[compression_buffer_idx] = is_valid;
all_valid = all_valid && is_valid;
all_invalid = all_invalid && !is_valid;
if (is_valid) {
compression_buffer[compression_buffer_idx] = value;
minimum = MinValue<T>(minimum, value);
maximum = MaxValue<T>(maximum, value);
}
compression_buffer_idx++;
if (compression_buffer_idx == BITPACKING_METADATA_GROUP_SIZE) {
bool success = Flush<OP>();
Reset();
return success;
}
return true;
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x4810(%rdi), %rax
movb %dl, 0x4010(%rdi,%rax)
andb %dl, 0x4844(%rdi)
xorb $0x1, %dl
andb %dl, 0x4845(%rdi)
testb %dl, %dl
jne 0xf888ff
movq 0x2008(%rbx), %rcx
movl %esi, (%rcx,%rax,4)
movl 0x4828(%rbx), %ecx
movl 0x482c(%rbx), %edx
cmpl %esi, %ecx
cmovgel %esi, %ecx
movl %ecx, 0x4828(%rbx)
cmpl %esi, %edx
cmovgl %edx, %esi
movl %esi, 0x482c(%rbx)
incq %rax
movq %rax, 0x4810(%rbx)
cmpq $0x800, %rax # imm = 0x800
jne 0xf8895b
movq %rbx, %rdi
callq 0xbcf4b0
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movl %ecx, 0x4828(%rbx)
movl %ecx, 0x4834(%rbx)
movl $0x80000000, %ecx # imm = 0x80000000
movq %rcx, 0x482c(%rbx)
movq %rcx, 0x4838(%rbx)
movabsq $0x10100000000, %rcx # imm = 0x10100000000
movq %rcx, 0x4840(%rbx)
movq $0x0, 0x4810(%rbx)
jmp 0xf8895d
movb $0x1, %al
popq %rbx
retq
nop
|
/duckdb[P]duckdb/src/storage/compression/bitpacking.cpp
|
0xf888ae
|
duckdb[P]duckdb[P]build_O1[P]tools[P]sqlite3_api_wrapper[P]libsqlite3_api_wrapper.so
|
CheckNinjaVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void CheckNinjaVersion(const string& version) {
int bin_major, bin_minor;
ParseVersion(kNinjaVersion, &bin_major, &bin_minor);
int file_major, file_minor;
ParseVersion(version, &file_major, &file_minor);
if (bin_major > file_major) {
Warning("ninja executable version (%s) greater than build file "
"ninja_required_version (%s); versions may be incompatible.",
kNinjaVersion, version.c_str());
return;
}
if ((bin_major == file_major && bin_minor < file_minor) ||
bin_major < file_major) {
Fatal("ninja version (%s) incompatible with build file "
"ninja_required_version version (%s).",
kNinjaVersion, version.c_str());
}
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x12de1(%rip), %rsi # 0x36478
leaq 0x18(%rsp), %r14
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0xd8e6
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x235c0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x236d6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53e0
leaq 0x18(%rsp), %r14
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x235c0
movl 0x14(%rsp), %eax
movl (%r14), %ecx
cmpl %ecx, %eax
jle 0x23710
movq 0x12d7b(%rip), %rsi # 0x36478
movq (%rbx), %rdx
leaq 0x4b54(%rip), %rdi # 0x2825b
xorl %eax, %eax
callq 0x5d90
jmp 0x2371c
jne 0x2371a
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jl 0x23724
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x12d4d(%rip), %rsi # 0x36478
movq (%rbx), %rdx
leaq 0x4b97(%rip), %rdi # 0x282cc
xorl %eax, %eax
callq 0x20df4
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2375a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53e0
movq %rbx, %rdi
callq 0x57e0
nop
|
/Kitware[P]ninja/src/version.cc
|
0x23686
|
Kitware[P]ninja[P]build_O1[P]canon_perftest
|
int baryonyx::itm::compute_order::run<baryonyx::itm::solver_inequalities_01coeff<float, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<float>, true>, baryonyx::bit_array, float>(baryonyx::itm::solver_inequalities_01coeff<float, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<float>, true>&, baryonyx::bit_array&, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, float, float, float)
|
int run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta)
{
bool pi_changed = false;
int remaining = 0;
switch (order) {
case solver_parameters::constraint_order::reversing:
solver.compute_update_row(
x, R.crbegin(), R.crend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::random_sorting:
std::shuffle(R.begin(), R.end(), rng);
solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::infeasibility_decr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return rhs.second < lhs.second;
});
solver.compute_update_row(
x, m_order.cbegin(), m_order.cend(), kappa, delta, theta);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::infeasibility_incr:
std::sort(m_order.begin(),
m_order.end(),
[](const auto& lhs, const auto& rhs) {
return lhs.second < rhs.second;
});
solver.compute_update_row(
x, m_order.cbegin(), m_order.cend(), kappa, delta, theta);
return infeasibility_local_compute_violated_constraints(solver, x);
case solver_parameters::constraint_order::lagrangian_decr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[rhs] < solver.pi[lhs];
});
solver.compute_update_row(
x, R.cbegin(), R.cend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::lagrangian_incr:
std::sort(
R.begin(), R.end(), [&solver](const auto lhs, const auto rhs) {
return solver.pi[lhs] < solver.pi[rhs];
});
solver.compute_update_row(
x, R.cbegin(), R.cend(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
case solver_parameters::constraint_order::pi_sign_change:
std::shuffle(R.begin(), R.end(), rng);
pi_changed = solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
remaining = local_compute_violated_constraints(solver, x);
if (!pi_changed && remaining == 0)
return 0;
return remaining;
case solver_parameters::constraint_order::none:
default:
solver.compute_update_row(
x, R.begin(), R.end(), kappa, delta, theta);
return compute_violated_constraints(solver, x, R);
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x30(%rdi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x278fd8
leaq 0x27e7f1(%rip), %rdx # 0x4f7650
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movq (%r14), %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x279722
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x27960d
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x27908f
movq %r13, %rax
subq %r12, %rax
sarq $0x2, %rax
lzcntq %rax, %rdx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
vmovss %xmm2, 0xc(%rsp)
vmovss %xmm1, 0x8(%rsp)
vmovss %xmm0, 0x4(%rsp)
callq 0x27b339
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x27b459
jmp 0x27907d
movq 0x18(%r14), %r12
movq 0x20(%r14), %r13
cmpq %r13, %r12
je 0x278faa
movq %r13, %rax
subq %r12, %rax
sarq $0x3, %rax
lzcntq %rax, %rdx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r13, %rsi
vmovss %xmm2, 0xc(%rsp)
vmovss %xmm1, 0x8(%rsp)
vmovss %xmm0, 0x4(%rsp)
callq 0x27aafd
movq %r12, %rdi
movq %r13, %rsi
callq 0x27ac07
jmp 0x278f98
movq 0x18(%r14), %r12
movq 0x20(%r14), %r13
cmpq %r13, %r12
je 0x278faa
movq %r13, %rax
subq %r12, %rax
sarq $0x3, %rax
lzcntq %rax, %rdx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r13, %rsi
vmovss %xmm2, 0xc(%rsp)
vmovss %xmm1, 0x8(%rsp)
vmovss %xmm0, 0x4(%rsp)
callq 0x27af1b
movq %r12, %rdi
movq %r13, %rsi
callq 0x27b025
vmovss 0x4(%rsp), %xmm0
vmovss 0x8(%rsp), %xmm1
vmovss 0xc(%rsp), %xmm2
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x279be6
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x279e3e
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
jmp 0x279027
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rcx, %rdx
vmovss %xmm2, 0xc(%rsp)
vmovss %xmm1, 0x8(%rsp)
vmovss %xmm0, 0x4(%rsp)
callq 0x45001
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
vmovss 0x4(%rsp), %xmm0
vmovss 0x8(%rsp), %xmm1
vmovss 0xc(%rsp), %xmm2
callq 0x27998e
jmp 0x2790a1
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x27908f
movq %r13, %rax
subq %r12, %rax
sarq $0x2, %rax
lzcntq %rax, %rdx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
vmovss %xmm2, 0xc(%rsp)
vmovss %xmm1, 0x8(%rsp)
vmovss %xmm0, 0x4(%rsp)
callq 0x27b751
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x27b871
vmovss 0x4(%rsp), %xmm0
vmovss 0x8(%rsp), %xmm1
vmovss 0xc(%rsp), %xmm2
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x279f46
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x27960d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rcx, %rdx
vmovss %xmm2, 0xc(%rsp)
vmovss %xmm1, 0x8(%rsp)
vmovss %xmm0, 0x4(%rsp)
callq 0x45001
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %rbx, %rsi
vmovss 0x4(%rsp), %xmm0
vmovss 0x8(%rsp), %xmm1
vmovss 0xc(%rsp), %xmm2
callq 0x27998e
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x27a19e
|
/quesnel[P]baryonyx/lib/src/itm-common.hpp
|
0x278e34
|
quesnel[P]baryonyx[P]build_O1[P]lib[P]testpreprocess
|
void Diligent::FormatStrSS<std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>, char [43], unsigned int, char [22], unsigned int, char [3]>(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [43], unsigned int const&, char const (&) [22], unsigned int const&, char const (&) [3])
|
void FormatStrSS(SSType& ss, const FirstArgType& FirstArg, const RestArgsType&... RestArgs)
{
FormatStrSS(ss, FirstArg);
FormatStrSS(ss, RestArgs...); // recursive call using pack expansion syntax
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x10(%rdi), %rbx
movq %rsi, %rdi
callq 0x8ebd0
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x8ff60
movl (%r12), %esi
movq %rbx, %rdi
callq 0x8eed0
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq (%rsp), %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11f3bf
|
/DiligentGraphics[P]DiligentCore/Primitives/interface/FormatString.hpp
|
0x11f647
|
DiligentGraphics[P]DiligentCore[P]build_O1[P]Graphics[P]GraphicsEngineVulkan[P]libGraphicsEngineVk.so
|
bool llvm::DenseMapBase<llvm::DenseMap<void*, clang::ento::CheckerManager::EventInfo, llvm::DenseMapInfo<void*, void>, llvm::detail::DenseMapPair<void*, clang::ento::CheckerManager::EventInfo>>, void*, clang::ento::CheckerManager::EventInfo, llvm::DenseMapInfo<void*, void>, llvm::detail::DenseMapPair<void*, clang::ento::CheckerManager::EventInfo>>::LookupBucketFor<void const*>(void const* const&, llvm::detail::DenseMapPair<void*, clang::ento::CheckerManager::EventInfo> const*&) const
|
bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of whether we find a tombstone while probing.
const BucketT *FoundTombstone = nullptr;
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
!KeyInfoT::isEqual(Val, TombstoneKey) &&
"Empty/Tombstone value shouldn't be inserted into map!");
unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
unsigned ProbeAmt = 1;
while (true) {
const BucketT *ThisBucket = BucketsPtr + BucketNo;
// Found Val's bucket? If so, return it.
if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
FoundBucket = ThisBucket;
return true;
}
// If we found an empty bucket, the key doesn't exist in the set.
// Insert it and return the default value.
if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
// If we've already seen a tombstone while probing, fill it in instead
// of the empty bucket we eventually probed to.
FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
return false;
}
// If this is a tombstone, remember it. If Val ends up not in the map, we
// prefer to return it than something that would require more probing.
if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
!FoundTombstone)
FoundTombstone = ThisBucket; // Remember the first tombstone found.
// Otherwise, it's a hash collision or a tombstone, continue quadratic
// probing.
BucketNo += ProbeAmt++;
BucketNo &= (NumBuckets-1);
}
}
|
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8b6bf60
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x8a6b300
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x8b6bd32
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rsp)
jmp 0x8b6be6b
movq $0x0, 0x40(%rsp)
callq 0x8a6b240
movq %rax, 0x38(%rsp)
callq 0x8a6d860
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rdi
callq 0x8b6bfb0
movl 0x4c(%rsp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x2c(%rsp)
movl $0x1, 0x28(%rsp)
movq 0x50(%rsp), %rax
movl 0x2c(%rsp), %ecx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x8b6bfd0
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0x2c3b010
testb $0x1, %al
jne 0x8b6bdad
jmp 0x8b6bdc4
movq 0x20(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x77(%rsp)
jmp 0x8b6be6b
movq 0x20(%rsp), %rdi
callq 0x8b6bfd0
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x2c3b010
testb $0x1, %al
jne 0x8b6bde1
jmp 0x8b6be13
cmpq $0x0, 0x40(%rsp)
je 0x8b6bdf5
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x8b6bdff
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movb $0x0, 0x77(%rsp)
jmp 0x8b6be6b
movq 0x20(%rsp), %rdi
callq 0x8b6bfd0
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x2c3b010
testb $0x1, %al
jne 0x8b6be30
jmp 0x8b6be42
cmpq $0x0, 0x40(%rsp)
jne 0x8b6be42
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x28(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rsp)
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
andl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x8b6bd6e
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
|
/llvm/ADT/DenseMap.h
|
0x8b6bce0
|
llvm-project[P]build_O0[P]bin[P]clang-19
|
google::operator<<(std::ostream&, google::Counter_t const&)
|
ostream& operator<<(ostream& os, const Counter_t&) {
#ifdef DISABLE_RTTI
LogMessage::LogStream* log = static_cast<LogMessage::LogStream*>(&os);
#else
auto* log = dynamic_cast<LogMessage::LogStream*>(&os);
#endif
CHECK(log && log == log->self())
<< "You must not use COUNTER with non-glog ostream";
os << log->ctr();
return os;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x1329b
movq -0xa0(%rbp), %rdi
movq 0x5ed4e(%rip), %rsi # 0x71fd0
leaq 0x5e207(%rip), %rdx # 0x71490
xorl %eax, %eax
movl %eax, %ecx
callq 0x9840
movq %rax, -0xa8(%rbp)
jmp 0x132a6
xorl %eax, %eax
movq %rax, -0xa8(%rbp)
jmp 0x132a6
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movb $0x0, -0x81(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0xa9(%rbp)
je 0x132f4
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b180
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
sete %al
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13305
jmp 0x13385
leaq -0x19(%rbp), %rdi
callq 0xdc60
leaq 0x3b6ea(%rip), %rsi # 0x4e9ff
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x7b0, %edx # imm = 0x7B0
callq 0x16520
movq -0xc8(%rbp), %rdi
movb $0x1, -0x81(%rbp)
callq 0x121e0
movq %rax, %rdi
leaq 0x3b7a7(%rip), %rsi # 0x4eaee
callq 0x96f0
movq %rax, -0xc0(%rbp)
jmp 0x13355
movq -0xc0(%rbp), %rdi
leaq 0x3b7b4(%rip), %rsi # 0x4eb17
callq 0x96f0
movq %rax, -0xd0(%rbp)
jmp 0x13371
movq -0xd0(%rbp), %rsi
leaq -0x19(%rbp), %rdi
callq 0xdc70
jmp 0x13383
jmp 0x13385
testb $0x1, -0x81(%rbp)
jne 0x13390
jmp 0x133b6
leaq -0x80(%rbp), %rdi
callq 0x16590
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
testb $0x1, -0x81(%rbp)
jne 0x133e6
jmp 0x133ef
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b1a0
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x9d60
movq -0x8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x80(%rbp), %rdi
callq 0x16590
jmp 0x133f1
movq -0x90(%rbp), %rdi
callq 0x9d00
nopl (%rax)
|
/sergiud[P]glog/src/logging.cc
|
0x13250
|
sergiud[P]glog[P]build_O0[P]cleanup_with_absolute_prefix_unittest
|
pagerAddPageToRollbackJournal
|
static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){
Pager *pPager = pPg->pPager;
int rc;
u32 cksum;
char *pData2;
i64 iOff = pPager->journalOff;
/* We should never write to the journal file the page that
** contains the database locks. The following assert verifies
** that we do not. */
assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
assert( pPager->journalHdr<=pPager->journalOff );
CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2);
cksum = pager_cksum(pPager, (u8*)pData2);
/* Even if an IO or diskfull error occurs while journalling the
** page in the block above, set the need-sync flag for the page.
** Otherwise, when the transaction is rolled back, the logic in
** playback_one_page() will think that the page needs to be restored
** in the database file. And if an IO error occurs while doing so,
** then corruption may follow.
*/
pPg->flags |= PGHDR_NEED_SYNC;
rc = write32bits(pPager->jfd, iOff, pPg->pgno);
if( rc!=SQLITE_OK ) return rc;
rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
if( rc!=SQLITE_OK ) return rc;
rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
if( rc!=SQLITE_OK ) return rc;
IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
pPager->journalOff, pPager->pageSize));
PAGER_INCR(sqlite3_pager_writej_count);
PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
PAGERID(pPager), pPg->pgno,
((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
pPager->journalOff += 8 + pPager->pageSize;
pPager->nRec++;
assert( pPager->pInJournal!=0 );
rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
testcase( rc==SQLITE_NOMEM );
assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
rc |= addToSavepointBitvecs(pPager, pPg->pgno);
assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
return rc;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2dc80
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x34(%rax), %ecx
orl $0x8, %ecx
movw %cx, 0x34(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edx
callq 0x27480
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x32cab
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32d75
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0xbc(%rax), %edx
movq -0x30(%rbp), %rcx
addq $0x4, %rcx
callq 0x11910
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x32ce2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32d75
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq 0xbc(%rax), %rax
addq %rax, %rsi
addq $0x4, %rsi
movl -0x20(%rbp), %edx
callq 0x27480
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x32d19
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32d75
movq -0x18(%rbp), %rax
movl 0xbc(%rax), %eax
addl $0x8, %eax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x27c30
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x274c0
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
|
/xujihui1985[P]learingcpp/thirdparty/sqlite3.c
|
0x32c30
|
xujihui1985[P]learingcpp[P]build_O0[P]sqlite
|
clang::RecursiveASTVisitor<(anonymous namespace)::DiagnoseUnguardedAvailability>::VisitOMPThreadLimitClause(clang::OMPThreadLimitClause*)
|
bool RecursiveASTVisitor<Derived>::VisitOMPThreadLimitClause(
OMPThreadLimitClause *C) {
TRY_TO(VisitOMPClauseWithPreInit(C));
TRY_TO(TraverseStmt(C->getThreadLimit()));
return true;
}
|
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x231ab30
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x20(%rsp)
je 0x24851bc
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2485860
testb $0x1, %al
jne 0x24851d6
movb $0x0, 0x47(%rsp)
jmp 0x2485212
jmp 0x24851d8
jmp 0x24851da
movq 0x28(%rsp), %rdi
callq 0x231ab30
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x73d6a0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x231a830
testb $0x1, %al
jne 0x248520b
movb $0x0, 0x47(%rsp)
jmp 0x2485212
jmp 0x248520d
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
|
/clang/AST/RecursiveASTVisitor.h
|
0x2485170
|
llvm-project[P]build_O0[P]bin[P]lldb-server
|
llvm::detail::DoubleAPFloat::DoubleAPFloat(llvm::fltSemantics const&, unsigned long)
|
DoubleAPFloat::DoubleAPFloat(const fltSemantics &S, integerPart I)
: Semantics(&S), Floats(new APFloat[2]{APFloat(semIEEEdouble, I),
APFloat(semIEEEdouble)}) {
assert(Semantics == &semPPCDoubleDouble);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, (%rdi)
movl $0x48, %edi
callq 0x11e3a0
movq %rax, %r15
movq $0x2, (%rax)
leaq 0x8(%rax), %r13
leaq 0x10(%rax), %rdi
leaq 0x1432981(%rip), %r12 # 0x1836f4c
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3fe5aa
addq $0x30, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3fe8b0
movq %r13, 0x8(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/Support/APFloat.cpp
|
0x404596
|
llvm-project[P]build_O3[P]bin[P]sancov
|
std::enable_if<is_hashable_data<char const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<char const>(char const*, char const*)
|
std::enable_if_t<is_hashable_data<ValueT>::value, hash_code>
hash_combine_range_impl(ValueT *first, ValueT *last) {
const uint64_t seed = get_execution_seed();
const char *s_begin = reinterpret_cast<const char *>(first);
const char *s_end = reinterpret_cast<const char *>(last);
const size_t length = std::distance(s_begin, s_end);
if (length <= 64)
return hash_short(s_begin, length, seed);
const char *s_aligned_end = s_begin + (length & ~63);
hash_state state = state.create(s_begin, seed);
s_begin += 64;
while (s_begin != s_aligned_end) {
state.mix(s_begin);
s_begin += 64;
}
if (length & 63)
state.mix(s_end - 64);
return state.finalize(length);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r15
movabsq $-0xae502812aa7333, %rdx # imm = 0xFF51AFD7ED558CCD
movq %rsi, %rbx
subq %rdi, %rbx
cmpq $0x40, %rbx
ja 0x4aa126
movq %r15, %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4aa1e4
movq %rsi, %r14
movq %rbx, %r13
andq $-0x40, %r13
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
movq %rdx, 0x8(%rdi)
movabsq $0x75c285c0667d5866, %rax # imm = 0x75C285C0667D5866
movq %rax, 0x10(%rdi)
movabsq $-0x7323d61940a0da1f, %rax # imm = 0x8CDC29E6BF5F25E1
movq %rax, 0x18(%rdi)
movabsq $-0x409daf76c3bff5e9, %rax # imm = 0xBF6250893C400A17
movq %rax, 0x20(%rdi)
addq $-0x11a5f, %rdx # imm = 0xFFFEE5A1
movq %rdx, 0x28(%rdi)
movabsq $-0x85335acd9bb6c6a, %rax # imm = 0xF7ACCA5326449396
movq %rax, 0x30(%rdi)
movq %r15, %rsi
callq 0x4aa444
cmpq $0x40, %r13
je 0x4aa1b3
addq $0x40, %r15
addq $-0x40, %r13
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4aa444
addq $0x40, %r15
addq $-0x40, %r13
jne 0x4aa19e
testb $0x3f, %bl
je 0x4aa1c9
addq $-0x40, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4aa444
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4aa528
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/llvm/ADT/Hashing.h
|
0x4aa0e8
|
llvm-project[P]build_O3[P]bin[P]clang-installapi
|
Variable_addTwoVariables_Test::~Variable_addTwoVariables_Test()
|
TEST(Variable, addTwoVariables)
{
const std::string in = "valid_name";
const std::string e =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<model xmlns=\"http://www.cellml.org/cellml/2.0#\">\n"
" <component name=\"valid_name\">\n"
" <variable name=\"variable1\"/>\n"
" <variable name=\"variable2\"/>\n"
" </component>\n"
"</model>\n";
libcellml::ModelPtr m = createModelWithComponent();
libcellml::ComponentPtr c = m->component(0);
c->setName(in);
libcellml::VariablePtr v1 = libcellml::Variable::create();
v1->setName("variable1");
c->addVariable(v1);
libcellml::VariablePtr v2 = libcellml::Variable::create();
v2->setName("variable2");
c->addVariable(v2);
libcellml::PrinterPtr printer = libcellml::Printer::create();
const std::string a = printer->printModel(m);
EXPECT_EQ(e, a);
}
|
pushq %rbx
movq %rdi, %rbx
callq 0xb640
pushq $0x10
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xb330
nop
|
/cellml[P]libcellml/tests/variable/variable.cpp
|
0x22db4
|
cellml[P]libcellml[P]build_O2[P]tests[P]test_variable
|
llvm::SmallPtrSetIterator<llvm::PHINode*>::operator++()
|
inline SmallPtrSetIterator& operator++() { // Preincrement
assert(isHandleInSync() && "invalid iterator access!");
if (shouldReverseIterate()) {
--Bucket;
RetreatIfNotValid();
return *this;
}
++Bucket;
AdvanceIfNotValid();
return *this;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x8, (%rdi)
callq 0x117e56c
movq %rbx, %rax
popq %rbx
retq
|
/llvm/ADT/SmallPtrSet.h
|
0x147957c
|
llvm-project[P]build_O2[P]bin[P]clang-19
|
testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
|
std::string XmlUnitTestResultPrinter::EscapeXml(
const std::string& str, bool is_attribute) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '<':
m << "<";
break;
case '>':
m << ">";
break;
case '&':
m << "&";
break;
case '\'':
if (is_attribute)
m << "'";
else
m << '\'';
break;
case '"':
if (is_attribute)
m << """;
else
m << '"';
break;
default:
if (IsValidXmlCharacter(ch)) {
if (is_attribute && IsNormalizableWhitespace(ch))
m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
<< ";";
else
m << ch;
}
break;
}
}
return m.GetString();
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r12
movq %rdi, -0x48(%rbp)
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0xc73e
movq (%rbx), %rax
movq %rax, -0x40(%rbp)
addq $0x10, %rax
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
leaq -0x70(%rbp), %r15
cmpq 0x8(%r12), %rbx
jae 0x12e0a
movq (%r12), %rax
movzbl (%rax,%rbx), %r14d
cmpl $0x22, %r14d
je 0x12dcf
cmpl $0x26, %r14d
je 0x12d2d
cmpl $0x27, %r14d
je 0x12d39
leaq 0x196be(%rip), %rsi # 0x2c3cf
cmpl $0x3e, %r14d
je 0x12ddc
cmpl $0x3c, %r14d
jne 0x12d5b
leaq 0x196a2(%rip), %rsi # 0x2c3ca
jmp 0x12ddc
leaq 0x196a0(%rip), %rsi # 0x2c3d4
jmp 0x12ddc
leaq 0x1969a(%rip), %rsi # 0x2c3da
cmpb $0x0, -0x2c(%rbp)
jne 0x12ddc
movq -0x38(%rbp), %rdi
pushq $0x27
popq %rsi
callq 0x8650
jmp 0x12de5
cmpb $0x1f, %r14b
jg 0x12d72
cmpl $0xd, %r14d
ja 0x12de5
movl $0x2600, %eax # imm = 0x2600
btl %r14d, %eax
jae 0x12de5
cmpb $0x0, -0x2c(%rbp)
je 0x12ded
cmpl $0xd, %r14d
ja 0x12ded
movl $0x2600, %eax # imm = 0x2600
btl %r14d, %eax
jae 0x12ded
movq -0x38(%rbp), %rdi
leaq 0x19654(%rip), %rsi # 0x2c3e8
callq 0x8500
movq %r15, %r13
movq %r15, %rdi
movl %r14d, %esi
callq 0xee58
movq -0x38(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x8480
movq %r14, %rdi
leaq 0x18a8c(%rip), %rsi # 0x2b84c
callq 0x8500
movq %r13, %rdi
callq 0x8b68
jmp 0x12de5
leaq 0x1960b(%rip), %rsi # 0x2c3e1
cmpb $0x0, -0x2c(%rbp)
je 0x12dfc
movq -0x38(%rbp), %rdi
callq 0x8500
incq %rbx
jmp 0x12ce0
movsbl %r14b, %esi
movq -0x38(%rbp), %rdi
callq 0x8650
jmp 0x12de5
movq -0x38(%rbp), %rdi
pushq $0x22
popq %rsi
callq 0x8650
jmp 0x12de5
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq -0x40(%rbp), %rbx
movq %rbx, %rsi
callq 0xc929
testq %rbx, %rbx
je 0x12e2b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12e53
jmp 0x12e53
jmp 0x12e53
jmp 0x12e53
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x8b68
jmp 0x12e56
movq %rax, %r14
cmpq $0x0, -0x40(%rbp)
je 0x12e67
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x8a30
nop
|
/metacall[P]core/build_O2/source/tests/src/google-test-depends/googletest/src/gtest.cc
|
0x12ca4
|
metacall[P]core[P]build_O2[P]metacall-handle-export-test
|
spirv_cross::AlignedBuffer<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 8ul>::data()
|
T *data()
{
#if defined(_MSC_VER) && _MSC_VER < 1900
// MSVC 2013 workarounds, sigh ...
// Only use this workaround on MSVC 2013 due to some confusion around default initialized unions.
// Spec seems to suggest the memory will be zero-initialized, which is *not* what we want.
return reinterpret_cast<T *>(u.aligned_char);
#else
return reinterpret_cast<T *>(aligned_char);
#endif
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
|
/3D4Medical[P]SPIRV-Cross/spirv_cross_containers.hpp
|
0x1b63d0
|
3D4Medical[P]SPIRV-Cross[P]build_O0[P]spirv-cross
|
spirv_cross::SPIRVariable* spirv_cross::ObjectPool<spirv_cross::SPIRVariable>::allocate<unsigned int&, spv::StorageClass, int, unsigned int&>(unsigned int&, spv::StorageClass&&, int&&, unsigned int&)
|
T *allocate(P &&... p)
{
if (vacants.empty())
{
unsigned num_objects = start_object_count << memory.size();
T *ptr = static_cast<T *>(malloc(num_objects * sizeof(T)));
if (!ptr)
return nullptr;
vacants.reserve(num_objects);
for (unsigned i = 0; i < num_objects; i++)
vacants.push_back(&ptr[i]);
memory.emplace_back(ptr);
}
T *ptr = vacants.back();
vacants.pop_back();
new (ptr) T(std::forward<P>(p)...);
return ptr;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x8, %rdi
callq 0x210300
testb $0x1, %al
jne 0x2ee4e9
jmp 0x2ee594
movq -0x70(%rbp), %rdi
movl 0x80(%rdi), %eax
movl %eax, -0x74(%rbp)
addq $0x28, %rdi
callq 0x210320
movq %rax, %rcx
movl -0x74(%rbp), %eax
shll %cl, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
imulq $0xb0, %rax, %rdi
callq 0x2da40
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x2ee531
movq $0x0, -0x8(%rbp)
jmp 0x2ee611
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x210340
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0x2ee583
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %ecx
imulq $0xb0, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x2104f0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2ee54a
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
callq 0x210540
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
callq 0x2105a0
movq -0x70(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
callq 0x2105c0
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq -0x5c(%rbp), %rdi
callq 0x1aec00
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x1aebe0
movq -0x30(%rbp), %rax
movl (%rax), %esi
leaq -0x64(%rbp), %rdi
callq 0x1add80
movq -0x80(%rbp), %rdi
movl -0x78(%rbp), %edx
movl -0x5c(%rbp), %esi
movl -0x60(%rbp), %ecx
movl -0x64(%rbp), %r8d
callq 0x210600
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
|
/HansKristian-Work[P]dxil-spirv/third_party/SPIRV-Cross/spirv_cross_containers.hpp
|
0x2ee4b0
|
HansKristian-Work[P]dxil-spirv[P]build_O0[P]dxil-spirv
|
wabt::WastParser::ParseModuleField(wabt::Module*)
|
Result WastParser::ParseModuleField(Module* module) {
WABT_TRACE(ParseModuleField);
switch (Peek(1)) {
case TokenType::Data: return ParseDataModuleField(module);
case TokenType::Elem: return ParseElemModuleField(module);
case TokenType::Except: return ParseExceptModuleField(module);
case TokenType::Export: return ParseExportModuleField(module);
case TokenType::Func: return ParseFuncModuleField(module);
case TokenType::Type: return ParseTypeModuleField(module);
case TokenType::Global: return ParseGlobalModuleField(module);
case TokenType::Import: return ParseImportModuleField(module);
case TokenType::Memory: return ParseMemoryModuleField(module);
case TokenType::Start: return ParseStartModuleField(module);
case TokenType::Table: return ParseTableModuleField(module);
default:
assert(
!"ParseModuleField should only be called if IsModuleField() is true");
return Result::Error;
}
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0xca3d32
addl $-0xb, %eax
cmpl $0x1a, %eax
ja 0xca6a2c
leaq 0x2782c6(%rip), %rcx # 0xf1ec44
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca6a4c
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca86e6
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca748e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca85d2
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca7002
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca76f8
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca6de4
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca8094
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca6ef0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca6c18
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xca79b6
leaq 0x2786c5(%rip), %rdi # 0xf1f0f8
leaq 0x278488(%rip), %rsi # 0xf1eec2
leaq 0x2786fc(%rip), %rcx # 0xf1f13d
movl $0x320, %edx # imm = 0x320
callq 0x1d0240
nop
|
/chakra-core[P]ChakraCore/lib/wabt/src/wast-parser.cc
|
0xca6956
|
chakra-core[P]ChakraCore[P]build_O2[P]bin[P]ChakraCore[P]libChakraCore.so
|
gguf_kv::gguf_kv(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
gguf_kv(const std::string & key, const std::string & value)
: key(key), is_array(false), type(GGUF_TYPE_STRING) {
GGML_ASSERT(!key.empty());
data_string.push_back(value);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
callq 0x16630
movb $0x0, 0x20(%r14)
movl $0x8, 0x24(%r14)
leaq 0x28(%r14), %rbp
leaq 0x40(%r14), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
cmpq $0x0, 0x8(%r13)
je 0x468b8
movq %r15, %rdi
movq %r12, %rsi
callq 0x16850
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1354e(%rip), %rdi # 0x59e0d
leaq 0x3d9b(%rip), %rdx # 0x4a661
leaq 0x13cf3(%rip), %rcx # 0x5a5c0
movl $0x96, %esi
xorl %eax, %eax
callq 0x17c60
movq %rax, %r12
movq %r15, %rdi
callq 0x16c50
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x468f9
movq 0x38(%r14), %rsi
subq %rdi, %rsi
callq 0x17070
movq %r14, %rdi
movq %rbx, %rsi
callq 0x189f0
movq %r12, %rdi
callq 0x17e20
|
/ggerganov[P]ggml/src/gguf.cpp
|
0x46846
|
ggerganov[P]ggml[P]build_O3[P]src[P]libggml-base.so
|
bool TestConstExpr::NotEqualTest<unsigned long long, long long>()
|
SAFEINT_CONSTEXPR11 bool NotEqualTest()
{
return
(U)2 != SafeInt<T>(3) &&
SafeInt<T>(4) != (U)5 &&
SafeInt<T>(6) != SafeInt<U>(7) &&
true != SafeInt<T>(1) &&
false != SafeInt<T>(0);
}
|
subq $0x68, %rsp
movl $0x3, 0x5c(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x1fe10
movq 0x60(%rsp), %rsi
movl $0x2, %edi
callq 0x1756d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x1755dc
jmp 0x1756bc
movl $0x4, 0x4c(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
callq 0x1fe10
movq 0x50(%rsp), %rdi
movl $0x5, %esi
callq 0x175700
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x175614
jmp 0x1756bc
movl $0x6, 0x3c(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x1fe10
movl $0x7, 0x2c(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x1e140
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x175730
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x175660
jmp 0x1756bc
movl $0x1, 0x1c(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x1fe10
movq 0x20(%rsp), %rsi
movl $0x1, %edi
callq 0x172110
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x175695
jmp 0x1756bc
movl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1fe10
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x172110
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw (%rax,%rax)
|
/dcleblanc[P]SafeInt/Test/ConstExpr.cpp
|
0x1755a0
|
dcleblanc[P]SafeInt[P]build_O0[P]Test[P]ClangTest[P]CompileTest_clang14_NoEH
|
readChunk_cHRM(LodePNGInfo*, unsigned char const*, unsigned long)
|
static unsigned readChunk_cHRM(LodePNGInfo* info, const unsigned char* data, size_t chunkLength) {
if(chunkLength != 32) return 97; /*invalid cHRM chunk size*/
info->chrm_defined = 1;
info->chrm_white_x = 16777216u * data[ 0] + 65536u * data[ 1] + 256u * data[ 2] + data[ 3];
info->chrm_white_y = 16777216u * data[ 4] + 65536u * data[ 5] + 256u * data[ 6] + data[ 7];
info->chrm_red_x = 16777216u * data[ 8] + 65536u * data[ 9] + 256u * data[10] + data[11];
info->chrm_red_y = 16777216u * data[12] + 65536u * data[13] + 256u * data[14] + data[15];
info->chrm_green_x = 16777216u * data[16] + 65536u * data[17] + 256u * data[18] + data[19];
info->chrm_green_y = 16777216u * data[20] + 65536u * data[21] + 256u * data[22] + data[23];
info->chrm_blue_x = 16777216u * data[24] + 65536u * data[25] + 256u * data[26] + data[27];
info->chrm_blue_y = 16777216u * data[28] + 65536u * data[29] + 256u * data[30] + data[31];
return 0; /* OK */
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x20, -0x20(%rbp)
je 0x2f2a3
movl $0x61, -0x4(%rbp)
jmp 0x2f47f
movq -0x10(%rbp), %rax
movl $0x1, 0xbc(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x7(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc4(%rax)
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x9(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0xa(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0xb(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc8(%rax)
movq -0x18(%rbp), %rax
movzbl 0xc(%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0xd(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0xe(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0xf(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xcc(%rax)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x11(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x12(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x13(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xd0(%rax)
movq -0x18(%rbp), %rax
movzbl 0x14(%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x15(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x16(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x17(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xd4(%rax)
movq -0x18(%rbp), %rax
movzbl 0x18(%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x19(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1a(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1b(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xd8(%rax)
movq -0x18(%rbp), %rax
movzbl 0x1c(%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1d(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1e(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movzbl 0x1f(%rax), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xdc(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/AGraber[P]librw/src/lodepng/lodepng.cpp
|
0x2f280
|
AGraber[P]librw[P]build_O0[P]tools[P]dumprwtree[P]dumprwtree
|
testing::internal::UnitTestImpl::UnitTestImpl(testing::UnitTest*)
|
UnitTestImpl::UnitTestImpl(UnitTest* parent)
: parent_(parent),
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
default_global_test_part_result_reporter_(this),
default_per_thread_test_part_result_reporter_(this),
GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_reporter_(
&default_global_test_part_result_reporter_),
per_thread_test_part_result_reporter_(
&default_per_thread_test_part_result_reporter_),
parameterized_test_registry_(),
parameterized_tests_registered_(false),
last_death_test_suite_(-1),
current_test_suite_(nullptr),
current_test_info_(nullptr),
ad_hoc_test_result_(),
os_stack_trace_getter_(nullptr),
post_flag_parse_init_performed_(false),
random_seed_(0), // Will be overridden by the flag before first use.
random_(0), // Will be reseeded before first use.
start_timestamp_(0),
elapsed_time_(0),
#ifdef GTEST_HAS_DEATH_TEST
death_test_factory_(new DefaultDeathTestFactory),
#endif
// Will be overridden by the flag before first use.
catch_exceptions_(false) {
listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
}
|
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0xa0(%rsp)
leaq 0x8fed2(%rip), %rax # 0x162f50
movq %rax, (%rdi)
movq 0xc8(%rsp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, 0x98(%rsp)
callq 0xdcb60
movq 0xa0(%rsp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
movq %rdi, 0xa8(%rsp)
callq 0xb90d0
jmp 0xd30bc
movq 0xa0(%rsp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
movq %rdi, 0x90(%rsp)
callq 0xb9220
jmp 0xd30da
movq 0xa0(%rsp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, 0x50(%rdi)
addq $0x58, %rdi
movq %rdi, 0x88(%rsp)
callq 0xe0240
jmp 0xd3100
movq 0xa0(%rsp), %rax
movq %rax, %rdi
addq $0x90, %rdi
movq %rdi, 0x80(%rsp)
addq $0x40, %rax
movq %rax, 0xb0(%rsp)
leaq 0xb0(%rsp), %rsi
callq 0xe36b0
jmp 0xd3135
movq 0xa0(%rsp), %rdi
addq $0xa0, %rdi
movq %rdi, 0x40(%rsp)
callq 0xe3740
movq 0xa0(%rsp), %rdi
addq $0xb8, %rdi
movq %rdi, 0x48(%rsp)
callq 0xe3750
movq 0xa0(%rsp), %rdi
addq $0xd0, %rdi
movq %rdi, 0x50(%rsp)
callq 0xe3760
movq 0xa0(%rsp), %rdi
addq $0x108, %rdi # imm = 0x108
movq %rdi, 0x58(%rsp)
callq 0xe1c10
movq 0xa0(%rsp), %rax
movq %rax, %rdi
addq $0x120, %rdi # imm = 0x120
movq %rdi, 0x60(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x160(%rax)
movups %xmm0, 0x150(%rax)
movups %xmm0, 0x140(%rax)
movups %xmm0, 0x130(%rax)
movups %xmm0, 0x120(%rax)
callq 0xe3770
movq 0xa0(%rsp), %rdi
addq $0x170, %rdi # imm = 0x170
movq %rdi, 0x68(%rsp)
callq 0xe37a0
movq 0xa0(%rsp), %rdi
addq $0x1a0, %rdi # imm = 0x1A0
movq %rdi, 0x70(%rsp)
callq 0xdda30
movq 0xa0(%rsp), %rdi
movb $0x0, 0x1d0(%rdi)
movl $0xffffffff, 0x1d4(%rdi) # imm = 0xFFFFFFFF
movq $0x0, 0x1d8(%rdi)
movq $0x0, 0x1e0(%rdi)
addq $0x1e8, %rdi # imm = 0x1E8
movq %rdi, 0x78(%rsp)
callq 0xbe0d0
jmp 0xd324f
movq 0xa0(%rsp), %rdi
addq $0x268, %rdi # imm = 0x268
movq %rdi, 0x38(%rsp)
callq 0xd1f20
jmp 0xd326a
movq 0xa0(%rsp), %rdi
movq $0x0, 0x280(%rdi)
movb $0x0, 0x288(%rdi)
movl $0x0, 0x28c(%rdi)
addq $0x290, %rdi # imm = 0x290
xorl %esi, %esi
callq 0xe37b0
jmp 0xd329e
movq 0xa0(%rsp), %rdi
movq $0x0, 0x298(%rdi)
movq $0x0, 0x2a0(%rdi)
addq $0x2a8, %rdi # imm = 0x2A8
movq %rdi, 0x20(%rsp)
callq 0xe37d0
movq 0xa0(%rsp), %rax
addq $0x2b0, %rax # imm = 0x2B0
movq %rax, 0x28(%rsp)
movl $0x8, %edi
callq 0xc810
movq %rax, 0x30(%rsp)
jmp 0xd32f1
movq 0x30(%rsp), %rdi
callq 0xe3800
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xe3830
movq 0xa0(%rsp), %rdi
addq $0x2b8, %rdi # imm = 0x2B8
movq %rdi, 0x18(%rsp)
callq 0xe3860
jmp 0xd3325
movq 0xa0(%rsp), %rdi
movb $0x0, 0x2c8(%rdi)
callq 0xdc140
movq %rax, 0x10(%rsp)
jmp 0xd3340
movl $0x8, %edi
callq 0xc810
movq %rax, 0x8(%rsp)
jmp 0xd3351
movq 0x8(%rsp), %rdi
callq 0xe38d0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xd2080
jmp 0xd336c
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xd3509
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xd34fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xd34ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xd34e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xd348f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xd3485
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xd347b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xd3471
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0xd3467
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
callq 0xe3900
movq 0x28(%rsp), %rdi
callq 0xe39d0
movq 0x20(%rsp), %rdi
callq 0xe3a30
movq 0x38(%rsp), %rdi
callq 0xd1fb0
movq 0x78(%rsp), %rdi
callq 0xbe130
movq 0x70(%rsp), %rdi
callq 0xdde60
movq 0x68(%rsp), %rdi
callq 0xe3a90
movq 0x60(%rsp), %rdi
callq 0xe3aa0
movq 0x58(%rsp), %rdi
callq 0xe1c20
movq 0x50(%rsp), %rdi
callq 0xe3b50
movq 0x48(%rsp), %rdi
callq 0xe3b60
movq 0x40(%rsp), %rdi
callq 0xe3bc0
movq 0x80(%rsp), %rdi
callq 0xe3c20
movq 0x88(%rsp), %rdi
callq 0xe0400
movq 0x90(%rsp), %rdi
callq 0xe3cf0
movq 0xa8(%rsp), %rdi
callq 0xe3d00
movq 0x98(%rsp), %rdi
callq 0xdca00
movq 0xc0(%rsp), %rdi
callq 0xd040
nopw %cs:(%rax,%rax)
|
/todo-group[P]exact/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
0xd3050
|
todo-group[P]exact[P]build_O0[P]ising[P]free_energy[P]square_finite_gt
|
ncnn::binary_op_broadcast_outer(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, int, ncnn::Option const&)
|
static int binary_op_broadcast_outer(const Mat& a, const Mat& b, Mat& c, int op_type, const Option& opt)
{
using namespace BinaryOp_x86_functor;
if (op_type == BinaryOp::Operation_ADD) return binary_op_broadcast_outer<binary_op_add>(a, b, c, opt);
if (op_type == BinaryOp::Operation_SUB) return binary_op_broadcast_outer<binary_op_sub>(a, b, c, opt);
if (op_type == BinaryOp::Operation_MUL) return binary_op_broadcast_outer<binary_op_mul>(a, b, c, opt);
if (op_type == BinaryOp::Operation_DIV) return binary_op_broadcast_outer<binary_op_div>(a, b, c, opt);
if (op_type == BinaryOp::Operation_MAX) return binary_op_broadcast_outer<binary_op_max>(a, b, c, opt);
if (op_type == BinaryOp::Operation_MIN) return binary_op_broadcast_outer<binary_op_min>(a, b, c, opt);
if (op_type == BinaryOp::Operation_POW) return binary_op_broadcast_outer<binary_op_pow>(a, b, c, opt);
if (op_type == BinaryOp::Operation_RSUB) return binary_op_broadcast_outer<binary_op_rsub>(a, b, c, opt);
if (op_type == BinaryOp::Operation_RDIV) return binary_op_broadcast_outer<binary_op_rdiv>(a, b, c, opt);
if (op_type == BinaryOp::Operation_RPOW) return binary_op_broadcast_outer<binary_op_rpow>(a, b, c, opt);
if (op_type == BinaryOp::Operation_ATAN2) return binary_op_broadcast_outer<binary_op_atan2>(a, b, c, opt);
if (op_type == BinaryOp::Operation_RATAN2) return binary_op_broadcast_outer<binary_op_ratan2>(a, b, c, opt);
// should never reach here
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
cmpl $0xb, %ecx
ja 0x2839df
movl %ecx, %eax
leaq 0x1dae37(%rip), %rcx # 0x45ca24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rsi
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r9d
movl %r9d, %ecx
movl 0x34(%rsi), %edx
movl 0x38(%rsi), %edi
movq %rdi, 0x18(%rsp)
movl 0x18(%rsi), %r8d
movl 0x28(%rsi), %edi
cmpl $0x2, %edi
sete %r10b
testl %r9d, %r9d
setg %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x281ce3
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r10b
cmpl $0x1, %r8d
setne %r9b
orb %r10b, %dil
orb %r10b, %r9b
xorl %r10d, %r10d
movq 0x10(%rsp), %rsi
movslq 0x2c(%rsi), %r11
imulq %r10, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
movq 0x30(%rsp), %r15
movslq 0x2c(%r15), %rbx
imulq %r10, %rbx
imulq 0x10(%r15), %rbx
movq 0x20(%rsp), %r14
movq (%r14), %r14
addq (%r15), %rbx
testb %dil, %dil
jne 0x281cad
movl %eax, %ebp
movups (%r11), %xmm0
movss (%r14), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
addps %xmm0, %xmm1
movups %xmm1, (%rbx)
addq $0x10, %r11
addq $0x4, %r14
addq $0x10, %rbx
decl %ebp
jne 0x281c8a
testb %r9b, %r9b
jne 0x281ccf
xorl %r15d, %r15d
movss (%r14,%r15,4), %xmm0
addss (%r11,%r15,4), %xmm0
movss %xmm0, (%rbx,%r15,4)
incq %r15
cmpl %r15d, %eax
jne 0x281cb5
incq %r10
cmpq %rcx, %r10
jne 0x281c56
movq 0x10(%rsp), %rsi
movl 0x28(%rsi), %edi
addl $-0x3, %edi
cmpl $0x2, %edi
setb %dil
cmpl $0x0, 0x18(%rsp)
setg %r9b
andb %dil, %r9b
cmpb $0x1, %r9b
jne 0x2839df
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r9b
cmpl $0x1, %r8d
setne %r8b
orb %r9b, %dil
orb %r9b, %r8b
xorl %r9d, %r9d
testl %edx, %edx
jle 0x281e16
movq 0x30(%rsp), %r11
movq 0x40(%r11), %r10
imulq %r9, %r10
imulq 0x10(%r11), %r10
addq (%r11), %r10
movq 0x10(%rsp), %rsi
movq 0x40(%rsi), %r11
imulq %r9, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x281e0c
movq 0x20(%rsp), %r14
movl 0x34(%r14), %ebp
decl %ebp
cmpl %ebx, %ebp
cmovgel %ebx, %ebp
movslq %ebp, %r14
xorl %ebp, %ebp
movq 0x20(%rsp), %rsi
movslq 0x30(%rsi), %r12
leal -0x1(%r12), %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movslq 0x2c(%rsi), %r13
imulq 0x10(%rsi), %r13
imulq %r14, %r12
imulq %r13, %r12
addq (%rsi), %r12
movslq %r15d, %r15
imulq %r13, %r15
addq %r12, %r15
testb %dil, %dil
jne 0x281dd3
movl %eax, %r12d
movups (%r11), %xmm0
movss (%r15), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
addps %xmm0, %xmm1
movups %xmm1, (%r10)
addq $0x10, %r11
addq $0x4, %r15
addq $0x10, %r10
decl %r12d
jne 0x281dae
testb %r8b, %r8b
jne 0x281e02
xorl %r12d, %r12d
xorl %r13d, %r13d
movss (%r15,%r13,4), %xmm0
addss (%r11,%r13,4), %xmm0
movss %xmm0, (%r10,%r13,4)
incq %r13
addq $-0x4, %r12
cmpl %r13d, %eax
jne 0x281dde
subq %r12, %r10
subq %r12, %r11
incl %ebp
cmpl %ecx, %ebp
jne 0x281d73
incl %ebx
cmpl %edx, %ebx
jne 0x281d56
incq %r9
cmpq 0x18(%rsp), %r9
jne 0x281d22
jmp 0x2839df
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ebx
movl 0x30(%rax), %ecx
movl %ecx, %r12d
movl 0x34(%rax), %edx
movl %edx, 0x3c(%rsp)
movl 0x38(%rax), %edx
movq %rdx, 0x78(%rsp)
movl 0x18(%rax), %esi
movl 0x28(%rax), %eax
cmpl $0x2, %eax
sete %dl
testl %ecx, %ecx
setg %cl
andb %dl, %cl
cmpb $0x1, %cl
movq %r12, 0x80(%rsp)
jne 0x281f76
cmpl $0x4, %esi
setne %cl
testl %ebx, %ebx
setle %al
movl %esi, 0x2c(%rsp)
cmpl $0x1, %esi
setne %dl
orb %al, %cl
movb %cl, 0xe(%rsp)
orb %al, %dl
movb %dl, 0xd(%rsp)
xorl %ecx, %ecx
leaq 0x60(%rsp), %r15
leaq 0x50(%rsp), %rdx
movq %rbx, 0x48(%rsp)
movq 0x10(%rsp), %rax
movslq 0x2c(%rax), %r14
imulq %rcx, %r14
imulq 0x10(%rax), %r14
addq (%rax), %r14
movq 0x30(%rsp), %rax
movslq 0x2c(%rax), %r12
movq %rcx, 0x18(%rsp)
imulq %rcx, %r12
imulq 0x10(%rax), %r12
movq 0x20(%rsp), %rcx
movq (%rcx), %r13
addq (%rax), %r12
cmpb $0x0, 0xe(%rsp)
jne 0x281f1c
movl %ebx, %ebp
movq %rdx, %rbx
movups (%r14), %xmm0
movaps %xmm0, 0x60(%rsp)
movss (%r13), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm0, 0x50(%rsp)
leaq 0xf(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x28598e
movups %xmm0, (%r12)
addq $0x10, %r14
addq $0x4, %r13
addq $0x10, %r12
decl %ebp
jne 0x281edf
cmpb $0x0, 0xd(%rsp)
movq 0x48(%rsp), %rbp
jne 0x281f49
xorl %ebx, %ebx
movss (%r13,%rbx,4), %xmm0
movss (%r14,%rbx,4), %xmm1
callq 0x5e170
movss %xmm0, (%r12,%rbx,4)
incq %rbx
cmpl %ebx, %ebp
jne 0x281f2a
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x80(%rsp), %r12
cmpq %r12, %rcx
movq %rbp, %rbx
leaq 0x50(%rsp), %rdx
jne 0x281e9c
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movl 0x2c(%rsp), %esi
addl $-0x3, %eax
cmpl $0x2, %eax
setb %al
cmpl $0x0, 0x78(%rsp)
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2839df
cmpl $0x4, %esi
setne %cl
testl %ebx, %ebx
setle %al
cmpl $0x1, %esi
setne %dl
orb %al, %cl
movb %cl, 0xe(%rsp)
orb %al, %dl
movb %dl, 0xd(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdx
cmpl $0x0, 0x3c(%rsp)
jle 0x282113
movq 0x30(%rsp), %rax
movq 0x40(%rax), %r15
movq 0x40(%rsp), %rcx
imulq %rcx, %r15
imulq 0x10(%rax), %r15
addq (%rax), %r15
movq 0x10(%rsp), %rax
movq 0x40(%rax), %r14
imulq %rcx, %r14
imulq 0x10(%rax), %r14
addq (%rax), %r14
xorl %ecx, %ecx
testl %r12d, %r12d
movl %ecx, 0x2c(%rsp)
jle 0x282103
movq 0x20(%rsp), %rax
movl 0x34(%rax), %eax
decl %eax
cmpl %ecx, %eax
cmovgel %ecx, %eax
cltq
movq %rax, 0x48(%rsp)
xorl %r8d, %r8d
movq 0x20(%rsp), %rdi
movslq 0x30(%rdi), %rax
leal -0x1(%rax), %ecx
cmpl %r8d, %ecx
movl %r8d, 0x18(%rsp)
cmovgel %r8d, %ecx
movslq 0x2c(%rdi), %r8
imulq 0x10(%rdi), %r8
imulq 0x48(%rsp), %rax
imulq %r8, %rax
addq (%rdi), %rax
movslq %ecx, %r13
imulq %r8, %r13
addq %rax, %r13
cmpb $0x0, 0xe(%rsp)
jne 0x2820a5
movl %ebx, %ebp
movups (%r14), %xmm0
movaps %xmm0, 0x60(%rsp)
movss (%r13), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm0, 0x50(%rsp)
leaq 0xf(%rsp), %rdi
callq 0x28598e
leaq 0x50(%rsp), %rdx
leaq 0x60(%rsp), %rsi
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x4, %r13
addq $0x10, %r15
decl %ebp
jne 0x282065
cmpb $0x0, 0xd(%rsp)
jne 0x2820f2
xorl %ebp, %ebp
movq %rbx, %r12
xorl %ebx, %ebx
movss (%r13,%rbx,4), %xmm0
movss (%r14,%rbx,4), %xmm1
callq 0x5e170
movss %xmm0, (%r15,%rbx,4)
incq %rbx
addq $-0x4, %rbp
cmpl %ebx, %r12d
jne 0x2820b3
subq %rbp, %r15
subq %rbp, %r14
movq %r12, %rbx
movq 0x80(%rsp), %r12
leaq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movl 0x18(%rsp), %r8d
incl %r8d
cmpl %r12d, %r8d
jne 0x282024
movl 0x2c(%rsp), %ecx
incl %ecx
cmpl 0x3c(%rsp), %ecx
jne 0x281ffe
movq 0x40(%rsp), %rcx
incq %rcx
movq %rcx, 0x40(%rsp)
cmpq 0x78(%rsp), %rcx
jne 0x281fc2
jmp 0x2839df
movq 0x10(%rsp), %rsi
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r9d
movl %r9d, %ecx
movl 0x34(%rsi), %edx
movl 0x38(%rsi), %edi
movq %rdi, 0x18(%rsp)
movl 0x18(%rsi), %r8d
movl 0x28(%rsi), %edi
cmpl $0x2, %edi
sete %r10b
testl %r9d, %r9d
setg %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x28221d
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r10b
cmpl $0x1, %r8d
setne %r9b
orb %r10b, %dil
orb %r10b, %r9b
xorl %r10d, %r10d
movq 0x10(%rsp), %rsi
movslq 0x2c(%rsi), %r11
imulq %r10, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
movq 0x30(%rsp), %r15
movslq 0x2c(%r15), %rbx
imulq %r10, %rbx
imulq 0x10(%r15), %rbx
movq 0x20(%rsp), %r14
movq (%r14), %r14
addq (%r15), %rbx
testb %dil, %dil
jne 0x2821e7
movl %eax, %ebp
movups (%r11), %xmm0
movss (%r14), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
maxps %xmm0, %xmm1
movups %xmm1, (%rbx)
addq $0x10, %r11
addq $0x4, %r14
addq $0x10, %rbx
decl %ebp
jne 0x2821c4
testb %r9b, %r9b
jne 0x282209
xorl %r15d, %r15d
movss (%r14,%r15,4), %xmm0
maxss (%r11,%r15,4), %xmm0
movss %xmm0, (%rbx,%r15,4)
incq %r15
cmpl %r15d, %eax
jne 0x2821ef
incq %r10
cmpq %rcx, %r10
jne 0x282190
movq 0x10(%rsp), %rsi
movl 0x28(%rsi), %edi
addl $-0x3, %edi
cmpl $0x2, %edi
setb %dil
cmpl $0x0, 0x18(%rsp)
setg %r9b
andb %dil, %r9b
cmpb $0x1, %r9b
jne 0x2839df
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r9b
cmpl $0x1, %r8d
setne %r8b
orb %r9b, %dil
orb %r9b, %r8b
xorl %r9d, %r9d
testl %edx, %edx
jle 0x282350
movq 0x30(%rsp), %r11
movq 0x40(%r11), %r10
imulq %r9, %r10
imulq 0x10(%r11), %r10
addq (%r11), %r10
movq 0x10(%rsp), %rsi
movq 0x40(%rsi), %r11
imulq %r9, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x282346
movq 0x20(%rsp), %r14
movl 0x34(%r14), %ebp
decl %ebp
cmpl %ebx, %ebp
cmovgel %ebx, %ebp
movslq %ebp, %r14
xorl %ebp, %ebp
movq 0x20(%rsp), %rsi
movslq 0x30(%rsi), %r12
leal -0x1(%r12), %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movslq 0x2c(%rsi), %r13
imulq 0x10(%rsi), %r13
imulq %r14, %r12
imulq %r13, %r12
addq (%rsi), %r12
movslq %r15d, %r15
imulq %r13, %r15
addq %r12, %r15
testb %dil, %dil
jne 0x28230d
movl %eax, %r12d
movups (%r11), %xmm0
movss (%r15), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
maxps %xmm0, %xmm1
movups %xmm1, (%r10)
addq $0x10, %r11
addq $0x4, %r15
addq $0x10, %r10
decl %r12d
jne 0x2822e8
testb %r8b, %r8b
jne 0x28233c
xorl %r12d, %r12d
xorl %r13d, %r13d
movss (%r15,%r13,4), %xmm0
maxss (%r11,%r13,4), %xmm0
movss %xmm0, (%r10,%r13,4)
incq %r13
addq $-0x4, %r12
cmpl %r13d, %eax
jne 0x282318
subq %r12, %r10
subq %r12, %r11
incl %ebp
cmpl %ecx, %ebp
jne 0x2822ad
incl %ebx
cmpl %edx, %ebx
jne 0x282290
incq %r9
cmpq 0x18(%rsp), %r9
jne 0x28225c
jmp 0x2839df
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ebx
movl 0x30(%rax), %ecx
movl %ecx, %r12d
movl 0x34(%rax), %edx
movl %edx, 0x3c(%rsp)
movl 0x38(%rax), %edx
movq %rdx, 0x78(%rsp)
movl 0x18(%rax), %esi
movl 0x28(%rax), %eax
cmpl $0x2, %eax
sete %dl
testl %ecx, %ecx
setg %cl
andb %dl, %cl
cmpb $0x1, %cl
movq %r12, 0x80(%rsp)
jne 0x2824b0
cmpl $0x4, %esi
setne %cl
testl %ebx, %ebx
setle %al
movl %esi, 0x2c(%rsp)
cmpl $0x1, %esi
setne %dl
orb %al, %cl
movb %cl, 0xe(%rsp)
orb %al, %dl
movb %dl, 0xd(%rsp)
xorl %ecx, %ecx
leaq 0x60(%rsp), %r15
leaq 0x50(%rsp), %rdx
movq %rbx, 0x48(%rsp)
movq 0x10(%rsp), %rax
movslq 0x2c(%rax), %r14
imulq %rcx, %r14
imulq 0x10(%rax), %r14
addq (%rax), %r14
movq 0x30(%rsp), %rax
movslq 0x2c(%rax), %r12
movq %rcx, 0x18(%rsp)
imulq %rcx, %r12
imulq 0x10(%rax), %r12
movq 0x20(%rsp), %rcx
movq (%rcx), %r13
addq (%rax), %r12
cmpb $0x0, 0xe(%rsp)
jne 0x282456
movl %ebx, %ebp
movq %rdx, %rbx
movups (%r14), %xmm0
movaps %xmm0, 0x60(%rsp)
movss (%r13), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm0, 0x50(%rsp)
leaq 0xf(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x285696
movups %xmm0, (%r12)
addq $0x10, %r14
addq $0x4, %r13
addq $0x10, %r12
decl %ebp
jne 0x282419
cmpb $0x0, 0xd(%rsp)
movq 0x48(%rsp), %rbp
jne 0x282483
xorl %ebx, %ebx
movss (%r13,%rbx,4), %xmm0
movss (%r14,%rbx,4), %xmm1
callq 0x5e0e0
movss %xmm0, (%r12,%rbx,4)
incq %rbx
cmpl %ebx, %ebp
jne 0x282464
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x80(%rsp), %r12
cmpq %r12, %rcx
movq %rbp, %rbx
leaq 0x50(%rsp), %rdx
jne 0x2823d6
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movl 0x2c(%rsp), %esi
addl $-0x3, %eax
cmpl $0x2, %eax
setb %al
cmpl $0x0, 0x78(%rsp)
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2839df
cmpl $0x4, %esi
setne %cl
testl %ebx, %ebx
setle %al
cmpl $0x1, %esi
setne %dl
orb %al, %cl
movb %cl, 0xe(%rsp)
orb %al, %dl
movb %dl, 0xd(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdx
cmpl $0x0, 0x3c(%rsp)
jle 0x28264d
movq 0x30(%rsp), %rax
movq 0x40(%rax), %r15
movq 0x40(%rsp), %rcx
imulq %rcx, %r15
imulq 0x10(%rax), %r15
addq (%rax), %r15
movq 0x10(%rsp), %rax
movq 0x40(%rax), %r14
imulq %rcx, %r14
imulq 0x10(%rax), %r14
addq (%rax), %r14
xorl %ecx, %ecx
testl %r12d, %r12d
movl %ecx, 0x2c(%rsp)
jle 0x28263d
movq 0x20(%rsp), %rax
movl 0x34(%rax), %eax
decl %eax
cmpl %ecx, %eax
cmovgel %ecx, %eax
cltq
movq %rax, 0x48(%rsp)
xorl %r8d, %r8d
movq 0x20(%rsp), %rdi
movslq 0x30(%rdi), %rax
leal -0x1(%rax), %ecx
cmpl %r8d, %ecx
movl %r8d, 0x18(%rsp)
cmovgel %r8d, %ecx
movslq 0x2c(%rdi), %r8
imulq 0x10(%rdi), %r8
imulq 0x48(%rsp), %rax
imulq %r8, %rax
addq (%rdi), %rax
movslq %ecx, %r13
imulq %r8, %r13
addq %rax, %r13
cmpb $0x0, 0xe(%rsp)
jne 0x2825df
movl %ebx, %ebp
movups (%r14), %xmm0
movaps %xmm0, 0x60(%rsp)
movss (%r13), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm0, 0x50(%rsp)
leaq 0xf(%rsp), %rdi
callq 0x285696
leaq 0x50(%rsp), %rdx
leaq 0x60(%rsp), %rsi
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x4, %r13
addq $0x10, %r15
decl %ebp
jne 0x28259f
cmpb $0x0, 0xd(%rsp)
jne 0x28262c
xorl %ebp, %ebp
movq %rbx, %r12
xorl %ebx, %ebx
movss (%r13,%rbx,4), %xmm0
movss (%r14,%rbx,4), %xmm1
callq 0x5e0e0
movss %xmm0, (%r15,%rbx,4)
incq %rbx
addq $-0x4, %rbp
cmpl %ebx, %r12d
jne 0x2825ed
subq %rbp, %r15
subq %rbp, %r14
movq %r12, %rbx
movq 0x80(%rsp), %r12
leaq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movl 0x18(%rsp), %r8d
incl %r8d
cmpl %r12d, %r8d
jne 0x28255e
movl 0x2c(%rsp), %ecx
incl %ecx
cmpl 0x3c(%rsp), %ecx
jne 0x282538
movq 0x40(%rsp), %rcx
incq %rcx
movq %rcx, 0x40(%rsp)
cmpq 0x78(%rsp), %rcx
jne 0x2824fc
jmp 0x2839df
movq 0x10(%rsp), %rsi
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r9d
movl %r9d, %ecx
movl 0x34(%rsi), %edx
movl 0x38(%rsi), %edi
movq %rdi, 0x18(%rsp)
movl 0x18(%rsi), %r8d
movl 0x28(%rsi), %edi
cmpl $0x2, %edi
sete %r10b
testl %r9d, %r9d
setg %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x282757
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r10b
cmpl $0x1, %r8d
setne %r9b
orb %r10b, %dil
orb %r10b, %r9b
xorl %r10d, %r10d
movq 0x10(%rsp), %rsi
movslq 0x2c(%rsi), %r11
imulq %r10, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
movq 0x30(%rsp), %r15
movslq 0x2c(%r15), %rbx
imulq %r10, %rbx
imulq 0x10(%r15), %rbx
movq 0x20(%rsp), %r14
movq (%r14), %r14
addq (%r15), %rbx
testb %dil, %dil
jne 0x282721
movl %eax, %ebp
movups (%r11), %xmm0
movss (%r14), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
mulps %xmm0, %xmm1
movups %xmm1, (%rbx)
addq $0x10, %r11
addq $0x4, %r14
addq $0x10, %rbx
decl %ebp
jne 0x2826fe
testb %r9b, %r9b
jne 0x282743
xorl %r15d, %r15d
movss (%r14,%r15,4), %xmm0
mulss (%r11,%r15,4), %xmm0
movss %xmm0, (%rbx,%r15,4)
incq %r15
cmpl %r15d, %eax
jne 0x282729
incq %r10
cmpq %rcx, %r10
jne 0x2826ca
movq 0x10(%rsp), %rsi
movl 0x28(%rsi), %edi
addl $-0x3, %edi
cmpl $0x2, %edi
setb %dil
cmpl $0x0, 0x18(%rsp)
setg %r9b
andb %dil, %r9b
cmpb $0x1, %r9b
jne 0x2839df
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r9b
cmpl $0x1, %r8d
setne %r8b
orb %r9b, %dil
orb %r9b, %r8b
xorl %r9d, %r9d
testl %edx, %edx
jle 0x28288a
movq 0x30(%rsp), %r11
movq 0x40(%r11), %r10
imulq %r9, %r10
imulq 0x10(%r11), %r10
addq (%r11), %r10
movq 0x10(%rsp), %rsi
movq 0x40(%rsi), %r11
imulq %r9, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x282880
movq 0x20(%rsp), %r14
movl 0x34(%r14), %ebp
decl %ebp
cmpl %ebx, %ebp
cmovgel %ebx, %ebp
movslq %ebp, %r14
xorl %ebp, %ebp
movq 0x20(%rsp), %rsi
movslq 0x30(%rsi), %r12
leal -0x1(%r12), %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movslq 0x2c(%rsi), %r13
imulq 0x10(%rsi), %r13
imulq %r14, %r12
imulq %r13, %r12
addq (%rsi), %r12
movslq %r15d, %r15
imulq %r13, %r15
addq %r12, %r15
testb %dil, %dil
jne 0x282847
movl %eax, %r12d
movups (%r11), %xmm0
movss (%r15), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
mulps %xmm0, %xmm1
movups %xmm1, (%r10)
addq $0x10, %r11
addq $0x4, %r15
addq $0x10, %r10
decl %r12d
jne 0x282822
testb %r8b, %r8b
jne 0x282876
xorl %r12d, %r12d
xorl %r13d, %r13d
movss (%r15,%r13,4), %xmm0
mulss (%r11,%r13,4), %xmm0
movss %xmm0, (%r10,%r13,4)
incq %r13
addq $-0x4, %r12
cmpl %r13d, %eax
jne 0x282852
subq %r12, %r10
subq %r12, %r11
incl %ebp
cmpl %ecx, %ebp
jne 0x2827e7
incl %ebx
cmpl %edx, %ebx
jne 0x2827ca
incq %r9
cmpq 0x18(%rsp), %r9
jne 0x282796
jmp 0x2839df
movq 0x10(%rsp), %rsi
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r9d
movl %r9d, %ecx
movl 0x34(%rsi), %edx
movl 0x38(%rsi), %edi
movq %rdi, 0x18(%rsp)
movl 0x18(%rsi), %r8d
movl 0x28(%rsi), %edi
cmpl $0x2, %edi
sete %r10b
testl %r9d, %r9d
setg %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x282995
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r10b
cmpl $0x1, %r8d
setne %r9b
orb %r10b, %dil
orb %r10b, %r9b
xorl %r10d, %r10d
movss 0x1d350c(%rip), %xmm0 # 0x455e0c
movq 0x10(%rsp), %rsi
movslq 0x2c(%rsi), %r11
imulq %r10, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
movq 0x30(%rsp), %r15
movslq 0x2c(%r15), %rbx
imulq %r10, %rbx
imulq 0x10(%r15), %rbx
movq 0x20(%rsp), %r14
movq (%r14), %r14
addq (%r15), %rbx
testb %dil, %dil
jne 0x28295f
movl %eax, %ebp
movaps %xmm0, %xmm1
divss (%r14), %xmm1
movups (%r11), %xmm2
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
mulps %xmm2, %xmm1
movups %xmm1, (%rbx)
addq $0x10, %r11
addq $0x4, %r14
addq $0x10, %rbx
decl %ebp
jne 0x282939
testb %r9b, %r9b
jne 0x282981
xorl %r15d, %r15d
movss (%r11,%r15,4), %xmm1
divss (%r14,%r15,4), %xmm1
movss %xmm1, (%rbx,%r15,4)
incq %r15
cmpl %r15d, %eax
jne 0x282967
incq %r10
cmpq %rcx, %r10
jne 0x282905
movq 0x10(%rsp), %rsi
movl 0x28(%rsi), %edi
addl $-0x3, %edi
cmpl $0x2, %edi
setb %dil
cmpl $0x0, 0x18(%rsp)
setg %r9b
andb %dil, %r9b
cmpb $0x1, %r9b
jne 0x2839df
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r9b
cmpl $0x1, %r8d
setne %r8b
orb %r9b, %dil
orb %r9b, %r8b
xorl %r9d, %r9d
movss 0x1d3430(%rip), %xmm0 # 0x455e0c
testl %edx, %edx
jle 0x282ad3
movq 0x30(%rsp), %r11
movq 0x40(%r11), %r10
imulq %r9, %r10
imulq 0x10(%r11), %r10
addq (%r11), %r10
movq 0x10(%rsp), %rsi
movq 0x40(%rsi), %r11
imulq %r9, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x282ac9
movq 0x20(%rsp), %r14
movl 0x34(%r14), %ebp
decl %ebp
cmpl %ebx, %ebp
cmovgel %ebx, %ebp
movslq %ebp, %r14
xorl %ebp, %ebp
movq 0x20(%rsp), %rsi
movslq 0x30(%rsi), %r12
leal -0x1(%r12), %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movslq 0x2c(%rsi), %r13
imulq 0x10(%rsi), %r13
imulq %r14, %r12
imulq %r13, %r12
addq (%rsi), %r12
movslq %r15d, %r15
imulq %r13, %r15
addq %r12, %r15
testb %dil, %dil
jne 0x282a90
movl %eax, %r12d
movaps %xmm0, %xmm1
divss (%r15), %xmm1
movups (%r11), %xmm2
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
mulps %xmm2, %xmm1
movups %xmm1, (%r10)
addq $0x10, %r11
addq $0x4, %r15
addq $0x10, %r10
decl %r12d
jne 0x282a68
testb %r8b, %r8b
jne 0x282abf
xorl %r12d, %r12d
xorl %r13d, %r13d
movss (%r11,%r13,4), %xmm1
divss (%r15,%r13,4), %xmm1
movss %xmm1, (%r10,%r13,4)
incq %r13
addq $-0x4, %r12
cmpl %r13d, %eax
jne 0x282a9b
subq %r12, %r10
subq %r12, %r11
incl %ebp
cmpl %ecx, %ebp
jne 0x282a2d
incl %ebx
cmpl %edx, %ebx
jne 0x282a10
incq %r9
cmpq 0x18(%rsp), %r9
jne 0x2829dc
jmp 0x2839df
movq 0x10(%rsp), %rsi
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r9d
movl %r9d, %ecx
movl 0x34(%rsi), %edx
movl 0x38(%rsi), %edi
movq %rdi, 0x18(%rsp)
movl 0x18(%rsi), %r8d
movl 0x28(%rsi), %edi
cmpl $0x2, %edi
sete %r10b
testl %r9d, %r9d
setg %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x282bd3
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r10b
cmpl $0x1, %r8d
setne %r9b
orb %r10b, %dil
orb %r10b, %r9b
xorl %r10d, %r10d
movq 0x10(%rsp), %rsi
movslq 0x2c(%rsi), %r11
imulq %r10, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
movq 0x30(%rsp), %r15
movslq 0x2c(%r15), %rbx
imulq %r10, %rbx
imulq 0x10(%r15), %rbx
movq 0x20(%rsp), %r14
movq (%r14), %r14
addq (%r15), %rbx
testb %dil, %dil
jne 0x282b9d
movl %eax, %ebp
movups (%r11), %xmm0
movss (%r14), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
subps %xmm0, %xmm1
movups %xmm1, (%rbx)
addq $0x10, %r11
addq $0x4, %r14
addq $0x10, %rbx
decl %ebp
jne 0x282b7a
testb %r9b, %r9b
jne 0x282bbf
xorl %r15d, %r15d
movss (%r14,%r15,4), %xmm0
subss (%r11,%r15,4), %xmm0
movss %xmm0, (%rbx,%r15,4)
incq %r15
cmpl %r15d, %eax
jne 0x282ba5
incq %r10
cmpq %rcx, %r10
jne 0x282b46
movq 0x10(%rsp), %rsi
movl 0x28(%rsi), %edi
addl $-0x3, %edi
cmpl $0x2, %edi
setb %dil
cmpl $0x0, 0x18(%rsp)
setg %r9b
andb %dil, %r9b
cmpb $0x1, %r9b
jne 0x2839df
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r9b
cmpl $0x1, %r8d
setne %r8b
orb %r9b, %dil
orb %r9b, %r8b
xorl %r9d, %r9d
testl %edx, %edx
jle 0x282d06
movq 0x30(%rsp), %r11
movq 0x40(%r11), %r10
imulq %r9, %r10
imulq 0x10(%r11), %r10
addq (%r11), %r10
movq 0x10(%rsp), %rsi
movq 0x40(%rsi), %r11
imulq %r9, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x282cfc
movq 0x20(%rsp), %r14
movl 0x34(%r14), %ebp
decl %ebp
cmpl %ebx, %ebp
cmovgel %ebx, %ebp
movslq %ebp, %r14
xorl %ebp, %ebp
movq 0x20(%rsp), %rsi
movslq 0x30(%rsi), %r12
leal -0x1(%r12), %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movslq 0x2c(%rsi), %r13
imulq 0x10(%rsi), %r13
imulq %r14, %r12
imulq %r13, %r12
addq (%rsi), %r12
movslq %r15d, %r15
imulq %r13, %r15
addq %r12, %r15
testb %dil, %dil
jne 0x282cc3
movl %eax, %r12d
movups (%r11), %xmm0
movss (%r15), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
subps %xmm0, %xmm1
movups %xmm1, (%r10)
addq $0x10, %r11
addq $0x4, %r15
addq $0x10, %r10
decl %r12d
jne 0x282c9e
testb %r8b, %r8b
jne 0x282cf2
xorl %r12d, %r12d
xorl %r13d, %r13d
movss (%r15,%r13,4), %xmm0
subss (%r11,%r13,4), %xmm0
movss %xmm0, (%r10,%r13,4)
incq %r13
addq $-0x4, %r12
cmpl %r13d, %eax
jne 0x282cce
subq %r12, %r10
subq %r12, %r11
incl %ebp
cmpl %ecx, %ebp
jne 0x282c63
incl %ebx
cmpl %edx, %ebx
jne 0x282c46
incq %r9
cmpq 0x18(%rsp), %r9
jne 0x282c12
jmp 0x2839df
movq 0x10(%rsp), %rsi
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r9d
movl %r9d, %ecx
movl 0x34(%rsi), %edx
movl 0x38(%rsi), %edi
movq %rdi, 0x18(%rsp)
movl 0x18(%rsi), %r8d
movl 0x28(%rsi), %edi
cmpl $0x2, %edi
sete %r10b
testl %r9d, %r9d
setg %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x282e06
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r10b
cmpl $0x1, %r8d
setne %r9b
orb %r10b, %dil
orb %r10b, %r9b
xorl %r10d, %r10d
movq 0x10(%rsp), %rsi
movslq 0x2c(%rsi), %r11
imulq %r10, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
movq 0x30(%rsp), %r15
movslq 0x2c(%r15), %rbx
imulq %r10, %rbx
imulq 0x10(%r15), %rbx
movq 0x20(%rsp), %r14
movq (%r14), %r14
addq (%r15), %rbx
testb %dil, %dil
jne 0x282dd0
movl %eax, %ebp
movups (%r11), %xmm0
movss (%r14), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
subps %xmm1, %xmm0
movups %xmm0, (%rbx)
addq $0x10, %r11
addq $0x4, %r14
addq $0x10, %rbx
decl %ebp
jne 0x282dad
testb %r9b, %r9b
jne 0x282df2
xorl %r15d, %r15d
movss (%r11,%r15,4), %xmm0
subss (%r14,%r15,4), %xmm0
movss %xmm0, (%rbx,%r15,4)
incq %r15
cmpl %r15d, %eax
jne 0x282dd8
incq %r10
cmpq %rcx, %r10
jne 0x282d79
movq 0x10(%rsp), %rsi
movl 0x28(%rsi), %edi
addl $-0x3, %edi
cmpl $0x2, %edi
setb %dil
cmpl $0x0, 0x18(%rsp)
setg %r9b
andb %dil, %r9b
cmpb $0x1, %r9b
jne 0x2839df
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r9b
cmpl $0x1, %r8d
setne %r8b
orb %r9b, %dil
orb %r9b, %r8b
xorl %r9d, %r9d
testl %edx, %edx
jle 0x282f39
movq 0x30(%rsp), %r11
movq 0x40(%r11), %r10
imulq %r9, %r10
imulq 0x10(%r11), %r10
addq (%r11), %r10
movq 0x10(%rsp), %rsi
movq 0x40(%rsi), %r11
imulq %r9, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x282f2f
movq 0x20(%rsp), %r14
movl 0x34(%r14), %ebp
decl %ebp
cmpl %ebx, %ebp
cmovgel %ebx, %ebp
movslq %ebp, %r14
xorl %ebp, %ebp
movq 0x20(%rsp), %rsi
movslq 0x30(%rsi), %r12
leal -0x1(%r12), %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movslq 0x2c(%rsi), %r13
imulq 0x10(%rsi), %r13
imulq %r14, %r12
imulq %r13, %r12
addq (%rsi), %r12
movslq %r15d, %r15
imulq %r13, %r15
addq %r12, %r15
testb %dil, %dil
jne 0x282ef6
movl %eax, %r12d
movups (%r11), %xmm0
movss (%r15), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
subps %xmm1, %xmm0
movups %xmm0, (%r10)
addq $0x10, %r11
addq $0x4, %r15
addq $0x10, %r10
decl %r12d
jne 0x282ed1
testb %r8b, %r8b
jne 0x282f25
xorl %r12d, %r12d
xorl %r13d, %r13d
movss (%r11,%r13,4), %xmm0
subss (%r15,%r13,4), %xmm0
movss %xmm0, (%r10,%r13,4)
incq %r13
addq $-0x4, %r12
cmpl %r13d, %eax
jne 0x282f01
subq %r12, %r10
subq %r12, %r11
incl %ebp
cmpl %ecx, %ebp
jne 0x282e96
incl %ebx
cmpl %edx, %ebx
jne 0x282e79
incq %r9
cmpq 0x18(%rsp), %r9
jne 0x282e45
jmp 0x2839df
movq 0x10(%rsp), %rsi
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r9d
movl %r9d, %ecx
movl 0x34(%rsi), %edx
movl 0x38(%rsi), %edi
movq %rdi, 0x18(%rsp)
movl 0x18(%rsi), %r8d
movl 0x28(%rsi), %edi
cmpl $0x2, %edi
sete %r10b
testl %r9d, %r9d
setg %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x283039
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r10b
cmpl $0x1, %r8d
setne %r9b
orb %r10b, %dil
orb %r10b, %r9b
xorl %r10d, %r10d
movq 0x10(%rsp), %rsi
movslq 0x2c(%rsi), %r11
imulq %r10, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
movq 0x30(%rsp), %r15
movslq 0x2c(%r15), %rbx
imulq %r10, %rbx
imulq 0x10(%r15), %rbx
movq 0x20(%rsp), %r14
movq (%r14), %r14
addq (%r15), %rbx
testb %dil, %dil
jne 0x283003
movl %eax, %ebp
movups (%r11), %xmm0
movss (%r14), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
minps %xmm0, %xmm1
movups %xmm1, (%rbx)
addq $0x10, %r11
addq $0x4, %r14
addq $0x10, %rbx
decl %ebp
jne 0x282fe0
testb %r9b, %r9b
jne 0x283025
xorl %r15d, %r15d
movss (%r14,%r15,4), %xmm0
minss (%r11,%r15,4), %xmm0
movss %xmm0, (%rbx,%r15,4)
incq %r15
cmpl %r15d, %eax
jne 0x28300b
incq %r10
cmpq %rcx, %r10
jne 0x282fac
movq 0x10(%rsp), %rsi
movl 0x28(%rsi), %edi
addl $-0x3, %edi
cmpl $0x2, %edi
setb %dil
cmpl $0x0, 0x18(%rsp)
setg %r9b
andb %dil, %r9b
cmpb $0x1, %r9b
jne 0x2839df
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r9b
cmpl $0x1, %r8d
setne %r8b
orb %r9b, %dil
orb %r9b, %r8b
xorl %r9d, %r9d
testl %edx, %edx
jle 0x28316c
movq 0x30(%rsp), %r11
movq 0x40(%r11), %r10
imulq %r9, %r10
imulq 0x10(%r11), %r10
addq (%r11), %r10
movq 0x10(%rsp), %rsi
movq 0x40(%rsi), %r11
imulq %r9, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x283162
movq 0x20(%rsp), %r14
movl 0x34(%r14), %ebp
decl %ebp
cmpl %ebx, %ebp
cmovgel %ebx, %ebp
movslq %ebp, %r14
xorl %ebp, %ebp
movq 0x20(%rsp), %rsi
movslq 0x30(%rsi), %r12
leal -0x1(%r12), %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movslq 0x2c(%rsi), %r13
imulq 0x10(%rsi), %r13
imulq %r14, %r12
imulq %r13, %r12
addq (%rsi), %r12
movslq %r15d, %r15
imulq %r13, %r15
addq %r12, %r15
testb %dil, %dil
jne 0x283129
movl %eax, %r12d
movups (%r11), %xmm0
movss (%r15), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
minps %xmm0, %xmm1
movups %xmm1, (%r10)
addq $0x10, %r11
addq $0x4, %r15
addq $0x10, %r10
decl %r12d
jne 0x283104
testb %r8b, %r8b
jne 0x283158
xorl %r12d, %r12d
xorl %r13d, %r13d
movss (%r15,%r13,4), %xmm0
minss (%r11,%r13,4), %xmm0
movss %xmm0, (%r10,%r13,4)
incq %r13
addq $-0x4, %r12
cmpl %r13d, %eax
jne 0x283134
subq %r12, %r10
subq %r12, %r11
incl %ebp
cmpl %ecx, %ebp
jne 0x2830c9
incl %ebx
cmpl %edx, %ebx
jne 0x2830ac
incq %r9
cmpq 0x18(%rsp), %r9
jne 0x283078
jmp 0x2839df
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ebx
movl 0x30(%rax), %ecx
movl %ecx, %r12d
movl 0x34(%rax), %edx
movl %edx, 0x3c(%rsp)
movl 0x38(%rax), %edx
movq %rdx, 0x78(%rsp)
movl 0x18(%rax), %esi
movl 0x28(%rax), %eax
cmpl $0x2, %eax
sete %dl
testl %ecx, %ecx
setg %cl
andb %dl, %cl
cmpb $0x1, %cl
movq %r12, 0x80(%rsp)
jne 0x2832cc
cmpl $0x4, %esi
setne %cl
testl %ebx, %ebx
setle %al
movl %esi, 0x2c(%rsp)
cmpl $0x1, %esi
setne %dl
orb %al, %cl
movb %cl, 0xe(%rsp)
orb %al, %dl
movb %dl, 0xd(%rsp)
xorl %ecx, %ecx
leaq 0x60(%rsp), %r15
leaq 0x50(%rsp), %rdx
movq %rbx, 0x48(%rsp)
movq 0x10(%rsp), %rax
movslq 0x2c(%rax), %r14
imulq %rcx, %r14
imulq 0x10(%rax), %r14
addq (%rax), %r14
movq 0x30(%rsp), %rax
movslq 0x2c(%rax), %r12
movq %rcx, 0x18(%rsp)
imulq %rcx, %r12
imulq 0x10(%rax), %r12
movq 0x20(%rsp), %rcx
movq (%rcx), %r13
addq (%rax), %r12
cmpb $0x0, 0xe(%rsp)
jne 0x283272
movl %ebx, %ebp
movq %rdx, %rbx
movups (%r14), %xmm0
movaps %xmm0, 0x60(%rsp)
movss (%r13), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm0, 0x50(%rsp)
leaq 0xf(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x28552a
movups %xmm0, (%r12)
addq $0x10, %r14
addq $0x4, %r13
addq $0x10, %r12
decl %ebp
jne 0x283235
cmpb $0x0, 0xd(%rsp)
movq 0x48(%rsp), %rbp
jne 0x28329f
xorl %ebx, %ebx
movss (%r14,%rbx,4), %xmm0
movss (%r13,%rbx,4), %xmm1
callq 0x5e0e0
movss %xmm0, (%r12,%rbx,4)
incq %rbx
cmpl %ebx, %ebp
jne 0x283280
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x80(%rsp), %r12
cmpq %r12, %rcx
movq %rbp, %rbx
leaq 0x50(%rsp), %rdx
jne 0x2831f2
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movl 0x2c(%rsp), %esi
addl $-0x3, %eax
cmpl $0x2, %eax
setb %al
cmpl $0x0, 0x78(%rsp)
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2839df
cmpl $0x4, %esi
setne %cl
testl %ebx, %ebx
setle %al
cmpl $0x1, %esi
setne %dl
orb %al, %cl
movb %cl, 0xe(%rsp)
orb %al, %dl
movb %dl, 0xd(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdx
cmpl $0x0, 0x3c(%rsp)
jle 0x283469
movq 0x30(%rsp), %rax
movq 0x40(%rax), %r15
movq 0x40(%rsp), %rcx
imulq %rcx, %r15
imulq 0x10(%rax), %r15
addq (%rax), %r15
movq 0x10(%rsp), %rax
movq 0x40(%rax), %r14
imulq %rcx, %r14
imulq 0x10(%rax), %r14
addq (%rax), %r14
xorl %ecx, %ecx
testl %r12d, %r12d
movl %ecx, 0x2c(%rsp)
jle 0x283459
movq 0x20(%rsp), %rax
movl 0x34(%rax), %eax
decl %eax
cmpl %ecx, %eax
cmovgel %ecx, %eax
cltq
movq %rax, 0x48(%rsp)
xorl %r8d, %r8d
movq 0x20(%rsp), %rdi
movslq 0x30(%rdi), %rax
leal -0x1(%rax), %ecx
cmpl %r8d, %ecx
movl %r8d, 0x18(%rsp)
cmovgel %r8d, %ecx
movslq 0x2c(%rdi), %r8
imulq 0x10(%rdi), %r8
imulq 0x48(%rsp), %rax
imulq %r8, %rax
addq (%rdi), %rax
movslq %ecx, %r13
imulq %r8, %r13
addq %rax, %r13
cmpb $0x0, 0xe(%rsp)
jne 0x2833fb
movl %ebx, %ebp
movups (%r14), %xmm0
movaps %xmm0, 0x60(%rsp)
movss (%r13), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm0, 0x50(%rsp)
leaq 0xf(%rsp), %rdi
callq 0x28552a
leaq 0x50(%rsp), %rdx
leaq 0x60(%rsp), %rsi
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x4, %r13
addq $0x10, %r15
decl %ebp
jne 0x2833bb
cmpb $0x0, 0xd(%rsp)
jne 0x283448
xorl %ebp, %ebp
movq %rbx, %r12
xorl %ebx, %ebx
movss (%r14,%rbx,4), %xmm0
movss (%r13,%rbx,4), %xmm1
callq 0x5e0e0
movss %xmm0, (%r15,%rbx,4)
incq %rbx
addq $-0x4, %rbp
cmpl %ebx, %r12d
jne 0x283409
subq %rbp, %r15
subq %rbp, %r14
movq %r12, %rbx
movq 0x80(%rsp), %r12
leaq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movl 0x18(%rsp), %r8d
incl %r8d
cmpl %r12d, %r8d
jne 0x28337a
movl 0x2c(%rsp), %ecx
incl %ecx
cmpl 0x3c(%rsp), %ecx
jne 0x283354
movq 0x40(%rsp), %rcx
incq %rcx
movq %rcx, 0x40(%rsp)
cmpq 0x78(%rsp), %rcx
jne 0x283318
jmp 0x2839df
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ebx
movl 0x30(%rax), %ecx
movl %ecx, %r12d
movl 0x34(%rax), %edx
movl %edx, 0x3c(%rsp)
movl 0x38(%rax), %edx
movq %rdx, 0x78(%rsp)
movl 0x18(%rax), %esi
movl 0x28(%rax), %eax
cmpl $0x2, %eax
sete %dl
testl %ecx, %ecx
setg %cl
andb %dl, %cl
cmpb $0x1, %cl
movq %r12, 0x80(%rsp)
jne 0x2835d3
cmpl $0x4, %esi
setne %cl
testl %ebx, %ebx
setle %al
movl %esi, 0x2c(%rsp)
cmpl $0x1, %esi
setne %dl
orb %al, %cl
movb %cl, 0xe(%rsp)
orb %al, %dl
movb %dl, 0xd(%rsp)
xorl %edx, %edx
leaq 0x60(%rsp), %r15
leaq 0x50(%rsp), %rsi
movq %rbx, 0x48(%rsp)
movq 0x10(%rsp), %rax
movslq 0x2c(%rax), %r14
imulq %rdx, %r14
imulq 0x10(%rax), %r14
addq (%rax), %r14
movq 0x30(%rsp), %rax
movslq 0x2c(%rax), %r12
imulq %rdx, %r12
imulq 0x10(%rax), %r12
movq 0x20(%rsp), %rcx
movq (%rcx), %r13
addq (%rax), %r12
cmpb $0x0, 0xe(%rsp)
movq %rdx, 0x18(%rsp)
jne 0x283579
movl %ebx, %ebp
movq %rsi, %rbx
movups (%r14), %xmm0
movaps %xmm0, 0x60(%rsp)
movss (%r13), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm0, 0x50(%rsp)
leaq 0xf(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x285802
movups %xmm0, (%r12)
addq $0x10, %r14
addq $0x4, %r13
addq $0x10, %r12
decl %ebp
jne 0x28353c
cmpb $0x0, 0xd(%rsp)
movq 0x48(%rsp), %rbp
jne 0x2835a6
xorl %ebx, %ebx
movss (%r14,%rbx,4), %xmm0
movss (%r13,%rbx,4), %xmm1
callq 0x5e170
movss %xmm0, (%r12,%rbx,4)
incq %rbx
cmpl %ebx, %ebp
jne 0x283587
movq 0x18(%rsp), %rdx
incq %rdx
movq 0x80(%rsp), %r12
cmpq %r12, %rdx
movq %rbp, %rbx
leaq 0x50(%rsp), %rsi
jne 0x2834f9
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movl 0x2c(%rsp), %esi
addl $-0x3, %eax
cmpl $0x2, %eax
setb %al
cmpl $0x0, 0x78(%rsp)
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2839df
cmpl $0x4, %esi
setne %cl
testl %ebx, %ebx
setle %al
cmpl $0x1, %esi
setne %dl
orb %al, %cl
movb %cl, 0xe(%rsp)
orb %al, %dl
movb %dl, 0xd(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdx
cmpl $0x0, 0x3c(%rsp)
jle 0x283770
movq 0x30(%rsp), %rax
movq 0x40(%rax), %r15
movq 0x40(%rsp), %rcx
imulq %rcx, %r15
imulq 0x10(%rax), %r15
addq (%rax), %r15
movq 0x10(%rsp), %rax
movq 0x40(%rax), %r14
imulq %rcx, %r14
imulq 0x10(%rax), %r14
addq (%rax), %r14
xorl %ecx, %ecx
testl %r12d, %r12d
movl %ecx, 0x2c(%rsp)
jle 0x283760
movq 0x20(%rsp), %rax
movl 0x34(%rax), %eax
decl %eax
cmpl %ecx, %eax
cmovgel %ecx, %eax
cltq
movq %rax, 0x48(%rsp)
xorl %r8d, %r8d
movq 0x20(%rsp), %rdi
movslq 0x30(%rdi), %rax
leal -0x1(%rax), %ecx
cmpl %r8d, %ecx
movl %r8d, 0x18(%rsp)
cmovgel %r8d, %ecx
movslq 0x2c(%rdi), %r8
imulq 0x10(%rdi), %r8
imulq 0x48(%rsp), %rax
imulq %r8, %rax
addq (%rdi), %rax
movslq %ecx, %r13
imulq %r8, %r13
addq %rax, %r13
cmpb $0x0, 0xe(%rsp)
jne 0x283702
movl %ebx, %ebp
movups (%r14), %xmm0
movaps %xmm0, 0x60(%rsp)
movss (%r13), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm0, 0x50(%rsp)
leaq 0xf(%rsp), %rdi
callq 0x285802
leaq 0x50(%rsp), %rdx
leaq 0x60(%rsp), %rsi
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x4, %r13
addq $0x10, %r15
decl %ebp
jne 0x2836c2
cmpb $0x0, 0xd(%rsp)
jne 0x28374f
xorl %ebp, %ebp
movq %rbx, %r12
xorl %ebx, %ebx
movss (%r14,%rbx,4), %xmm0
movss (%r13,%rbx,4), %xmm1
callq 0x5e170
movss %xmm0, (%r15,%rbx,4)
incq %rbx
addq $-0x4, %rbp
cmpl %ebx, %r12d
jne 0x283710
subq %rbp, %r15
subq %rbp, %r14
movq %r12, %rbx
movq 0x80(%rsp), %r12
leaq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movl 0x18(%rsp), %r8d
incl %r8d
cmpl %r12d, %r8d
jne 0x283681
movl 0x2c(%rsp), %ecx
incl %ecx
cmpl 0x3c(%rsp), %ecx
jne 0x28365b
movq 0x40(%rsp), %rcx
incq %rcx
movq %rcx, 0x40(%rsp)
cmpq 0x78(%rsp), %rcx
jne 0x28361f
jmp 0x2839df
movq 0x10(%rsp), %rsi
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r9d
movl %r9d, %ecx
movl 0x34(%rsi), %edx
movl 0x38(%rsi), %edi
movq %rdi, 0x18(%rsp)
movl 0x18(%rsi), %r8d
movl 0x28(%rsi), %edi
cmpl $0x2, %edi
sete %r10b
testl %r9d, %r9d
setg %r9b
andb %r10b, %r9b
cmpb $0x1, %r9b
jne 0x28388c
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r10b
cmpl $0x1, %r8d
setne %r9b
orb %r10b, %dil
orb %r10b, %r9b
xorl %r10d, %r10d
movq 0x10(%rsp), %rsi
movslq 0x2c(%rsi), %r11
imulq %r10, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
movq 0x30(%rsp), %r15
movslq 0x2c(%r15), %rbx
imulq %r10, %rbx
imulq 0x10(%r15), %rbx
movq 0x20(%rsp), %r14
movq (%r14), %r14
addq (%r15), %rbx
testb %dil, %dil
jne 0x283856
movl %eax, %ebp
movups (%r11), %xmm0
rcpps %xmm0, %xmm1
movss (%r14), %xmm2
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
movaps %xmm2, %xmm3
mulps %xmm1, %xmm3
mulps %xmm3, %xmm0
subps %xmm0, %xmm2
mulps %xmm1, %xmm2
addps %xmm3, %xmm2
movups %xmm2, (%rbx)
addq $0x10, %r11
addq $0x4, %r14
addq $0x10, %rbx
decl %ebp
jne 0x283821
testb %r9b, %r9b
jne 0x283878
xorl %r15d, %r15d
movss (%r14,%r15,4), %xmm0
divss (%r11,%r15,4), %xmm0
movss %xmm0, (%rbx,%r15,4)
incq %r15
cmpl %r15d, %eax
jne 0x28385e
incq %r10
cmpq %rcx, %r10
jne 0x2837ed
movq 0x10(%rsp), %rsi
movl 0x28(%rsi), %edi
addl $-0x3, %edi
cmpl $0x2, %edi
setb %dil
cmpl $0x0, 0x18(%rsp)
setg %r9b
andb %dil, %r9b
cmpb $0x1, %r9b
jne 0x2839df
cmpl $0x4, %r8d
setne %dil
testl %eax, %eax
setle %r9b
cmpl $0x1, %r8d
setne %r8b
orb %r9b, %dil
orb %r9b, %r8b
xorl %r9d, %r9d
testl %edx, %edx
jle 0x2839d1
movq 0x30(%rsp), %r11
movq 0x40(%r11), %r10
imulq %r9, %r10
imulq 0x10(%r11), %r10
addq (%r11), %r10
movq 0x10(%rsp), %rsi
movq 0x40(%rsi), %r11
imulq %r9, %r11
imulq 0x10(%rsi), %r11
addq (%rsi), %r11
xorl %ebx, %ebx
testl %ecx, %ecx
jle 0x2839c7
movq 0x20(%rsp), %r14
movl 0x34(%r14), %ebp
decl %ebp
cmpl %ebx, %ebp
cmovgel %ebx, %ebp
movslq %ebp, %r14
xorl %ebp, %ebp
movq 0x20(%rsp), %rsi
movslq 0x30(%rsi), %r12
leal -0x1(%r12), %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movslq 0x2c(%rsi), %r13
imulq 0x10(%rsi), %r13
imulq %r14, %r12
imulq %r13, %r12
addq (%rsi), %r12
movslq %r15d, %r15
imulq %r13, %r15
addq %r12, %r15
testb %dil, %dil
jne 0x28398e
movl %eax, %r12d
movups (%r11), %xmm0
rcpps %xmm0, %xmm1
movss (%r15), %xmm2
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
movaps %xmm2, %xmm3
mulps %xmm1, %xmm3
mulps %xmm3, %xmm0
subps %xmm0, %xmm2
mulps %xmm1, %xmm2
addps %xmm3, %xmm2
movups %xmm2, (%r10)
addq $0x10, %r11
addq $0x4, %r15
addq $0x10, %r10
decl %r12d
jne 0x283957
testb %r8b, %r8b
jne 0x2839bd
xorl %r12d, %r12d
xorl %r13d, %r13d
movss (%r15,%r13,4), %xmm0
divss (%r11,%r13,4), %xmm0
movss %xmm0, (%r10,%r13,4)
incq %r13
addq $-0x4, %r12
cmpl %r13d, %eax
jne 0x283999
subq %r12, %r10
subq %r12, %r11
incl %ebp
cmpl %ecx, %ebp
jne 0x28391c
incl %ebx
cmpl %edx, %ebx
jne 0x2838ff
incq %r9
cmpq 0x18(%rsp), %r9
jne 0x2838cb
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/csukuangfj[P]ncnn/src/layer/x86/binaryop_x86.cpp
|
0x281bbb
|
csukuangfj[P]ncnn[P]build_O3[P]examples[P]nanodet
|
mbedtls_md5_starts
|
int mbedtls_md5_starts_ret( mbedtls_md5_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
return( 0 );
}
|
movaps 0x401f(%rip), %xmm0 # 0x147a0
movups %xmm0, (%rdi)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%rdi)
retq
|
/ARMmbed[P]mbed-crypto/library/md5.c
|
0x1077a
|
ARMmbed[P]mbed-crypto[P]build_O1[P]tests[P]test_suite_dhm
|
bsplib::Rdma::hpget(int, unsigned long, unsigned long, void*, unsigned long)
|
void Rdma::hpget( int src_pid, Memslot src_slot, size_t src_offset,
void * dst, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::HPGET );
#endif
if ( size < m_min_n_hp_msg_size ) {
get( src_pid, src_slot, src_offset, dst, size );
return;
}
assert( !( slot( m_pid, src_slot ).status & Memblock::PUSHED) );
Memslot dst_slot = m_local_slots.size();
m_local_slots.push_back( dst );
int tag = m_unbuf.recv( src_pid, dst, size );
Action action = { Action::HPGET, src_pid, src_pid, m_pid,
tag, src_slot, dst_slot, src_offset, size };
m_send_actions.push_back( action );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%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)
leaq -0x50(%rbp), %rdi
movl $0x6, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1c0b0
movq -0xb0(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq 0x2f8(%rcx), %rax
jae 0x287ca
movq -0xb0(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x285c0
jmp 0x287a4
movl $0x1, -0x60(%rbp)
jmp 0x288fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c100
jmp 0x28910
movq -0xb0(%rbp), %rdi
movl 0x2f0(%rdi), %esi
movq -0x18(%rbp), %rdx
callq 0x1c480
movq %rax, -0xb8(%rbp)
jmp 0x287e9
movq -0xb8(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x28804
jmp 0x28806
jmp 0x28825
leaq 0x10175(%rip), %rdi # 0x38982
leaq 0x1002c(%rip), %rsi # 0x38840
movl $0x8f, %edx
leaq 0x101d5(%rip), %rcx # 0x389f5
callq 0x18200
movq -0xb0(%rbp), %rdi
addq $0x370, %rdi # imm = 0x370
movq %rdi, -0xc0(%rbp)
callq 0x2b1c0
movq -0xc0(%rbp), %rdi
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x2b260
jmp 0x28855
movq -0xb0(%rbp), %rdi
addq $0x428, %rdi # imm = 0x428
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x26080
movl %eax, -0xc4(%rbp)
jmp 0x2887b
movq -0xb0(%rbp), %rdi
movl -0xc4(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl $0x2, -0xa8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xa0(%rbp)
movl 0x2f0(%rdi), %eax
movl %eax, -0x9c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x388, %rdi # imm = 0x388
leaq -0xa8(%rbp), %rsi
callq 0x2b210
jmp 0x288f7
movl $0x0, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c100
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x18600
nopl (%rax)
|
/wijnand-suijlen[P]bsponmpi/src/rdma.cc
|
0x28730
|
wijnand-suijlen[P]bsponmpi[P]build_O0[P]test_move_payload_null_rma_prof
|
pybind11::class_<pybind11::detail::iterator_state<__gnu_cxx::__normal_iterator<std::vector<long, std::allocator<long>>*, std::vector<std::vector<long, std::allocator<long>>, std::allocator<std::vector<long, std::allocator<long>>>>>, __gnu_cxx::__normal_iterator<std::vector<long, std::allocator<long>>*, std::vector<std::vector<long, std::allocator<long>>, std::allocator<std::vector<long, std::allocator<long>>>>>, false, (pybind11::return_value_policy)6>>::init_instance(pybind11::detail::instance*, void const*)
|
static void init_instance(detail::instance *inst, const void *holder_ptr) {
auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
if (!v_h.instance_registered()) {
register_instance(inst, v_h.value_ptr(), v_h.type);
v_h.set_instance_registered();
}
init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10a71a(%rip), %rax # 0x197148
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorl %esi, %esi
callq 0x5c99b
leaq 0x10(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5e79a
movq %r15, %rdi
callq 0x5e852
testb %al, %al
jne 0x8ca82
leaq 0x10(%rsp), %r15
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x6feb2
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x6fef4
leaq 0x10(%rsp), %rsi
movq 0x18(%rsi), %rax
movq (%rax), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8cb04
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/bioinfologics[P]sdg/deps/pybind11/pybind11.h
|
0x8ca18
|
bioinfologics[P]sdg[P]build_O2[P]SDGpython[P]SDGpython.so
|
js_object_propertyIsEnumerable
|
static JSValue js_object_propertyIsEnumerable(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv)
{
JSValue obj, res = JS_EXCEPTION;
JSAtom prop = JS_ATOM_NULL;
JSPropertyDescriptor desc;
int has_prop;
obj = JS_ToObject(ctx, this_val);
if (JS_IsException(obj))
goto exception;
prop = JS_ValueToAtom(ctx, argv[0]);
if (unlikely(prop == JS_ATOM_NULL))
goto exception;
has_prop = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(obj), prop);
if (has_prop < 0)
goto exception;
if (has_prop) {
res = JS_NewBool(ctx, (desc.flags & JS_PROP_ENUMERABLE) != 0);
js_free_desc(ctx, &desc);
} else {
res = JS_FALSE;
}
exception:
JS_FreeAtom(ctx, prop);
JS_FreeValue(ctx, obj);
return res;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rdi, %rbx
callq 0x1d00e
movq %rax, %r14
movq %rdx, %r15
pushq $0x6
popq %r12
cmpl $0x6, %r15d
jne 0x52def
xorl %r13d, %r13d
jmp 0x52e35
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x1a5c3
testl %eax, %eax
je 0x52dea
movl %eax, %r13d
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %eax, %ecx
callq 0x1a103
testl %eax, %eax
js 0x52e35
pushq $0x1
popq %r12
je 0x52e35
movq %rsp, %rsi
movl (%rsi), %ebp
shrl $0x2, %ebp
andl $0x1, %ebp
movq %rbx, %rdi
callq 0x301ba
jmp 0x52e37
xorl %ebp, %ebp
movq %rbx, %rdi
movl %r13d, %esi
callq 0x16c23
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x147cb
movq %rbp, %rax
movq %r12, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/jameslahm[P]quick-preact-ssr/quickjs/quickjs.c
|
0x52dc1
|
jameslahm[P]quick-preact-ssr[P]build_O2[P]qpreact-linux-x86_64
|
png_print_info
|
void png_print_info(png_t* png)
{
printf("PNG INFO:\n");
printf("\twidth:\t\t%d\n", png->width);
printf("\theight:\t\t%d\n", png->height);
printf("\tdepth:\t\t%d\n", png->depth);
printf("\tcolor:\t\t");
switch(png->color_type)
{
case PNG_GREYSCALE: printf("greyscale\n"); break;
case PNG_TRUECOLOR: printf("truecolor\n"); break;
case PNG_INDEXED: printf("palette\n"); break;
case PNG_GREYSCALE_ALPHA: printf("greyscale with alpha\n"); break;
case PNG_TRUECOLOR_ALPHA: printf("truecolor with alpha\n"); break;
default: printf("unknown, this is not good\n"); break;
}
printf("\tcompression:\t%s\n", png->compression_method?"unknown, this is not good":"inflate/deflate");
printf("\tfilter:\t\t%s\n", png->filter_method?"unknown, this is not good":"adaptive");
printf("\tinterlace:\t%s\n", png->interlace_method?"interlace":"no interlace");
}
|
endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3349d(%rip), %rsi # 0xe1350
movl $0x1, %edi
xorl %eax, %eax
callq 0x13ac0
movl 0x2c(%rbx), %edx
leaq 0x33492(%rip), %rsi # 0xe135b
movl $0x1, %edi
xorl %eax, %eax
callq 0x13ac0
movl 0x30(%rbx), %edx
leaq 0x33489(%rip), %rsi # 0xe1368
movl $0x1, %edi
xorl %eax, %eax
callq 0x13ac0
movzbl 0x34(%rbx), %edx
leaq 0x33480(%rip), %rsi # 0xe1376
movl $0x1, %edi
xorl %eax, %eax
callq 0x13ac0
leaq 0x3347a(%rip), %rsi # 0xe1383
movl $0x1, %edi
xorl %eax, %eax
callq 0x13ac0
movzbl 0x35(%rbx), %eax
cmpq $0x6, %rax
ja 0xadf2f
leaq 0x333c2(%rip), %rcx # 0xe12e8
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0xadf36
leaq 0x334a2(%rip), %rsi # 0xe13d8
movl $0x1, %edi
xorl %eax, %eax
callq 0x13ac0
cmpb $0x0, 0x36(%rbx)
leaq 0x334d2(%rip), %rdx # 0xe141f
leaq 0x334b1(%rip), %r14 # 0xe1405
cmovneq %r14, %rdx
leaq 0x33494(%rip), %rsi # 0xe13f3
movl $0x1, %edi
xorl %eax, %eax
callq 0x13ac0
cmpb $0x0, 0x37(%rbx)
leaq 0x334c7(%rip), %rdx # 0xe143d
cmovneq %r14, %rdx
leaq 0x334ae(%rip), %rsi # 0xe142f
movl $0x1, %edi
xorl %eax, %eax
callq 0x13ac0
cmpb $0x0, 0x38(%rbx)
leaq 0x334be(%rip), %rax # 0xe1456
leaq 0x334ba(%rip), %rdx # 0xe1459
cmoveq %rax, %rdx
leaq 0x3349c(%rip), %rsi # 0xe1446
movl $0x1, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13ac0
|
/TsFreddie[P]teeworlds/src/engine/external/pnglite/pnglite.c
|
0xadea1
|
TsFreddie[P]teeworlds[P]build_O3[P]teeworlds
|
fmt::v9::detail::counting_iterator fmt::v9::detail::write_codepoint<8ul, char, fmt::v9::detail::counting_iterator>(fmt::v9::detail::counting_iterator, char, unsigned int)
|
auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {
*out++ = static_cast<Char>('\\');
*out++ = static_cast<Char>(prefix);
Char buf[width];
fill_n(buf, width, static_cast<Char>('0'));
format_uint<4>(buf, cp, width);
return copy_str<Char>(buf, buf + width, out);
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
pushq $0x8
popq %rax
movl %edx, %esi
movl %eax, %edx
xorl %ecx, %ecx
callq 0x220f4
addq $0xa, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
|
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
0x2a643
|
njoy[P]ENDFtk[P]build_O2[P]src[P]ENDFtk[P]section[P]2[P]152[P]test[P]ENDFtk.section.2.152.test
|
ncnn::HardSigmoid_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const
|
int HardSigmoid_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int d = bottom_top_blob.d;
int channels = bottom_top_blob.c;
int elempack = bottom_top_blob.elempack;
int size = w * h * d * elempack;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
float* ptr = bottom_top_blob.channel(q);
int i = 0;
#if __SSE2__
#if __AVX__
#if __AVX512F__
__m512 _zero_avx512 = _mm512_setzero_ps();
__m512 _one_avx512 = _mm512_set1_ps(1.f);
for (; i + 15 < size; i += 16)
{
__m512 _p = _mm512_loadu_ps(ptr);
__m512 _ans = _mm512_set1_ps(beta);
_ans = _mm512_fmadd_ps(_p, _mm512_set1_ps(alpha), _ans);
_ans = _mm512_max_ps(_ans, _zero_avx512);
_ans = _mm512_min_ps(_ans, _one_avx512);
_mm512_storeu_ps(ptr, _ans);
ptr += 16;
}
#endif // __AVX512F__
__m256 _zero_avx = _mm256_setzero_ps();
__m256 _one_avx = _mm256_set1_ps(1.f);
for (; i + 7 < size; i += 8)
{
__m256 _p = _mm256_loadu_ps(ptr);
__m256 _ans = _mm256_set1_ps(beta);
_ans = _mm256_comp_fmadd_ps(_p, _mm256_set1_ps(alpha), _ans);
_ans = _mm256_max_ps(_ans, _zero_avx);
_ans = _mm256_min_ps(_ans, _one_avx);
_mm256_storeu_ps(ptr, _ans);
ptr += 8;
}
#endif // __AVX__
__m128 _zero = _mm_setzero_ps();
__m128 _one = _mm_set1_ps(1.f);
for (; i + 3 < size; i += 4)
{
__m128 _p = _mm_load_ps(ptr);
__m128 _ans = _mm_set1_ps(beta);
_ans = _mm_add_ps(_mm_mul_ps(_p, _mm_set1_ps(alpha)), _ans);
_ans = _mm_max_ps(_ans, _zero);
_ans = _mm_min_ps(_ans, _one);
_mm_store_ps(ptr, _ans);
ptr += 4;
}
#endif // __SSE2__
for (; i < size; i++)
{
if (*ptr < lower)
*ptr = 0.f;
else if (*ptr > upper)
*ptr = 1.f;
else
*ptr = *ptr * alpha + beta;
ptr++;
}
}
return 0;
}
|
movslq 0x38(%rsi), %rax
testq %rax, %rax
jle 0x3ab69b
movl 0x30(%rsi), %ecx
imull 0x2c(%rsi), %ecx
imull 0x34(%rsi), %ecx
imull 0x18(%rsi), %ecx
movl %ecx, %edx
andl $-0x8, %edx
xorl %r8d, %r8d
vbroadcastss 0x14490d(%rip), %ymm0 # 0x4efe98
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm2, %xmm2, %xmm2
vbroadcastss 0x1448fc(%rip), %xmm3 # 0x4efe98
vmovss 0x1448f4(%rip), %xmm4 # 0x4efe98
movq 0x40(%rsi), %r9
imulq %r8, %r9
imulq 0x10(%rsi), %r9
addq (%rsi), %r9
cmpl $0x8, %ecx
jl 0x3ab5f9
movl $0x7, %r10d
vbroadcastss 0xd4(%rdi), %ymm5
vbroadcastss 0xd0(%rdi), %ymm6
vmulps (%r9), %ymm6, %ymm6
vaddps %ymm5, %ymm6, %ymm5
vmaxps %ymm1, %ymm5, %ymm5
vminps %ymm0, %ymm5, %ymm5
vmovups %ymm5, (%r9)
addq $0x20, %r9
addl $0x8, %r10d
cmpl %ecx, %r10d
jl 0x3ab5bf
movl %edx, %r10d
jmp 0x3ab5fc
xorl %r10d, %r10d
movl %r10d, %r11d
orl $0x3, %r11d
cmpl %ecx, %r11d
jge 0x3ab644
vbroadcastss 0xd4(%rdi), %xmm5
vbroadcastss 0xd0(%rdi), %xmm6
vmulps (%r9), %xmm6, %xmm6
vaddps %xmm5, %xmm6, %xmm5
vmaxps %xmm2, %xmm5, %xmm5
vminps %xmm3, %xmm5, %xmm5
vmovaps %xmm5, (%r9)
addq $0x10, %r9
leal 0x4(%r10), %r11d
addl $0x7, %r10d
cmpl %ecx, %r10d
movl %r11d, %r10d
jl 0x3ab608
movl %ecx, %r11d
subl %r10d, %r11d
jle 0x3ab68f
xorl %r10d, %r10d
vmovss (%r9,%r10,4), %xmm5
vxorps %xmm6, %xmm6, %xmm6
vucomiss 0xd8(%rdi), %xmm5
jb 0x3ab681
vucomiss 0xdc(%rdi), %xmm5
vmovaps %xmm4, %xmm6
ja 0x3ab681
vmulss 0xd0(%rdi), %xmm5, %xmm5
vaddss 0xd4(%rdi), %xmm5, %xmm6
vmovss %xmm6, (%r9,%r10,4)
incq %r10
cmpl %r10d, %r11d
jne 0x3ab64f
incq %r8
cmpq %rax, %r8
jne 0x3ab5a4
xorl %eax, %eax
vzeroupper
retq
nop
|
/Tencent[P]ncnn/build_O1/src/layer/x86/hardsigmoid_x86_avx.cpp
|
0x3ab55e
|
Tencent[P]ncnn[P]build_O1[P]examples[P]mobilenetssd
|
ReleaseMutex
|
BOOL
PALAPI
ReleaseMutex( IN HANDLE hMutex )
{
PAL_ERROR palError = NO_ERROR;
CPalThread *pthr = NULL;
PERF_ENTRY(ReleaseMutex);
ENTRY("ReleaseMutex(hMutex=%p)\n", hMutex);
pthr = InternalGetCurrentThread();
palError = InternalReleaseMutex(pthr, hMutex);
if (NO_ERROR != palError)
{
pthr->SetLastError(palError);
}
LOGEXIT("ReleaseMutex returns BOOL %d\n", (NO_ERROR == palError));
PERF_EXIT(ReleaseMutex);
return (NO_ERROR == palError);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x126681f(%rip), %r14 # 0x14a8fa4
cmpb $0x0, (%r14)
je 0x2427d0
movq %rdi, %rbx
leaq 0x1267a1b(%rip), %rax # 0x14aa1b0
movl (%rax), %edi
callq 0x1d6110
testq %rax, %rax
jne 0x2427a6
callq 0x2337ec
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2427d5
movl %eax, %ebx
testl %eax, %eax
je 0x2427be
callq 0x1d5ff0
movl %ebx, (%rax)
cmpb $0x0, (%r14)
je 0x2427d0
xorl %eax, %eax
testl %ebx, %ebx
sete %al
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1d5b70
|
/chakra-core[P]ChakraCore/pal/src/synchobj/mutex.cpp
|
0x242777
|
chakra-core[P]ChakraCore[P]build_O1[P]bin[P]ChakraCore[P]libChakraCore.so
|
void mp::internal::NLReader<mp::internal::TextReader<fmt::Locale>, mp::internal::VarBoundHandler<ExprCounter>>::ReadColumnSizes<false>()
|
void NLReader<Reader, Handler>::ReadColumnSizes() {
int num_sizes = header_.num_vars - 1;
if (reader_.ReadUInt() != num_sizes)
reader_.ReportError("expected {}", num_sizes);
reader_.ReadTillEndOfLine();
typename Handler::ColumnSizeHandler size_handler = handler_.OnColumnSizes();
int prev_size = 0;
for (int i = 0; i < num_sizes; ++i) {
int size = reader_.ReadUInt();
if (CUMULATIVE) {
if (size < prev_size)
reader_.ReportError("invalid column offset");
size -= prev_size;
prev_size += size;
}
size_handler.Add(size);
reader_.ReadTillEndOfLine();
}
}
|
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movl %ecx, 0x2c(%rsp)
movq (%rax), %rdi
callq 0x7f70
cmpl 0x2c(%rsp), %eax
je 0x8efe
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x7acc7(%rip), %rsi # 0x83bad
callq 0x4bd0
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0x92d0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x7d10
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xc0e0
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x8f6c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x7f70
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
leaq 0x1f(%rsp), %rdi
callq 0xc100
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x7d10
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8f29
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/ampl[P]mp/include/mp/nl-reader.h
|
0x8ea0
|
ampl[P]mp[P]build_O0[P]bin[P]nl-reader-example
|
void capnp::_::checkList<capnp::Text, capnp::DynamicValue::Builder>(capnp::DynamicValue::Builder, std::initializer_list<capnp::ReaderFor_<capnp::Text, ::capnp::kind<capnp::Text>()>::Type>)
|
void checkList(T reader, std::initializer_list<ReaderFor<Element>> expected) {
auto list = reader.as<DynamicList>();
ASSERT_EQ(expected.size(), list.size());
for (uint i = 0; i < expected.size(); i++) {
expectPrimitiveEq(expected.begin()[i], list[i].as<Element>());
}
auto typed = reader.as<List<Element>>();
ASSERT_EQ(expected.size(), typed.size());
for (uint i = 0; i < expected.size(); i++) {
expectPrimitiveEq(expected.begin()[i], typed[i]);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ff794
movl 0x28(%r15), %eax
cmpq %rbx, %rax
jne 0x25afec
testq %rbx, %rbx
je 0x25afc1
movq %r12, 0x30(%rsp)
xorl %eax, %eax
leaq 0x40(%rsp), %r13
xorl %r15d, %r15d
shlq $0x4, %rax
movq (%r14,%rax), %r12
movq 0x8(%r14,%rax), %rbp
movq %r13, %rdi
leaq 0xb0(%rsp), %rsi
movl %r15d, %edx
callq 0x2fc430
leaq 0x98(%rsp), %rdi
movq %r13, %rsi
callq 0x2ff6e0
movups 0x98(%rsp), %xmm0
movaps %xmm0, (%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r12, 0x20(%rsp)
movq %rbp, 0x28(%rsp)
cmpq %rbp, %rax
jne 0x25ae58
movq 0x8(%rsp), %rsi
decq %rbp
movq %r12, %rdi
movq %rbp, %rdx
callq 0x171520
testl %eax, %eax
je 0x25ae9b
leaq 0x2d56ff(%rip), %rax # 0x530550
cmpl $0x3, (%rax)
jl 0x25ae64
jmp 0x25ae9b
leaq 0x2d56f1(%rip), %rax # 0x530550
cmpl $0x2, (%rax)
jg 0x25ae9b
subq $0x8, %rsp
leaq 0x18e0bc(%rip), %rdi # 0x3e8f2b
movl $0x9f, %esi
movl $0x2, %edx
leaq 0x18e158(%rip), %rcx # 0x3e8fd8
leaq 0x18e178(%rip), %r8 # 0x3e8fff
leaq 0x28(%rsp), %r9
leaq 0x8(%rsp), %rax
pushq %rax
callq 0x25c3aa
addq $0x10, %rsp
movq %r13, %rdi
callq 0x2fe3d4
incl %r15d
movq %r15, %rax
cmpq %rbx, %r15
jb 0x25addb
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq 0x30(%rsp), %rsi
callq 0x25c4ae
movl 0x18(%r15), %eax
cmpq %rbx, %rax
jne 0x25b033
testq %rbx, %rbx
je 0x25afda
addq $0x8, %r14
xorl %ebp, %ebp
leaq 0x80(%rsp), %r12
movq -0x8(%r14), %r15
movl 0x5c(%rsp), %eax
imulq %rbp, %rax
shrq $0x3, %rax
addq 0x50(%rsp), %rax
movq (%r14), %r13
movaps 0x40(%rsp), %xmm0
movaps %xmm0, (%rsp)
movq %rax, 0x10(%rsp)
movq %r12, %rdi
movq %rsp, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2d79d4
movups 0x80(%rsp), %xmm0
movaps %xmm0, (%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r15, 0x20(%rsp)
movq %r13, 0x28(%rsp)
cmpq %r13, %rax
jne 0x25af6a
movq 0x8(%rsp), %rsi
decq %r13
movq %r15, %rdi
movq %r13, %rdx
callq 0x171520
testl %eax, %eax
je 0x25afad
leaq 0x2d55ed(%rip), %rax # 0x530550
cmpl $0x3, (%rax)
jl 0x25af76
jmp 0x25afad
leaq 0x2d55df(%rip), %rax # 0x530550
cmpl $0x2, (%rax)
jg 0x25afad
subq $0x8, %rsp
leaq 0x18dfaa(%rip), %rdi # 0x3e8f2b
movl $0x9f, %esi
movl $0x2, %edx
leaq 0x18e046(%rip), %rcx # 0x3e8fd8
leaq 0x18e066(%rip), %r8 # 0x3e8fff
leaq 0x28(%rsp), %r9
leaq 0x8(%rsp), %rax
pushq %rax
callq 0x25c3aa
addq $0x10, %rsp
incq %rbp
movl %ebp, %eax
addq $0x10, %r14
cmpq %rbx, %rax
jb 0x25aee8
jmp 0x25afda
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x25c4ae
movl 0x18(%r14), %eax
cmpq %rbx, %rax
jne 0x25b033
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %r10
movq %rbx, (%r10)
leaq 0x20(%rsp), %r11
movl %eax, (%r11)
leaq 0x18df2a(%rip), %rsi # 0x3e8f2b
leaq 0x164f96(%rip), %r8 # 0x3bff9e
leaq 0x164fb2(%rip), %r9 # 0x3bffc1
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movl $0xa6, %edx
xorl %ecx, %ecx
pushq %r11
pushq %r10
callq 0x1cb01a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x37dcf2
leaq 0x20(%rsp), %r10
movq %rbx, (%r10)
leaq 0x3c(%rsp), %r11
movl %eax, (%r11)
leaq 0x18dee1(%rip), %rsi # 0x3e8f2b
leaq 0x16505d(%rip), %r8 # 0x3c00ae
leaq 0x16507a(%rip), %r9 # 0x3c00d2
movq %rsp, %rbx
movq %rbx, %rdi
movl $0xac, %edx
xorl %ecx, %ecx
pushq %r11
pushq %r10
callq 0x1cb01a
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x37dcf2
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2fe3d4
jmp 0x25b0a3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x37dc22
jmp 0x25b0a3
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x37dc22
movq %rbx, %rdi
callq 0x1718d0
movq %rax, %rdi
callq 0x192185
|
/Cosmic-Sans[P]capnproto/c++/src/capnp/test-util.h
|
0x25ad89
|
Cosmic-Sans[P]capnproto[P]build_O3[P]c++[P]src[P]capnp[P]capnp-heavy-tests
|
printAddress
|
static void printAddress(MCInst *MI, unsigned Base, int64_t Disp, unsigned Index, SStream *O)
{
if (Disp >= 0) {
if (Disp > HEX_THRESHOLD)
SStream_concat(O, "0x%"PRIx64, Disp);
else
SStream_concat(O, "%"PRIu64, Disp);
} else {
if (Disp < -HEX_THRESHOLD)
SStream_concat(O, "-0x%"PRIx64, -Disp);
else
SStream_concat(O, "-%"PRIu64, -Disp);
}
if (Base) {
SStream_concat0(O, "(");
if (Index)
SStream_concat(O, "%%%s, ", getRegisterName(Index));
SStream_concat(O, "%%%s)", getRegisterName(Base));
if (MI->csh->detail) {
MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_MEM;
MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.base = (uint8_t)SystemZ_map_register(Base);
MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.index = (uint8_t)SystemZ_map_register(Index);
MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].mem.disp = Disp;
MI->flat_insn->detail->sysz.op_count++;
}
} else if (!Index) {
if (MI->csh->detail) {
MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].type = SYSZ_OP_IMM;
MI->flat_insn->detail->sysz.operands[MI->flat_insn->detail->sysz.op_count].imm = Disp;
MI->flat_insn->detail->sysz.op_count++;
}
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x1310b8
cmpq $0x9, -0x18(%rbp)
jle 0x1310a0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x8ef7e(%rip), %rsi # 0x1c0015
movb $0x0, %al
callq 0x45da0
jmp 0x1310b6
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x8ef6f(%rip), %rsi # 0x1c001e
movb $0x0, %al
callq 0x45da0
jmp 0x1310f7
cmpq $-0x9, -0x18(%rbp)
jge 0x1310db
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
subq -0x18(%rbp), %rdx
leaq 0x75d5(%rip), %rsi # 0x1386a7
movb $0x0, %al
callq 0x45da0
jmp 0x1310f5
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
subq -0x18(%rbp), %rdx
leaq 0x75c1(%rip), %rsi # 0x1386af
movb $0x0, %al
callq 0x45da0
jmp 0x1310f7
cmpl $0x0, -0xc(%rbp)
je 0x13129a
movq -0x28(%rbp), %rdi
leaq 0x1178b(%rip), %rsi # 0x142897
callq 0x45d30
cmpl $0x0, -0x1c(%rbp)
je 0x13113c
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %edi
callq 0x131030
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x956cf(%rip), %rsi # 0x1c6804
movb $0x0, %al
callq 0x45da0
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %edi
callq 0x131030
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x956b1(%rip), %rsi # 0x1c680b
movb $0x0, %al
callq 0x45da0
movq -0x8(%rbp), %rax
movq 0x320(%rax), %rax
cmpl $0x0, 0x68(%rax)
je 0x131295
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rax
movq 0xe8(%rax), %rax
addq $0x30, %rax
addq $0x8, %rax
movq -0x8(%rbp), %rcx
movq 0x310(%rcx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x34(%rcx), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x3, (%rax)
movl -0xc(%rbp), %edi
callq 0x1316b0
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rax
movq 0xe8(%rax), %rax
addq $0x30, %rax
addq $0x8, %rax
movq -0x8(%rbp), %rdx
movq 0x310(%rdx), %rdx
movq 0xe8(%rdx), %rdx
movzbl 0x34(%rdx), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movb %cl, 0x8(%rax)
movl -0x1c(%rbp), %edi
callq 0x1316b0
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rax
movq 0xe8(%rax), %rax
addq $0x30, %rax
addq $0x8, %rax
movq -0x8(%rbp), %rdx
movq 0x310(%rdx), %rdx
movq 0xe8(%rdx), %rdx
movzbl 0x34(%rdx), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movb %cl, 0x9(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rax
movq 0xe8(%rax), %rax
addq $0x30, %rax
addq $0x8, %rax
movq -0x8(%rbp), %rdx
movq 0x310(%rdx), %rdx
movq 0xe8(%rdx), %rdx
movzbl 0x34(%rdx), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rax
movq 0xe8(%rax), %rax
movb 0x34(%rax), %cl
addb $0x1, %cl
movb %cl, 0x34(%rax)
jmp 0x131354
cmpl $0x0, -0x1c(%rbp)
jne 0x131352
movq -0x8(%rbp), %rax
movq 0x320(%rax), %rax
cmpl $0x0, 0x68(%rax)
je 0x131350
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rax
movq 0xe8(%rax), %rax
addq $0x30, %rax
addq $0x8, %rax
movq -0x8(%rbp), %rcx
movq 0x310(%rcx), %rcx
movq 0xe8(%rcx), %rcx
movzbl 0x34(%rcx), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x2, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rax
movq 0xe8(%rax), %rax
addq $0x30, %rax
addq $0x8, %rax
movq -0x8(%rbp), %rdx
movq 0x310(%rdx), %rdx
movq 0xe8(%rdx), %rdx
movzbl 0x34(%rdx), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rax
movq 0xe8(%rax), %rax
movb 0x34(%rax), %cl
addb $0x1, %cl
movb %cl, 0x34(%rax)
jmp 0x131352
jmp 0x131354
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/sidneyp[P]capstone-tricore/arch/SystemZ/SystemZInstPrinter.c
|
0x131060
|
sidneyp[P]capstone-tricore[P]build_O0[P]test_detail
|
google::protobuf::UnknownField::SerializeLengthDelimitedNoTag(google::protobuf::io::CodedOutputStream*) const
|
void UnknownField::SerializeLengthDelimitedNoTag(
io::CodedOutputStream* output) const {
GOOGLE_DCHECK_EQ(TYPE_LENGTH_DELIMITED, type());
const string& data = *data_.length_delimited_.string_value_;
output->WriteVarint32(data.size());
output->WriteRawMaybeAliased(data.data(), data.size());
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5a73d0
movl %eax, %ecx
movb $0x0, -0x49(%rbp)
movl $0x3, %eax
cmpl %ecx, %eax
jne 0xa521e1
jmp 0xa5222a
leaq 0x77276(%rip), %rdx # 0xac945e
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x3, %esi
movl $0x145, %ecx # imm = 0x145
callq 0x5c4040
movq -0x80(%rbp), %rdi
movb $0x1, -0x49(%rbp)
leaq 0x77308(%rip), %rsi # 0xac9516
callq 0x602510
movq %rax, -0x78(%rbp)
jmp 0xa52219
movq -0x78(%rbp), %rsi
leaq -0x5d(%rbp), %rdi
callq 0x5d9840
jmp 0xa52228
jmp 0xa5222a
testb $0x1, -0x49(%rbp)
jne 0xa52232
jmp 0xa5223b
leaq -0x48(%rbp), %rdi
callq 0x5e7660
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x68(%rbp), %rdi
callq 0x5ac6f0
movq -0x98(%rbp), %rdi
movl %eax, %esi
callq 0x5d3c60
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x68(%rbp), %rdi
callq 0x5a8240
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rdi
callq 0x5ac6f0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl %eax, %edx
callq 0x5e6dc0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x49(%rbp)
jne 0xa522bf
jmp 0xa522c8
leaq -0x48(%rbp), %rdi
callq 0x5e7660
jmp 0xa522ca
movq -0x58(%rbp), %rdi
callq 0x5ca740
nopw %cs:(%rax,%rax)
|
/1duo[P]coremltools/deps/protobuf/src/google/protobuf/unknown_field_set.cc
|
0xa521b0
|
1duo[P]coremltools[P]build_O0[P]libcaffeconverter.so
|
testing::AssertionResult& testing::AssertionResult::operator<<<char [106]>(char const (&) [106])
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xac2a
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x74e0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x220ae
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1e6d0
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1e6f0
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x79e0
|
/metacall[P]core/build_O2/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
|
0x1e68a
|
metacall[P]core[P]build_O2[P]configuration-default-test[P]metacall-configuration-default-test
|
roaring_bitmap_minimum
|
uint32_t roaring_bitmap_minimum(const roaring_bitmap_t *bm) {
if (bm->high_low_container.size > 0) {
container_t *c = bm->high_low_container.containers[0];
uint8_t type = bm->high_low_container.typecodes[0];
uint32_t key = bm->high_low_container.keys[0];
uint32_t lowvalue = container_minimum(c, type);
return lowvalue | (key << 16);
}
return UINT32_MAX;
}
|
pushq %rbx
cmpl $0x0, (%rdi)
jle 0x13fe0
movq %rdi, %rax
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movq (%rdx), %rdi
movq 0x18(%rax), %rax
movb (%rax), %al
cmpb $0x4, %al
jne 0x13fc3
movb 0x8(%rdi), %al
movq (%rdi), %rdi
movzwl (%rcx), %ebx
cmpb $0x3, %al
je 0x13fd2
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x13fe5
cmpl $0x0, (%rdi)
je 0x13fec
movq 0x8(%rdi), %rax
movzwl (%rax), %eax
jmp 0x13fee
pushq $-0x1
popq %rbx
jmp 0x13ff6
callq 0x265ef
jmp 0x13fee
xorl %eax, %eax
movzwl %ax, %eax
shll $0x10, %ebx
orl %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
|
/RoaringBitmap[P]CRoaring/src/roaring.c
|
0x13f9f
|
RoaringBitmap[P]CRoaring[P]build_O2[P]tests[P]cpp_unit
|
gmlc::networking::TcpAcceptor::TcpAcceptor(asio::io_context&, asio::ip::basic_endpoint<asio::ip::tcp>&)
|
TcpAcceptor::TcpAcceptor(asio::io_context& io_context, tcp::endpoint& ep) :
endpoint_(ep), acceptor_(io_context)
{
acceptor_.open(ep.protocol());
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups (%rdx), %xmm0
movups 0xc(%rdx), %xmm1
movups %xmm0, 0x10(%rdi)
movups %xmm1, 0x1c(%rdi)
leaq 0x30(%rdi), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x27308c
leaq 0x88(%rbx), %r15
leaq 0xf0(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xb8(%rbx)
movups %xmm0, 0xa8(%rbx)
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0x88(%rbx)
andl $0x0, 0xe8(%rbx)
movq %r13, %rdi
xorl %esi, %esi
callq 0x14cc18
xorl %eax, %eax
cmpw $0x2, (%r12)
setne %al
leal 0x2(,%rax,8), %eax
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x273098
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq 0xc8(%rbx), %rbp
leaq 0xa8(%rbx), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rdi
callq 0x14cd3c
movq %rbp, %rdi
callq 0x91dfc
movq 0x8(%rsp), %rdi
callq 0x91dfc
movq %r15, %rdi
callq 0x91dfc
movq %r14, %rdi
callq 0x26be0e
jmp 0x27259c
movq %rax, %r12
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xa69ec
movq %r12, %rdi
callq 0x65bd0
|
/GMLC-TDC[P]HELICS/ThirdParty/networking/gmlc/networking/TcpAcceptor.cpp
|
0x2724a4
|
GMLC-TDC[P]HELICS[P]build_O2[P]bin[P]helics_broker
|
testing::AssertionResult testing::internal::CmpHelperOpFailure<unsigned int, unsigned long>(char const*, char const*, unsigned int const&, unsigned long const&, char const*)
|
AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
const T1& val1, const T2& val2,
const char* op) {
return AssertionFailure()
<< "Expected: (" << expr1 << ") " << op << " (" << expr2
<< "), actual: " << FormatForComparisonFailureMessage(val1, val2)
<< " vs " << FormatForComparisonFailureMessage(val2, val1);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %r9, (%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x4566f
leaq 0x4cb76(%rip), %rsi # 0x6f423
movq %r12, %rdi
callq 0x175e4
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x17662
leaq 0x4cb66(%rip), %rsi # 0x6f42f
movq %rax, %rdi
callq 0x176f2
movq %rsp, %rsi
movq %rax, %rdi
callq 0x17662
leaq 0x4cb49(%rip), %rsi # 0x6f42c
movq %rax, %rdi
callq 0x176f2
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x17662
leaq 0x4cb33(%rip), %rsi # 0x6f432
movq %rax, %rdi
callq 0x175e4
movq %rax, %r12
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x1dd88
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x17770
leaq 0x4cb13(%rip), %rsi # 0x6f43e
movq %rax, %rdi
callq 0x177e4
movq %rax, %r15
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x17926
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x17770
movq %rbx, %rdi
movq %rax, %rsi
callq 0x455a4
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2296e
callq 0x10510
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22981
callq 0x10510
movq 0x20(%rsp), %r14
testq %r14, %r14
je 0x229a4
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x2299c
callq 0x10510
movq %r14, %rdi
callq 0x10510
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x229cf
jmp 0x229e7
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x229d2
callq 0x10510
jmp 0x229d2
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x229ea
callq 0x10510
jmp 0x229ea
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1634e
movq %rbx, %rdi
callq 0x10a90
|
/nmoinvaz[P]zlib-ng/build_O3/_deps/googletest-src/googletest/include/gtest/gtest.h
|
0x22877
|
nmoinvaz[P]zlib-ng[P]build_O3[P]gtest_zlib
|
main
|
int main(int argc, char *argv[])
{
fpstate fpvar;
if (argc <= 1) { fp_usage (); fp_hint (); exit (-1); }
fp_init (&fpvar);
fp_get_param (argc, argv, &fpvar);
if (fpvar.listonly) {
fp_list (argc, argv, fpvar);
} else {
fp_preflight (argc, argv, FPACK, &fpvar);
fp_loop (argc, argv, FPACK, fpvar);
}
exit (0);
}
|
subq $0xd88, %rsp # imm = 0xD88
movl $0x0, 0xd84(%rsp)
movl %edi, 0xd80(%rsp)
movq %rsi, 0xd78(%rsp)
cmpl $0x1, 0xd80(%rsp)
jg 0xe1af
callq 0xe2a0
callq 0xe2d0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x6150
leaq 0x6d0(%rsp), %rdi
callq 0x6aa0
movl 0xd80(%rsp), %edi
movq 0xd78(%rsp), %rsi
leaq 0x6d0(%rsp), %rdx
callq 0xe2f0
cmpl $0x0, 0x734(%rsp)
je 0xe229
movl 0xd80(%rsp), %eax
movl %eax, 0x6cc(%rsp)
movq 0xd78(%rsp), %rax
movq %rax, 0x6c0(%rsp)
movq %rsp, %rdi
movl $0xd5, %ecx
leaq 0x6d0(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
movq 0x6c0(%rsp), %rsi
movl 0x6cc(%rsp), %edi
callq 0x6c70
jmp 0xe290
movl 0xd80(%rsp), %edi
movq 0xd78(%rsp), %rsi
xorl %edx, %edx
leaq 0x6d0(%rsp), %rcx
callq 0x7570
movl 0xd80(%rsp), %eax
movl %eax, 0x6bc(%rsp)
movq 0xd78(%rsp), %rax
movq %rax, 0x6b0(%rsp)
xorl %eax, %eax
movq %rsp, %rdi
movl $0xd5, %ecx
leaq 0x6d0(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
movq 0x6b0(%rsp), %rsi
movl 0x6bc(%rsp), %edi
xorl %edx, %edx
callq 0x80d0
xorl %edi, %edi
callq 0x6150
nopw (%rax,%rax)
|
/Helioviewer-Project[P]fits2img/support/cfitsio/cfitsio-4.6.2/utilities/fpack.c
|
0xe170
|
Helioviewer-Project[P]fits2img[P]build_O0[P]support[P]cfitsio[P]fpack
|
flatbuffers::(anonymous namespace)::CamelToSnake(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
std::string CamelToSnake(const std::string &input) {
std::string s;
for (size_t i = 0; i < input.length(); i++) {
if (i == 0) {
s += CharToLower(input[i]);
} else if (input[i] == '_') {
s += '_';
} else if (!islower(input[i])) {
// Prevent duplicate underscores for Upper_Snake_Case strings
// and UPPERCASE strings.
if (islower(input[i - 1]) ||
(isdigit(input[i - 1]) && !isdigit(input[i]))) {
s += '_';
}
s += CharToLower(input[i]);
} else {
s += input[i];
}
}
return s;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5740
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0xb3d0f
cmpq $0x0, -0x20(%rbp)
jne 0xb3bfe
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x55a0
movsbl (%rax), %edi
callq 0xb4790
movb %al, -0x49(%rbp)
jmp 0xb3bce
movq -0x40(%rbp), %rdi
movb -0x49(%rbp), %al
movsbl %al, %esi
callq 0x52f0
jmp 0xb3bdf
jmp 0xb3cfc
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x52e0
jmp 0xb3d2c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x55a0
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0xb3c28
movq -0x40(%rbp), %rdi
movl $0x5f, %esi
callq 0x52f0
jmp 0xb3c23
jmp 0xb3cfa
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x55a0
movsbl (%rax), %edi
callq 0x5690
cmpl $0x0, %eax
jne 0xb3cdb
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq $0x1, %rsi
callq 0x55a0
movsbl (%rax), %edi
callq 0x5690
cmpl $0x0, %eax
jne 0xb3c9c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq $0x1, %rsi
callq 0x55a0
movsbl (%rax), %edi
callq 0x5460
cmpl $0x0, %eax
je 0xb3cae
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x55a0
movsbl (%rax), %edi
callq 0x5460
cmpl $0x0, %eax
jne 0xb3cae
movq -0x40(%rbp), %rdi
movl $0x5f, %esi
callq 0x52f0
jmp 0xb3cac
jmp 0xb3cae
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x55a0
movsbl (%rax), %edi
callq 0xb4790
movb %al, -0x4a(%rbp)
jmp 0xb3cc8
movq -0x40(%rbp), %rdi
movb -0x4a(%rbp), %al
movsbl %al, %esi
callq 0x52f0
jmp 0xb3cd9
jmp 0xb3cf8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x55a0
movq -0x40(%rbp), %rdi
movsbl (%rax), %esi
callq 0x52f0
jmp 0xb3cf6
jmp 0xb3cf8
jmp 0xb3cfa
jmp 0xb3cfc
jmp 0xb3cfe
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb3b8c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xb3d22
movq -0x40(%rbp), %rdi
callq 0x52e0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5900
nopw %cs:(%rax,%rax)
|
/aardappel[P]flatbuffers/src/util.cpp
|
0xb3b60
|
aardappel[P]flatbuffers[P]build_O0[P]flatsamplebfbs
|
fmt::v8::detail::thousands_sep_result<char> fmt::v8::detail::thousands_sep_impl<char>(fmt::v8::detail::locale_ref)
|
FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
auto grouping = facet.grouping();
auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
return {std::move(grouping), thousands_sep};
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x25d60
movq %r14, %rdi
callq 0x24920
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x25de0
movq (%r14), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
cmpq $0x0, 0x8(%r15)
je 0x2d38d
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
jmp 0x2d38f
xorl %eax, %eax
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
leaq 0x18(%rsp), %rcx
movq -0x10(%rcx), %rsi
cmpq %rcx, %rsi
je 0x2d3b2
movq %rsi, (%rbx)
movq 0x18(%rsp), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x2d3b8
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rdx
movq %rcx, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, 0x8(%rbx)
movb $0x0, 0x10(%rdi)
movb %al, 0x20(%rbx)
callq 0x24950
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x24950
jmp 0x2d402
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25de0
movq %rbx, %rdi
callq 0x26670
|
/mrzv[P]henson/ext/fmt/include/fmt/format-inl.h
|
0x2d331
|
mrzv[P]henson[P]build_O2[P]examples[P]storage[P]storage
|
testing::internal::HasGoogleTestFlagPrefix(char const*)
|
static bool HasGoogleTestFlagPrefix(const char* str) {
return (SkipPrefix("--", &str) ||
SkipPrefix("-", &str) ||
SkipPrefix("/", &str)) &&
!SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
(SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x96329(%rip), %rdi # 0x118e69
leaq 0x10(%rsp), %rsi
callq 0x787e0
testb $0x1, %al
jne 0x82b83
leaq 0x96315(%rip), %rdi # 0x118e6a
leaq 0x10(%rsp), %rsi
callq 0x787e0
testb $0x1, %al
jne 0x82b83
leaq 0x95e44(%rip), %rdi # 0x1189ae
leaq 0x10(%rsp), %rsi
callq 0x787e0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x82b83
jmp 0x82bdc
leaq 0x9759a(%rip), %rdi # 0x11a124
leaq 0x10(%rsp), %rsi
callq 0x787e0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x82bdc
leaq 0x96658(%rip), %rdi # 0x119200
leaq 0x10(%rsp), %rsi
callq 0x787e0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x82bd4
leaq 0x9756e(%rip), %rdi # 0x11a134
leaq 0x10(%rsp), %rsi
callq 0x787e0
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
|
/rjenkins[P]stats-cpp/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
0x82b30
|
rjenkins[P]stats-cpp[P]build_O0[P]test[P]stats_cpp_tst
|
save_column
|
void save_column(int symbol, int default_state)
{
register int i;
register int m;
register int n;
register Yshort *sp;
register Yshort *sp1;
register Yshort *sp2;
register int count;
register int symno;
m = goto_map[symbol];
n = goto_map[symbol + 1];
count = 0;
for (i = m; i < n; i++)
{
if (to_state[i] != default_state)
++count;
}
if (count == 0) return;
symno = symbol_value[symbol] + 3*nstates;
froms[symno] = sp1 = sp = NEW2(count, Yshort);
tos[symno] = sp2 = NEW2(count, Yshort);
for (i = m; i < n; i++)
{
if (to_state[i] != default_state)
{
*sp1++ = from_state[i];
*sp2++ = to_state[i];
}
}
tally[symno] = count;
width[symno] = sp1[-1] - sp[0] + 1;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x16133(%rip), %rax # 0x2b1f8
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
leaq 0x1611f(%rip), %rax # 0x2b1f8
movq (%rax), %rax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1512c
leaq 0x16109(%rip), %rax # 0x2b210
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
je 0x1511f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x15121
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x150f8
cmpl $0x0, -0x34(%rbp)
jne 0x15137
jmp 0x15249
leaq 0x16252(%rip), %rax # 0x2b390
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
leaq 0x16159(%rip), %rcx # 0x2b2a8
imull $0x3, (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x38(%rbp)
movslq -0x34(%rbp), %rax
shlq $0x2, %rax
movl %eax, %edi
callq 0x105c0
movq %rax, %rdx
movq %rdx, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq 0x162b8(%rip), %rax # 0x2b430
movslq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movslq -0x34(%rbp), %rax
shlq $0x2, %rax
movl %eax, %edi
callq 0x105c0
movq %rax, %rdx
movq %rdx, -0x30(%rbp)
movq 0x1629b(%rip), %rax # 0x2b438
movslq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1521a
leaq 0x16056(%rip), %rax # 0x2b210
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
je 0x1520d
leaq 0x16038(%rip), %rax # 0x2b208
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
leaq 0x1601e(%rip), %rax # 0x2b210
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x30(%rbp)
movl %ecx, (%rax)
jmp 0x1520f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x151ab
movl -0x34(%rbp), %edx
movq 0x1621c(%rip), %rax # 0x2b440
movslq -0x38(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movl -0x4(%rax), %edx
movq -0x20(%rbp), %rax
subl (%rax), %edx
addl $0x1, %edx
movq 0x16206(%rip), %rax # 0x2b448
movslq -0x38(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x40, %rsp
popq %rbp
retq
nop
|
/ChrisDodd[P]btyacc/output.c
|
0x150b0
|
ChrisDodd[P]btyacc[P]build_O0[P]btyacc
|
h264_print_ref_pic_list_modification
|
void h264_print_ref_pic_list_modification(struct h264_ref_pic_list_modification *list, char *which) {
static const char *const opnames[6] = { "pic_num sub", "pic_num add", "long term", "end", "view idx sub", "view idx add" };
static const char *const argnames[6] = { "abs_diff_pic_num_minus1", "abs_diff_pic_num_minus1", "long_term_pic_num", 0, "abs_diff_view_idx_minus1", "abs_diff_view_idx_minus1" };
int i;
printf("\tref_pic_list_modification_flag_%s = %d\n", which, list->flag);
for (i = 0; list->list[i].op != 3; i++) {
int op = list->list[i].op;
printf("\tmodification_of_pic_nums_idc = %d [%s]\n", op, opnames[op]);
printf("\t%s = %d\n", argnames[op], list->list[i].op);
}
printf("\tmodification_of_pic_nums_idc = 3 [END]\n");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edx
leaq 0xc1f9(%rip), %rdi # 0x17260
xorl %eax, %eax
callq 0x3070
addq $0x4, %rbx
leaq 0xadeb(%rip), %r13 # 0x15e64
leaq 0xc209(%rip), %r14 # 0x17289
leaq 0x25ff9(%rip), %rbp # 0x31080
leaq 0xc224(%rip), %r15 # 0x172b2
movslq (%rbx), %r12
cmpq $0x3, %r12
je 0xb0c3
movslq (%r13,%r12,4), %rdx
addq %r13, %rdx
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x3070
movq (%rbp,%r12,8), %rsi
movl (%rbx), %edx
movq %r15, %rdi
xorl %eax, %eax
callq 0x3070
addq $0xc, %rbx
jmp 0xb08e
leaq 0xce42(%rip), %rdi # 0x17f0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3060
|
/polachok[P]envytools/vstream/h264_print.c
|
0xb050
|
polachok[P]envytools[P]build_O2[P]vstream[P]deh264
|
sysbvm_simpleFunctionType_primitiveAnalyzeAndTypeCheckFunctionApplicationNode
|
static sysbvm_tuple_t sysbvm_simpleFunctionType_primitiveAnalyzeAndTypeCheckFunctionApplicationNode(sysbvm_context_t *context, sysbvm_tuple_t closure, size_t argumentCount, sysbvm_tuple_t *arguments)
{
(void)closure;
if(argumentCount != 3) sysbvm_error_argumentCountMismatch(3, argumentCount);
sysbvm_simpleFunctionType_t **simpleFunctionType = (sysbvm_simpleFunctionType_t**)&arguments[0];
sysbvm_astFunctionApplicationNode_t **functionApplicationNode = (sysbvm_astFunctionApplicationNode_t**)&arguments[1];
sysbvm_tuple_t *environment = &arguments[2];
struct {
sysbvm_tuple_t argumentNode;
sysbvm_tuple_t analyzedArgument;
sysbvm_tuple_t analyzedArguments;
sysbvm_tuple_t expectedArgumentType;
sysbvm_tuple_t variadicArguments;
sysbvm_tuple_t variadicArgumentsNode;
} gcFrame = {0};
SYSBVM_STACKFRAME_PUSH_GC_ROOTS(gcFrameRecord, gcFrame);
sysbvm_bitflags_t flags = sysbvm_tuple_bitflags_decode((*simpleFunctionType)->super.functionFlags);
bool isVariadic = (flags & SYSBVM_FUNCTION_FLAGS_VARIADIC) != 0;
bool isMemoizedTemplate = (flags & SYSBVM_FUNCTION_FLAGS_MEMOIZED_TEMPLATE) == SYSBVM_FUNCTION_FLAGS_MEMOIZED_TEMPLATE;
size_t typeArgumentCount = sysbvm_array_getSize((*simpleFunctionType)->argumentTypes);
size_t expectedArgumentCount = typeArgumentCount;
size_t applicationArgumentCount = sysbvm_array_getSize((*functionApplicationNode)->arguments);
size_t startingArgumentIndex = isMemoizedTemplate ? 1 : 0;
if(isVariadic && typeArgumentCount == 0)
sysbvm_error("Variadic applications require at least a single argument.");
size_t directApplicationArgumentCount = isVariadic ? typeArgumentCount - 1 : typeArgumentCount;
if(isMemoizedTemplate)
{
if(expectedArgumentCount == 0)
sysbvm_error("Memoized template requires at least a single argument.");
--expectedArgumentCount;
--directApplicationArgumentCount;
}
if(isVariadic && applicationArgumentCount < directApplicationArgumentCount)
sysbvm_error("Missing required arguments.");
else if(!isVariadic && applicationArgumentCount != expectedArgumentCount)
sysbvm_error("Expected number of arguments is mismatching.");
gcFrame.analyzedArguments = sysbvm_array_create(context, expectedArgumentCount);
for(size_t i = 0; i < directApplicationArgumentCount; ++i)
{
gcFrame.expectedArgumentType = sysbvm_array_at((*simpleFunctionType)->argumentTypes, startingArgumentIndex + i);
gcFrame.argumentNode = sysbvm_array_at((*functionApplicationNode)->arguments, i);
gcFrame.analyzedArgument = sysbvm_interpreter_analyzeASTWithExpectedTypeWithEnvironment(context, gcFrame.argumentNode, gcFrame.expectedArgumentType, *environment);
sysbvm_array_atPut(gcFrame.analyzedArguments, i, gcFrame.analyzedArgument);
}
// Analyze the variadic arguments.
if(isVariadic)
{
gcFrame.variadicArguments = sysbvm_array_create(context, applicationArgumentCount - directApplicationArgumentCount);
for(size_t i = directApplicationArgumentCount; i < applicationArgumentCount; ++i)
sysbvm_array_atPut(gcFrame.variadicArguments, i - directApplicationArgumentCount, sysbvm_array_at((*functionApplicationNode)->arguments, i));
gcFrame.variadicArgumentsNode = sysbvm_astMakeArrayNode_create(context, (*functionApplicationNode)->super.sourcePosition, gcFrame.variadicArguments);
gcFrame.variadicArgumentsNode = sysbvm_interpreter_analyzeASTWithExpectedTypeWithEnvironment(context, gcFrame.variadicArgumentsNode, context->roots.arrayType, *environment);
sysbvm_array_atPut(gcFrame.analyzedArguments, directApplicationArgumentCount, gcFrame.variadicArgumentsNode);
}
(*functionApplicationNode)->applicationFlags = sysbvm_tuple_bitflags_encode(sysbvm_tuple_bitflags_decode((*functionApplicationNode)->applicationFlags)
| (isMemoizedTemplate ? 0 : SYSBVM_FUNCTION_APPLICATION_FLAGS_NO_TYPECHECK)
| SYSBVM_FUNCTION_APPLICATION_FLAGS_VARIADIC_EXPANDED);
(*functionApplicationNode)->arguments = gcFrame.analyzedArguments;
(*functionApplicationNode)->super.analyzedType = (*simpleFunctionType)->resultType;
SYSBVM_STACKFRAME_POP_GC_ROOTS(gcFrameRecord);
return sysbvm_astFunctionApplicationNode_optimizePureApplication(context, functionApplicationNode);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x3, -0x18(%rbp)
je 0x46030
movq -0x18(%rbp), %rsi
movl $0x3, %edi
callq 0x2bd50
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2060
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2060
movl $0x0, -0x80(%rbp)
movq $0x6, -0x78(%rbp)
leaq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x68100
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0xf8(%rax), %rdi
callq 0x39140
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x91(%rbp)
movq -0x90(%rbp), %rax
andq $0x600, %rax # imm = 0x600
cmpq $0x600, %rax # imm = 0x600
sete %al
andb $0x1, %al
movb %al, -0x92(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x100(%rax), %rdi
callq 0x38d30
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdi
callq 0x38d30
movq %rax, -0xb0(%rbp)
movb -0x92(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
movq %rax, -0xb8(%rbp)
testb $0x1, -0x91(%rbp)
je 0x46162
cmpq $0x0, -0xa0(%rbp)
jne 0x46162
leaq 0x60e71(%rip), %rdi # 0xa6fce
callq 0x2bb70
testb $0x1, -0x91(%rbp)
je 0x4617f
movq -0xa0(%rbp), %rax
subq $0x1, %rax
movq %rax, -0xd8(%rbp)
jmp 0x4618d
movq -0xa0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xc0(%rbp)
testb $0x1, -0x92(%rbp)
je 0x461de
cmpq $0x0, -0xa8(%rbp)
jne 0x461ba
leaq 0x60e53(%rip), %rdi # 0xa7008
callq 0x2bb70
movq -0xa8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xa8(%rbp)
movq -0xc0(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xc0(%rbp)
testb $0x1, -0x91(%rbp)
je 0x46205
movq -0xb0(%rbp), %rax
cmpq -0xc0(%rbp), %rax
jae 0x46205
leaq 0x60e41(%rip), %rdi # 0xa703f
callq 0x2bb70
jmp 0x4622c
testb $0x1, -0x91(%rbp)
jne 0x4622a
movq -0xb0(%rbp), %rax
cmpq -0xa8(%rbp), %rax
je 0x4622a
leaq 0x60e36(%rip), %rdi # 0xa705b
callq 0x2bb70
jmp 0x4622c
movq -0x8(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x74560
movq %rax, -0x58(%rbp)
movq $0x0, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
cmpq -0xc0(%rbp), %rax
jae 0x462e6
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x100(%rax), %rdi
movq -0xb8(%rbp), %rsi
addq -0xc8(%rbp), %rsi
callq 0x38d50
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdi
movq -0xc8(%rbp), %rsi
callq 0x38d50
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x38(%rbp), %rax
movq (%rax), %rcx
callq 0x48130
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x39100
movq -0xc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc8(%rbp)
jmp 0x4624b
testb $0x1, -0x91(%rbp)
je 0x463e0
movq -0x8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
subq -0xc0(%rbp), %rsi
callq 0x74560
movq %rax, -0x48(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
cmpq -0xb0(%rbp), %rax
jae 0x4638d
movq -0x48(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xd0(%rbp), %rax
subq -0xc0(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdi
movq -0xd0(%rbp), %rsi
callq 0x38d50
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movq %rax, %rdx
callq 0x39100
movq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd0(%rbp)
jmp 0x4631c
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq -0x48(%rbp), %rdx
callq 0x19a80
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x388(%rax), %rdx
movq -0x38(%rbp), %rax
movq (%rax), %rcx
callq 0x48130
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x39100
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdi
callq 0x39140
movq %rax, %rdi
movb -0x92(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
orq %rax, %rdi
orq $0x2, %rdi
callq 0x49a70
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x58(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x108(%rax), %rcx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
leaq -0x88(%rbp), %rdi
callq 0x68160
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x48ca0
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
|
/ronsaldo[P]sysmel/lib/sysbvm/interpreter.c
|
0x46000
|
ronsaldo[P]sysmel[P]build_O0[P]dist[P]TestSysbvm
|
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<VkSamplerReductionMode>, rapidjson::internal::IsGenericValue<VkSamplerReductionMode>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>&>::Type rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::AddMember<VkSamplerReductionMode>(rapidjson::GenericStringRef<char>, VkSamplerReductionMode, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
|
AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
}
|
subq $0x28, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
leaq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movslq %edx, %rdx
movq %rdx, (%rax)
testl %edx, %edx
movl $0x1f6, %edx # imm = 0x1F6
movl $0xb6, %r8d
cmovnsl %edx, %r8d
movw %r8w, 0xe(%rax)
movq %rax, %rdx
callq 0x6f5a6
addq $0x28, %rsp
retq
nop
|
/ValveSoftware[P]Fossilize/rapidjson/include/rapidjson/document.h
|
0x71728
|
ValveSoftware[P]Fossilize[P]build_O3[P]cli[P]fossilize-opt
|
std::enable_if<(unsigned short)41 + (unsigned short)29 >= 64, void>::type (anonymous namespace)::pack_single_in64<(unsigned short)41, (unsigned short)29, 2199023255551ul>(unsigned long, unsigned int* restrict&)
|
pack_single_in64(
const uint64_t in, uint32_t *__restrict__ &out) {
*out |= in << SHL;
++out;
*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
++out;
if (DELTA + SHL > 64) {
*out = (in & MASK) >> (64 - SHL);
}
}
|
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rdx
shlq $0x1d, %rdx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %ecx
orq %rdx, %rcx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movabsq $0x1ffffffffff, %rax # imm = 0x1FFFFFFFFFF
andq -0x8(%rsp), %rax
shrq $0x3, %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movabsq $0x1ffffffffff, %rax # imm = 0x1FFFFFFFFFF
andq -0x8(%rsp), %rax
shrq $0x23, %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
retq
nop
|
/lemire[P]FastPFor/src/bitpacking.cpp
|
0x12ed70
|
lemire[P]FastPFor[P]build_O0[P]FastPFOR_unittest
|
leveldb::Footer::DecodeFrom(leveldb::Slice*)
|
Status Footer::DecodeFrom(Slice* input) {
const char* magic_ptr = input->data() + kEncodedLength - 8;
const uint32_t magic_lo = DecodeFixed32(magic_ptr);
const uint32_t magic_hi = DecodeFixed32(magic_ptr + 4);
const uint64_t magic = ((static_cast<uint64_t>(magic_hi) << 32) |
(static_cast<uint64_t>(magic_lo)));
if (magic != kTableMagicNumber) {
return Status::Corruption("not an sstable (bad magic number)");
}
Status result = metaindex_handle_.DecodeFrom(input);
if (result.ok()) {
result = index_handle_.DecodeFrom(input);
}
if (result.ok()) {
// We skip over any leftover data (just padding for now) in "input"
const char* end = magic_ptr + 8;
*input = Slice(end, input->data() + input->size() - end);
}
return result;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdx), %r13
movabsq $-0x24b88adb747f04a9, %rax # imm = 0xDB4775248B80FB57
cmpq %rax, 0x28(%r13)
jne 0x2a649
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, %rdi
callq 0x2a4cc
cmpq $0x0, (%rbx)
jne 0x2a62c
addq $0x10, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2a4cc
movq (%rbx), %rdi
movq (%r12), %rax
movq %rax, (%rbx)
movq %rdi, (%r12)
testq %rdi, %rdi
je 0x2a62c
callq 0x9800
cmpq $0x0, (%rbx)
jne 0x2a682
movq (%r14), %rax
addq 0x8(%r14), %rax
addq $0x30, %r13
subq %r13, %rax
movq %r13, (%r14)
movq %rax, 0x8(%r14)
jmp 0x2a682
leaq 0x32bad(%rip), %rax # 0x5d1fd
movq %rsp, %rdx
movq %rax, (%rdx)
movq $0x21, 0x8(%rdx)
leaq 0x35500(%rip), %rax # 0x5fb65
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq $0x0, 0x8(%rcx)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x26744
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/walterzhaoJR[P]leveldb/table/format.cc
|
0x2a5c8
|
walterzhaoJR[P]leveldb[P]build_O1[P]recovery_test
|
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<unsigned long&>(unsigned long&, bool)
|
std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0xb4240
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r15), %rcx
andq %rdx, %rcx
xorl %edi, %edi
cmpq %r15, %rcx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rdx, %rax
jae 0xb40d3
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq (%rsi), %rsi
movq %r14, %rdi
callq 0xb42da
movq %r14, %rdi
movl $0x1, %esi
callq 0xacfb0
testb %bpl, %bpl
jne 0xb4080
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0xb4261
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0xb4214
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0xb40dd
movq -0x8(%rax), %rax
testq %rax, %rax
je 0xb4214
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0xb4137
cmpl $0x2, %ecx
jne 0xb4266
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0xb0dbe
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0xb4210
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0xb4230
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0xacfb0
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0xacfb0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0xaf11c
movq %r15, %rdi
xorl %esi, %esi
callq 0xacfb0
movq %r15, %rdi
callq 0xb1638
movq (%rbx), %r14
jmp 0xb4210
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0xb4274
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r15), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r15, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0xb41a9
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0xb4214
cmpq $0x0, 0x70(%rbx)
je 0xb4295
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0xacfb0
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0xacfb0
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0xaf11c
movq %r15, %rdi
xorl %esi, %esi
callq 0xacfb0
movq %r15, %rdi
callq 0xb1638
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0xb4219
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xacfb0
movq %r15, %rdi
callq 0xb1638
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8e5d9(%rip), %rdi # 0x142820
leaq 0x84537(%rip), %rdx # 0x138785
leaq 0x8f53a(%rip), %rcx # 0x14378f
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x243e0
callq 0x24a20
leaq 0x8f536(%rip), %rcx # 0x1437a3
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0xb4280
leaq 0x8f566(%rip), %rcx # 0x1437e1
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x8e599(%rip), %rdi # 0x142820
leaq 0x844f7(%rip), %rdx # 0x138785
xorl %eax, %eax
callq 0x243e0
leaq 0x8e584(%rip), %rdi # 0x142820
leaq 0x844e2(%rip), %rdx # 0x138785
leaq 0x8f54f(%rip), %rcx # 0x1437f9
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x243e0
jmp 0xb42b8
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xacfb0
movq %r14, %rdi
callq 0xb1638
movq %rbx, %rdi
callq 0x23f60
|
/ggerganov[P]llama/common/json.hpp
|
0xb3f9e
|
ggerganov[P]llama[P]build_O3[P]bin[P]llama-mtmd-cli
|
QUnit::UnitTest::evaluate(bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*, int, char const*)
|
inline void UnitTest::evaluate(
bool compare, bool result,
std::string val1, std::string val2,
std::string str1, std::string str2,
const char * file, int line, const char * func) {
bool ok = result ? (val1 == val2) : (val1 != val2);
tests_ += 1;
errors_ += ok ? 0 : 1;
if( (ok && !(verboseLevel_ > normal)) || verboseLevel_ == silent )
return;
out_ << file << ( ok ? ";" : ":" ) << line << ": ";
out_ << ( ok ? "OK/" : "FAILED/" ) << func << "(): ";
if( compare ) {
const std::string cmp = ( result ? "==" : "!=" );
out_ << "compare {" << str1 << "} " << cmp << " {" << str2 << "} "
<< "got {\"" << val1 << "\"} " << cmp << " {\"" << val2 << "\"}";
} else {
out_ << "evaluate {" << str1 << "} == " << val1;
}
out_ << std::endl;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x18(%rsp)
movq %r8, %r14
movq %rcx, %r12
movl %edx, %ebp
movl %esi, 0x14(%rsp)
movq %rdi, %rbx
movq 0x8(%rcx), %rdx
movq 0x8(%r8), %rax
testl %ebp, %ebp
je 0x9c24
cmpq %rax, %rdx
jne 0x9c45
testq %rdx, %rdx
je 0x9c4a
movq (%r14), %rsi
movq (%r12), %rdi
callq 0x21c0
testl %eax, %eax
sete %r13b
jmp 0x9c4d
movb $0x1, %r13b
cmpq %rax, %rdx
jne 0x9c4d
testq %rdx, %rdx
je 0x9c45
movq (%r14), %rsi
movq (%r12), %rdi
callq 0x21c0
testl %eax, %eax
setne %r13b
jmp 0x9c4d
xorl %r13d, %r13d
jmp 0x9c4d
movb $0x1, %r13b
movl %r13d, %eax
xorb $0x1, %al
movzbl %al, %r15d
movd %r15d, %xmm0
movq 0x4(%rbx), %xmm1
movaps 0x1589(%rip), %xmm2 # 0xb1f0
movss %xmm0, %xmm2 # xmm2 = xmm0[0],xmm2[1,2,3]
paddd %xmm1, %xmm2
movq %xmm2, 0x4(%rbx)
movl (%rbx), %eax
cmpl $0x3, %eax
setl %cl
andb %r13b, %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0x9fa4
movq %r12, 0x8(%rsp)
movq %r14, 0x40(%rsp)
movq 0x88(%rsp), %r12
movq 0x10(%rbx), %r14
testq %r12, %r12
je 0x9cbf
movq %r12, %rdi
callq 0x20b0
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x21e0
jmp 0x9cd7
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2290
leaq 0x168b(%rip), %rax # 0xb369
leaq 0x1686(%rip), %rsi # 0xb36b
testb %r13b, %r13b
cmovneq %rax, %rsi
leaq 0x167a(%rip), %rax # 0xb36d
leaq 0x1677(%rip), %r12 # 0xb371
cmovneq %rax, %r12
leaq 0x1676(%rip), %r13 # 0xb37b
movl $0x1, %edx
movq %r14, %rdi
callq 0x21e0
movq %r14, %rdi
movl 0x90(%rsp), %esi
callq 0x22a0
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21e0
movq 0x10(%rbx), %r14
leaq 0x3(,%r15,4), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21e0
movq 0x98(%rsp), %r15
testq %r15, %r15
je 0x9d6d
movq %r15, %rdi
callq 0x20b0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x21e0
jmp 0x9d85
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2290
movq 0x8(%rsp), %r15
leaq 0x15e8(%rip), %rsi # 0xb379
movl $0x4, %edx
movq %r14, %rdi
callq 0x21e0
cmpb $0x0, 0x14(%rsp)
je 0x9f27
leaq 0x15ce(%rip), %rax # 0xb37e
leaq 0x15ca(%rip), %rsi # 0xb381
testb %bpl, %bpl
cmovneq %rax, %rsi
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15b1(%rip), %rax # 0xb380
leaq 0x15ad(%rip), %rdx # 0xb383
cmovneq %rax, %rdx
leaq 0x20(%rsp), %rdi
callq 0x35d4
movq 0x10(%rbx), %r14
leaq 0x1595(%rip), %rsi # 0xb384
movl $0x9, %edx
movq %r14, %rdi
callq 0x21e0
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x157c(%rip), %rsi # 0xb396
movl $0x2, %edx
movq %rax, %rdi
callq 0x21e0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x1548(%rip), %rsi # 0xb38b
movl $0x2, %edx
movq %rax, %rdi
callq 0x21e0
movq 0x80(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x1525(%rip), %rsi # 0xb396
movl $0x2, %edx
movq %rax, %rdi
callq 0x21e0
leaq 0x1509(%rip), %rsi # 0xb38e
movl $0x6, %edx
movq %r14, %rdi
callq 0x21e0
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x14e5(%rip), %rsi # 0xb395
movl $0x3, %edx
movq %rax, %rdi
callq 0x21e0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x14b8(%rip), %rsi # 0xb391
movl $0x3, %edx
movq %rax, %rdi
callq 0x21e0
movq 0x40(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x21e0
leaq 0x1498(%rip), %rsi # 0xb399
movl $0x2, %edx
movq %rax, %rdi
callq 0x21e0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x9f79
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x9f79
movq 0x10(%rbx), %r14
leaq 0x146a(%rip), %rsi # 0xb39c
movl $0xa, %edx
movq %r14, %rdi
callq 0x21e0
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x144a(%rip), %rsi # 0xb3a7
movl $0x5, %edx
movq %rax, %rdi
callq 0x21e0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x21e0
movq 0x10(%rbx), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x9fcd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22b0
nop
|
/Hao-Lin[P]A1/Main/Qunit/headers/QUnit.h
|
0x9bd8
|
Hao-Lin[P]A1[P]build_O3[P]A1
|
testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
|
AssertionResult EqFailure(const char* lhs_expression,
const char* rhs_expression,
const std::string& lhs_value,
const std::string& rhs_value,
bool ignoring_case) {
Message msg;
msg << "Expected equality of these values:";
msg << "\n " << lhs_expression;
if (lhs_value != lhs_expression) {
msg << "\n Which is: " << lhs_value;
}
msg << "\n " << rhs_expression;
if (rhs_value != rhs_expression) {
msg << "\n Which is: " << rhs_value;
}
if (ignoring_case) {
msg << "\nIgnoring case";
}
if (!lhs_value.empty() && !rhs_value.empty()) {
const std::vector<std::string> lhs_lines =
SplitEscapedString(lhs_value);
const std::vector<std::string> rhs_lines =
SplitEscapedString(rhs_value);
if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
msg << "\nWith diff:\n"
<< edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
}
}
return AssertionFailure() << msg;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xc0(%rbp)
movb %r9b, %al
movq %rdi, %r9
movq %r9, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x13680
movq -0xb0(%rbp), %rdi
leaq 0x4a257(%rip), %rsi # 0x5f4ed
callq 0x3a250
jmp 0x1529d
leaq 0x4a26c(%rip), %rsi # 0x5f510
leaq -0x38(%rbp), %rdi
callq 0x3a290
movq %rax, -0xc8(%rbp)
jmp 0x152b6
movq -0xc8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3a2d0
jmp 0x152c8
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3a340
movb %al, -0xc9(%rbp)
jmp 0x152dd
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x152e9
jmp 0x15327
leaq 0x4a224(%rip), %rsi # 0x5f514
leaq -0x38(%rbp), %rdi
callq 0x3a370
movq %rax, -0xd8(%rbp)
jmp 0x15302
movq -0xd8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x39620
jmp 0x15314
jmp 0x15327
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1554a
leaq 0x4a1e2(%rip), %rsi # 0x5f510
leaq -0x38(%rbp), %rdi
callq 0x3a290
movq %rax, -0xe0(%rbp)
jmp 0x15340
movq -0xe0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3a2d0
jmp 0x15352
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a340
movb %al, -0xe1(%rbp)
jmp 0x15367
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x15373
jmp 0x153a0
leaq 0x4a19a(%rip), %rsi # 0x5f514
leaq -0x38(%rbp), %rdi
callq 0x3a370
movq %rax, -0xf0(%rbp)
jmp 0x1538c
movq -0xf0(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x39620
jmp 0x1539e
jmp 0x153a0
testb $0x1, -0x29(%rbp)
je 0x153ba
leaq 0x4a177(%rip), %rsi # 0x5f524
leaq -0x38(%rbp), %rdi
callq 0x3a3b0
jmp 0x153b8
jmp 0x153ba
movq -0x20(%rbp), %rdi
callq 0xac60
testb $0x1, %al
jne 0x154d1
movq -0x28(%rbp), %rdi
callq 0xac60
testb $0x1, %al
jne 0x154d1
movq -0x20(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x15560
jmp 0x153eb
movq -0x28(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x15560
jmp 0x153fa
leaq -0x60(%rbp), %rdi
callq 0x39f60
cmpq $0x1, %rax
ja 0x1541c
leaq -0x78(%rbp), %rdi
callq 0x39f60
cmpq $0x1, %rax
jbe 0x154a9
leaq 0x4a110(%rip), %rsi # 0x5f533
leaq -0x38(%rbp), %rdi
callq 0x3a3f0
movq %rax, -0xf8(%rbp)
jmp 0x15435
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x78(%rbp), %rdx
movl $0x2, %ecx
callq 0x149d0
jmp 0x15450
movq -0xf8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x39620
jmp 0x15465
leaq -0x98(%rbp), %rdi
callq 0xae68
jmp 0x154a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x154c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x154bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xae68
jmp 0x154bd
leaq -0x78(%rbp), %rdi
callq 0x38ea0
leaq -0x60(%rbp), %rdi
callq 0x38ea0
jmp 0x154d1
leaq -0x78(%rbp), %rdi
callq 0x38ea0
leaq -0x60(%rbp), %rdi
callq 0x38ea0
jmp 0x1554a
leaq -0xa8(%rbp), %rdi
callq 0x13d80
jmp 0x154df
leaq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x39820
movq %rax, -0x100(%rbp)
jmp 0x154f8
movq -0x100(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x13b80
jmp 0x1550d
leaq -0xa8(%rbp), %rdi
callq 0xc2d0
leaq -0x38(%rbp), %rdi
callq 0xc2c0
movq -0xb8(%rbp), %rax
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xc2d0
leaq -0x38(%rbp), %rdi
callq 0xc2c0
movq -0x40(%rbp), %rdi
callq 0xacd0
nopl (%rax)
|
/metacall[P]core/build_O0/source/tests/src/google-test-depends/googletest/src/gtest.cc
|
0x15240
|
metacall[P]core[P]build_O0[P]metacall-backtrace-plugin-test
|
google::LogMessage::~LogMessage()
|
LogMessage::~LogMessage() {
Flush();
#ifdef GLOG_THREAD_LOCAL_STORAGE
if (data_ == static_cast<void*>(&thread_msg_data)) {
data_->~LogMessageData();
thread_data_available = true;
} else {
delete allocated_;
}
#else // !defined(GLOG_THREAD_LOCAL_STORAGE)
delete allocated_;
#endif // defined(GLOG_THREAD_LOCAL_STORAGE)
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xf6e0
jmp 0xf64b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
leaq -0x76e8(%rcx), %rcx
cmpq %rcx, %rax
jne 0xf69b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x17460
movq %fs:0x0, %rax
leaq -0x76f0(%rax), %rax
movb $0x1, (%rax)
jmp 0xf6c5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xf6c3
movq -0x20(%rbp), %rdi
callq 0x17460
movq -0x20(%rbp), %rdi
movl $0x76e8, %esi # imm = 0x76E8
callq 0x9730
jmp 0xf6c5
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xcd50
nopw %cs:(%rax,%rax)
|
/sergiud[P]glog/src/logging.cc
|
0xf630
|
sergiud[P]glog[P]build_O0[P]stacktrace_unittest
|
fts5ExprNodeTest_AND
|
static int fts5ExprNodeTest_AND(
Fts5Expr *pExpr, /* Expression pPhrase belongs to */
Fts5ExprNode *pAnd /* FTS5_AND node to advance */
){
int iChild;
i64 iLast = pAnd->iRowid;
int rc = SQLITE_OK;
int bMatch;
assert( pAnd->bEof==0 );
do {
pAnd->bNomatch = 0;
bMatch = 1;
for(iChild=0; iChild<pAnd->nChild; iChild++){
Fts5ExprNode *pChild = pAnd->apChild[iChild];
int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
if( cmp>0 ){
/* Advance pChild until it points to iLast or laster */
rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
if( rc!=SQLITE_OK ){
pAnd->bNomatch = 0;
return rc;
}
}
/* If the child node is now at EOF, so is the parent AND node. Otherwise,
** the child node is guaranteed to have advanced at least as far as
** rowid iLast. So if it is not at exactly iLast, pChild->iRowid is the
** new lastest rowid seen so far. */
assert( pChild->bEof || fts5RowidCmp(pExpr, iLast, pChild->iRowid)<=0 );
if( pChild->bEof ){
fts5ExprSetEof(pAnd);
bMatch = 1;
break;
}else if( iLast!=pChild->iRowid ){
bMatch = 0;
iLast = pChild->iRowid;
}
if( pChild->bNomatch ){
pAnd->bNomatch = 1;
}
}
}while( bMatch==0 );
if( pAnd->bNomatch && pAnd!=pExpr->pRoot ){
fts5ExprNodeZeroPoslist(pAnd);
}
pAnd->iRowid = iLast;
return SQLITE_OK;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rsi), %rbp
movl 0x28(%rsi), %eax
xorl %ecx, %ecx
movl $0x0, 0x8(%rbx)
testl %eax, %eax
jle 0xa7d4a
movl $0x1, %r13d
xorl %r14d, %r14d
movq %rbp, %r15
movq 0x30(%rbx,%r14,8), %r12
movq 0x18(%r12), %rax
cmpl $0x0, 0x18(%rdi)
je 0xa7cc7
cmpq %rax, %r15
jl 0xa7ccc
jmp 0xa7ce8
cmpq %rax, %r15
jle 0xa7ce8
movq %rdi, %rbp
movq %r12, %rsi
movl $0x1, %edx
movq %r15, %rcx
callq *0x10(%r12)
xorl %ecx, %ecx
movq %rbp, %rdi
testl %eax, %eax
jne 0xa7d52
cmpl $0x0, 0x4(%r12)
jne 0xa7d25
movq 0x18(%r12), %rbp
cmpq %rbp, %r15
cmovnel %ecx, %r13d
cmpl $0x0, 0x8(%r12)
je 0xa7d0b
movl $0x1, 0x8(%rbx)
incq %r14
movslq 0x28(%rbx), %rax
movq %rbp, %r15
cmpq %rax, %r14
jl 0xa7cb0
testl %r13d, %r13d
je 0xa7c95
jmp 0xa7d36
movq %rdi, %r14
movq %rbx, %rdi
callq 0xa3407
movq %r14, %rdi
movq %r15, %rbp
cmpl $0x0, 0x8(%rbx)
je 0xa7d4a
cmpq %rbx, 0x10(%rdi)
je 0xa7d4a
movq %rbx, %rdi
callq 0xa8216
movq %rbp, 0x18(%rbx)
xorl %eax, %eax
jmp 0xa7d59
movl $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/4rterius[P]cgtfs/third_party/sqlite3/src/sqlite3.c
|
0xa7c7e
|
4rterius[P]cgtfs[P]build_O3[P]example_2
|
Memory::HeapBucketT<Memory::SmallFinalizableWithBarrierHeapBlockT<MediumAllocationBlockAttributes>>::StopAllocationBeforeSweep()
|
void
HeapBucketT<TBlockType>::StopAllocationBeforeSweep()
{
#if ENABLE_ALLOCATIONS_DURING_CONCURRENT_SWEEP
this->allocationsStartedDuringConcurrentSweep = false;
#if SUPPORT_WIN32_SLIST
this->lastKnownNextAllocableBlockHead = this->nextAllocableBlockHead;
#endif
#endif
Assert(!this->IsAllocationStopped());
this->isAllocationStopped = true;
this->nextAllocableBlockHead = nullptr;
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x130d64
testb %al, %al
je 0x130aa6
leaq 0x12e2b0(%rip), %rax # 0x25ed0c
incl (%rax)
callq 0xf72e6
movq %fs:0x0, %rax
addq 0x12c4ad(%rip), %rax # 0x25cf20
movq %rax, %r14
movl $0x1, (%rax)
leaq 0xcaee3(%rip), %rdi # 0x1fb966
leaq 0xcb309(%rip), %rdx # 0x1fbd93
leaq 0xcb321(%rip), %rcx # 0x1fbdb2
movl $0x584, %esi # imm = 0x584
callq 0xf7302
testb %al, %al
je 0x130aba
movl $0x0, (%r14)
movb $0x1, 0x98(%rbx)
movq $0x0, 0x60(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
ud2
|
/chakra-core[P]ChakraCore/lib/Common/Memory/HeapBucket.cpp
|
0x130a42
|
chakra-core[P]ChakraCore[P]build_O1[P]bin[P]GCStress[P]GCStress
|
std::enable_if<(unsigned short)41 + (unsigned short)29 >= 64, void>::type (anonymous namespace)::pack_single_in64<(unsigned short)41, (unsigned short)29, 2199023255551ul>(unsigned long, unsigned int* restrict&)
|
pack_single_in64(
const uint64_t in, uint32_t *__restrict__ &out) {
*out |= in << SHL;
++out;
*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
++out;
if (DELTA + SHL > 64) {
*out = (in & MASK) >> (64 - SHL);
}
}
|
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rdx
shlq $0x1d, %rdx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %ecx
orq %rdx, %rcx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movabsq $0x1ffffffffff, %rax # imm = 0x1FFFFFFFFFF
andq -0x8(%rsp), %rax
shrq $0x3, %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movabsq $0x1ffffffffff, %rax # imm = 0x1FFFFFFFFFF
andq -0x8(%rsp), %rax
shrq $0x23, %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
retq
nop
|
/lemire[P]FastPFor/src/bitpacking.cpp
|
0x12ed70
|
lemire[P]FastPFor[P]build_O0[P]FastPFOR_unittest
|
std::enable_if<(unsigned short)41 + (unsigned short)29 >= 64, void>::type (anonymous namespace)::pack_single_in64<(unsigned short)41, (unsigned short)29, 2199023255551ul>(unsigned long, unsigned int* restrict&)
|
pack_single_in64(
const uint64_t in, uint32_t *__restrict__ &out) {
*out |= in << SHL;
++out;
*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
++out;
if (DELTA + SHL > 64) {
*out = (in & MASK) >> (64 - SHL);
}
}
|
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rdx
shlq $0x1d, %rdx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %ecx
orq %rdx, %rcx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movabsq $0x1ffffffffff, %rax # imm = 0x1FFFFFFFFFF
andq -0x8(%rsp), %rax
shrq $0x3, %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movabsq $0x1ffffffffff, %rax # imm = 0x1FFFFFFFFFF
andq -0x8(%rsp), %rax
shrq $0x23, %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
retq
nop
|
/lemire[P]FastPFor/src/bitpacking.cpp
|
0x12ed70
|
lemire[P]FastPFor[P]build_O0[P]FastPFOR_unittest
|
llvm::createR600ControlFlowFinalizer()
|
FunctionPass *llvm::createR600ControlFlowFinalizer() {
return new R600ControlFlowFinalizer();
}
|
pushq %rax
movl $0x58, %edi
callq 0xfc59e0
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x7519876(%rip), %rdx # 0x87daa54
movq %rdx, 0x10(%rax)
movl $0x2, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rcx, 0x30(%rax)
leaq 0x70ae70d(%rip), %rdx # 0x836f908
movq %rdx, (%rax)
movq %rcx, 0x50(%rax)
movups %xmm0, 0x38(%rax)
popq %rcx
retq
|
/Target/AMDGPU/R600ControlFlowFinalizer.cpp
|
0x12c11c6
|
llvm-project[P]build_O1[P]bin[P]clang-19
|
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
|
Message& Message::operator <<(const ::std::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x6c78f
movq (%rsi), %r13
leaq 0x18(%rsp), %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
cmpl $0x0, (%r13,%rbp,4)
je 0x6c76e
leaq (,%rbp,4), %rsi
addq %r13, %rsi
movl %r15d, %edx
subl %ebp, %edx
movq %r14, %rdi
callq 0x6f636
movq (%rbx), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3f800
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6c75c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3f6e0
cmpq %rbp, %r15
je 0x6c78f
cmpl $0x0, (%r13,%rbp,4)
je 0x6c78a
incq %rbp
jmp 0x6c75c
movq (%rbx), %rdi
addq $0x10, %rdi
movb $0x0, 0x8(%rsp)
movl $0x1, %edx
movq %r14, %rsi
callq 0x3f800
incq %rbp
cmpq %r15, %rbp
jne 0x6c70f
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6c7bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3f6e0
movq %rbx, %rdi
callq 0x3fd80
nop
|
/Tom1975[P]SugarConvDsk/googletest/googletest/src/gtest.cc
|
0x6c6e2
|
Tom1975[P]SugarConvDsk[P]build_O3[P]Tests[P]Tests
|
add64
|
static inline void add64( mbedtls_mpi_uint *dst, mbedtls_mpi_uint *src, mbedtls_mpi_uint *carry )
{
unsigned char i;
mbedtls_mpi_uint c = 0;
for( i = 0; i < 8 / sizeof( mbedtls_mpi_uint ); i++, dst++, src++ )
{
*dst += c; c = ( *dst < c );
*dst += *src; c += ( *dst < *src );
}
*carry += c;
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movb $0x0, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpq $0x1, %rax
jae 0x349e3
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x3495c
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/ARMmbed[P]mbed-crypto/library/ecp_curves.c
|
0x34940
|
ARMmbed[P]mbed-crypto[P]build_O0[P]programs[P]test[P]benchmark
|
Js::JavascriptOperators::UpdateNativeArrayProfileInfoToCreateVarArray(void*, bool, bool)
|
void JavascriptOperators::UpdateNativeArrayProfileInfoToCreateVarArray(Var instance, const bool expectingNativeFloatArray, const bool expectingVarArray)
{
Assert(instance);
Assert(expectingNativeFloatArray ^ expectingVarArray);
JavascriptNativeArray * nativeArr = JavascriptOperators::TryFromVar<JavascriptNativeArray>(instance);
if (!nativeArr)
{
return;
}
ArrayCallSiteInfo *const arrayCallSiteInfo = nativeArr->GetArrayCallSiteInfo();
if (!arrayCallSiteInfo)
{
return;
}
if (expectingNativeFloatArray)
{
// Profile data is expecting a native float array. Ensure that at the array's creation site, that a native int array
// is not created, such that the profiled array type would be correct.
arrayCallSiteInfo->SetIsNotNativeIntArray();
}
else
{
// Profile data is expecting a var array. Ensure that at the array's creation site, that a native array is not
// created, such that the profiled array type would be correct.
Assert(expectingVarArray);
arrayCallSiteInfo->SetIsNotNativeArray();
}
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
testq %rdi, %rdi
jne 0x9acf96
leaq 0xae6375(%rip), %rax # 0x14932bc
incl (%rax)
callq 0x592f56
leaq 0xa9bfb2(%rip), %rdi # 0x1448f08
callq 0x1cf730
movq %rax, %r12
movl $0x1, (%rax)
leaq 0x667412(%rip), %rdi # 0x1014380
leaq 0x62c2c2(%rip), %rdx # 0xfd9237
leaq 0x6e9c70(%rip), %rcx # 0x1096bec
movl $0xdfd, %esi # imm = 0xDFD
callq 0x592f72
testb %al, %al
je 0x9ad09c
movl $0x0, (%r12)
cmpb %bl, %r14b
jne 0x9acff1
leaq 0xae631a(%rip), %rax # 0x14932bc
incl (%rax)
callq 0x592f56
leaq 0xa9bf57(%rip), %rdi # 0x1448f08
callq 0x1cf730
movq %rax, %r12
movl $0x1, (%rax)
leaq 0x6673b7(%rip), %rdi # 0x1014380
leaq 0x667f79(%rip), %rdx # 0x1014f49
leaq 0x667fa2(%rip), %rcx # 0x1014f79
movl $0xdfe, %esi # imm = 0xDFE
callq 0x592f72
testb %al, %al
je 0x9ad09c
movl $0x0, (%r12)
movq %r15, %rdi
callq 0x9a3de9
testb %al, %al
je 0x9ad02f
movq %r15, %rdi
callq 0x9a3d7b
testq %rax, %rax
je 0x9ad02f
movq %rax, %rdi
callq 0xa6b908
testq %rax, %rax
je 0x9ad02f
movq %rax, %r15
testb %r14b, %r14b
je 0x9ad038
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85e3d2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testb %bl, %bl
jne 0x9ad08c
leaq 0xae6279(%rip), %rax # 0x14932bc
incl (%rax)
callq 0x592f56
leaq 0xa9beb6(%rip), %rdi # 0x1448f08
callq 0x1cf730
movq %rax, %rbx
movl $0x1, (%rax)
leaq 0x667316(%rip), %rdi # 0x1014380
leaq 0x667f36(%rip), %rdx # 0x1014fa7
leaq 0x667f1d(%rip), %rcx # 0x1014f95
movl $0xe16, %esi # imm = 0xE16
callq 0x592f72
testb %al, %al
je 0x9ad09c
movl $0x0, (%rbx)
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85e5ee
ud2
|
/chakra-core[P]ChakraCore/lib/Runtime/Language/JavascriptOperators.cpp
|
0x9acf28
|
chakra-core[P]ChakraCore[P]build_O3[P]bin[P]ChakraCore[P]libChakraCore.so
|
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 1