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
|
bool duckdb::IntegerCastLoop<duckdb::IntegerDecimalCastData<unsigned int>, true, true, duckdb::IntegerDecimalCastOperation, (char)46>(char const*, unsigned long, duckdb::IntegerDecimalCastData<unsigned int>&, bool)
|
static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict) {
idx_t start_pos;
if (NEGATIVE) {
start_pos = 1;
} else {
if (*buf == '+') {
if (strict) {
// leading plus is not allowed in strict mode
return false;
}
start_pos = 1;
} else {
start_pos = 0;
}
}
idx_t pos = start_pos;
while (pos < len) {
if (!StringUtil::CharacterIsDigit(buf[pos])) {
// not a digit!
if (buf[pos] == decimal_separator) {
if (strict) {
return false;
}
bool number_before_period = pos > start_pos;
// decimal point: we accept decimal values for integers as well
// we just truncate them
// make sure everything after the period is a number
pos++;
idx_t start_digit = pos;
while (pos < len) {
if (!StringUtil::CharacterIsDigit(buf[pos])) {
break;
}
if (!OP::template HandleDecimal<T, NEGATIVE, ALLOW_EXPONENT>(
result, UnsafeNumericCast<uint8_t>(buf[pos] - '0'))) {
return false;
}
pos++;
if (pos != len && buf[pos] == '_') {
// Skip one underscore if it is not the last character and followed by a digit
pos++;
if (pos == len || !StringUtil::CharacterIsDigit(buf[pos])) {
return false;
}
}
}
// make sure there is either (1) one number after the period, or (2) one number before the period
// i.e. we accept "1." and ".1" as valid numbers, but not "."
if (!(number_before_period || pos > start_digit)) {
return false;
}
if (pos >= len) {
break;
}
}
if (StringUtil::CharacterIsSpace(buf[pos])) {
// skip any trailing spaces
while (++pos < len) {
if (!StringUtil::CharacterIsSpace(buf[pos])) {
return false;
}
}
break;
}
if (ALLOW_EXPONENT) {
if (buf[pos] == 'e' || buf[pos] == 'E') {
if (strict) {
return false;
}
if (pos == start_pos) {
return false;
}
pos++;
if (pos >= len) {
return false;
}
using ExponentData = IntegerCastData<int16_t>;
ExponentData exponent {};
int negative = buf[pos] == '-';
if (negative) {
if (!IntegerCastLoop<ExponentData, true, false, IntegerCastOperation, decimal_separator>(
buf + pos, len - pos, exponent, strict)) {
return false;
}
} else {
if (!IntegerCastLoop<ExponentData, false, false, IntegerCastOperation, decimal_separator>(
buf + pos, len - pos, exponent, strict)) {
return false;
}
}
return OP::template HandleExponent<T, NEGATIVE>(result, exponent.result);
}
}
return false;
}
auto digit = UnsafeNumericCast<uint8_t>(buf[pos++] - '0');
if (!OP::template HandleDigit<T, NEGATIVE>(result, digit)) {
return false;
}
if (pos != len && buf[pos] == '_' && !strict) {
// Skip one underscore if it is not the last character and followed by a digit
pos++;
if (pos == len || !StringUtil::CharacterIsDigit(buf[pos])) {
return false;
}
}
}
if (!OP::template Finalize<T, NEGATIVE>(result)) {
return false;
}
return pos > start_pos;
}
|
subq $0x68, %rsp
movb %cl, %al
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
movq $0x1, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x1681d4e
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x144770
testb $0x1, %al
jne 0x1681ca6
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x1681b12
testb $0x1, 0x47(%rsp)
je 0x16819e1
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
seta %al
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x1681ae2
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x144770
testb $0x1, %al
jne 0x1681a38
jmp 0x1681ae2
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %edi
subl $0x30, %edi
callq 0x233e20
movq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x238e80
testb $0x1, %al
jne 0x1681a73
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x1681add
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
jne 0x1681add
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x1681ad1
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x144770
testb $0x1, %al
jne 0x1681adb
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
jmp 0x1681add
jmp 0x1681a0c
testb $0x1, 0x2f(%rsp)
jne 0x1681aff
movq 0x30(%rsp), %rax
cmpq 0x20(%rsp), %rax
ja 0x1681aff
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
jb 0x1681b10
jmp 0x1681d4e
jmp 0x1681b12
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x144f30
testb $0x1, %al
jne 0x1681b2b
jmp 0x1681b6a
jmp 0x1681b2d
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
cmpq 0x50(%rsp), %rax
jae 0x1681b65
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x144f30
testb $0x1, %al
jne 0x1681b63
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
jmp 0x1681b2d
jmp 0x1681d4e
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x65, %eax
je 0x1681b94
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x45, %eax
jne 0x1681c9c
testb $0x1, 0x47(%rsp)
je 0x1681ba5
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x1681bbb
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
jb 0x1681bdf
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
leaq 0x1e(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xd2190
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x1681c4b
movq 0x58(%rsp), %rdi
addq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
subq 0x30(%rsp), %rsi
movb 0x47(%rsp), %al
leaq 0x1e(%rsp), %rdx
andb $0x1, %al
movzbl %al, %ecx
callq 0x16795b0
testb $0x1, %al
jne 0x1681c49
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
jmp 0x1681c82
movq 0x58(%rsp), %rdi
addq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
subq 0x30(%rsp), %rsi
movb 0x47(%rsp), %al
leaq 0x1e(%rsp), %rdx
andb $0x1, %al
movzbl %al, %ecx
callq 0x16798a0
testb $0x1, %al
jne 0x1681c80
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
jmp 0x1681c82
movq 0x48(%rsp), %rdi
movswl 0x1e(%rsp), %esi
callq 0x238f10
andb $0x1, %al
movb %al, 0x67(%rsp)
jmp 0x1681d76
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x30(%rsp)
movsbl (%rax,%rcx), %edi
subl $0x30, %edi
callq 0x233e20
movb %al, 0x17(%rsp)
movq 0x48(%rsp), %rdi
movzbl 0x17(%rsp), %esi
callq 0x2391f0
testb $0x1, %al
jne 0x1681ce9
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x1681d49
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
jne 0x1681d49
testb $0x1, 0x47(%rsp)
jne 0x1681d49
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x1681d40
movq 0x58(%rsp), %rax
movq 0x30(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x144770
testb $0x1, %al
jne 0x1681d47
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
jmp 0x1681d49
jmp 0x168198e
movq 0x48(%rsp), %rdi
callq 0x239270
testb $0x1, %al
jne 0x1681d63
movb $0x0, 0x67(%rsp)
jmp 0x1681d76
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
seta %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
|
/duckdb[P]duckdb/src/include/duckdb/common/operator/integer_cast_operator.hpp
|
0x1681960
|
duckdb[P]duckdb[P]build_O0[P]duckdb
|
void slang::ast::ASTVisitor<auto slang::ast::makeVisitor<SvTypeReflector::reflect()::$_3>(SvTypeReflector::reflect()::$_3)::Result, true, true, false, false>::visit<slang::ast::TimingPathSymbol>(slang::ast::TimingPathSymbol const&)
|
void visit(const T& t) {
if constexpr (!VisitBad && requires { t.bad(); }) {
if (t.bad())
return;
}
if constexpr (requires { (DERIVED).handle(t); })
(DERIVED).handle(t);
else if constexpr (requires { (DERIVED)(DERIVED, t); })
(DERIVED)(DERIVED, t);
else
visitDefault(t);
}
|
pushq %rax
callq 0x24e076
testq %rax, %rax
je 0x7c68b
movq %rax, %rdi
callq 0x1aacf8
testq %rax, %rax
je 0x7c68b
movq %rax, %rdi
popq %rax
jmp 0x7ca12
popq %rax
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h
|
0x7c66a
|
MikePopoloski[P]slang[P]build_O1[P]bin[P]slang-reflect
|
Assimp::IFC::Schema_2x3::IfcCostItem::~IfcCostItem()
|
IfcCostItem() : Object("IfcCostItem") {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x429771(%rip), %rax # 0x882a20
movq %rax, (%rdi)
leaq 0x4297df(%rip), %rax # 0x882a98
movq %rax, 0xf0(%rdi)
leaq 0x429781(%rip), %rax # 0x882a48
movq %rax, 0x88(%rdi)
leaq 0x42979b(%rip), %rax # 0x882a70
movq %rax, 0x98(%rdi)
movq 0xa8(%rdi), %rdi
leaq 0xb8(%rbx), %rax
cmpq %rax, %rdi
je 0x4592fa
movq (%rax), %rsi
incq %rsi
callq 0x202180
leaq 0x429837(%rip), %rax # 0x882b38
movq %rax, (%rbx)
leaq 0x429855(%rip), %rax # 0x882b60
movq %rax, 0xf0(%rbx)
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x45932a
movq (%rax), %rsi
incq %rsi
callq 0x202180
movq 0x38(%rbx), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x459342
movq (%rax), %rsi
incq %rsi
callq 0x202180
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x45935b
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x202180
popq %rbx
retq
nop
|
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h
|
0x4592a4
|
hbina[P]fatuous[P]build_O1[P]thirdparty[P]assimp[P]test[P]unit
|
ShowDemoWindowWidgets()::Funcs::MyResizeCallback(ImGuiInputTextCallbackData*)
|
static int MyResizeCallback(ImGuiInputTextCallbackData* data)
{
if (data->EventFlag == ImGuiInputTextFlags_CallbackResize)
{
ImVector<char>* my_str = (ImVector<char>*)data->UserData;
IM_ASSERT(my_str->begin() == data->Buf);
my_str->resize(data->BufSize); // NB: On resizing calls, generally data->BufSize == data->BufTextLen + 1
data->Buf = my_str->begin();
}
return 0;
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x40000, (%rax) # imm = 0x40000
jne 0x803dc
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x24(%rax), %esi
callq 0x3dab0
movq 0x8(%rsp), %rdi
callq 0x44cf0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
|
/ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui_demo.cpp
|
0x80390
|
ggerganov[P]imgui-ws[P]build_O0[P]bin[P]textures-null
|
llvm::SmallVectorImpl<clang::FieldDecl*>::operator=(llvm::SmallVectorImpl<clang::FieldDecl*> const&)
|
SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
// Assign common elements.
iterator NewEnd;
if (RHSSize)
NewEnd = std::copy(RHS.begin(), RHS.begin()+RHSSize, this->begin());
else
NewEnd = this->begin();
// Destroy excess elements.
this->destroy_range(NewEnd, this->end());
// Trim.
this->set_size(RHSSize);
return *this;
}
// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: don't do this if they're efficiently moveable.
if (this->capacity() < RHSSize) {
// Destroy current elements.
this->clear();
CurSize = 0;
this->grow(RHSSize);
} else if (CurSize) {
// Otherwise, use assignment for the already-constructed elements.
std::copy(RHS.begin(), RHS.begin()+CurSize, this->begin());
}
// Copy construct the new elements in place.
this->uninitialized_copy(RHS.begin()+CurSize, RHS.end(),
this->begin()+CurSize);
// Set end.
this->set_size(RHSSize);
return *this;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xc56d5c
movq %rsi, %r15
movl 0x8(%rsi), %r14d
movl 0x8(%rbx), %r12d
cmpl %r14d, %r12d
jae 0xc56cff
cmpl %r14d, 0xc(%rbx)
jae 0xc56d19
andl $0x0, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5c7286
jmp 0xc56d33
testl %r14d, %r14d
je 0xc56d58
movq (%r15), %rsi
leaq (,%r14,8), %rdx
movq (%rbx), %rdi
callq 0x13fb00
jmp 0xc56d58
testq %r12, %r12
je 0xc56d33
movq (%r15), %rsi
leaq (,%r12,8), %rdx
movq (%rbx), %rdi
callq 0x13fb00
jmp 0xc56d36
xorl %r12d, %r12d
movl 0x8(%r15), %edx
subq %r12, %rdx
je 0xc56d58
shlq $0x3, %r12
movq (%r15), %rsi
addq %r12, %rsi
addq (%rbx), %r12
shlq $0x3, %rdx
movq %r12, %rdi
callq 0x140010
movl %r14d, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/SmallVector.h
|
0xc56cc4
|
llvm-project[P]build_O2[P]bin[P]lldb-server
|
llvm::ResourceSegments::sortAndMerge()
|
void ResourceSegments::sortAndMerge() {
if (_Intervals.size() <= 1)
return;
// First sort the collection.
_Intervals.sort(sortIntervals);
// can use next because I have at least 2 elements in the list
auto next = std::next(std::begin(_Intervals));
auto E = std::end(_Intervals);
for (; next != E; ++next) {
if (std::prev(next)->second >= next->first) {
next->first = std::prev(next)->first;
_Intervals.erase(std::prev(next));
continue;
}
}
}
|
cmpq $0x2, 0x10(%rdi)
jb 0x2c00859
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x25c(%rip), %rsi # 0x2c00a68
callq 0x2c0085a
movq (%rbx), %rax
movq (%rax), %r15
cmpq %rbx, %r15
je 0x2c00854
movq 0x8(%r15), %rax
movq 0x18(%rax), %rax
cmpq 0x10(%r15), %rax
jl 0x2c0084f
movq 0x8(%r15), %r14
movq 0x10(%r14), %rax
movq %rax, 0x10(%r15)
decq 0x10(%rbx)
movq %r14, %rdi
callq 0x7dd770
movl $0x20, %esi
movq %r14, %rdi
callq 0x7dd920
movq (%r15), %r15
jmp 0x2c00817
popq %rbx
popq %r14
popq %r15
retq
|
/CodeGen/MachineScheduler.cpp
|
0x2c007f6
|
llvm-project[P]build_O1[P]bin[P]clangd
|
helics::CommsBroker<helics::zeromq::ZmqComms, helics::CoreBroker>::CommsBroker(bool)
|
CommsBroker<COMMS, BrokerT>::CommsBroker(bool arg) noexcept: BrokerT(arg)
{
static_assert(std::is_base_of<CommsInterface, COMMS>::value,
"COMMS object must be a CommsInterface Object");
static_assert(std::is_base_of<BrokerBase, BrokerT>::value,
"Broker must be an object with a base of BrokerBase");
loadComms();
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x238fca
leaq 0x2833fa(%rip), %rax # 0x457638
leaq 0x10(%rax), %rcx
movq %rcx, (%rbx)
addq $0x168, %rax # imm = 0x168
movq %rax, 0x8(%rbx)
movl $0x0, 0xe70(%rbx)
movq $0x0, 0xe78(%rbx)
movb $0x0, 0xe80(%rbx)
movq %rbx, %rdi
callq 0x1d410c
popq %rbx
retq
movq %rax, %rdi
callq 0x93cc4
nop
|
/GMLC-TDC[P]HELICS/src/helics/network/CommsBroker_impl.hpp
|
0x1d422e
|
GMLC-TDC[P]HELICS[P]build_O3[P]bin[P]helics_broker
|
jrtplib::RTCPCompoundPacketBuilder::RTCPCompoundPacketBuilder(jrtplib::RTPMemoryManager*)
|
RTCPCompoundPacketBuilder::RTCPCompoundPacketBuilder(RTPMemoryManager *mgr) : RTCPCompoundPacket(mgr), report(mgr), sdes(mgr)
{
byesize = 0;
appsize = 0;
#ifdef RTP_SUPPORT_RTCPUNKNOWN
unknownsize = 0;
#endif // RTP_SUPPORT_RTCPUNKNOWN
maximumpacketsize = 0;
buffer = 0;
external = false;
arebuilding = false;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2e3ca
leaq 0x1725a(%rip), %rax # 0x45858
movq %rax, (%rbx)
movq %r14, 0x70(%rbx)
leaq 0x17284(%rip), %rax # 0x45890
movq %rax, 0x68(%rbx)
leaq 0xa8(%rbx), %rax
movq %rax, 0xb0(%rbx)
movq %rax, 0xa8(%rbx)
andq $0x0, 0xb8(%rbx)
leaq 0x88(%rbx), %rax
movq %rax, 0x80(%rbx)
movb $0x0, 0x78(%rbx)
andq $0x0, 0xa0(%rbx)
movq %r14, 0xc8(%rbx)
leaq 0x17273(%rip), %rax # 0x458c8
movq %rax, 0xc0(%rbx)
leaq 0xd0(%rbx), %rax
movq %rax, 0xd8(%rbx)
movq %rax, 0xd0(%rbx)
andq $0x0, 0xe0(%rbx)
movq %rax, 0xe8(%rbx)
leaq 0xf0(%rbx), %rax
movq %rax, 0xf8(%rbx)
movq %rax, 0xf0(%rbx)
andq $0x0, 0x100(%rbx)
leaq 0x110(%rbx), %rax
movq %rax, 0x118(%rbx)
movq %rax, 0x110(%rbx)
andq $0x0, 0x108(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
andw $0x0, 0x60(%rbx)
movups %xmm0, 0x120(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/astronautlabs[P]rtp/src/rtcpcompoundpacketbuilder.cpp
|
0x2e5e8
|
astronautlabs[P]rtp[P]build_O2[P]examples[P]example5
|
std::vector<tinyusdz::value::color3h, std::allocator<tinyusdz::value::color3h>> tinyusdz::lerp<tinyusdz::value::color3h>(std::vector<tinyusdz::value::color3h, std::allocator<tinyusdz::value::color3h>> const&, std::vector<tinyusdz::value::color3h, std::allocator<tinyusdz::value::color3h>> const&, double)
|
inline std::vector<T> lerp(const std::vector<T> &a, const std::vector<T> &b,
const double t) {
std::vector<T> dst;
// Choose shorter one
size_t n = std::min(a.size(), b.size());
if (n == 0) {
return dst;
}
dst.resize(n);
if (a.size() != b.size()) {
return dst;
}
for (size_t i = 0; i < n; i++) {
dst[i] = lerp(a[i], b[i], t);
}
return dst;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x6
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %rcx
cmpq %r12, %rax
cmovbq %rax, %r12
testq %r12, %r12
je 0x98ce7
movq %rsi, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x9ad52
movq 0x8(%r15), %rax
subq (%r15), %rax
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
cmpq %rcx, %rax
jne 0x98ce7
xorl %r13d, %r13d
subq $0x1, %r12
jb 0x98ce7
movq (%r15), %rdi
addq %r13, %rdi
movq (%rbx), %rsi
addq %r13, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x98b7f
movq (%r14), %rcx
movl %eax, (%rcx,%r13)
shrq $0x20, %rax
movw %ax, 0x4(%rcx,%r13)
addq $0x6, %r13
jmp 0x98cb3
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/syoyo[P]tinyusdz/src/value-eval-util.hh
|
0x98c41
|
syoyo[P]tinyusdz[P]build_O2[P]save_usda
|
prepare_coeffs
|
static inline void prepare_coeffs(const InterpFilterParams *const filter_params,
const int subpel_q4,
__m256i *const coeffs /* [4] */) {
const int16_t *filter = av1_get_interp_filter_subpel_kernel(
filter_params, subpel_q4 & SUBPEL_MASK);
const __m128i coeff_8 = _mm_loadu_si128((__m128i *)filter);
const __m256i coeff = _mm256_broadcastsi128_si256(coeff_8);
// coeffs 0 1 0 1 0 1 0 1
coeffs[0] = _mm256_shuffle_epi32(coeff, 0x00);
// coeffs 2 3 2 3 2 3 2 3
coeffs[1] = _mm256_shuffle_epi32(coeff, 0x55);
// coeffs 4 5 4 5 4 5 4 5
coeffs[2] = _mm256_shuffle_epi32(coeff, 0xaa);
// coeffs 6 7 6 7 6 7 6 7
coeffs[3] = _mm256_shuffle_epi32(coeff, 0xff);
}
|
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x80, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
andl $0xf, %esi
callq 0x50aa60
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa %xmm0, 0x60(%rsp)
vbroadcastf128 0x60(%rsp), %ymm0 # ymm0 = mem[0,1,0,1]
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm0
vpshufd $0x0, %ymm0, %ymm0 # ymm0 = ymm0[0,0,0,0,4,4,4,4]
movq 0x40(%rsp), %rax
vmovaps %ymm0, (%rax)
vmovaps (%rsp), %ymm0
vpshufd $0x55, %ymm0, %ymm0 # ymm0 = ymm0[1,1,1,1,5,5,5,5]
movq 0x40(%rsp), %rax
vmovaps %ymm0, 0x20(%rax)
vmovaps (%rsp), %ymm0
vpshufd $0xaa, %ymm0, %ymm0 # ymm0 = ymm0[2,2,2,2,6,6,6,6]
movq 0x40(%rsp), %rax
vmovaps %ymm0, 0x40(%rax)
vmovaps (%rsp), %ymm0
vpshufd $0xff, %ymm0, %ymm0 # ymm0 = ymm0[3,3,3,3,7,7,7,7]
movq 0x40(%rsp), %rax
vmovdqa %ymm0, 0x60(%rax)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax,%rax)
|
/m-ab-s[P]aom/aom_dsp/x86/convolve_avx2.h
|
0x505170
|
m-ab-s[P]aom[P]build_O0[P]aomenc
|
QJsonDocument::operator=(QJsonDocument const&)
|
QJsonDocument &QJsonDocument::operator =(const QJsonDocument &other)
{
if (this != &other) {
if (other.d) {
if (!d)
d = std::make_unique<QJsonDocumentPrivate>();
d->value = other.d->value;
} else {
d.reset();
}
}
return *this;
}
|
endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
cmpq %rsi, %rdi
je 0x1f4fa1
movq %rsi, %r14
cmpq $0x0, (%rsi)
je 0x1f4f97
cmpq $0x0, (%rbx)
jne 0x1f4f8a
movl $0x18, %edi
callq 0xd4930
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x117, 0x10(%rax) # imm = 0x117
movq %rsp, %r15
movq %rcx, (%r15)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1f6064
movq %r15, %rdi
callq 0x1f5fc0
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0xd7330
jmp 0x1f4fa1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1f6064
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0x1f4fbe
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0xd5ba0
nop
|
/qt[P]qtbase/src/corelib/serialization/qjsondocument.cpp
|
0x1f4f22
|
qt[P]qtbase[P]build_O1[P]lib[P]libQt6Core.so.6.10.0
|
bool TestComparisonsF<Counter<unsigned short, 16u>>()
|
bool TestComparisonsF()
{
CounterT a = 2, b = 2, c = 3;
TEST_CHECK(a == b);
TEST_CHECK(b != c);
b = c;
TEST_CHECK(b == c);
TEST_CHECK(a != b);
for (unsigned sep = 0; sep < 3; ++sep)
{
a = CounterT::kMask - sep;
b = 0;
c = 1 + sep;
for (unsigned ii = 0; ii < 1000; ++ii)
{
TEST_CHECK(a == a);
TEST_CHECK(b == b);
TEST_CHECK(c == c);
TEST_CHECK(a != b);
TEST_CHECK(a != c);
TEST_CHECK(b != a);
TEST_CHECK(b != c);
TEST_CHECK(c != a);
TEST_CHECK(c != b);
TEST_CHECK(a < b);
TEST_CHECK(a < c);
TEST_CHECK(b < c);
TEST_CHECK(a <= b);
TEST_CHECK(a <= c);
TEST_CHECK(b <= c);
TEST_CHECK(a <= a);
TEST_CHECK(b <= b);
TEST_CHECK(c <= c);
TEST_CHECK(b > a);
TEST_CHECK(c > a);
TEST_CHECK(c > b);
TEST_CHECK(b >= a);
TEST_CHECK(c >= a);
TEST_CHECK(c >= b);
TEST_CHECK(a >= a);
TEST_CHECK(b >= b);
TEST_CHECK(c >= c);
a++;
++b;
c++;
}
for (unsigned ii = 0; ii < 2000; ++ii)
{
TEST_CHECK(a == a);
TEST_CHECK(b == b);
TEST_CHECK(c == c);
TEST_CHECK(a != b);
TEST_CHECK(a != c);
TEST_CHECK(b != a);
TEST_CHECK(b != c);
TEST_CHECK(c != a);
TEST_CHECK(c != b);
TEST_CHECK(a < b);
TEST_CHECK(a < c);
TEST_CHECK(b < c);
TEST_CHECK(a <= b);
TEST_CHECK(a <= c);
TEST_CHECK(b <= c);
TEST_CHECK(a <= a);
TEST_CHECK(b <= b);
TEST_CHECK(c <= c);
TEST_CHECK(b > a);
TEST_CHECK(c > a);
TEST_CHECK(c > b);
TEST_CHECK(b >= a);
TEST_CHECK(c >= a);
TEST_CHECK(c >= b);
TEST_CHECK(a >= a);
TEST_CHECK(b >= b);
TEST_CHECK(c >= c);
a--;
--b;
c--;
}
}
return true;
}
|
movb $0x1, %al
retq
|
/catid[P]counter/tests/CounterUnitTest.cpp
|
0x18c4
|
catid[P]counter[P]build_O2[P]counter_unit_test
|
args::FlagBase::Match(char)
|
virtual FlagBase *Match(const char flag)
{
if (matcher.Match(flag))
{
if (extraError && matched)
{
#ifdef ARGS_NOEXCEPT
error = Error::Extra;
#else
std::ostringstream problem;
problem << "Flag '" << flag << "' was passed multiple times, but is only allowed to be passed once";
throw ExtraError(problem.str());
#endif
}
matched = true;
return this;
}
return nullptr;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %esi, %ebx
movq %rdi, %r14
addq $0x58, %rdi
leaq 0x28(%rsp), %rsi
movb %bl, (%rsi)
callq 0xc72a
testq %rax, %rax
je 0xc016
cmpb $0x1, 0x51(%r14)
jne 0xc00f
cmpb $0x1, 0x8(%r14)
je 0xc028
movb $0x1, 0x8(%r14)
jmp 0xc019
xorl %r14d, %r14d
movq %r14, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x54c0
leaq 0x17453(%rip), %rsi # 0x2348f
movl $0x6, %edx
movq %r14, %rdi
callq 0x5410
leaq 0x8(%rsp), %rsi
movb %bl, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x5410
leaq 0x17430(%rip), %rsi # 0x23496
movl $0x42, %edx
movq %rax, %rdi
callq 0x5410
movl $0x10, %edi
callq 0x51c0
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5570
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5460
leaq 0x239f2(%rip), %rax # 0x2fa98
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x239be(%rip), %rsi # 0x2fa70
movq 0x23f07(%rip), %rdx # 0x2ffc0
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc0d7
callq 0x5350
testb %bpl, %bpl
jne 0xc0e1
jmp 0xc0ee
movq %rax, %r14
movq %rbx, %rdi
callq 0x52d0
jmp 0xc0ee
movq %rax, %r14
movq 0x23ec3(%rip), %rsi # 0x2ffb8
leaq 0x28(%rsp), %rdi
callq 0x51f0
leaq 0x98(%rsp), %rdi
callq 0x5130
movq %r14, %rdi
callq 0x5640
|
/rilianx[P]IMRTsolver/main/args.hxx
|
0xbfdc
|
rilianx[P]IMRTsolver[P]build_O3[P]IAS
|
bool baryonyx::itm::solver_inequalities_01coeff<float, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<float>, false>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>, float, float, float)
|
bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
int selected = select_variables(r_size, b[k].min, b[k].max);
logger::log("constraints {}: {} <= ", k, b[k].min);
for (int i = 0; i < r_size; ++i)
logger::log("({} {}) ", R[i].value, R[i].id);
logger::log("<= {} => Selected: {}\n", b[k].max, selected);
auto pi_change = affect(
*this, x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rdi), %rax
vmovss %xmm2, 0x14(%rsp)
vmovss %xmm1, 0x10(%rsp)
vmovss %xmm0, 0xc(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebp, %ebp
movq %rax, 0x28(%rsp)
cmpq 0x30(%rsp), %r14
je 0x21c3a4
movslq (%r14), %rbx
movq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movl %ebx, %edx
callq 0x371fc
vmovss 0x14(%rsp), %xmm0
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq %r12, %rdi
callq 0x21c5d8
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rcx
callq 0x21c5f6
movq 0x58(%r12), %rdi
movq 0x8(%r12), %rdx
movslq %eax, %r13
leaq (%rdi,%r13,8), %rsi
callq 0x21c6c3
movq 0x60(%r12), %rax
movq %r12, %rdi
movl %r13d, %esi
movl (%rax,%rbx,8), %edx
movl 0x4(%rax,%rbx,8), %ecx
callq 0x21c6f6
vmovss 0xc(%rsp), %xmm0
vmovss 0x10(%rsp), %xmm1
movq 0x20(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %ecx
movl %eax, %r8d
movl %r13d, %r9d
callq 0x21c754
orb %al, %bpl
addq $0x8, %r14
jmp 0x21c2fb
andb $0x1, %bpl
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/quesnel[P]baryonyx/lib/src/itm-solver-inequalities-01.cpp
|
0x21c2c2
|
quesnel[P]baryonyx[P]build_O2[P]lib[P]testsolver
|
clipp::operator,(clipp::group, clipp::parameter)
|
inline group
operator , (group a, parameter b)
{
return !a.scoped() && !a.blocking() && !a.exclusive() && !a.repeatable()
&& !a.joinable() && (a.doc().empty() || a.doc() == b.doc())
? a.push_back(std::move(b))
: group{std::move(a), std::move(b)}.scoped(false);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x0, 0x42(%rsi)
jne 0x2c9aa
movq %r15, %rdi
callq 0x2fc34
testb %al, %al
jne 0x2c9aa
cmpb $0x0, 0x40(%r15)
jne 0x2c9aa
cmpb $0x0, 0x20(%r15)
jne 0x2c9aa
cmpb $0x0, 0x41(%r15)
jne 0x2c9aa
cmpq $0x0, 0x8(%r15)
je 0x2c997
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fc6a
testb %al, %al
je 0x2c9aa
leaq 0x28(%r15), %rdi
movq %r14, %rsi
callq 0x305da
xorl %ebp, %ebp
jmp 0x2cc42
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%r15), %rdx
leaq 0x10(%r15), %rax
cmpq %rax, %rdx
je 0x2c9ce
movq %rdx, 0x8(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
jmp 0x2c9d4
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r15), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movb $0x0, 0x10(%r15)
movzwl 0x20(%r15), %ecx
movw %cx, 0x28(%rsp)
movups 0x28(%r15), %xmm0
movups %xmm0, 0x30(%rsp)
movq 0x38(%r15), %rcx
movq %rcx, 0x40(%rsp)
movq %rax, 0x38(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r15)
movb 0x42(%r15), %al
movb %al, 0x4a(%rsp)
movzwl 0x40(%r15), %eax
movw %ax, 0x48(%rsp)
leaq 0x60(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x2ca4a
movq %rdx, 0x50(%rsp)
movq (%rax), %rcx
movq %rcx, 0x60(%rsp)
jmp 0x2ca50
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x58(%rsp)
movq %rax, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movb $0x0, 0x10(%r14)
movzwl 0x20(%r14), %ecx
movw %cx, 0x70(%rsp)
movups 0x28(%r14), %xmm0
movups %xmm0, 0x78(%rsp)
movq 0x38(%r14), %rcx
movq %rcx, 0x88(%rsp)
movq %rax, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups 0x40(%r14), %xmm1
movups %xmm1, 0x90(%rsp)
movq 0x50(%r14), %rcx
movq %rcx, 0xa0(%rsp)
movq %rax, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movups 0x58(%r14), %xmm1
movups %xmm1, 0xa8(%rsp)
movq 0x68(%r14), %rcx
movq %rcx, 0xb8(%rsp)
movq %rax, 0x68(%r14)
movups %xmm0, 0x58(%r14)
movups 0x70(%r14), %xmm1
movups %xmm1, 0xc0(%rsp)
movq 0x80(%r14), %rcx
movq %rcx, 0xd0(%rsp)
movq %rax, 0x80(%r14)
movups %xmm0, 0x70(%r14)
movups 0x88(%r14), %xmm1
movups %xmm1, 0xd8(%rsp)
movq 0x98(%r14), %rcx
movq %rcx, 0xe8(%rsp)
movq %rax, 0x98(%r14)
movups %xmm0, 0x88(%r14)
movups 0xa0(%r14), %xmm1
movups %xmm1, 0xf0(%rsp)
movq 0xb0(%r14), %rcx
movq %rcx, 0x100(%rsp)
movq %rax, 0xb0(%r14)
movups %xmm0, 0xa0(%r14)
movq %rax, 0x118(%rsp)
movups %xmm0, 0x108(%rsp)
movq 0xd0(%r14), %rax
movq %rax, 0x120(%rsp)
movq 0xc8(%r14), %rax
testq %rax, %rax
je 0x2cba7
leaq 0x108(%rsp), %rcx
leaq 0xc8(%r14), %rdx
movups 0xb8(%r14), %xmm1
movups %xmm1, (%rcx)
movq %rax, 0x10(%rcx)
movups %xmm0, (%rdx)
movl $0xe8, %eax
leaq 0x50(%rsp), %rdx
leaq (%rdx,%rax), %rcx
movq %rcx, 0xd8(%rdx)
movq 0xd8(%r14), %rdx
addq %r14, %rax
cmpq %rax, %rdx
je 0x2cbe0
movq %rdx, 0x128(%rsp)
movq (%rax), %rcx
movq %rcx, 0x138(%rsp)
jmp 0x2cbe6
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0xe0(%r14), %rcx
leaq 0x50(%rsp), %rdx
movq %rcx, 0xe0(%rdx)
movq %rax, 0xd8(%r14)
movq $0x0, 0xe0(%r14)
movb $0x0, 0xe8(%r14)
movzwl 0xf8(%r14), %eax
movw %ax, 0xf8(%rdx)
leaq 0x150(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x30c4c
movb $0x0, 0x192(%rsp)
movb $0x1, %bpl
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2dc8e
testb %bpl, %bpl
je 0x2cca2
leaq 0x178(%rsp), %r14
movq %r14, %rdi
callq 0x304ac
movq -0x28(%r14), %rdi
leaq 0x160(%rsp), %rax
cmpq %rax, %rdi
je 0x2cc78
callq 0x24390
leaq 0x50(%rsp), %rdi
callq 0x2bfe4
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x304ac
movq -0x28(%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2cca2
callq 0x24390
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movb $0x1, %bpl
jmp 0x2ccd0
movq %rax, %rbx
testb %bpl, %bpl
je 0x2ccd0
leaq 0x150(%rsp), %rdi
callq 0x2c86e
testb %bpl, %bpl
je 0x2cce9
leaq 0x50(%rsp), %rdi
callq 0x2bfe4
leaq 0x8(%rsp), %rdi
callq 0x2c86e
movq %rbx, %rdi
callq 0x24670
|
/dkolmakov[P]hm/thirdparty/clipp/./clipp.hpp
|
0x2c944
|
dkolmakov[P]hm[P]build_O1[P]src[P]hm-db
|
cmake::RunCheckForUnusedVariables()
|
void cmake::RunCheckForUnusedVariables()
{
#ifdef CMAKE_BUILD_WITH_CMAKE
bool haveUnused = false;
std::ostringstream msg;
msg << "Manually-specified variables were not used by the project:";
for (std::map<std::string, bool>::const_iterator it =
this->UsedCliVariables.begin();
it != this->UsedCliVariables.end(); ++it) {
if (!it->second) {
haveUnused = true;
msg << "\n " << it->first;
}
}
if (haveUnused) {
this->IssueMessage(cmake::WARNING, msg.str());
}
#endif
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x143fc0
leaq 0x292214(%rip), %rsi # 0x468582
movl $0x3a, %edx
movq %r14, %rdi
callq 0x1440d0
movq 0xe8(%rbx), %r14
leaq 0xd8(%rbx), %r13
cmpq %r13, %r14
je 0x1d6449
xorl %ebp, %ebp
leaq 0x2a8e7f(%rip), %r15 # 0x47f21a
leaq 0x40(%rsp), %r12
cmpb $0x0, 0x40(%r14)
je 0x1d63b9
movq %r14, %rdi
callq 0x143e00
movq %rax, %r14
cmpq %r13, %rax
jne 0x1d63a0
jmp 0x1d63ee
movl $0x3, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1440d0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r12, %rdi
callq 0x1440d0
movq %r14, %rdi
callq 0x143e00
movq %rax, %r14
movb $0x1, %bpl
cmpq %r13, %rax
jne 0x1d63a0
jmp 0x1d63f4
testb $0x1, %bpl
je 0x1d6449
leaq 0x48(%rsp), %rsi
movq %rsp, %rdi
callq 0x142b60
leaq 0x20(%rsp), %rdi
callq 0x2fbe84
movq 0x290(%rbx), %rdi
movq %rsp, %rdx
leaq 0x20(%rsp), %rcx
movl $0x5, %esi
callq 0x32095a
leaq 0x20(%rsp), %rdi
callq 0x2fbefe
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d6449
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1422d0
movq 0x3bab20(%rip), %rsi # 0x590f70
leaq 0x40(%rsp), %rdi
callq 0x143700
leaq 0xb0(%rsp), %rdi
callq 0x143670
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2fbefe
jmp 0x1d648b
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d64af
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1422d0
jmp 0x1d64af
jmp 0x1d64ac
jmp 0x1d64ac
movq %rax, %rbx
movq 0x3baaba(%rip), %rsi # 0x590f70
leaq 0x40(%rsp), %rdi
callq 0x143700
leaq 0xb0(%rsp), %rdi
callq 0x143670
movq %rbx, %rdi
callq 0x143460
nop
|
/jdavidberger[P]CMake/Source/cmake.cxx
|
0x1d6346
|
jdavidberger[P]CMake[P]build_O3[P]bin[P]cmake
|
cmPropertyDefinitionMap::DefineProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, cmProperty::ScopeType, char const*, char const*, bool)
|
void cmPropertyDefinitionMap::DefineProperty(const std::string& name,
cmProperty::ScopeType scope,
const char* ShortDescription,
const char* FullDescription,
bool chain)
{
cmPropertyDefinitionMap::iterator it = this->find(name);
cmPropertyDefinition* prop;
if (it == this->end()) {
prop = &(*this)[name];
prop->DefineProperty(name, scope, ShortDescription, FullDescription,
chain);
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x44f6d0
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x44f730
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x44f700
testb $0x1, %al
jne 0x44f5d8
jmp 0x44f60a
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x44f760
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x4f24b0
addq $0x50, %rsp
popq %rbp
retq
|
/havogt[P]cmakels/cmakels/external/cmake/Source/cmPropertyDefinitionMap.cxx
|
0x44f580
|
havogt[P]cmakels[P]build_O0[P]cmakels[P]external[P]cmake[P]bin[P]cmake
|
QPDFPageDocumentHelper::addPageAt(QPDFPageObjectHelper, bool, QPDFPageObjectHelper)
|
void
QPDFPageDocumentHelper::addPageAt(
QPDFPageObjectHelper newpage, bool before, QPDFPageObjectHelper refpage)
{
this->qpdf.addPageAt(newpage.getObjectHandle(), before, refpage.getObjectHandle());
}
|
pushq %rbx
subq $0x20, %rsp
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0xd2547
movq 0x121a47(%rip), %rsi # 0x1f3f80
cmpb $0x0, (%rsi)
je 0xd2543
incl 0x8(%rax)
jmp 0xd2547
lock
incl 0x8(%rax)
movq 0x8(%rcx), %rax
movq %rax, (%rsp)
movq 0x10(%rcx), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xd2572
movq 0x121a1c(%rip), %rcx # 0x1f3f80
cmpb $0x0, (%rcx)
je 0xd256e
incl 0x8(%rax)
jmp 0xd2572
lock
incl 0x8(%rax)
movzbl %dl, %edx
leaq 0x10(%rsp), %rsi
movq %rsp, %rcx
callq 0x13ebe8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd2591
callq 0x1d7d8
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd25a0
callq 0x1d7d8
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd25b8
callq 0x1d7d8
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd25c7
callq 0x1d7d8
movq %rbx, %rdi
callq 0x19700
nop
|
/jberkenbilt[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc
|
0xd2512
|
jberkenbilt[P]qpdf[P]build_O1[P]libtests[P]concatenate
|
llvm::SmallVectorImpl<clang::RISCV::PrototypeDescriptor>::insert(clang::RISCV::PrototypeDescriptor*, unsigned long, clang::RISCV::PrototypeDescriptor)
|
iterator insert(iterator I, size_type NumToInsert, ValueParamT Elt) {
// Convert iterator to elt# to avoid invalidating iterator when we reserve()
size_t InsertElt = I - this->begin();
if (I == this->end()) { // Important special case for empty vector.
append(NumToInsert, Elt);
return this->begin()+InsertElt;
}
assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
// Ensure there is enough space, and get the (maybe updated) address of
// Elt.
const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumToInsert);
// Uninvalidate the iterator.
I = this->begin()+InsertElt;
// If there are more elements between the insertion point and the end of the
// range than there are being inserted, we can use a simple approach to
// insertion. Since we already reserved space, we know that this won't
// reallocate the vector.
if (size_t(this->end()-I) >= NumToInsert) {
T *OldEnd = this->end();
append(std::move_iterator<iterator>(this->end() - NumToInsert),
std::move_iterator<iterator>(this->end()));
// Copy the existing elements that get replaced.
std::move_backward(I, OldEnd-NumToInsert, OldEnd);
// If we just moved the element we're inserting, be sure to update
// the reference (never happens if TakesParamByValue).
if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
EltPtr += NumToInsert;
std::fill_n(I, NumToInsert, *EltPtr);
return I;
}
// Otherwise, we're inserting more elements than exist already, and we're
// not inserting at the end.
// Move over the elements that we're about to overwrite.
T *OldEnd = this->end();
this->set_size(this->size() + NumToInsert);
size_t NumOverwritten = OldEnd-I;
this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
// If we just moved the element we're inserting, be sure to update
// the reference (never happens if TakesParamByValue).
if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
EltPtr += NumToInsert;
// Replace the overwritten part.
std::fill_n(I, NumOverwritten, *EltPtr);
// Insert the non-overwritten middle part.
std::uninitialized_fill_n(OldEnd, NumToInsert - NumOverwritten, *EltPtr);
return I;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r8
movq %rdi, %rbp
movq (%rdi), %r12
movq 0x8(%rdi), %rax
movq %rsi, %r13
subq %r12, %r13
leaq (%rax,%rax,2), %rcx
addq %r12, %rcx
cmpq %rsi, %rcx
je 0xe2f528
leaq (%rax,%r8), %rdx
movq %r12, %rcx
cmpq 0x10(%rbp), %rdx
ja 0xe2f6a4
leaq (%rcx,%r13), %r10
leaq (%rax,%rax,2), %r14
leaq (%rcx,%r14), %r15
movq %r14, %rdx
subq %r13, %rdx
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
movq %rdx, %r9
imulq %rdi, %r9
cmpq %r9, %r8
jbe 0xe2f53e
addq %r8, %rax
movq %rax, 0x8(%rbp)
cmpq %r13, %r14
movq %r10, %r13
je 0xe2f418
leaq (%rax,%rax,2), %rax
addq %rax, %rcx
movq %r9, %rax
negq %rax
leaq (%rax,%rax,2), %rdi
addq %rcx, %rdi
movq %rsi, 0x8(%rsp)
movq %r13, %rsi
movq %r8, %rbp
movq %r13, 0x10(%rsp)
movq %r9, %r13
callq 0x4170e0
movq %r13, %r9
movq 0x10(%rsp), %r13
movq %rbp, %r8
addq %r12, %r14
subq 0x8(%rsp), %r14
addq $-0x3, %r14
movq %r14, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %xmm0
shrq %rdx
addq $0x4, %rdx
andq $-0x4, %rdx
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
psrlq $0x1, %xmm0
xorl %eax, %eax
movdqa 0x604716(%rip), %xmm1 # 0x1433a50
movdqa 0x603c3e(%rip), %xmm2 # 0x1432f80
movdqa 0x603c46(%rip), %xmm3 # 0x1432f90
pxor %xmm3, %xmm0
movl %ebx, %ecx
shrl $0x10, %ecx
pcmpeqd %xmm4, %xmm4
movq %r13, %rsi
movq %rax, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0xe2f3a3
movw %bx, (%rsi)
movb %cl, 0x2(%rsi)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xe2f3b9
movw %bx, 0x3(%rsi)
movb %cl, 0x5(%rsi)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0xe2f3f5
movw %bx, 0x6(%rsi)
movb %cl, 0x8(%rsi)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0xe2f407
movw %bx, 0x9(%rsi)
movb %cl, 0xb(%rsi)
addq $0x4, %rax
addq $0xc, %rsi
cmpq %rax, %rdx
jne 0xe2f35a
subq %r9, %r8
je 0xe2f692
leaq 0x3(%r8), %rax
andq $-0x4, %rax
decq %r8
movq %r8, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
xorl %ecx, %ecx
movdqa 0x604610(%rip), %xmm1 # 0x1433a50
movdqa 0x603b38(%rip), %xmm2 # 0x1432f80
movdqa 0x603b40(%rip), %xmm3 # 0x1432f90
pxor %xmm3, %xmm0
movl %ebx, %edx
shrl $0x10, %edx
pcmpeqd %xmm4, %xmm4
movq %rcx, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0xe2f4a8
movw %bx, (%r15)
movb %dl, 0x2(%r15)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0xe2f4c0
movw %bx, 0x3(%r15)
movb %dl, 0x5(%r15)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0xe2f4fe
movw %bx, 0x6(%r15)
movb %dl, 0x8(%r15)
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0xe2f512
movw %bx, 0x9(%r15)
movb %dl, 0xb(%r15)
addq $0x4, %rcx
addq $0xc, %r15
cmpq %rcx, %rax
jne 0xe2f45d
jmp 0xe2f692
movq %rbp, %rdi
movq %r8, %rsi
movl %ebx, %edx
callq 0xe2ff56
addq (%rbp), %r13
jmp 0xe2f692
movq %r8, %r12
negq %r8
leaq (%r8,%r8,2), %r14
addq %r15, %r14
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r10, %r13
callq 0xe300ae
subq %r13, %r14
je 0xe2f572
subq %r14, %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x4171d0
testq %r12, %r12
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
je 0xe2f692
leaq (%r12,%r12,2), %rax
addq $-0x3, %rax
mulq %rcx
movq %rdx, %xmm0
shrq %rdx
addq $0x4, %rdx
andq $-0x4, %rdx
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
psrlq $0x1, %xmm0
xorl %eax, %eax
movdqa 0x60449c(%rip), %xmm1 # 0x1433a50
movdqa 0x6039c4(%rip), %xmm2 # 0x1432f80
movdqa 0x6039cc(%rip), %xmm3 # 0x1432f90
pxor %xmm3, %xmm0
movl %ebx, %ecx
shrl $0x10, %ecx
pcmpeqd %xmm4, %xmm4
movq %r13, %rsi
movq %rax, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0xe2f61d
movw %bx, (%rsi)
movb %cl, 0x2(%rsi)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xe2f633
movw %bx, 0x3(%rsi)
movb %cl, 0x5(%rsi)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0xe2f66f
movw %bx, 0x6(%rsi)
movb %cl, 0x8(%rsi)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0xe2f681
movw %bx, 0x9(%rsi)
movb %cl, 0xb(%rsi)
addq $0x4, %rax
addq $0xc, %rsi
cmpq %rax, %rdx
jne 0xe2f5d4
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
leaq 0x18(%rbp), %rsi
movl $0x3, %ecx
movq %rbp, %rdi
movq %r8, %r14
callq 0x44a264
movq %r15, %rsi
movq %r14, %r8
movq (%rbp), %rcx
movq 0x8(%rbp), %rax
jmp 0xe2f284
|
/llvm/ADT/SmallVector.h
|
0xe2f240
|
llvm-project[P]build_O3[P]bin[P]clang-diff
|
nlohmann::detail::binary_reader<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_input_adapter<char const*>, nlohmann::detail::json_sax_dom_parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>>::get_ubjson_object()
|
bool get_ubjson_object()
{
std::pair<std::size_t, char_int_type> size_and_type;
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
{
return false;
}
string_t key;
if (size_and_type.first != string_t::npos)
{
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
{
return false;
}
if (size_and_type.second != 0)
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
{
return false;
}
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
{
return false;
}
key.clear();
}
}
else
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
{
return false;
}
if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
{
return false;
}
key.clear();
}
}
}
else
{
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
{
return false;
}
while (current != '}')
{
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
{
return false;
}
if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
{
return false;
}
get_ignore_noop();
key.clear();
}
}
return sax->end_object();
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsp, %rsi
movq $0x0, (%rsi)
movl $0x0, 0x8(%rsi)
callq 0x21ab10
testb %al, %al
je 0x5991a5
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%rsp), %rsi
movq 0x28(%rbx), %rdi
cmpq $-0x1, %rsi
je 0x599053
callq 0x21d570
testb %al, %al
je 0x5991a1
cmpl $0x0, 0x8(%rsp)
movq (%rsp), %rax
je 0x59910f
testq %rax, %rax
je 0x599177
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x22a070
testb %al, %al
je 0x5991a1
movq 0x28(%rbx), %r13
movq 0x10(%r13), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x220630
movq %rax, 0x20(%r13)
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x20e3f0
testb %al, %al
je 0x5991a1
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
incq %r12
cmpq (%rsp), %r12
jb 0x598fec
jmp 0x599177
movq $-0x1, %rsi
callq 0x21d570
testb %al, %al
je 0x5991a1
cmpl $0x7d, 0x10(%rbx)
je 0x599177
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x22a070
testb %al, %al
je 0x5991a1
movq 0x28(%rbx), %r12
movq 0x10(%r12), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x220630
movq %rax, 0x20(%r12)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x20e830
testb %al, %al
je 0x5991a1
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rbx), %rdx
incq %rdx
movq %rdx, 0x18(%rbx)
cmpq %rcx, %rax
je 0x5990eb
movzbl (%rax), %esi
incq %rax
movq %rax, (%rbx)
movl %esi, 0x10(%rbx)
incq %rdx
cmpl $0x4e, %esi
je 0x5990cc
jmp 0x5990f2
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
jmp 0x5990de
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
cmpl $0x7d, 0x10(%rbx)
jne 0x599076
jmp 0x599177
testq %rax, %rax
je 0x599177
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x22a070
testb %al, %al
je 0x5991a1
movq 0x28(%rbx), %r13
movq 0x10(%r13), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x220630
movq %rax, 0x20(%r13)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x20e830
testb %al, %al
je 0x5991a1
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
incq %r12
cmpq (%rsp), %r12
jb 0x59911c
movq 0x28(%rbx), %rax
addq $-0x8, 0x10(%rax)
movb $0x1, %bl
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x599191
callq 0x21aca0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x599182
xorl %ebx, %ebx
jmp 0x599191
jmp 0x5991af
jmp 0x5991af
jmp 0x5991af
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x5991c1
callq 0x21aca0
movq %rbx, %rdi
callq 0x2274d0
nop
|
/ornladios[P]ADIOS2/thirdparty/nlohmann_json/nlohmann_json_wrapper/single_include/nlohmann/json.hpp
|
0x598f6a
|
ornladios[P]ADIOS2[P]build_O1[P]lib[P]libadios2_core.so.2.10.0
|
llvm::DIEHash::collectAttributes(llvm::DIE const&, llvm::DIEHash::DIEAttrs&)
|
void DIEHash::collectAttributes(const DIE &Die, DIEAttrs &Attrs) {
for (const auto &V : Die.values()) {
LLVM_DEBUG(dbgs() << "Attribute: "
<< dwarf::AttributeString(V.getAttribute())
<< " added.\n");
switch (V.getAttribute()) {
#define HANDLE_DIE_HASH_ATTR(NAME) \
case dwarf::NAME: \
Attrs.NAME = V; \
break;
#include "DIEHashAttributes.def"
default:
break;
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2aecc76
movq (%rax), %r14
andq $-0x8, %r14
jmp 0x2aecc79
xorl %r14d, %r14d
leaq 0x310(%rbx), %rax
movq %rax, 0x170(%rsp)
leaq 0x300(%rbx), %rax
movq %rax, 0x168(%rsp)
leaq 0x2f0(%rbx), %rax
movq %rax, 0x160(%rsp)
leaq 0x2e0(%rbx), %rax
movq %rax, 0x158(%rsp)
leaq 0x2d0(%rbx), %rax
movq %rax, 0x150(%rsp)
leaq 0x2c0(%rbx), %rax
movq %rax, 0x148(%rsp)
leaq 0x2b0(%rbx), %rax
movq %rax, 0x140(%rsp)
leaq 0x2a0(%rbx), %rax
movq %rax, 0x138(%rsp)
leaq 0x290(%rbx), %rax
movq %rax, 0x130(%rsp)
leaq 0x280(%rbx), %rax
movq %rax, 0x128(%rsp)
leaq 0x270(%rbx), %rax
movq %rax, 0x120(%rsp)
leaq 0x260(%rbx), %rax
movq %rax, 0x118(%rsp)
leaq 0x250(%rbx), %rax
movq %rax, 0x110(%rsp)
leaq 0x240(%rbx), %rax
movq %rax, 0x108(%rsp)
leaq 0x230(%rbx), %rax
movq %rax, 0x100(%rsp)
leaq 0x220(%rbx), %rax
movq %rax, 0xf8(%rsp)
leaq 0x210(%rbx), %rax
movq %rax, 0xf0(%rsp)
leaq 0x200(%rbx), %rax
movq %rax, 0xe8(%rsp)
leaq 0x1f0(%rbx), %rax
movq %rax, 0xe0(%rsp)
leaq 0x1e0(%rbx), %rax
movq %rax, 0xd8(%rsp)
leaq 0x1d0(%rbx), %rax
movq %rax, 0xd0(%rsp)
leaq 0x1c0(%rbx), %rax
movq %rax, 0xc8(%rsp)
leaq 0x1b0(%rbx), %rax
movq %rax, 0xc0(%rsp)
leaq 0x1a0(%rbx), %rax
movq %rax, 0xb8(%rsp)
leaq 0x190(%rbx), %rax
movq %rax, 0xb0(%rsp)
leaq 0x180(%rbx), %rax
movq %rax, 0xa8(%rsp)
leaq 0x170(%rbx), %rax
movq %rax, 0xa0(%rsp)
leaq 0x160(%rbx), %rax
movq %rax, 0x98(%rsp)
leaq 0x150(%rbx), %rax
movq %rax, 0x90(%rsp)
leaq 0x140(%rbx), %rax
movq %rax, 0x88(%rsp)
leaq 0x130(%rbx), %rax
movq %rax, 0x80(%rsp)
leaq 0x120(%rbx), %rax
movq %rax, 0x78(%rsp)
leaq 0x110(%rbx), %rax
movq %rax, 0x70(%rsp)
leaq 0x100(%rbx), %rax
movq %rax, 0x68(%rsp)
leaq 0xf0(%rbx), %rax
movq %rax, 0x60(%rsp)
leaq 0xe0(%rbx), %rax
movq %rax, 0x58(%rsp)
leaq 0xd0(%rbx), %rax
movq %rax, 0x50(%rsp)
leaq 0xc0(%rbx), %rax
movq %rax, 0x48(%rsp)
leaq 0xb0(%rbx), %rax
movq %rax, 0x40(%rsp)
leaq 0xa0(%rbx), %rax
movq %rax, 0x38(%rsp)
leaq 0x90(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x80(%rbx), %rax
movq %rax, 0x28(%rsp)
leaq 0x70(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x60(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rbx), %rax
movq %rax, (%rsp)
leaq 0x20(%rbx), %rbp
leaq 0x10(%rbx), %r15
xorl %r12d, %r12d
leaq 0x3ccff4c(%rip), %r13 # 0x67bce58
testq %r14, %r14
je 0x2aed164
movzwl 0xc(%r14), %eax
addl $-0x2, %eax
cmpl $0x6c, %eax
ja 0x2aed14f
movslq (%r13,%rax,4), %rax
addq %r13, %rax
movq %rbx, %rdi
jmpq *%rax
movq 0xe0(%rsp), %rdi
jmp 0x2aed146
movq 0x128(%rsp), %rdi
jmp 0x2aed146
movq 0x170(%rsp), %rdi
jmp 0x2aed146
movq 0x10(%rsp), %rdi
jmp 0x2aed146
movq 0x88(%rsp), %rdi
jmp 0x2aed146
movq 0x110(%rsp), %rdi
jmp 0x2aed146
movq 0x18(%rsp), %rdi
jmp 0x2aed146
movq 0x168(%rsp), %rdi
jmp 0x2aed146
movq 0xd0(%rsp), %rdi
jmp 0x2aed146
movq %r15, %rdi
jmp 0x2aed146
movq 0x70(%rsp), %rdi
jmp 0x2aed146
movq 0x60(%rsp), %rdi
jmp 0x2aed146
movq 0xd8(%rsp), %rdi
jmp 0x2aed146
movq 0x118(%rsp), %rdi
jmp 0x2aed146
movq 0x158(%rsp), %rdi
jmp 0x2aed146
movq 0xa0(%rsp), %rdi
jmp 0x2aed146
movq 0xa8(%rsp), %rdi
jmp 0x2aed146
movq 0x98(%rsp), %rdi
jmp 0x2aed146
movq 0x50(%rsp), %rdi
jmp 0x2aed146
movq 0x148(%rsp), %rdi
jmp 0x2aed146
movq 0x38(%rsp), %rdi
jmp 0x2aed146
movq 0x150(%rsp), %rdi
jmp 0x2aed146
movq (%rsp), %rdi
jmp 0x2aed146
movq 0xf8(%rsp), %rdi
jmp 0x2aed146
movq 0x78(%rsp), %rdi
jmp 0x2aed146
movq 0x90(%rsp), %rdi
jmp 0x2aed146
movq %rbp, %rdi
jmp 0x2aed146
movq 0x58(%rsp), %rdi
jmp 0x2aed146
movq 0x100(%rsp), %rdi
jmp 0x2aed146
movq 0xc8(%rsp), %rdi
jmp 0x2aed146
movq 0x20(%rsp), %rdi
jmp 0x2aed146
movq 0xc0(%rsp), %rdi
jmp 0x2aed146
movq 0xb8(%rsp), %rdi
jmp 0x2aed146
movq 0x68(%rsp), %rdi
jmp 0x2aed146
movq 0x28(%rsp), %rdi
jmp 0x2aed146
movq 0x80(%rsp), %rdi
jmp 0x2aed146
movq 0x160(%rsp), %rdi
jmp 0x2aed146
movq 0xe8(%rsp), %rdi
jmp 0x2aed146
movq 0x108(%rsp), %rdi
jmp 0x2aed146
movq 0xb0(%rsp), %rdi
jmp 0x2aed146
movq 0x120(%rsp), %rdi
jmp 0x2aed146
movq 0x40(%rsp), %rdi
jmp 0x2aed146
movq 0x130(%rsp), %rdi
jmp 0x2aed146
movq 0x30(%rsp), %rdi
jmp 0x2aed146
movq 0xf0(%rsp), %rdi
jmp 0x2aed146
movq 0x8(%rsp), %rdi
jmp 0x2aed146
movq 0x138(%rsp), %rdi
jmp 0x2aed146
movq 0x140(%rsp), %rdi
jmp 0x2aed146
movq 0x48(%rsp), %rdi
leaq 0x8(%r14), %rsi
callq 0x2aed176
movq (%r14), %rax
movq %rax, %r14
andq $-0x8, %r14
testb $0x4, %al
cmovneq %r12, %r14
jmp 0x2aecf0c
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/CodeGen/AsmPrinter/DIEHash.cpp
|
0x2aecc50
|
llvm-project[P]build_O2[P]bin[P]clang-19
|
validation_layer::basic_leakChecker::ZEbasic_leakChecker::zeContextDestroyEpilogue(_ze_context_handle_t*, _ze_result_t)
|
ze_result_t basic_leakChecker::ZEbasic_leakChecker::zeContextDestroyEpilogue(ze_context_handle_t, ze_result_t result) {
if (result == ZE_RESULT_SUCCESS) {
countFunctionCall("zeContextDestroy");
}
return result;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
testl %edx, %edx
jne 0x92e4b
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x124de(%rip), %rsi # 0xa52e5
leaq 0x124e7(%rip), %rdx # 0xa52f5
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x271e0
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x27370
testq %rax, %rax
je 0x92e34
lock
incq 0x28(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x92e4b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x275a0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x92e73
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x275a0
movq %rbx, %rdi
callq 0x279f0
nop
|
/oneapi-src[P]level-zero/source/layers/validation/checkers/basic_leak/zel_basic_leak_checker.cpp
|
0x92de2
|
oneapi-src[P]level-zero[P]build_O3[P]lib[P]libze_validation_layer.so.1.22.0
|
File::copy(String const&, String const&, bool)
|
bool File::copy(const String& src, const String& destination, bool failIfExists)
{
#ifdef _WIN32
return CopyFile(src, destination, failIfExists) == TRUE;
#else
int fd = ::open(src, O_RDONLY);
if(fd == -1)
return false;
off64_t size = lseek(fd, 0, SEEK_END);
if(size < 0)
return false;
if(lseek(fd, 0, SEEK_SET) < 0)
return false;
int dest = ::open(destination, failIfExists ? (O_CREAT | O_EXCL | O_CLOEXEC | O_TRUNC | O_WRONLY) : (O_CREAT | O_CLOEXEC | O_TRUNC | O_WRONLY), S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if(dest == -1)
{
::close(fd);
return false;
}
if(sendfile(dest, fd, 0, size) != size)
{
::close(fd);
::close(dest);
return false;
}
::close(fd);
::close(dest);
return true;
#endif
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6350
movq %rax, %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x4350
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x16e2e
movb $0x0, -0x1(%rbp)
jmp 0x16ef5
movl -0x20(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x49a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x16e53
movb $0x0, -0x1(%rbp)
jmp 0x16ef5
movl -0x20(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x49a0
cmpq $0x0, %rax
jge 0x16e70
movb $0x0, -0x1(%rbp)
jmp 0x16ef5
movq -0x18(%rbp), %rdi
callq 0x6350
movq %rax, %rdi
movb -0x19(%rbp), %cl
movl $0x80241, %esi # imm = 0x80241
movl $0x802c1, %eax # imm = 0x802C1
testb $0x1, %cl
cmovnel %eax, %esi
movl $0x1a4, %edx # imm = 0x1A4
movb $0x0, %al
callq 0x4350
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x16eb2
movl -0x20(%rbp), %edi
callq 0x49f0
movb $0x0, -0x1(%rbp)
jmp 0x16ef5
movl -0x2c(%rbp), %edi
movl -0x20(%rbp), %esi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x4820
cmpq -0x28(%rbp), %rax
je 0x16ee1
movl -0x20(%rbp), %edi
callq 0x49f0
movl -0x2c(%rbp), %edi
callq 0x49f0
movb $0x0, -0x1(%rbp)
jmp 0x16ef5
movl -0x20(%rbp), %edi
callq 0x49f0
movl -0x2c(%rbp), %edi
callq 0x49f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
|
/craflin[P]dehprox/3rdparty/libnstd/src/File.cpp
|
0x16df0
|
craflin[P]dehprox[P]build_O0[P]src[P]dehprox
|
DecodeVLDST3Instruction
|
static DecodeStatus DecodeVLDST3Instruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned align, load;
unsigned size = fieldFromInstruction_4(Insn, 6, 2);
if (size == 3) return MCDisassembler_Fail;
align = fieldFromInstruction_4(Insn, 4, 2);
if (align & 2) return MCDisassembler_Fail;
load = fieldFromInstruction_4(Insn, 21, 1);
return load ? DecodeVLDInstruction(Inst, Insn, Address, Decoder)
: DecodeVSTInstruction(Inst, Insn, Address, Decoder);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl $0x6, %esi
movl $0x2, %edx
callq 0x48660
movl %eax, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jne 0x64b7b
movl $0x0, -0x4(%rbp)
jmp 0x64bf5
movl -0x14(%rbp), %edi
movl $0x4, %esi
movl $0x2, %edx
callq 0x48660
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x64ba4
movl $0x0, -0x4(%rbp)
jmp 0x64bf5
movl -0x14(%rbp), %edi
movl $0x15, %esi
movl $0x1, %edx
callq 0x48660
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x64bd8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x684e0
movl %eax, -0x38(%rbp)
jmp 0x64bef
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x689d0
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
|
/bughoho[P]capstone/arch/ARM/ARMDisassembler.c
|
0x64b40
|
bughoho[P]capstone[P]build_O0[P]libcapstone.so
|
BufferInputSource::~BufferInputSource()
|
BufferInputSource::~BufferInputSource()
{
if (this->own_memory) {
delete this->buf;
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1cf904(%rip), %rax # 0x1eeb50
movq %rax, (%rdi)
cmpb $0x1, 0xa8(%rdi)
jne 0x1f279
movq 0xd0(%rbx), %r14
testq %r14, %r14
je 0x1f279
movq %r14, %rdi
callq 0x1ef14
movl $0x8, %esi
movq %r14, %rdi
callq 0x190e0
movq 0xb0(%rbx), %rdi
addq $0xc0, %rbx
cmpq %rbx, %rdi
je 0x1f29e
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x190e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/jberkenbilt[P]qpdf/libqpdf/BufferInputSource.cc
|
0x1f23e
|
jberkenbilt[P]qpdf[P]build_O1[P]libtests[P]logger
|
void google::protobuf::(anonymous namespace)::FlatAllocatorImpl<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables, google::protobuf::FeatureSet, google::protobuf::MessageOptions, google::protobuf::FieldOptions, google::protobuf::EnumOptions, google::protobuf::EnumValueOptions, google::protobuf::ExtensionRangeOptions, google::protobuf::OneofOptions, google::protobuf::ServiceOptions, google::protobuf::MethodOptions, google::protobuf::FileOptions>::PlanArray<google::protobuf::ExtensionRangeOptions>(int)
|
void PlanArray(int array_size) {
// We can't call PlanArray after FinalizePlanning has been called.
ABSL_CHECK(!has_allocated());
if (std::is_trivially_destructible<U>::value) {
// Trivial types are aligned to 8 bytes.
static_assert(alignof(U) <= 8, "");
total_.template Get<char>() += RoundUpTo<8>(array_size * sizeof(U));
} else {
// Since we can't use `if constexpr`, just make the expression compile
// when this path is not taken.
using TypeToUse =
typename std::conditional<std::is_trivially_destructible<U>::value,
char, U>::type;
total_.template Get<TypeToUse>() += array_size;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2138e0
xorb $-0x1, %al
xorb $-0x1, %al
movb $0x0, -0x21(%rbp)
testb $0x1, %al
jne 0x215e5a
jmp 0x215e97
leaq 0x44125b(%rip), %rsi # 0x6570bc
leaq 0x464ab3(%rip), %rcx # 0x67a91b
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x19b, %edx # imm = 0x19B
callq 0x57ac50
movq -0x48(%rbp), %rdi
movb $0x1, -0x21(%rbp)
callq 0x83de0
movq %rax, %rsi
leaq -0xd(%rbp), %rdi
callq 0x83dc0
jmp 0x215e95
jmp 0x215e97
testb $0x1, -0x21(%rbp)
jne 0x215e9f
jmp 0x215ebc
leaq -0x20(%rbp), %rdi
callq 0x57ace0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x215edc
jmp 0x215ee5
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x4c(%rbp)
addq $0x70, %rdi
callq 0x215ef0
movl -0x4c(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x57ace0
jmp 0x215ee7
movq -0x30(%rbp), %rdi
callq 0x27c20
|
/protocolbuffers[P]protobuf/src/google/protobuf/descriptor.cc
|
0x215e30
|
protocolbuffers[P]protobuf[P]build_O0[P]test_plugin
|
printLogicalImm64
|
static void printLogicalImm64(MCInst *MI, unsigned OpNum, SStream *O)
{
int64_t Val = MCOperand_getImm(MCInst_getOperand(MI, OpNum));
Val = AArch64_AM_decodeLogicalImmediate(Val, 64);
switch(MI->flat_insn->id) {
default:
printInt64Bang(O, Val);
break;
case ARM64_INS_ORR:
case ARM64_INS_AND:
case ARM64_INS_EOR:
case ARM64_INS_TST:
// do not print number in negative form
if (Val >= 0 && Val <= HEX_THRESHOLD)
SStream_concat(O, "#%u", (int)Val);
else
SStream_concat(O, "#0x%"PRIx64, Val);
break;
}
if (MI->csh->detail) {
MI->flat_insn->detail->arm64.operands[MI->flat_insn->detail->arm64.op_count].type = ARM64_OP_IMM;
MI->flat_insn->detail->arm64.operands[MI->flat_insn->detail->arm64.op_count].imm = (int)Val;
MI->flat_insn->detail->arm64.op_count++;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x44d20
movq %rax, %rdi
callq 0x44e90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x40, %esi
callq 0xcdab0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0xe, %eax
je 0xcc5a5
jmp 0xcc574
movl -0x24(%rbp), %eax
subl $0x3f, %eax
je 0xcc5a5
jmp 0xcc57e
movl -0x24(%rbp), %eax
subl $0xc8, %eax
je 0xcc5a5
jmp 0xcc58a
movl -0x24(%rbp), %eax
subl $0x1b3, %eax # imm = 0x1B3
je 0xcc5a5
jmp 0xcc596
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x451a0
jmp 0xcc5e5
cmpq $0x0, -0x20(%rbp)
jl 0xcc5cd
cmpq $0x9, -0x20(%rbp)
jg 0xcc5cd
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0x7f442(%rip), %rsi # 0x14ba06
movb $0x0, %al
callq 0x450c0
jmp 0xcc5e3
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x6b06e(%rip), %rsi # 0x13764a
movb $0x0, %al
callq 0x450c0
jmp 0xcc5e5
movq -0x8(%rbp), %rax
movq 0x320(%rax), %rax
cmpl $0x0, 0x68(%rax)
je 0xcc695
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 0x36(%rcx), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x2, 0x18(%rax)
movq -0x20(%rbp), %rax
movslq %eax, %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 0x36(%rdx), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x310(%rax), %rax
movq 0xe8(%rax), %rax
movb 0x36(%rax), %cl
addb $0x1, %cl
movb %cl, 0x36(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/bughoho[P]capstone/arch/AArch64/AArch64InstPrinter.c
|
0xcc520
|
bughoho[P]capstone[P]build_O0[P]test_x86
|
KDIS::PDU::Entity_State_PDU::operator==(KDIS::PDU::Entity_State_PDU const&) const
|
KBOOL Entity_State_PDU::operator == ( const Entity_State_PDU & Value ) const
{
if( Header::operator !=( Value ) ) return false;
if( m_EntityID != Value.m_EntityID ) return false;
if( m_ui8ForceID != Value.m_ui8ForceID ) return false;
if( m_ui8NumOfVariableParams != Value.m_ui8NumOfVariableParams ) return false;
if( m_EntityType != Value.m_EntityType ) return false;
if( m_AltEntityType != Value.m_AltEntityType ) return false;
if( m_EntityLinearVelocity != Value.m_EntityLinearVelocity ) return false;
if( m_EntityLocation != Value.m_EntityLocation ) return false;
if( m_EntityOrientation != Value.m_EntityOrientation ) return false;
if( m_EntityAppearance != Value.m_EntityAppearance ) return false;
if( m_DeadReckoningParameter != Value.m_DeadReckoningParameter ) return false;
if( m_EntityMarking != Value.m_EntityMarking ) return false;
if( m_EntityCapabilities != Value.m_EntityCapabilities ) return false;
if( m_vVariableParameters != Value.m_vVariableParameters ) return false;
return true;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3c7cc
testb %al, %al
jne 0x35799
leaq 0x28(%r14), %rdi
leaq 0x28(%rbx), %rsi
callq 0x29414
testb %al, %al
jne 0x35799
movb 0x38(%r14), %al
cmpb 0x38(%rbx), %al
jne 0x35799
movb 0x39(%r14), %al
cmpb 0x39(%rbx), %al
jne 0x35799
leaq 0x40(%r14), %rdi
leaq 0x40(%rbx), %rsi
callq 0x2a452
testb %al, %al
jne 0x35799
leaq 0x50(%r14), %rdi
leaq 0x50(%rbx), %rsi
callq 0x2a452
testb %al, %al
jne 0x35799
leaq 0x60(%r14), %rdi
leaq 0x60(%rbx), %rsi
callq 0x2edba
testb %al, %al
jne 0x35799
leaq 0x78(%r14), %rdi
leaq 0x78(%rbx), %rsi
callq 0x2f69a
testb %al, %al
jne 0x35799
movl $0x98, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x2af34
testb %al, %al
jne 0x35799
movl $0xb0, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x28bc0
testb %al, %al
jne 0x35799
movl $0xc0, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x27e40
testb %al, %al
jne 0x35799
movl $0x108, %esi # imm = 0x108
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x29c90
testb %al, %al
jne 0x35799
movl $0x120, %esi # imm = 0x120
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x290b8
testb %al, %al
je 0x357a3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x130, %eax # imm = 0x130
addq %rax, %r14
addq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x35c13
xorb $0x1, %al
jmp 0x3579b
nop
|
/jarvisfriends[P]KDIS/KDIS/PDU/Entity_Info_Interaction/Entity_State_PDU.cpp
|
0x3569e
|
jarvisfriends[P]KDIS[P]build_O1[P]Examples[P]PDU[P]Bundle[P]Example_Bundle
|
testing::internal::ParameterizedTestSuiteInfo<bssl::(anonymous namespace)::SimplePathBuilderDelegate1024SuccessTest>::RegisterTests()
|
iterator begin() const { return iterator(impl_->Begin()); }
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
leaq 0x128(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r13
xorl %r14d, %r14d
movb %r14b, (%rax)
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %r14b, (%rax)
movq 0x50(%rdi), %r12
movq 0x58(%rdi), %rax
movq %rax, 0x80(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x88(%rsp)
leaq 0x118(%rsp), %r15
cmpq 0x80(%rsp), %r12
je 0x1eec13
movq 0x68(%r13), %rax
movq 0x70(%r13), %rcx
movq %rcx, 0x90(%rsp)
cmpq 0x90(%rsp), %rax
je 0x1eec0a
leaq 0x70(%rsp), %rdi
movq %rax, %rbx
callq *0x20(%rax)
movq 0x28(%rbx), %rax
movq %rax, 0xa0(%rsp)
movq 0x30(%rbx), %rax
movq %rax, 0x30(%rsp)
movl 0x38(%rbx), %eax
movl %eax, 0x24(%rsp)
cmpq $0x0, 0x8(%rbx)
movq %rbx, 0x98(%rsp)
je 0x1ee712
movq %rbx, %rsi
leaq 0xe8(%rsp), %rbx
movq %rbx, %rdi
leaq 0x17239d(%rip), %rdx # 0x360a95
callq 0xe91eb
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9a850
movq %rbx, %rdi
callq 0x9ae88
jmp 0x1ee726
andq $0x0, 0x120(%rsp)
movq 0x118(%rsp), %rax
movb $0x0, (%rax)
movq %r15, %rdi
movq 0x88(%rsp), %rsi
callq 0x9ae20
andl $0x0, 0xf0(%rsp)
andq $0x0, 0xf8(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %rax, 0x108(%rsp)
andq $0x0, 0x110(%rsp)
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, 0x38(%rsp)
movq $0x0, 0x60(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xf8c00
testb %al, %al
je 0x1eebc2
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
leaq 0xc8(%rsp), %rbx
andq $0x0, 0xb0(%rsp)
movq 0xa8(%rsp), %rcx
movb $0x0, (%rcx)
movq %rax, 0x68(%rsp)
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %rbx, %rdi
leaq 0x40(%rsp), %rsi
callq *0xa0(%rsp)
movq 0xd0(%rsp), %rax
testq %rax, %rax
je 0x1ee840
xorl %r14d, %r14d
cmpq %rax, %r14
setae %bpl
jae 0x1ee842
movq 0xc8(%rsp), %rax
movsbl (%rax,%r14), %edi
callq 0xf4623
testb %al, %al
jne 0x1ee833
movq 0xc8(%rsp), %rax
cmpb $0x5f, (%rax,%r14)
jne 0x1ee842
incq %r14
movq 0xd0(%rsp), %rax
jmp 0x1ee805
xorl %ebp, %ebp
movzbl %bpl, %edi
callq 0x256e4f
leaq 0xe8(%rsp), %r14
testb %al, %al
jne 0x1ee8f9
leaq 0x40(%rsp), %rdi
pushq $0x3
popq %rsi
leaq 0x108032(%rip), %rdx # 0x2f689c
movl $0x247, %ecx # imm = 0x247
callq 0x259af2
movq 0x2dc76d(%rip), %rdi # 0x4cafe8
leaq 0x108b67(%rip), %rsi # 0x2f73e9
callq 0x9a610
movq %rax, %rdi
leaq 0x108b88(%rip), %rsi # 0x2f7419
callq 0x9a610
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9a570
movq %rax, %rdi
leaq 0x108b88(%rip), %rsi # 0x2f7433
callq 0x9a610
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x9a610
movq %rax, %rdi
leaq 0x170cc2(%rip), %rsi # 0x35f589
callq 0x9a610
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0x9aca0
movq %rax, %rdi
leaq 0x150c2e(%rip), %rsi # 0x33f510
callq 0x9a610
movq %rax, %rdi
callq 0x9a2a0
leaq 0x40(%rsp), %rdi
callq 0x259bb6
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf4596
xorl %edi, %edi
testq %rax, %rax
sete %dil
callq 0x256e4f
testb %al, %al
jne 0x1ee9a9
leaq 0x40(%rsp), %rdi
pushq $0x3
popq %rsi
leaq 0x107f73(%rip), %rdx # 0x2f689c
movl $0x24d, %ecx # imm = 0x24D
callq 0x259af2
movq 0x2dc6ae(%rip), %rdi # 0x4cafe8
leaq 0x108b59(%rip), %rsi # 0x2f749a
callq 0x9a610
movq %rax, %rdi
leaq 0x108b85(%rip), %rsi # 0x2f74d5
callq 0x9a610
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9a570
movq %rax, %rdi
leaq 0x108b8f(%rip), %rsi # 0x2f74f9
callq 0x9a610
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x9a610
movq %rax, %rdi
leaq 0x170c03(%rip), %rsi # 0x35f589
callq 0x9a610
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0x9aca0
movq %rax, %rdi
callq 0x9a2a0
leaq 0x40(%rsp), %rdi
callq 0x259bb6
movq (%r12), %rsi
cmpq $0x0, 0x8(%rsi)
je 0x1ee9d0
leaq 0xa8(%rsp), %rdi
callq 0x9ae20
movq %rax, %rdi
leaq 0x1720ca(%rip), %rsi # 0x360a95
callq 0x9ade0
leaq 0xa8(%rsp), %rdi
movq %rbx, %rsi
callq 0x9ae20
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf46aa
leaq 0x138(%rsp), %rdi
movq %r15, %rsi
callq 0x9a9d0
movq 0xa8(%rsp), %r14
leaq 0x40(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xf5f57
movq 0x40(%rsp), %rbp
movq (%r12), %rsi
addq $0x28, %rsi
leaq 0x180(%rsp), %rdi
callq 0xebdfa
movq %r15, %rbx
movq (%r13), %rax
movq %r13, %r15
movq %r13, %rdi
callq *0x18(%rax)
movq %rax, %r13
pushq $0x1
popq %rdi
callq 0x256e4f
testb %al, %al
jne 0x1eeab8
leaq 0x20(%rsp), %rdi
pushq $0x3
popq %rsi
leaq 0x106bc0(%rip), %rdx # 0x2f561a
movl $0x201, %ecx # imm = 0x201
callq 0x259af2
movq 0x2dc57d(%rip), %rdi # 0x4cafe8
leaq 0x106c6f(%rip), %rsi # 0x2f56e1
callq 0x9a610
movq %rax, %rdi
leaq 0x106c93(%rip), %rsi # 0x2f5714
callq 0x9a610
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x9a610
movq %rax, %rdi
leaq 0x106b46(%rip), %rsi # 0x2f55e3
callq 0x9a610
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0x9aca0
leaq 0x20(%rsp), %rdi
callq 0x259bb6
pushq $0x1
popq %rdi
callq 0x256e4f
testb %al, %al
jne 0x1eeb31
leaq 0x20(%rsp), %rdi
pushq $0x3
popq %rsi
leaq 0x106b47(%rip), %rdx # 0x2f561a
movl $0x216, %ecx # imm = 0x216
callq 0x259af2
movq 0x2dc504(%rip), %rdi # 0x4cafe8
leaq 0x106bf6(%rip), %rsi # 0x2f56e1
callq 0x9a610
movq %rax, %rdi
leaq 0x106c85(%rip), %rsi # 0x2f577f
callq 0x9a610
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x9a610
movq %rax, %rdi
leaq 0x106acd(%rip), %rsi # 0x2f55e3
callq 0x9a610
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0x9aca0
leaq 0x20(%rsp), %rdi
callq 0x259bb6
movq (%r12), %rax
movq 0x20(%rax), %rdi
movq 0x68(%rsp), %rax
movq (%rax), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
leaq 0x138(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbp, %rcx
leaq 0x180(%rsp), %r8
movq %r13, %r9
callq 0x260873
leaq 0x180(%rsp), %rdi
callq 0x9ae88
leaq 0x40(%rsp), %rdi
callq 0x9ae88
leaq 0x138(%rsp), %rdi
callq 0x9ae88
incq 0x60(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x9ae88
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movb $0x1, %r14b
callq *0x18(%rax)
movq %r15, %r13
movq %rbx, %r15
jmp 0x1ee791
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1eebd2
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1eebe2
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xe8(%rsp), %rdi
callq 0xf486a
leaq 0x78(%rsp), %rdi
callq 0xe9b88
movq 0x98(%rsp), %rax
addq $0x40, %rax
jmp 0x1ee69f
addq $0x10, %r12
jmp 0x1ee681
testb $0x1, %r14b
jne 0x1eec61
movq (%r13), %rax
movq %r13, %rdi
callq *0x10(%rax)
movq %rax, %rbx
leaq 0x28(%r13), %rsi
leaq 0x158(%rsp), %rdi
callq 0xebdfa
movq 0x50(%r13), %rax
xorl %edx, %edx
cmpq 0x58(%r13), %rax
setne %dl
leaq 0x158(%rsp), %rsi
movq %rbx, %rdi
callq 0x25b82f
leaq 0x158(%rsp), %rdi
callq 0x9ae88
leaq 0xa8(%rsp), %rdi
callq 0x9ae88
leaq 0x118(%rsp), %rdi
callq 0x9ae88
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x158(%rsp), %rdi
callq 0x9ae88
jmp 0x1eed6f
jmp 0x1eeca6
jmp 0x1eecae
movq %rax, %rbx
jmp 0x1eed6f
movq %rax, %rbx
jmp 0x1eed65
movq %rax, %rbx
jmp 0x1eed58
movq %rax, %rbx
jmp 0x1eed48
jmp 0x1eed28
jmp 0x1eed28
movq %rax, %rbx
jmp 0x1eed0f
movq %rax, %rbx
jmp 0x1eed19
jmp 0x1eecd8
jmp 0x1eecd8
movq %rax, %rbx
jmp 0x1eed38
jmp 0x1eecdf
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x259bb6
jmp 0x1eed02
jmp 0x1eecf0
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x259bb6
jmp 0x1eed2b
movq %rax, %rbx
leaq 0x180(%rsp), %rdi
callq 0x9ae88
leaq 0x40(%rsp), %rdi
callq 0x9ae88
leaq 0x138(%rsp), %rdi
callq 0x9ae88
jmp 0x1eed2b
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x9ae88
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1eed48
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1eed58
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xe8(%rsp), %rdi
callq 0xf486a
leaq 0x78(%rsp), %rdi
callq 0xe9b88
leaq 0xa8(%rsp), %rdi
callq 0x9ae88
leaq 0x118(%rsp), %rdi
callq 0x9ae88
movq %rbx, %rdi
callq 0x9ace0
|
/jedisct1[P]boringssl/third_party/googletest/googletest/include/gtest/internal/gtest-param-util.h
|
0x1ee61e
|
jedisct1[P]boringssl[P]build_O2[P]pki_test
|
foreach_test_func(void*, void*)
|
static void foreach_test_func (ppointer data, ppointer user_data)
{
if (user_data == NULL)
return;
TestData *test_data = (TestData *) user_data;
if (test_data->index < 0 || test_data->index > 2)
return;
test_data->test_array[test_data->index] = P_POINTER_TO_INT (data);
++test_data->index;
}
|
testq %rsi, %rsi
je 0x19ff
movl 0xc(%rsi), %eax
cmpq $0x2, %rax
ja 0x19ff
movl %edi, (%rsi,%rax,4)
incl 0xc(%rsi)
retq
|
/saprykin[P]plibsys/tests/plist_test.cpp
|
0x19eb
|
saprykin[P]plibsys[P]build_O3[P]tests[P]plist_test
|
aom_paeth_predictor_4x4_ssse3
|
void aom_paeth_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t stride,
const uint8_t *above, const uint8_t *left) {
__m128i l = _mm_loadl_epi64((const __m128i *)left);
const __m128i t = _mm_loadl_epi64((const __m128i *)above);
const __m128i zero = _mm_setzero_si128();
const __m128i t16 = _mm_unpacklo_epi8(t, zero);
const __m128i tl16 = _mm_set1_epi16((int16_t)above[-1]);
__m128i rep = _mm_set1_epi16((short)0x8000);
const __m128i one = _mm_set1_epi16(1);
int i;
for (i = 0; i < 4; ++i) {
const __m128i l16 = _mm_shuffle_epi8(l, rep);
const __m128i row = paeth_8x1_pred(&l16, &t16, &tl16);
*(int *)dst = _mm_cvtsi128_si32(_mm_packus_epi16(row, row));
dst += stride;
rep = _mm_add_epi16(rep, one);
}
}
|
subq $0x238, %rsp # imm = 0x238
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movq %rcx, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x108(%rsp), %rax
movq (%rax), %xmm0
movaps %xmm0, 0xf0(%rsp)
movaps 0xf0(%rsp), %xmm0
movaps %xmm0, 0xa0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
movq (%rax), %xmm0
movaps %xmm0, 0xd0(%rsp)
movaps 0xd0(%rsp), %xmm0
movaps %xmm0, 0x90(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x110(%rsp)
movaps 0x110(%rsp), %xmm0
movaps %xmm0, 0x80(%rsp)
movaps 0x90(%rsp), %xmm1
movaps 0x80(%rsp), %xmm0
movaps %xmm1, 0x130(%rsp)
movaps %xmm0, 0x120(%rsp)
movaps 0x130(%rsp), %xmm0
movaps 0x120(%rsp), %xmm1
punpcklbw %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
movaps %xmm0, 0x70(%rsp)
movq 0xb8(%rsp), %rax
movzbl -0x1(%rax), %eax
movw %ax, 0x14e(%rsp)
movw 0x14e(%rsp), %ax
movw %ax, 0xa(%rsp)
movw %ax, 0x1ee(%rsp)
movw %ax, 0x1ec(%rsp)
movw %ax, 0x1ea(%rsp)
movw %ax, 0x1e8(%rsp)
movw %ax, 0x1e6(%rsp)
movw %ax, 0x1e4(%rsp)
movw %ax, 0x1e2(%rsp)
movw %ax, 0x1e0(%rsp)
movzwl 0x1ee(%rsp), %eax
movd %eax, %xmm1
movzwl 0x1ec(%rsp), %eax
movd %eax, %xmm0
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
movzwl 0x1ea(%rsp), %eax
movd %eax, %xmm2
movzwl 0x1e8(%rsp), %eax
movd %eax, %xmm1
punpcklwd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
punpckldq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movzwl 0x1e6(%rsp), %eax
movd %eax, %xmm0
movzwl 0x1e4(%rsp), %eax
movd %eax, %xmm2
punpcklwd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3]
movzwl 0x1e2(%rsp), %eax
movd %eax, %xmm3
movzwl 0x1e0(%rsp), %eax
movd %eax, %xmm0
punpcklwd %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1],xmm0[2],xmm3[2],xmm0[3],xmm3[3]
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
punpcklqdq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movaps %xmm0, 0x1d0(%rsp)
movaps 0x1d0(%rsp), %xmm0
movaps %xmm0, 0x60(%rsp)
movw $0x8000, 0x14c(%rsp) # imm = 0x8000
movw 0x14c(%rsp), %ax
movw %ax, 0xc(%rsp)
movw %ax, 0x20e(%rsp)
movw %ax, 0x20c(%rsp)
movw %ax, 0x20a(%rsp)
movw %ax, 0x208(%rsp)
movw %ax, 0x206(%rsp)
movw %ax, 0x204(%rsp)
movw %ax, 0x202(%rsp)
movw %ax, 0x200(%rsp)
movzwl 0x20e(%rsp), %eax
movd %eax, %xmm1
movzwl 0x20c(%rsp), %eax
movd %eax, %xmm0
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
movzwl 0x20a(%rsp), %eax
movd %eax, %xmm2
movzwl 0x208(%rsp), %eax
movd %eax, %xmm1
punpcklwd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
punpckldq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movzwl 0x206(%rsp), %eax
movd %eax, %xmm0
movzwl 0x204(%rsp), %eax
movd %eax, %xmm2
punpcklwd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3]
movzwl 0x202(%rsp), %eax
movd %eax, %xmm3
movzwl 0x200(%rsp), %eax
movd %eax, %xmm0
punpcklwd %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1],xmm0[2],xmm3[2],xmm0[3],xmm3[3]
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
punpcklqdq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movaps %xmm0, 0x1f0(%rsp)
movaps 0x1f0(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
movw $0x1, 0x14a(%rsp)
movw 0x14a(%rsp), %ax
movw %ax, 0xe(%rsp)
movw %ax, 0x236(%rsp)
movw %ax, 0x234(%rsp)
movw %ax, 0x232(%rsp)
movw %ax, 0x230(%rsp)
movw %ax, 0x22e(%rsp)
movw %ax, 0x22c(%rsp)
movw %ax, 0x22a(%rsp)
movw %ax, 0x228(%rsp)
movzwl 0x236(%rsp), %eax
movd %eax, %xmm1
movzwl 0x234(%rsp), %eax
movd %eax, %xmm0
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
movzwl 0x232(%rsp), %eax
movd %eax, %xmm2
movzwl 0x230(%rsp), %eax
movd %eax, %xmm1
punpcklwd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
punpckldq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movzwl 0x22e(%rsp), %eax
movd %eax, %xmm0
movzwl 0x22c(%rsp), %eax
movd %eax, %xmm2
punpcklwd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3]
movzwl 0x22a(%rsp), %eax
movd %eax, %xmm3
movzwl 0x228(%rsp), %eax
movd %eax, %xmm0
punpcklwd %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1],xmm0[2],xmm3[2],xmm0[3],xmm3[3]
punpckldq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
punpcklqdq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movdqa %xmm0, 0x210(%rsp)
movdqa 0x210(%rsp), %xmm0
movdqa %xmm0, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
cmpl $0x4, 0x3c(%rsp)
jge 0x3c709f
movaps 0xa0(%rsp), %xmm1
movaps 0x50(%rsp), %xmm0
movaps %xmm1, 0x160(%rsp)
movaps %xmm0, 0x150(%rsp)
movaps 0x160(%rsp), %xmm0
movaps 0x150(%rsp), %xmm1
pshufb %xmm1, %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x3c70b0
movaps %xmm0, 0x10(%rsp)
movaps 0x10(%rsp), %xmm0
movaps %xmm0, 0x1a0(%rsp)
movaps %xmm0, 0x190(%rsp)
movaps 0x1a0(%rsp), %xmm0
movaps 0x190(%rsp), %xmm1
packuswb %xmm1, %xmm0
movaps %xmm0, 0x180(%rsp)
movaps 0x180(%rsp), %xmm0
movaps %xmm0, 0x170(%rsp)
movl 0x170(%rsp), %ecx
movq 0xc8(%rsp), %rax
movl %ecx, (%rax)
movq 0xc0(%rsp), %rax
addq 0xc8(%rsp), %rax
movq %rax, 0xc8(%rsp)
movdqa 0x50(%rsp), %xmm1
movdqa 0x40(%rsp), %xmm0
movdqa %xmm1, 0x1c0(%rsp)
movdqa %xmm0, 0x1b0(%rsp)
movdqa 0x1c0(%rsp), %xmm0
movdqa 0x1b0(%rsp), %xmm1
paddw %xmm1, %xmm0
movdqa %xmm0, 0x50(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x3c6f90
addq $0x238, %rsp # imm = 0x238
retq
nopw (%rax,%rax)
|
/m-ab-s[P]aom/aom_dsp/x86/intrapred_ssse3.c
|
0x3c6be0
|
m-ab-s[P]aom[P]build_O0[P]examples[P]simple_encoder
|
Fl::screen_dpi(float&, float&, int)
|
void Fl::screen_dpi(float &h, float &v, int n)
{
if (num_screens < 0) screen_init();
h = v = 0.0f;
#ifdef WIN32
if (n >= 0 && n < num_screens) {
h = float(dpi[n][0]);
v = float(dpi[n][1]);
}
#elif defined(__APPLE__)
if (n >= 0 && n < num_screens) {
h = dpi_h[n];
v = dpi_v[n];
}
#else
if (n >= 0 && n < num_screens) {
h = dpi[n][0];
v = dpi[n][1];
}
#endif // WIN32
}
|
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x9a12d(%rip) # 0x18d5d4
jns 0xf34ae
callq 0xf2e1e
andl $0x0, (%rbx)
andl $0x0, (%r14)
testl %ebp, %ebp
js 0xf34de
cmpl %ebp, 0x9a115(%rip) # 0x18d5d4
jle 0xf34de
movl %ebp, %eax
leaq 0xb1f76(%rip), %rcx # 0x1a5440
movss (%rcx,%rax,8), %xmm0
movss %xmm0, (%r14)
movss 0x4(%rcx,%rax,8), %xmm0
movss %xmm0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/sidneydijkstra[P]SDEN/external/fltk-1.3.4-1/src/screen_xywh.cxx
|
0xf3494
|
meruiden[P]CS3D[P]build_O2[P]external[P]fltk-1.3.4-1[P]bin[P]fluid
|
wasm::(anonymous namespace)::GlobalTypeOptimization::updateTypes(wasm::Module&)::TypeRewriter::~TypeRewriter()
|
void updateTypes(Module& wasm) {
class TypeRewriter : public GlobalTypeRewriter {
GlobalTypeOptimization& parent;
public:
TypeRewriter(Module& wasm, GlobalTypeOptimization& parent)
: GlobalTypeRewriter(wasm), parent(parent) {}
void modifyStruct(HeapType oldStructType, Struct& struct_) override {
auto& newFields = struct_.fields;
// Adjust immutability.
auto immIter = parent.canBecomeImmutable.find(oldStructType);
if (immIter != parent.canBecomeImmutable.end()) {
auto& immutableVec = immIter->second;
for (Index i = 0; i < immutableVec.size(); i++) {
if (immutableVec[i]) {
newFields[i].mutable_ = Immutable;
}
}
}
// Remove/reorder fields where we can.
auto remIter = parent.indexesAfterRemovals.find(oldStructType);
if (remIter != parent.indexesAfterRemovals.end()) {
auto& indexesAfterRemoval = remIter->second;
Index removed = 0;
auto copy = newFields;
for (Index i = 0; i < newFields.size(); i++) {
auto newIndex = indexesAfterRemoval[i];
if (newIndex != RemovedField) {
newFields[newIndex] = copy[i];
} else {
removed++;
}
}
newFields.resize(newFields.size() - removed);
// Update field names as well. The Type Rewriter cannot do this for
// us, as it does not know which old fields map to which new ones (it
// just keeps the names in sequence).
auto iter = wasm.typeNames.find(oldStructType);
if (iter != wasm.typeNames.end()) {
auto& nameInfo = iter->second;
// Make a copy of the old ones to base ourselves off of as we do so.
auto oldFieldNames = nameInfo.fieldNames;
// Clear the old names and write the new ones.
nameInfo.fieldNames.clear();
for (Index i = 0; i < oldFieldNames.size(); i++) {
auto newIndex = indexesAfterRemoval[i];
if (newIndex != RemovedField && oldFieldNames.count(i)) {
assert(oldFieldNames[i].is());
nameInfo.fieldNames[newIndex] = oldFieldNames[i];
}
}
}
}
}
};
TypeRewriter(wasm, *this).update();
}
|
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x77c100
pushq $0x70
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x741cc0
nop
|
/WebAssembly[P]binaryen/src/passes/GlobalTypeOptimization.cpp
|
0x9092fa
|
WebAssembly[P]binaryen[P]build_O2[P]lib[P]libbinaryen.so
|
bool baryonyx::itm::solver_inequalities_01coeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::push_and_compute_update_row<baryonyx::bit_array, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>>(baryonyx::bit_array&, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>, long double, long double, long double, long double)
|
bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
Float objective_amplifier)
{
auto at_least_one_pi_changed{ false };
logger::log("push-update-row {} {} {}\n", kappa, delta, theta);
for (; first != last; ++first) {
auto k = constraint(first);
bx_expects(k < m);
const auto it = ap.row(k);
decrease_preference(std::get<0>(it), std::get<1>(it), theta);
const auto r_size =
compute_reduced_costs(std::get<0>(it), std::get<1>(it), x);
// Before sort and select variables, we apply the push method: for
// each reduces cost, we had the cost multiply with an objective
// amplifier.
for (int i = 0; i != r_size; ++i)
R[i].value += objective_amplifier * c(R[i].id, x);
calculator_sort<Mode>(R.get(), R.get() + r_size, rng);
int selected = select_variables(r_size, b[k].min, b[k].max);
logger::log("constraints {}: {} <= ", k, b[k].min);
for (int i = 0; i < r_size; ++i)
logger::log("({} {}) ", R[i].value, R[i].id);
logger::log("<= {} => Selected: {}\n", b[k].max, selected);
auto pi_change = affect(
*this, x, std::get<0>(it), k, selected, r_size, kappa, delta);
at_least_one_pi_changed = at_least_one_pi_changed || pi_change;
}
return at_least_one_pi_changed;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rcx, -0x100(%rbp)
movq %rdx, -0xf8(%rbp)
fldt 0x40(%rbp)
fldt 0x30(%rbp)
fldt 0x20(%rbp)
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
fstpt -0x30(%rbp)
fstpt -0x40(%rbp)
fstpt -0x50(%rbp)
fstpt -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movb $0x0, -0x61(%rbp)
leaq -0x78(%rbp), %rdi
leaq 0x46139c(%rip), %rsi # 0xb9f6f7
callq 0x147d0
movq -0xf0(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x40(%rbp), %r8
leaq -0x50(%rbp), %r9
callq 0x33a4d0
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdi
callq 0xb5f40
xorb $-0x1, %al
testb $0x1, %al
jne 0x73e39e
jmp 0x73e7b1
movq -0xf8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0xb5fb0
leaq -0x88(%rbp), %rdi
callq 0xb5f80
movq -0xf0(%rbp), %rcx
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
cmpl 0x78(%rcx), %eax
setl %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x73e3da
jmp 0x73e3dc
jmp 0x73e3fd
leaq 0x45dbfb(%rip), %rdi # 0xb9bfde
leaq 0x45f7b5(%rip), %rsi # 0xb9db9f
leaq 0x465da0(%rip), %rdx # 0xba4191
leaq 0x465e37(%rip), %rcx # 0xba422f
callq 0x658b0
movq -0xf0(%rbp), %rsi
addq $0x10, %rsi
movl -0x7c(%rbp), %edx
leaq -0x98(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0xb5fd0
movq -0x118(%rbp), %rdi
callq 0x203500
movq -0x118(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x110(%rbp)
callq 0x203520
movq -0x110(%rbp), %rsi
movq -0xf0(%rbp), %rdi
movq (%rax), %rdx
fldt -0x50(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x7385a0
leaq -0x98(%rbp), %rdi
callq 0x203500
movq (%rax), %rax
movq %rax, -0x108(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x203520
movq -0xf0(%rbp), %rdi
movq -0x108(%rbp), %rsi
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
callq 0x738610
movl %eax, -0x9c(%rbp)
movl $0x0, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
cmpl -0x9c(%rbp), %eax
je 0x73e544
movq -0xf0(%rbp), %rdi
fldt -0x60(%rbp)
fstpt -0x124(%rbp)
movq 0x70(%rdi), %rax
movq %rax, -0x140(%rbp)
addq $0x58, %rdi
movq %rdi, -0x138(%rbp)
movslq -0xa0(%rbp), %rsi
callq 0x738920
movq -0x140(%rbp), %rdi
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x1b8b70
movq -0x138(%rbp), %rdi
fstpt -0x130(%rbp)
movslq -0xa0(%rbp), %rsi
callq 0x738920
fldt -0x130(%rbp)
fldt -0x124(%rbp)
fldt (%rax)
fxch %st(1)
fmulp %st, %st(2)
faddp %st, %st(1)
fstpt (%rax)
movl -0xa0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa0(%rbp)
jmp 0x73e4aa
movq -0xf0(%rbp), %rdi
addq $0x58, %rdi
callq 0x738820
movq -0xf0(%rbp), %rdi
movq %rax, -0x150(%rbp)
addq $0x58, %rdi
callq 0x738820
movq -0x150(%rbp), %rdi
movq %rax, %rsi
movq -0xf0(%rbp), %rax
movslq -0x9c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdx
callq 0x7387d0
movq -0xf0(%rbp), %rdi
movl -0x9c(%rbp), %eax
movl %eax, -0x148(%rbp)
addq $0x60, %rdi
movslq -0x7c(%rbp), %rsi
callq 0x736860
movq -0xf0(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x144(%rbp)
addq $0x60, %rdi
movslq -0x7c(%rbp), %rsi
callq 0x736860
movl -0x148(%rbp), %esi
movl -0x144(%rbp), %edx
movq -0xf0(%rbp), %rdi
movl 0x4(%rax), %ecx
callq 0x738850
movl %eax, -0xa4(%rbp)
leaq -0xb8(%rbp), %rdi
leaq 0x465c03(%rip), %rsi # 0xba4201
callq 0x147d0
movq -0xf0(%rbp), %rdi
addq $0x60, %rdi
movslq -0x7c(%rbp), %rsi
callq 0x736860
movq -0xf0(%rbp), %rdi
movq %rax, %r8
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x7c(%rbp), %rcx
callq 0x2154a0
movl $0x0, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
cmpl -0x9c(%rbp), %eax
jge 0x73e6d8
leaq -0xd0(%rbp), %rdi
leaq 0x46817c(%rip), %rsi # 0xba67de
callq 0x147d0
movq -0xf0(%rbp), %rdi
addq $0x58, %rdi
movslq -0xbc(%rbp), %rsi
callq 0x738920
movq -0xf0(%rbp), %rdi
movq %rax, -0x158(%rbp)
addq $0x58, %rdi
movslq -0xbc(%rbp), %rsi
callq 0x738920
movq -0xf0(%rbp), %rdi
movq -0x158(%rbp), %rcx
movq %rax, %r8
addq $0x10, %r8
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x33a7d0
movl -0xbc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xbc(%rbp)
jmp 0x73e642
leaq 0x465b39(%rip), %rsi # 0xba4218
leaq -0xe0(%rbp), %rdi
callq 0x147d0
movq -0xf0(%rbp), %rdi
addq $0x60, %rdi
movslq -0x7c(%rbp), %rsi
callq 0x736860
movq -0xf0(%rbp), %rdi
movq %rax, %rcx
addq $0x4, %rcx
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0xa4(%rbp), %r8
callq 0x2154a0
movq -0x10(%rbp), %rax
movq %rax, -0x168(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x203500
movq -0xf0(%rbp), %rdi
movq -0x168(%rbp), %rsi
movq (%rax), %rdx
movl -0x7c(%rbp), %ecx
movl -0xa4(%rbp), %r8d
movl -0x9c(%rbp), %r9d
fldt -0x30(%rbp)
fldt -0x40(%rbp)
movq %rsp, %rax
fstpt 0x10(%rax)
fstpt (%rax)
callq 0x738960
andb $0x1, %al
movb %al, -0xe1(%rbp)
movb $0x1, %al
testb $0x1, -0x61(%rbp)
movb %al, -0x159(%rbp)
jne 0x73e795
movb -0xe1(%rbp), %al
movb %al, -0x159(%rbp)
movb -0x159(%rbp), %al
andb $0x1, %al
movb %al, -0x61(%rbp)
movq -0xf8(%rbp), %rdi
callq 0xb6410
jmp 0x73e380
movb -0x61(%rbp), %al
andb $0x1, %al
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
nop
|
/quesnel[P]baryonyx/lib/src/itm-solver-inequalities-01.cpp
|
0x73e300
|
quesnel[P]baryonyx[P]build_O0[P]app[P]baryonyx-0.5
|
doctest::(anonymous namespace)::XmlReporter::test_case_skipped(doctest::TestCaseData const&)
|
void test_case_skipped(const TestCaseData& in) override {
if(opt.no_skipped_summary == false) {
test_case_start_impl(in);
xml.writeAttribute("skipped", "true");
xml.endElement();
}
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x78(%rdi), %rax
cmpb $0x0, 0x7f(%rax)
jne 0x1fe19
movq %rdi, %rbx
callq 0x20970
addq $0x8, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x371f2(%rip), %rsi # 0x56fc9
leaq 0x371f2(%rip), %rdx # 0x56fd0
movq %rsp, %r14
movq %r14, %rdi
callq 0x4edda
leaq 0x340fe(%rip), %rdx # 0x53eee
movq %rbx, %rdi
movq %r14, %rsi
callq 0x206a6
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1fe11
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x1fe94
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1fe3c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x74b0
movq %rbx, %rdi
callq 0x7830
|
/taskflow[P]taskflow/3rd-party/doctest/doctest.h
|
0x1fda8
|
taskflow[P]taskflow[P]build_O3[P]unittests[P]test_find
|
fminnewt
|
int fminnewt(custom_function *funcpt, custom_gradient *funcgrad, int N, double *xi,
double delta,double *dx,double fsval,double maxstep, int method,double *xf) {
int retval;
int MAXITER,niter;
double eps,gtol,stol;
/*
* Method 1 - Newton Line Search
* Method 2 - Newton Trust Region - Hook Step
* Method 3 - Newton Trust Region - Double Dog-Leg
*
* Default Values :
*
* fsval = 1.0
* delta = -1.0
* dx = {1.0,1.0,...} - 1XN vector
*/
/*
* Return Codes
*
* Code 1 denotes probable success.
* Codes 2,3 and 6 denote possible success.
* Codes 0, 4 and 15 denote failure. [Code 4 my also occur in cases where the minima is realized but
* convergence is not achieved due to tolerance values being too small. It is recommended that you use
* another method if you suspect that such a scenario has occured.]
*
* 0 - Input Error
* 1 - df(x)/dx <= gtol achieved so current point may be the local minima.
* 2 - Distance between the last two steps is less than stol or |xf - xi| <= stol so the point may be the local minima.
* 3 - Global Step failed to locate a lower point than the current point so it may be the local minima.
* 4 - Iteration Limit exceeded. Convergence probably not achieved.
* 6 - Function value drops below ftol (relative functional tolerance).
* 15 - Overflow occurs. Try a different method.
*
*/
MAXITER = 200*N;
niter = 0;
eps = macheps(); // Use macheps program
if (method == 1) {
gtol = pow(eps,1.0/3.0);
stol = gtol * gtol;
if (MAXITER < 1000) {
MAXITER = 1000;
}
retval = newton_min_func(funcpt,funcgrad,xi,N,dx,fsval,maxstep,MAXITER,&niter,eps,gtol,stol,xf);
} else if (method == 2) {
gtol = pow(eps,1.0/3.0);
stol = gtol * gtol;
if (MAXITER < 1000) {
MAXITER = 1000;
}
retval = newton_min_trust(funcpt,funcgrad,xi,N,dx,fsval,delta,0,MAXITER,&niter,eps,gtol,stol,xf);
} else if (method == 3) {
gtol = pow(eps,1.0/3.0);
stol = gtol * gtol;
if (MAXITER < 1000) {
MAXITER = 1000;
}
retval = newton_min_trust(funcpt,funcgrad,xi,N,dx,fsval,delta,1,MAXITER,&niter,eps,gtol,stol,xf);
} else {
printf("Method Value should be one of 1,2 or 3. See Documentation. \n");
exit(1);
}
return retval;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm2, -0x40(%rbp)
movl %r9d, -0x44(%rbp)
imull $0xc8, -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movb $0x0, %al
callq 0x25200
movsd %xmm0, -0x58(%rbp)
cmpl $0x1, -0x44(%rbp)
jne 0x388f0
movsd -0x58(%rbp), %xmm0
movsd 0x408d7(%rip), %xmm1 # 0x79150
callq 0x60a0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
mulsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
cmpl $0x3e8, -0x4c(%rbp) # imm = 0x3E8
jge 0x388a2
movl $0x3e8, -0x4c(%rbp) # imm = 0x3E8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %r8
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
movl -0x4c(%rbp), %r9d
movsd -0x58(%rbp), %xmm2
movsd -0x60(%rbp), %xmm3
movsd -0x68(%rbp), %xmm4
movq 0x10(%rbp), %rax
leaq -0x50(%rbp), %r10
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x34950
movl %eax, -0x48(%rbp)
jmp 0x38a38
cmpl $0x2, -0x44(%rbp)
jne 0x38986
movsd -0x58(%rbp), %xmm0
movsd 0x40849(%rip), %xmm1 # 0x79150
callq 0x60a0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
mulsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
cmpl $0x3e8, -0x4c(%rbp) # imm = 0x3E8
jge 0x38930
movl $0x3e8, -0x4c(%rbp) # imm = 0x3E8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %r8
movsd -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x4c(%rbp), %r11d
movsd -0x58(%rbp), %xmm2
movsd -0x60(%rbp), %xmm3
movsd -0x68(%rbp), %xmm4
movq 0x10(%rbp), %rax
xorl %r9d, %r9d
leaq -0x50(%rbp), %r10
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x368d0
movl %eax, -0x48(%rbp)
jmp 0x38a36
cmpl $0x3, -0x44(%rbp)
jne 0x38a1c
movsd -0x58(%rbp), %xmm0
movsd 0x407b3(%rip), %xmm1 # 0x79150
callq 0x60a0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
mulsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
cmpl $0x3e8, -0x4c(%rbp) # imm = 0x3E8
jge 0x389c6
movl $0x3e8, -0x4c(%rbp) # imm = 0x3E8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %r8
movsd -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x4c(%rbp), %r11d
movsd -0x58(%rbp), %xmm2
movsd -0x60(%rbp), %xmm3
movsd -0x68(%rbp), %xmm4
movq 0x10(%rbp), %rax
movl $0x1, %r9d
leaq -0x50(%rbp), %r10
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x368d0
movl %eax, -0x48(%rbp)
jmp 0x38a34
leaq 0x4092d(%rip), %rdi # 0x79350
movb $0x0, %al
callq 0x60e0
movl $0x1, %edi
callq 0x6250
jmp 0x38a36
jmp 0x38a38
movl -0x48(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/rafat[P]ctsa/src/optimc.c
|
0x38810
|
rafat[P]ctsa[P]build_O0[P]Bin[P]sarimatest3
|
measure_lincost
|
int measure_lincost( int pid, int nprocs, int repeat,
int msg_size, int total_size, int min_niters, int niters, int ncomms,
conf_interval_method_t conf_interval_method,
int * n_samples,
const char * sample_file_name,
double * alpha_msg, double * alpha_msg_min, double * alpha_msg_max,
double * alpha_rma, double * alpha_rma_min, double * alpha_rma_max,
double * beta_msg, double * beta_msg_min, double * beta_msg_max,
double * beta_rma, double * beta_rma_min, double * beta_rma_max,
double * beta_memcpy, double *beta_memcpy_min, double *beta_memcpy_max,
double conf_level )
{
char * sendbuf, * recvbuf;
lincost_sample_t * samples;
size_t rng = 0;
int i, k, my_error=0, glob_error=0;
MPI_Request * reqs = 0;
int * pid_perms;
MPI_Win * wins; MPI_Comm * comms;
const int n_avgs = (int) (10.0 / (1.0 - conf_level));
const int max_h = total_size / msg_size;
int o[7]; /* two methods x two msg sizes + 1 */
double T[6], T_min[6], T_max[6]; /* two methods x two msg sizes */
FILE * sample_file;
double t0, t1;
* n_samples = 0;
if ( pid == 0 && sample_file_name ) {
sample_file = fopen( sample_file_name, "w" );
if (sample_file) {
fprintf( sample_file, "#ID\tSTAMP\tMETHOD\tTOPOLOGY\t"
"MSG_SIZE\tH_REL\tTIME\n" );
my_error = 0;
}
else {
my_error = 1;
}
}
else {
sample_file = NULL;
my_error = 0;
}
MPI_Allreduce( &my_error, &glob_error, 1, MPI_INT,
MPI_MAX, MPI_COMM_WORLD );
if ( glob_error ) {
if (!pid) fprintf( stderr,
"Could not open file '%s' for writing sample data\n",
sample_file_name );
return 1;
}
/* allocate memory */
sendbuf = calloc( 2* total_size, 1 );
recvbuf = calloc( 2* total_size, 1 );
samples = calloc( niters, sizeof(samples[0]) );
reqs = calloc( 2*max_h, sizeof(MPI_Request) );
pid_perms = calloc( nprocs, sizeof(pid_perms[0]) );
wins = calloc( ncomms, sizeof(MPI_Win) );
comms = calloc( ncomms, sizeof(MPI_Comm) );
if (comms) {
for ( i = 0; i < ncomms; ++i )
comms[i] = MPI_COMM_NULL;
}
if (wins) {
for ( i = 0; i < ncomms; ++i)
wins[i] = MPI_WIN_NULL;
}
my_error = !sendbuf || !recvbuf || !samples || !reqs
|| !pid_perms || !wins || !comms;
MPI_Allreduce( &my_error, &glob_error, 1, MPI_INT,
MPI_MAX, MPI_COMM_WORLD );
if ( glob_error ) {
if (!pid) fprintf( stderr,
"Insufficient memory. For a benchmark on "
"%d processes I require 2x %d bytes of memory "
"for send and receive buffers, %ld bytes for "
"storing the measurements, %ld bytes for "
"the request queue, %ld bytes for "
"communication infrastructure\n",
nprocs, 2*total_size,
(long) niters * (long) sizeof(samples[0]),
2*max_h * (long) sizeof(MPI_Request),
ncomms * (long) sizeof(MPI_Win) +
ncomms * (long) sizeof(MPI_Comm) +
nprocs * (long) sizeof(pid_perms[0]) );
goto exit;
}
memset( sendbuf, 1, 2*total_size );
memset( recvbuf, 2, 2*total_size );
/* Create random topologies */
for ( i = 0 ; i < nprocs; ++i )
pid_perms[i] = i;
MPI_Comm_dup( MPI_COMM_WORLD, &comms[0] );
MPI_Win_create( recvbuf, 2*total_size, 1,
MPI_INFO_NULL, comms[0], & wins[0] );
for ( i = 1; i < ncomms; ++i ) {
permute( &rng, pid_perms, nprocs, sizeof(pid_perms[0]) );
MPI_Comm_split( comms[0], 0, pid_perms[pid], &comms[i] );
MPI_Win_create( recvbuf, 2*total_size, 1,
MPI_INFO_NULL, comms[i], & wins[i] );
}
/* Create measurement points */
for ( i = 0 ; i < niters; ++i )
samples[i].msg_size = (i%2 + 1) * msg_size;
permute( &rng, samples, niters, sizeof(samples[0]) );
for ( i = 0; i < niters; ++i )
samples[i].h = i % ( max_h + 1);
permute( &rng, samples, niters, sizeof(samples[0]) );
for ( i = 0; i < niters; ++i )
samples[i].comm = i % ncomms;
permute( &rng, samples, niters, sizeof(samples[0]) );
for ( i = 0 ; i < niters; ++i )
samples[i].method = i % 3;
permute( &rng, samples, niters, sizeof(samples[0]) );
/* Warm up */
for ( i = 0; i < ncomms; ++i ) {
measure_hrel_msg( comms[i], sendbuf, recvbuf, reqs,
max_h, 2*msg_size, repeat );
measure_hrel_rma( comms[i], wins[i], sendbuf,
max_h, 2*msg_size, repeat );
measure_hrel_memcpy( comms[i], sendbuf, recvbuf,
max_h, 2*msg_size, repeat );
}
/* And now the measurements */
t0 = t1 = bsp_time();
for ( i = 0; i < niters; ++i ) {
double t = HUGE_VAL;
int h = samples[i].h;
int size = samples[i].msg_size;
MPI_Comm comm = comms[ samples[i].comm ];
MPI_Win win = wins[ samples[i].comm ];
switch( samples[i].method ) {
case 0: t = measure_hrel_rma( comm, win, sendbuf,
h, size, repeat );
break;
case 1: t = measure_hrel_msg( comm, sendbuf, recvbuf, reqs,
h, size, repeat );
break;
case 2: t = measure_hrel_memcpy( comm, sendbuf, recvbuf,
h, size, repeat );
break;
}
samples[i].time = t;
samples[i].timestamp = bsp_time() - t0;
samples[i].serial = i;
if ( !pid && bsp_time() - t1 > 10.0 ) {
printf("# Sample time remaining: %.0f seconds\n"
"# (Press CTRL+C to interrupt)\n",
(bsp_time() - t0) / i *(niters - i - 1) );
t1 = bsp_time();
}
MPI_Allreduce( &s_interrupted, &glob_error, 1, MPI_INT,
MPI_MAX, MPI_COMM_WORLD );
if ( glob_error ) {
if (i > min_niters) {
niters = i;
break;
}
else {
goto exit;
}
}
}
/* Saving data */
if (sample_file) {
for ( i = 0; i < niters; ++i ) {
fprintf( sample_file,
"%d\t%.15e\t%d\t%d\t%d\t%d\t%.15e\n",
samples[i].serial, samples[i].timestamp,
samples[i].method, samples[i].comm,
samples[i].msg_size, samples[i].h, samples[i].time );
}
fclose( sample_file );
sample_file = NULL;
}
/* Analysis */
/* sort on (msg_size, method) */
qsort( samples, niters, sizeof(samples[0]), cmp_lincost_sample );
/* create an index to each (msg_size, method) in array 'o' */
o[0] = 0;
i = 0;
for ( k = 0; k < 6; ++k ) {
for ( ; i < niters; ++i )
if (samples[i].msg_size != (k%2+1)*msg_size
|| samples[i].method != (k/2) )
break;
o[k+1] = i;
}
my_error = (*conf_interval_method)( &rng, samples, sizeof(samples[0]),
lincost_samples_get_hrel_time,
o, 6, conf_level, n_avgs,
T, T_min, T_max );
MPI_Allreduce( &my_error, &glob_error, 1, MPI_INT,
MPI_MAX, MPI_COMM_WORLD );
if (glob_error) {
goto exit;
}
/* saving results */
*alpha_rma = 2*T[0] - T[1];
*alpha_rma_min = 2*T_min[0] - T_max[1];
*alpha_rma_max = 2*T_max[0] - T_min[1];
*alpha_msg = 2*T[2] - T[3];
*alpha_msg_min = 2*T_min[2] - T_max[3];
*alpha_msg_max = 2*T_max[2] - T_min[3];
*beta_rma = (T[1] - T[0])/msg_size ;
*beta_rma_min = (T_min[1] - T_max[0])/msg_size;
*beta_rma_max = (T_max[1] - T_min[0])/msg_size;
*beta_msg = (T[3] - T[2])/msg_size ;
*beta_msg_min = (T_min[3] - T_max[2])/msg_size;
*beta_msg_max = (T_max[3] - T_min[2])/msg_size;
*beta_memcpy = (T[5] - T[4])/msg_size ;
*beta_memcpy_min = (T_min[5] - T_max[4])/msg_size;
*beta_memcpy_max = (T_max[5] - T_min[4])/msg_size;
*n_samples = niters;
exit:
/* free resources */
for ( i = 0; i < ncomms; ++i ) {
if (wins[i] != MPI_WIN_NULL)
MPI_Win_free( &wins[i] );
if (comms[i] != MPI_COMM_NULL )
MPI_Comm_free( &comms[i] );
}
free( sendbuf );
free( recvbuf );
free( samples );
free( reqs );
free( comms );
free( pid_perms );
free( wins );
return glob_error;
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq 0xa8(%rbp), %rax
movq 0xa0(%rbp), %rax
movq 0x98(%rbp), %rax
movq 0x90(%rbp), %rax
movq 0x88(%rbp), %rax
movq 0x80(%rbp), %rax
movq 0x78(%rbp), %rax
movq 0x70(%rbp), %rax
movq 0x68(%rbp), %rax
movq 0x60(%rbp), %rax
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %edi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movsd %xmm0, -0x38(%rbp)
movq $0x0, -0x58(%rbp)
movl $0x0, -0x64(%rbp)
movl $0x0, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movsd 0x239d3(%rip), %xmm1 # 0x3c010
subsd -0x38(%rbp), %xmm1
movsd 0x239ce(%rip), %xmm0 # 0x3c018
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x8c(%rbp)
movl -0x28(%rbp), %eax
cltd
idivl -0x24(%rbp)
movl %eax, -0x90(%rbp)
movq 0x28(%rbp), %rax
movl $0x0, (%rax)
cmpl $0x0, -0x18(%rbp)
jne 0x186c4
cmpq $0x0, 0x30(%rbp)
je 0x186c4
movq 0x30(%rbp), %rdi
leaq 0x23aac(%rip), %rsi # 0x3c133
callq 0x17410
movq %rax, -0x148(%rbp)
cmpq $0x0, -0x148(%rbp)
je 0x186bb
movq -0x148(%rbp), %rdi
leaq 0x23a8a(%rip), %rsi # 0x3c135
movb $0x0, %al
callq 0x175a0
movl $0x0, -0x64(%rbp)
jmp 0x186c2
movl $0x1, -0x64(%rbp)
jmp 0x186d6
movq $0x0, -0x148(%rbp)
movl $0x0, -0x64(%rbp)
leaq -0x64(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x1, %edx
movq 0x358d6(%rip), %rcx # 0x4dfc0
movq 0x358a7(%rip), %r8 # 0x4df98
movq 0x35898(%rip), %r9 # 0x4df90
callq 0x17480
cmpl $0x0, -0x68(%rbp)
je 0x18731
cmpl $0x0, -0x18(%rbp)
jne 0x18725
movq 0x358b8(%rip), %rax # 0x4dfc8
movq (%rax), %rdi
movq 0x30(%rbp), %rdx
leaq 0x23a46(%rip), %rsi # 0x3c164
movb $0x0, %al
callq 0x175a0
movl $0x1, -0x14(%rbp)
jmp 0x19473
movl -0x28(%rbp), %eax
shll %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x17220
movq %rax, -0x40(%rbp)
movl -0x28(%rbp), %eax
shll %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x17220
movq %rax, -0x48(%rbp)
movslq 0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x17220
movq %rax, -0x50(%rbp)
movl -0x90(%rbp), %eax
shll %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x17220
movq %rax, -0x70(%rbp)
movslq -0x1c(%rbp), %rdi
movl $0x4, %esi
callq 0x17220
movq %rax, -0x78(%rbp)
movslq 0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x17220
movq %rax, -0x80(%rbp)
movslq 0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x17220
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
je 0x187fd
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x18(%rbp), %eax
jge 0x187fb
movq -0x88(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq 0x357cc(%rip), %rdx # 0x4dfb8
movq %rdx, (%rax,%rcx,8)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x187d2
jmp 0x187fd
cmpq $0x0, -0x80(%rbp)
je 0x18833
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x18(%rbp), %eax
jge 0x18831
movq -0x80(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq 0x3575e(%rip), %rdx # 0x4df80
movq %rdx, (%rax,%rcx,8)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x1880b
jmp 0x18833
movb $0x1, %al
cmpq $0x0, -0x40(%rbp)
movb %al, -0x179(%rbp)
je 0x188a0
movb $0x1, %al
cmpq $0x0, -0x48(%rbp)
movb %al, -0x179(%rbp)
je 0x188a0
movb $0x1, %al
cmpq $0x0, -0x50(%rbp)
movb %al, -0x179(%rbp)
je 0x188a0
movb $0x1, %al
cmpq $0x0, -0x70(%rbp)
movb %al, -0x179(%rbp)
je 0x188a0
movb $0x1, %al
cmpq $0x0, -0x78(%rbp)
movb %al, -0x179(%rbp)
je 0x188a0
movb $0x1, %al
cmpq $0x0, -0x80(%rbp)
movb %al, -0x179(%rbp)
je 0x188a0
cmpq $0x0, -0x88(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x179(%rbp)
movb -0x179(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x64(%rbp)
leaq -0x64(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x1, %edx
movq 0x356fe(%rip), %rcx # 0x4dfc0
movq 0x356cf(%rip), %r8 # 0x4df98
movq 0x356c0(%rip), %r9 # 0x4df90
callq 0x17480
cmpl $0x0, -0x68(%rbp)
je 0x1893f
cmpl $0x0, -0x18(%rbp)
jne 0x1893a
movq 0x356e0(%rip), %rax # 0x4dfc8
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
movl -0x28(%rbp), %ecx
shll %ecx
movslq 0x10(%rbp), %rax
imulq $0x28, %rax, %r8
movl -0x90(%rbp), %eax
shll %eax
movslq %eax, %r9
shlq $0x3, %r9
movslq 0x18(%rbp), %rax
shlq $0x3, %rax
movslq 0x18(%rbp), %rsi
shlq $0x3, %rsi
addq %rsi, %rax
movslq -0x1c(%rbp), %rsi
shlq $0x2, %rsi
addq %rsi, %rax
leaq 0x23867(%rip), %rsi # 0x3c196
movq %rax, (%rsp)
movb $0x0, %al
callq 0x175a0
jmp 0x193b7
movq -0x40(%rbp), %rdi
movl -0x28(%rbp), %eax
shll %eax
movslq %eax, %rdx
movl $0x1, %esi
callq 0x171c0
movq -0x48(%rbp), %rdi
movl -0x28(%rbp), %eax
shll %eax
movslq %eax, %rdx
movl $0x2, %esi
callq 0x171c0
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x18993
movl -0x5c(%rbp), %edx
movq -0x78(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x18972
movq -0x88(%rbp), %rsi
movq 0x355ef(%rip), %rdi # 0x4df90
callq 0x17520
movq -0x48(%rbp), %rdi
movl -0x28(%rbp), %eax
shll %eax
movslq %eax, %rsi
movq -0x88(%rbp), %rax
movq (%rax), %r8
movq -0x80(%rbp), %r9
movl $0x1, %edx
movq 0x35614(%rip), %rcx # 0x4dfe0
callq 0x17050
movl $0x1, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x18(%rbp), %eax
jge 0x18a70
movq -0x78(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x58(%rbp), %rdi
movl $0x4, %ecx
callq 0x17ba0
movq -0x88(%rbp), %rax
movq (%rax), %rdi
movq -0x78(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x88(%rbp), %rcx
movslq -0x5c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
xorl %esi, %esi
callq 0x175e0
movq -0x48(%rbp), %rdi
movl -0x28(%rbp), %eax
shll %eax
movslq %eax, %rsi
movq -0x88(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq (%rax,%rcx,8), %r8
movq -0x80(%rbp), %r9
movslq -0x5c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %r9
movl $0x1, %edx
movq 0x35583(%rip), %rcx # 0x4dfe0
callq 0x17050
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x189d8
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x18ab0
movl -0x5c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, %ecx
addl $0x1, %ecx
imull -0x24(%rbp), %ecx
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x18a77
movq -0x50(%rbp), %rsi
movl 0x10(%rbp), %edx
leaq -0x58(%rbp), %rdi
movl $0x28, %ecx
callq 0x17ba0
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x18b00
movl -0x5c(%rbp), %eax
movl -0x90(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl %edx, 0x8(%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x18acc
movq -0x50(%rbp), %rsi
movl 0x10(%rbp), %edx
leaq -0x58(%rbp), %rdi
movl $0x28, %ecx
callq 0x17ba0
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x18b48
movl -0x5c(%rbp), %eax
cltd
idivl 0x18(%rbp)
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl %edx, 0x10(%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x18b1c
movq -0x50(%rbp), %rsi
movl 0x10(%rbp), %edx
leaq -0x58(%rbp), %rdi
movl $0x28, %ecx
callq 0x17ba0
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x18b94
movl -0x5c(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl %edx, 0x14(%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x18b64
movq -0x50(%rbp), %rsi
movl 0x10(%rbp), %edx
leaq -0x58(%rbp), %rdi
movl $0x28, %ecx
callq 0x17ba0
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x18(%rbp), %eax
jge 0x18c60
movq -0x88(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x70(%rbp), %rcx
movl -0x90(%rbp), %r8d
movl -0x24(%rbp), %r9d
shll %r9d
movl -0x20(%rbp), %eax
movl %eax, (%rsp)
callq 0x179e0
movq -0x88(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x80(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x40(%rbp), %rdx
movl -0x90(%rbp), %ecx
movl -0x24(%rbp), %r8d
shll %r8d
movl -0x20(%rbp), %r9d
callq 0x178b0
movq -0x88(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movl -0x90(%rbp), %ecx
movl -0x24(%rbp), %r8d
shll %r8d
movl -0x20(%rbp), %r9d
callq 0x177d0
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x18bb0
callq 0x1e400
movsd %xmm0, -0x158(%rbp)
movsd %xmm0, -0x150(%rbp)
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x18edf
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq %rax, -0x160(%rbp)
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
leaq (%rcx,%rcx,4), %rcx
movl 0x8(%rax,%rcx,8), %eax
movl %eax, -0x164(%rbp)
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
leaq (%rcx,%rcx,4), %rcx
movl 0xc(%rax,%rcx,8), %eax
movl %eax, -0x168(%rbp)
movq -0x88(%rbp), %rax
movq -0x50(%rbp), %rcx
movslq -0x5c(%rbp), %rdx
leaq (%rdx,%rdx,4), %rdx
movslq 0x10(%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x170(%rbp)
movq -0x80(%rbp), %rax
movq -0x50(%rbp), %rcx
movslq -0x5c(%rbp), %rdx
leaq (%rdx,%rdx,4), %rdx
movslq 0x10(%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x178(%rbp)
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
leaq (%rcx,%rcx,4), %rcx
movl 0x14(%rax,%rcx,8), %eax
movl %eax, -0x180(%rbp)
testl %eax, %eax
je 0x18d41
jmp 0x18d24
movl -0x180(%rbp), %eax
subl $0x1, %eax
je 0x18d73
jmp 0x18d31
movl -0x180(%rbp), %eax
subl $0x2, %eax
je 0x18da9
jmp 0x18dd6
movq -0x170(%rbp), %rdi
movq -0x178(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl -0x164(%rbp), %ecx
movl -0x168(%rbp), %r8d
movl -0x20(%rbp), %r9d
callq 0x178b0
movsd %xmm0, -0x160(%rbp)
jmp 0x18dd6
movq -0x170(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x70(%rbp), %rcx
movl -0x164(%rbp), %r8d
movl -0x168(%rbp), %r9d
movl -0x20(%rbp), %eax
movl %eax, (%rsp)
callq 0x179e0
movsd %xmm0, -0x160(%rbp)
jmp 0x18dd6
movq -0x170(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movl -0x164(%rbp), %ecx
movl -0x168(%rbp), %r8d
movl -0x20(%rbp), %r9d
callq 0x177d0
movsd %xmm0, -0x160(%rbp)
movsd -0x160(%rbp), %xmm0
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
callq 0x1e400
subsd -0x150(%rbp), %xmm0
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x20(%rax)
movl -0x5c(%rbp), %ecx
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
cmpl $0x0, -0x18(%rbp)
jne 0x18e8a
callq 0x1e400
subsd -0x158(%rbp), %xmm0
movsd 0x231d6(%rip), %xmm1 # 0x3c018
ucomisd %xmm1, %xmm0
jbe 0x18e8a
callq 0x1e400
subsd -0x150(%rbp), %xmm0
cvtsi2sdl -0x5c(%rbp), %xmm1
divsd %xmm1, %xmm0
movl 0x10(%rbp), %eax
subl -0x5c(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
leaq 0x23408(%rip), %rdi # 0x3c27e
movb $0x1, %al
callq 0x17030
callq 0x1e400
movsd %xmm0, -0x158(%rbp)
leaq 0x35533(%rip), %rdi # 0x4e3c4
leaq -0x68(%rbp), %rsi
movl $0x1, %edx
movq 0x3511f(%rip), %rcx # 0x4dfc0
movq 0x350f0(%rip), %r8 # 0x4df98
movq 0x350e1(%rip), %r9 # 0x4df90
callq 0x17480
cmpl $0x0, -0x68(%rbp)
je 0x18ecf
movl -0x5c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jle 0x18eca
movl -0x5c(%rbp), %eax
movl %eax, 0x10(%rbp)
jmp 0x18edf
jmp 0x193b7
jmp 0x18ed1
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x18c7c
cmpq $0x0, -0x148(%rbp)
je 0x18fc0
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x18fa9
movq -0x148(%rbp), %rdi
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rax), %edx
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x20(%rax), %xmm0
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %ecx
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rsi
imulq $0x28, %rsi, %rsi
addq %rsi, %rax
movl 0x10(%rax), %r8d
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rsi
imulq $0x28, %rsi, %rsi
addq %rsi, %rax
movl 0xc(%rax), %r9d
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rsi
imulq $0x28, %rsi, %rsi
addq %rsi, %rax
movl 0x8(%rax), %eax
movq -0x50(%rbp), %rsi
movslq -0x5c(%rbp), %r10
imulq $0x28, %r10, %r10
addq %r10, %rsi
movsd (%rsi), %xmm1
leaq 0x23335(%rip), %rsi # 0x3c2c6
movl %eax, (%rsp)
movb $0x2, %al
callq 0x175a0
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x18ef4
movq -0x148(%rbp), %rdi
callq 0x17350
movq $0x0, -0x148(%rbp)
movq -0x50(%rbp), %rdi
movslq 0x10(%rbp), %rsi
movl $0x28, %edx
leaq -0x1344(%rip), %rcx # 0x17c90
callq 0x176b0
movl $0x0, -0xb0(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x60(%rbp)
cmpl $0x6, -0x60(%rbp)
jge 0x19099
jmp 0x18ffd
movl -0x5c(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x19079
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x184(%rbp)
movl -0x60(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x184(%rbp), %eax
movl %edx, %ecx
addl $0x1, %ecx
imull -0x24(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1906a
movq -0x50(%rbp), %rax
movslq -0x5c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
movl %eax, -0x188(%rbp)
movl -0x60(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x188(%rbp), %eax
cmpl %ecx, %eax
je 0x1906c
jmp 0x19079
jmp 0x1906e
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x18ffd
movl -0x5c(%rbp), %ecx
movl -0x60(%rbp), %eax
addl $0x1, %eax
cltq
movl %ecx, -0xb0(%rbp,%rax,4)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x18ff1
movq 0x20(%rbp), %rax
movq -0x50(%rbp), %rsi
leaq -0xb0(%rbp), %r8
movsd -0x38(%rbp), %xmm0
movl -0x8c(%rbp), %r14d
leaq -0xe0(%rbp), %rbx
leaq -0x110(%rbp), %r11
leaq -0x140(%rbp), %r10
leaq -0x58(%rbp), %rdi
movl $0x28, %edx
leaq -0x11f9(%rip), %rcx # 0x17ee0
movl $0x6, %r9d
movl %r14d, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
callq *%rax
movl %eax, -0x64(%rbp)
leaq -0x64(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x1, %edx
movq 0x34eb5(%rip), %rcx # 0x4dfc0
movq 0x34e86(%rip), %r8 # 0x4df98
movq 0x34e77(%rip), %r9 # 0x4df90
callq 0x17480
cmpl $0x0, -0x68(%rbp)
je 0x19129
jmp 0x193b7
movsd -0xe0(%rbp), %xmm0
movsd -0xd8(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0x50(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x110(%rbp), %xmm0
movsd -0x138(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0x58(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x140(%rbp), %xmm0
movsd -0x108(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0x60(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0xd0(%rbp), %xmm0
movsd -0xc8(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0x38(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x100(%rbp), %xmm0
movsd -0x128(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0x40(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x130(%rbp), %xmm0
movsd -0xf8(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0x48(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0xd8(%rbp), %xmm0
subsd -0xe0(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq 0x80(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x108(%rbp), %xmm0
subsd -0x140(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq 0x88(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x138(%rbp), %xmm0
subsd -0x110(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq 0x90(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0xc8(%rbp), %xmm0
subsd -0xd0(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq 0x68(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0xf8(%rbp), %xmm0
subsd -0x130(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq 0x70(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x128(%rbp), %xmm0
subsd -0x100(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq 0x78(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0xb8(%rbp), %xmm0
subsd -0xc0(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq 0x98(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0xe8(%rbp), %xmm0
subsd -0x120(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq 0xa0(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x118(%rbp), %xmm0
subsd -0xf0(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movq 0xa8(%rbp), %rax
movsd %xmm0, (%rax)
movl 0x10(%rbp), %ecx
movq 0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl 0x18(%rbp), %eax
jge 0x1942b
movq -0x80(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq 0x34bab(%rip), %rdx # 0x4df80
cmpq %rdx, (%rax,%rcx,8)
je 0x193ef
movq -0x80(%rbp), %rdi
movslq -0x5c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x170a0
movq -0x88(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movq 0x34bb7(%rip), %rdx # 0x4dfb8
cmpq %rdx, (%rax,%rcx,8)
je 0x1941e
movq -0x88(%rbp), %rdi
movslq -0x5c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x175d0
jmp 0x19420
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x193be
movq -0x40(%rbp), %rdi
callq 0x17430
movq -0x48(%rbp), %rdi
callq 0x17430
movq -0x50(%rbp), %rdi
callq 0x17430
movq -0x70(%rbp), %rdi
callq 0x17430
movq -0x88(%rbp), %rdi
callq 0x17430
movq -0x78(%rbp), %rdi
callq 0x17430
movq -0x80(%rbp), %rdi
callq 0x17430
movl -0x68(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/wijnand-suijlen[P]bsponmpi/src/bompiprobe.c
|
0x18590
|
wijnand-suijlen[P]bsponmpi[P]build_O0[P]bompiprobe
|
njoy::ENDFtk::section::Type<2, 151>::RMatrixLimited::ResonanceChannels::generateList(std::vector<unsigned int, std::allocator<unsigned int>>&&, std::vector<unsigned int, std::allocator<unsigned int>>&&, std::vector<double, std::allocator<double>>&&, std::vector<double, std::allocator<double>>&&, std::vector<double, std::allocator<double>>&&, std::vector<double, std::allocator<double>>&&)
|
static std::vector< double >
generateList( std::vector< unsigned int >&& ppi,
std::vector< unsigned int >&& l,
std::vector< double >&& s,
std::vector< double >&& b,
std::vector< double >&& ape,
std::vector< double >&& apt ) {
unsigned int nch = l.size();
if ( ( ppi.size() != nch ) or ( s.size() != nch ) or ( b.size() != nch ) or
( ape.size() != nch ) or ( apt.size() != nch ) ) {
Log::info( "The number of channels and the channel data is not consistent" );
Log::info( "NCH value: {}", nch );
Log::info( "ppi.size(): {}", ppi.size() );
Log::info( "l.size(): {}", l.size() );
Log::info( "s.size(): {}", s.size() );
Log::info( "b.size(): {}", b.size() );
Log::info( "ape.size(): {}", ape.size() );
Log::info( "apt.size(): {}", apt.size() );
throw std::exception();
}
std::vector< double > list;
for ( unsigned int i = 0; i < nch; ++i ) {
list.push_back( ppi[i] );
list.push_back( l[i] );
list.push_back( s[i] );
list.push_back( b[i] );
list.push_back( ape[i] );
list.push_back( apt[i] );
}
return list;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %rbp
movq 0x8(%rdx), %rbx
subq (%rdx), %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x2, %rbx
sarq $0x2, %rax
movl %ebx, %ecx
cmpq %rcx, %rax
jne 0x41907
movq 0x18(%rsp), %rdx
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x41907
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x41907
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x41907
movq 0x60(%rsp), %rdx
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x41907
movq %rdi, %r13
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %ebx, %ebx
je 0x418f5
movl %ebx, %r14d
xorl %r15d, %r15d
movq (%rbp), %rax
movl (%rax,%r15,4), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rax
cmpq %rax, %rsi
je 0x417ce
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r13)
jmp 0x417e3
movq %r13, %rdi
leaq 0x20(%rsp), %rdx
callq 0x41046
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rax
movq (%r12), %rcx
movl (%rcx,%r15,4), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movsd %xmm0, 0x20(%rsp)
cmpq %rax, %rsi
je 0x4180c
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r13)
jmp 0x41821
movq %r13, %rdi
leaq 0x20(%rsp), %rdx
callq 0x41046
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rax
leaq (,%r15,8), %rbx
movq 0x18(%rsp), %rcx
movq (%rcx), %rdx
addq %rbx, %rdx
cmpq %rax, %rsi
je 0x4184b
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r13)
jmp 0x4185b
movq %r13, %rdi
callq 0x40f22
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
addq %rbx, %rdx
cmpq %rax, %rsi
je 0x4187d
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r13)
jmp 0x4188d
movq %r13, %rdi
callq 0x40f22
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
addq %rbx, %rdx
cmpq %rax, %rsi
je 0x418af
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r13)
jmp 0x418bf
movq %r13, %rdi
callq 0x40f22
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rax
movq 0x60(%rsp), %rcx
addq (%rcx), %rbx
cmpq %rax, %rsi
je 0x418de
movsd (%rbx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r13)
jmp 0x418e9
movq %r13, %rdi
movq %rbx, %rdx
callq 0x40f22
incq %r15
cmpq %r14, %r15
jne 0x4179d
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x71398(%rip), %rdi # 0xb2ca6
callq 0x34bae
leaq 0x713ca(%rip), %rdi # 0xb2ce4
movl %ebx, %esi
callq 0x34c08
movq 0x8(%rbp), %rsi
subq (%rbp), %rsi
sarq $0x2, %rsi
leaq 0x713be(%rip), %rdi # 0xb2cf2
callq 0x34c70
movq 0x8(%r12), %rsi
subq (%r12), %rsi
sarq $0x2, %rsi
leaq 0x713b4(%rip), %rdi # 0xb2d01
callq 0x34c70
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x3, %rsi
leaq 0x714ec(%rip), %rdi # 0xb2e55
callq 0x34c70
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x3, %rsi
leaq 0x70dc7(%rip), %rdi # 0xb274c
callq 0x34c70
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x3, %rsi
leaq 0x7136d(%rip), %rdi # 0xb2d0e
callq 0x34c70
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x3, %rsi
leaq 0x71360(%rip), %rdi # 0xb2d1d
callq 0x34c70
movl $0x8, %edi
callq 0x172c0
movq 0xba575(%rip), %rcx # 0xfbf48
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xba5df(%rip), %rsi # 0xfbfc0
movq 0xba600(%rip), %rdx # 0xfbfe8
movq %rax, %rdi
callq 0x17ae0
jmp 0x419f4
jmp 0x419f4
movq %rax, %rbx
movq (%r13), %rdi
testq %rdi, %rdi
je 0x41a0c
movq 0x10(%r13), %rsi
subq %rdi, %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b40
|
/njoy[P]ENDFtk/src/ENDFtk/section/2/151/RMatrixLimited/ResonanceChannels/src/generateList.hpp
|
0x416d4
|
njoy[P]ENDFtk[P]build_O3[P]src[P]ENDFtk[P]section[P]2[P]151[P]RMatrixLimited[P]test[P]ENDFtk.section.2.151.RMatrixLimited.test
|
google::protobuf::compiler::(anonymous namespace)::GetBootstrapParam(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
bool GetBootstrapParam(const std::string& parameter) {
std::vector<std::string> parts = absl::StrSplit(parameter, ',');
for (const auto& part : parts) {
if (part == "bootstrap") {
return true;
}
}
return false;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xda9d50
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movl $0x2c, %ecx
callq 0xe70230
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe70290
leaq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x434210
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x434050
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x802280
testb $0x1, %al
jne 0x149b814
jmp 0x149b876
leaq -0x60(%rbp), %rdi
callq 0x4344f0
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
leaq 0x9ccf51(%rip), %rsi # 0x1e6877d
callq 0x4475a0
movb %al, -0x81(%rbp)
jmp 0x149b839
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x149b845
jmp 0x149b869
movb $0x1, -0x1(%rbp)
movl $0x1, -0x80(%rbp)
jmp 0x149b881
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x40c280
jmp 0x149b898
jmp 0x149b86b
leaq -0x60(%rbp), %rdi
callq 0x802350
jmp 0x149b801
movb $0x0, -0x1(%rbp)
movl $0x1, -0x80(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x40c280
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x22a7a0
nopw %cs:(%rax,%rax)
|
/protocolbuffers[P]protobuf/src/google/protobuf/compiler/command_line_interface.cc
|
0x149b7a0
|
protocolbuffers[P]protobuf[P]build_O0[P]tests
|
DecodeRUSBitpInstruction
|
static DecodeStatus DecodeRUSBitpInstruction(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Op1, Op2;
DecodeStatus S = Decode2OpInstruction(Insn, &Op1, &Op2);
if (S != MCDisassembler_Success)
return Decode2OpInstructionFail(Inst, Insn, Address, Decoder);
DecodeGRRegsRegisterClass(Inst, Op1, Address, Decoder);
DecodeBitpOperand(Inst, Op2, Address, Decoder);
return S;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movl %ebp, %edi
callq 0xc0379
cmpl $0x3, %eax
jne 0xbfd7d
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xbf957
movl 0x8(%rsp), %eax
cmpq $0xb, %rax
ja 0xbfd6f
leaq 0x8f91c(%rip), %rcx # 0x14f680
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
callq 0x44a16
movl $0x3, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xc03ce
|
/TriDis[P]capstone/arch/XCore/XCoreDisassembler.c
|
0xbfd1e
|
TriDis[P]capstone[P]build_O3[P]test_x86
|
sarimax_wrapper
|
sarimax_wrapper_object sarimax_wrapper(sarimax_wrapper_object model,double *y, int N,int *order, int *seasonal, double *xreg, int r, int idrift,int mean,
double *lambda, int biasadj,int method) {
/*
Init here. { sarimax_object,drift}
*/
sarimax_wrapper_object obj = NULL;
int i, p,d,q,P,D,Q,s,ncoeff,drift,rr;
double *x, *origx,*xreg2;
double rsum;
x = (double*) malloc(sizeof(double)*N);
origx = (double*) malloc(sizeof(double)*N);
obj = (sarimax_wrapper_object) malloc (sizeof(struct sarimax_wrapper_set));
memcpy(x,y,sizeof(double)*N);
memcpy(origx,y,sizeof(double)*N);
if (lambda != NULL) boxcox_eval(y,N,*lambda,x);
if (seasonal == NULL) {
P = D = Q = s = 0;
}
if (model == NULL) {
p = order[0];
d = order[1];
q = order[2];
if (seasonal != NULL) {
P = seasonal[0];
D = seasonal[1];
Q = seasonal[2];
s = seasonal[3];
}
if (idrift == 1) {
drift = 1;
} else {
drift = 0;
}
if (d + D > 1 && idrift == 1) {
drift = 0;
}
//printf("drift %d \n",drift);
rr = r;
if (drift == 1) {
obj->idrift = 1;
rr++;
xreg2 = (double*)malloc(sizeof(double)*N*rr);
for(i = 0; i < N;++i) {
xreg2[i] = (double) (i+1);
}
memcpy(xreg2+N,xreg,sizeof(double)*N*(rr-1));
} else {
xreg2 = (double*)malloc(sizeof(double)*N*rr);
memcpy(xreg2,xreg,sizeof(double)*N*rr);
}
obj->sarimax = sarimax_init(p,d,q,P,D,Q,s,rr,mean,N);
sarimax_exec(obj->sarimax,x,xreg2);
obj->aic = obj->sarimax->aic;
ncoeff = (obj->sarimax->p + obj->sarimax->q + obj->sarimax->P + obj->sarimax->Q + obj->sarimax->M) + 1;
obj->aicc = obj->aic + 2 * ncoeff * ((double)obj->sarimax->Nused / (double) (obj->sarimax->Nused - ncoeff - 1) - 1.0);
obj->bic = obj->aic + ncoeff * (log((double)obj->sarimax->Nused) - 2.0);
rsum = 0.0;
for(i = 0; i < obj->sarimax->Nused;++i) {
rsum += obj->sarimax->res[i]*obj->sarimax->res[i];
}
obj->sigma2 = rsum / (double) (obj->sarimax->Nused - ncoeff + 1);
/// memory leak fix
free(xreg2);
}
free(x);
free(origx);
return obj;
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x48(%rbp)
movq %r8, -0x40(%rbp)
movq %rcx, -0x58(%rbp)
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %r15
movslq %edx, %rax
movq %rax, -0x70(%rbp)
leaq (,%rax,8), %rbx
movq %rbx, %rdi
callq 0x61e0
movq %rax, %r14
movl $0x38, %edi
callq 0x61e0
movq %rax, -0x50(%rbp)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, -0x30(%rbp)
movq %rbx, %rdx
callq 0x61b0
movq 0x28(%rbp), %rax
testq %rax, %rax
je 0xbb60
movsd (%rax), %xmm0
movq %r12, %rdi
movl %r13d, %esi
movq %r14, %rdx
callq 0x34447
testq %r15, %r15
jne 0xbd97
movl 0x18(%rbp), %eax
movq -0x58(%rbp), %rdi
movl 0x4(%rdi), %ecx
movq -0x40(%rbp), %r8
testq %r8, %r8
movq %r14, -0x68(%rbp)
je 0xbb9b
movl (%r8), %edx
movl %edx, -0x34(%rbp)
movl 0x4(%r8), %esi
movl 0x8(%r8), %edx
movl %edx, -0x38(%rbp)
movl 0xc(%r8), %edx
movq %rdx, -0x40(%rbp)
jmp 0xbbb3
xorl %esi, %esi
movl $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movl 0x10(%rbp), %r8d
movl (%rdi), %edx
movl %edx, -0x5c(%rbp)
movl 0x8(%rdi), %edx
movl %edx, -0x58(%rbp)
cmpl $0x1, %eax
setne %al
movq %rcx, %rbx
movq %rsi, %r14
addl %esi, %ecx
cmpl $0x2, %ecx
setge %cl
orb %al, %cl
jne 0xbc3d
movq -0x50(%rbp), %rax
movl $0x1, 0x8(%rax)
leal 0x1(%r8), %r12d
movslq %r12d, %rdi
imulq -0x30(%rbp), %rdi
callq 0x61e0
movq %rax, %r15
movq %r13, %rax
testl %eax, %eax
jle 0xbc1d
movl %eax, %eax
xorl %ecx, %ecx
leaq 0x1(%rcx), %rdx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd %xmm0, (%r15,%rcx,8)
movq %rdx, %rcx
cmpq %rdx, %rax
jne 0xbc04
movq -0x70(%rbp), %rax
leaq (%r15,%rax,8), %rdi
movl 0x10(%rbp), %eax
cltq
movq -0x30(%rbp), %rdx
imulq %rax, %rdx
movq -0x48(%rbp), %rsi
callq 0x61b0
jmp 0xbc66
movslq %r8d, %rax
movq -0x30(%rbp), %r12
imulq %rax, %r12
movq %r12, %rdi
callq 0x61e0
movq %rax, %r15
movq %rax, %rdi
movq -0x48(%rbp), %rsi
movq %r12, %rdx
callq 0x61b0
movl 0x10(%rbp), %r12d
movl -0x5c(%rbp), %edi
movl %ebx, %esi
movl -0x58(%rbp), %edx
movl -0x34(%rbp), %ecx
movl %r14d, %r8d
movl -0x38(%rbp), %r9d
pushq %r13
movl 0x20(%rbp), %eax
pushq %rax
pushq %r12
pushq -0x40(%rbp)
callq 0x6fa6
addq $0x20, %rsp
movq %rax, %r12
movq -0x50(%rbp), %r13
movq %rax, (%r13)
movq %rax, %rdi
movq -0x68(%rbp), %r14
movq %r14, %rsi
movq %r15, %rdx
callq 0x7769
movsd 0x90(%r12), %xmm0
movsd %xmm0, 0x10(%r13)
movapd %xmm0, %xmm4
movsd %xmm0, -0x30(%rbp)
movl 0x18(%r12), %ebx
addl 0x10(%r12), %ebx
addl 0x20(%r12), %ebx
addl 0x28(%r12), %ebx
movl 0x30(%r12), %eax
leal (%rax,%rbx), %ecx
incl %ecx
addl %eax, %ebx
leal 0x2(,%rbx,2), %eax
cvtsi2sd %eax, %xmm1
movl 0x4(%r12), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
subl %ebx, %eax
addl $-0x2, %eax
cvtsi2sd %eax, %xmm2
movapd %xmm0, %xmm3
divsd %xmm2, %xmm3
addsd 0x474be(%rip), %xmm3 # 0x531d0
mulsd %xmm1, %xmm3
addsd %xmm4, %xmm3
movsd %xmm3, 0x20(%r13)
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
movsd %xmm1, -0x48(%rbp)
callq 0x6130
addsd 0x47487(%rip), %xmm0 # 0x531c0
mulsd -0x48(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x18(%r13)
movslq 0x4(%r12), %rax
testq %rax, %rax
jle 0xbd75
movq 0x70(%r12), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0xbd5e
jmp 0xbd79
xorpd %xmm0, %xmm0
subl %ebx, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movq %r15, %rdi
callq 0x6040
movq %r14, %rdi
callq 0x6040
movq -0x50(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/rafat[P]ctsa/src/ctsa.c
|
0xbae5
|
rafat[P]ctsa[P]build_O1[P]Bin[P]sarimatest2
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.