name string | code string | asm string | file string |
|---|---|---|---|
ear::PolarSpeakerPosition::~PolarSpeakerPosition() | struct EAR_EXPORT PolarSpeakerPosition {
PolarSpeakerPosition(double az = 0.0, double el = 0.0, double dist = 1.0)
: azimuth(az), elevation(el), distance(dist){};
double azimuth;
boost::optional<double> azimuthMin;
boost::optional<double> azimuthMax;
double elevation;
boost::optional<dou... | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0xa0(%rdi)
jne 0x60f18
movq 0xa8(%rbx), %rdi
leaq 0xb8(%rbx), %rax
cmpq %rax, %rdi
je 0x60f11
movq (%rax), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0xa0(%rbx)
cmpb $0x1, 0x78(%rbx)
jne 0x60f40
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x60f3c
movq (%rax), %rsi
i... | /ebu[P]libear/include/ear/metadata.hpp |
void ear::mask_write<ear::OutputGains&, Eigen::CwiseUnaryOp<Eigen::internal::scalar_boolean_not_op<bool>, Eigen::Array<bool, -1, 1, 0, -1, 1> const>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>(ear::OutputGains&, Eigen::CwiseUnaryOp<Eigen::internal::scalar_boolean_not_op<bool>, Eigen::Array<bool, -1, 1, 0, -1, 1> const> co... | void mask_write(OutT &&out, const MaskT &mask, const ValuesT &values) {
Eigen::Index out_size = out.size();
Eigen::Index mask_size = mask.size();
Eigen::Index values_size = values.size();
ear_assert(
out_size == mask_size,
"in mask_write: out_size and mask_write must be the same length"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %r12
movq (%r14), %rax
cmpq 0x8(%rax), %r12
jne 0x6107c
movq 0x8(%rbx), %rax
movq %rax, 0x20(%rsp)
testq %r12, %r12
jle 0x6102a
xorl %r13d, %r1... | /ebu[P]libear/src/direct_speakers/../common/helpers/eigen_helpers.hpp |
ear::PolarExtentCoreScalar::run(ear::PolarExtentCoreContext&) const | void run(PolarExtentCoreContext &ctx) const override {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++)
ctx.results[speaker_idx] = 0.0;
for (size_t i = 0; i < ctx.num_points; i++) {
ExtentPosition pos;
pos.x = ctx.xs[i];
pos.y = ctx.ys[i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x6f872
movq 0x90(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x14330
cmpq $0x0, (%rbx)
je 0x6f96f
xorl %r12d, %r12d
leaq 0x4(%rsp), %r15
xorl %r13d, %r13d
movq 0x18(%rb... | /ebu[P]libear/src/object_based/polar_extent_scalar.cpp |
ear::PolarExtentCoreScalar::weight_circle(ear::PolarExtentCoreContext&, ear::ExtentPosition const&) const | extent_float_t dot(const extent_float_t *vec) const {
return x * vec[0] + y * vec[1] + z * vec[2];
} | pushq %rbx
subq $0x10, %rsp
movss (%rdx), %xmm1
movss 0x4(%rdx), %xmm0
mulss 0x54(%rsi), %xmm0
mulss 0x50(%rsi), %xmm1
addss %xmm0, %xmm1
movss 0x8(%rdx), %xmm0
mulss 0x58(%rsi), %xmm0
addss %xmm1, %xmm0
ucomiss 0x78(%rsi), %xmm0
jae 0x6f9e1
movq %rsi, %rbx
movss 0x7c(%rsi), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm... | /ebu[P]libear/src/object_based/polar_extent_scalar.cpp |
ear::PolarExtentCoreScalar::weight_stadium(ear::PolarExtentCoreContext&, ear::ExtentPosition const&) const | extent_float_t weight_stadium(PolarExtentCoreContext &ctx,
const ExtentPosition &position) const {
ExtentPosition position_t = position.transform(ctx.flippedBasis);
ExtentPosition position_t_right = position_t;
position_t_right.x = std::abs(position_t.x);
auto... | pushq %rbx
subq $0x10, %rsp
movq %rdx, %rdi
movq %rsi, %rbx
addq $0x44, %rsi
callq 0x6fac0
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2 # xmm2 = xmm2[1,1],xmm0[1,1]
andps 0x5cffc(%rip), %xmm0 # 0xcca10
movss 0x6c(%rbx), %xmm3
mulss %xmm2, %xmm3
movss 0x68(%rbx), %xmm4
mulss %xmm0, %xmm4
addss %xmm3, %xmm4
xorp... | /ebu[P]libear/src/object_based/polar_extent_scalar.cpp |
ear::convex_hull(std::vector<Eigen::Matrix<double, 3, 1, 0, 3, 1>, std::allocator<Eigen::Matrix<double, 3, 1, 0, 3, 1>>> const&, double) | std::vector<Facet> convex_hull(const std::vector<Eigen::Vector3d> &positions,
double tolerance) {
using Vec = Eigen::Vector3d;
using Tri = std::array<size_t, 3>;
// the mean point, guaranteed to be inside the convex hull
Vec inside_point = Vec::Zero();
for (auto &po... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movapd %xmm0, 0x70(%rsp)
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x6fb82
xorpd %xmm2, %xmm2
xorpd %xmm6, %xmm6
movq %rax, %rdx
movupd (%rdx), %xmm1
addpd %xmm1, %x... | /ebu[P]libear/src/common/convex_hull.cpp |
Catch::Benchmark::Detail::weighted_average_quantile(int, int, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>) | double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
auto count = last - first;
double idx = (count - 1) * k / static_cast<double>(q);
int j = static_cast<int>(idx);
double g = idx - j;
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rcx, %rax
subq %rdx, %rax
sarq $0x3, %rax
leaq -0x1(%rax), %rcx
movslq %edi, %rdi
imulq %rcx, %rdi
cvtsi2sd %rdi, %xmm3
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm3
cvttsd2si %xmm3, %ecx
cvttpd2dq %xmm3, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm3
movslq %ecx, ... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Benchmark::Detail::erfc_inv(double) | double erfc_inv(double x) {
return erf_inv(1.0 - x);
} | subq $0x28, %rsp
movsd 0x3e1c3(%rip), %xmm1 # 0xaf008
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movapd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm2, 0x8(%rsp)
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x144b0
movapd %xmm0, %xmm2
ucomisd 0x66de8(%rip), %xmm0 # 0xd7c60
jbe 0x70f9f
movsd 0x66f22(%r... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Benchmark::Detail::normal_quantile(double) | double normal_quantile(double p) {
static const double ROOT_TWO = std::sqrt(2.0);
double result = 0.0;
assert(p >= 0 && p <= 1);
if (p < 0 || p > 1) {
return result;
}
result = -erfc_inv(2.0 * p);
... | pushq %rax
movapd %xmm0, %xmm1
movb 0x9fbf3(%rip), %al # 0x110da8
testb %al, %al
je 0x71204
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x71215
movsd 0x3de3d(%rip), %xmm0 # 0xaf008
ucomisd %xmm1, %xmm0
jb 0x71215
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x71202
ucomisd 0x3de25(%rip), %xmm1 # 0xaf008
ja 0x71... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Benchmark::Detail::outlier_variance(Catch::Benchmark::Estimate<double>, Catch::Benchmark::Estimate<double>, int) | double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
double sb = stddev.point;
double mn = mean.point / n;
double mg_min = mn / 2.;
double sg = (std::min)(mg_min / 4., sb / std::sqrt(n));
double sg2 = sg * sg;
... | pushq %rbx
subq $0x80, %rsp
movl %edi, %ebx
movsd 0xb0(%rsp), %xmm1
movsd 0x90(%rsp), %xmm8
cvtsi2sd %edi, %xmm3
divsd %xmm3, %xmm8
movsd 0x3ddc5(%rip), %xmm9 # 0xaf028
mulsd %xmm8, %xmm9
movsd 0x66bf8(%rip), %xmm4 # 0xd7e68
mulsd %xmm9, %xmm4
xorpd %xmm6, %xmm6
ucomisd %xmm6, %xmm3
movapd %xmm3, 0x40(%rsp)
jb 0x... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Benchmark::Detail::analyse_samples(double, int, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>, __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double>>>) | bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
static std::random_device entropy;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movsd %xmm0, 0x40(%rsp)
movq %rdi, %rbx
movb 0xa0c94(%rip), %al # 0x112138
testb %al, %al
je 0x7156c
movq %r14, %r12
subq %r15, %r12
shrq $0x3, %r12
leaq 0x88(%rsp), %r13
movl %ebp, (%... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Detail::Approx::toString[abi:cxx11]() const | std::string Approx::toString() const {
ReusableStringStream rss;
rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
return rss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x9b02a(%rip), %rax # 0x10c7b8
movq %rax, 0x28(%rsp)
callq 0xa7f40
leaq 0x8(%rax), %rdi
callq 0x97e94
movq %rax, %r14
movq %rax, 0x30(%rsp)
callq 0xa7f40
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %r14
movq %r14, 0x38(%rsp)
leaq 0x... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Detail::Approx::setMargin(double) | void Approx::setMargin(double newMargin) {
CATCH_ENFORCE(newMargin >= 0,
"Invalid Approx::margin: " << newMargin << '.'
<< " Approx::Margin has to be non-negative.");
m_margin = newMargin;
} | pushq %rbx
subq $0x40, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7192c
movsd %xmm0, 0x8(%rdi)
addq $0x40, %rsp
popq %rbx
retq
movsd %xmm0, (%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x830d8
movq 0x10(%rbx), %rbx
leaq 0x67c21(%rip), %rsi # 0xd956a
movl $0x18, %edx
movq %rbx, %rdi
callq 0x146d0
movq %... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Detail::Approx::setEpsilon(double) | void Approx::setEpsilon(double newEpsilon) {
CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
"Invalid Approx::epsilon: " << newEpsilon << '.'
<< " Approx::epsilon has to be in [0, 1]");
m_epsilon = newEpsilon;
} | pushq %rbx
subq $0x40, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x71a33
movsd 0x3d5e5(%rip), %xmm1 # 0xaf008
ucomisd %xmm0, %xmm1
jb 0x71a33
movsd %xmm0, (%rdi)
addq $0x40, %rsp
popq %rbx
retq
movsd %xmm0, (%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x830d8
movq 0x10(%rbx), %rbx
leaq 0x67b5b(%rip), %rs... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::operator<<(std::ostream&, Catch::LazyExpression const&) | auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
if( lazyExpr.m_isNegated )
os << "!";
if( lazyExpr ) {
if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
os << "(" << *lazyExpr.m_transientEx... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0x71b98
leaq 0x687ee(%rip), %rsi # 0xda379
movl $0x1, %edx
movq %rbx, %rdi
callq 0x146d0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x71be4
cmpb $0x1, 0x8(%r14)
jne 0x71bda
cmpb $0x1, 0x8(%rdi)
jne 0x71bda
leaq 0x68d2a(%rip), %rsi ... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::getResultCapture() | inline IMutableContext& getCurrentMutableContext()
{
if( !IMutableContext::currentContext )
IMutableContext::createContext();
// NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
return *IMutableContext::currentContext;
} | pushq %rbx
subq $0x50, %rsp
movq 0xa050e(%rip), %rdi # 0x112150
testq %rdi, %rdi
je 0x71c4c
movq (%rdi), %rax
jmp 0x71c80
movl $0x30, %edi
callq 0x145c0
movq %rax, %rdi
leaq 0x9a4b0(%rip), %rax # 0x10c110
movq %rax, (%rdi)
leaq 0x9a4f6(%rip), %rcx # 0x10c160
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %x... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::AssertionHandler::allowThrows() const | auto AssertionHandler::allowThrows() const -> bool {
return getCurrentContext().getConfig()->allowThrows();
} | pushq %rax
movq 0xa03e0(%rip), %rdi # 0x112150
testq %rdi, %rdi
je 0x71d7a
movq (%rdi), %rax
jmp 0x71dae
movl $0x30, %edi
callq 0x145c0
movq %rax, %rdi
leaq 0x9a382(%rip), %rax # 0x10c110
movq %rax, (%rdi)
leaq 0x9a3c8(%rip), %rcx # 0x10c160
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
m... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::AssertionHandler::complete() | void AssertionHandler::complete() {
setCompleted();
if( m_reaction.shouldDebugBreak ) {
// If you find your debugger stopping you here then go one level up on the
// call-stack for the code that caused it (typically a failed assertion)
// (To go back to the test and... | pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x3a(%rdi)
cmpb $0x1, 0x38(%rdi)
jne 0x71dd4
callq 0x7935a
testb %al, %al
je 0x71dd4
int3
cmpb $0x1, 0x39(%rbx)
je 0x71ddc
popq %rbx
retq
movl $0x1, %edi
callq 0x14290
leaq 0x9a203(%rip), %rsi # 0x10bff0
movq %rax, %rdi
xorl %edx, %edx
callq 0x14a60
nop
| /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::AssertionHandler::handleUnexpectedInflightException() | void AssertionHandler::handleUnexpectedInflightException() {
m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %r14
callq 0x94db0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
movq (%rax), %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
leaq 0x38(%rbx), %rcx
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movq %r15,... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::handleExceptionMatchExpr(Catch::AssertionHandler&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::StringRef const&) | void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString ) {
handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x7209e
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x71fd8
leaq 0x9a465(%rip), %rax # 0x10c3b0
leaq 0x70(%rsp), %rcx
movq %rax, -0x68(%rcx)
leaq 0x9a47d(%rip), %rax... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::handleExceptionMatchExpr(Catch::AssertionHandler&, Catch::Matchers::Impl::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, Catch::StringRef const&) | void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString ) {
std::string exceptionMessage = Catch::translateActiveException();
MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
handler.han... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x94db0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
leaq 0x28(%r15), %rdi
movq 0x28(%r15), %rax
movq %r12, %... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Matchers::Equals(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive::Choice) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl %edx, -0x8(%rdi)
movq %rsp, %r14
movq %r14, %rsi
movq %rax, %rdx
callq 0x7ce18
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d124
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x720e7
movq 0x18(%rsp), %rsi
incq... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::AssertionResultData::reconstructExpression[abi:cxx11]() const | std::string AssertionResultData::reconstructExpression() const {
if( reconstructedExpression.empty() ) {
if( lazyExpression ) {
ReusableStringStream rss;
rss << lazyExpression;
reconstructedExpression = rss.str();
}
}
retur... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
movq 0x28(%rsi), %rdx
testq %rdx, %rdx
jne 0x72206
movq %rsi, %r15
cmpq $0x0, 0x40(%rsi)
je 0x72204
leaq 0x40(%r15), %r13
leaq 0x9a638(%rip), %rax # 0x10c7b8
movq %rax, 0x8(%rsp)
callq 0xa7f40
leaq 0x8(%rax... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::AssertionResult::AssertionResult(Catch::AssertionInfo const&, Catch::AssertionResultData const&) | AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
: m_info( info ),
m_resultData( data )
{} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rax
movq %rax, 0x30(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x38(%rdi), %r15
leaq 0x48(%rdi), %r12
mov... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::AssertionResult::getExpression[abi:cxx11]() const | std::string AssertionResult::getExpression() const {
// Possibly overallocating by 3 characters should be basically free
std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
if (isFalseTest(m_info.resultDisposition)) {
expr += "!(";
}
expr += m_info.c... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x28(%rsi), %rsi
addq $0x3, %rsi
callq 0x14940
testb $0x4, 0x30(%r14)
je 0x72383
leaq 0x672a4(%rip), %rsi # 0xd961f
movq %rbx, %rdi
callq 0x14ba0
movq 0x20(%r14), ... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::AssertionResult::hasExpandedExpression() const | constexpr auto empty() const noexcept -> bool {
return m_size == 0;
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x7252f
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x725a4
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x72342
movq 0x10(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x72533
movq 0x28(%rsp), %r14
testq %rdx, %rdx
je 0x7253c
movq 0x8(%rsp), %rdi
mo... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::AssertionResult::getExpandedExpression[abi:cxx11]() const | std::string AssertionResult::getExpandedExpression() const {
std::string expr = m_resultData.reconstructExpression();
return expr.empty()
? getExpression()
: expr;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x72146
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x725e3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x36894
jmp 0x725ee
movq %rbx,... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::AssertionResult::getMessage[abi:cxx11]() const | std::string AssertionResult::getMessage() const {
return m_resultData.message;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x36894
movq %rbx, %rax
popq %rbx
retq
nop
| /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::TestRunStats::TestRunStats(Catch::TestRunInfo const&, Catch::Totals const&, bool) | TestRunStats::TestRunStats( TestRunInfo const& _runInfo,
Totals const& _totals,
bool _aborting )
: runInfo( _runInfo ),
totals( _totals ),
aborting( _aborting )
{} | pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x91a78(%rip), %rax # 0x10c290
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x36894
movq 0x30(%r14), %rax
movq %rax, 0x58... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::TestRunStats::~TestRunStats() | TestRunStats::~TestRunStats() = default; | movq %rdi, %rax
leaq 0x91a1e(%rip), %rcx # 0x10c290
movq %rcx, (%rdi)
movq 0x8(%rdi), %rdi
addq $0x18, %rax
cmpq %rax, %rdi
je 0x7a88d
movq (%rax), %rsi
incq %rsi
jmp 0x145f0
retq
| /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Matchers::Floating::WithinRelMatcher::describe[abi:cxx11]() const | std::string WithinRelMatcher::describe() const {
Catch::ReusableStringStream sstr;
sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
return sstr.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8fc1e(%rip), %rax # 0x10c7b8
movq %rax, 0x8(%rsp)
callq 0xa7f40
leaq 0x8(%rax), %rdi
callq 0x97e94
movq %rax, %r14
movq %rax, 0x10(%rsp)
callq 0xa7f40
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %r14
movq %r14, 0x18(%rsp)
leaq 0x5... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Matchers::WithinULP(double, unsigned long) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
} | movq %rdi, %rax
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x8f69e(%rip), %rcx # 0x10c320
movq %rcx, (%rdi)
leaq 0x8f6c4(%rip), %rcx # 0x10c350
movq %rcx, 0x28(%rdi)
movsd %xmm0, 0x30(%rdi)
movq %rsi, 0x38(%rdi)
movb $0x1, 0x40(%rdi)
retq
| /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::Matchers::Generic::Detail::finalizeDescription(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
if (desc.empty()) {
return "matches undescribed predicate";
} else {
return "matches predicate: \"" + desc + '"';
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x7cd77
movq %rsi, %rdx
leaq 0x5d373(%rip), %rsi # 0xda0a2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3870f
movq 0x8(%r14), %rsi
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
movl $0x22, %r8d
callq 0x14b40
leaq 0x10(%rbx), %rdx
movq ... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const &arg ) -> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xa4275
movl 0x8(%r15), %eax
testl %eax, %eax
je 0x935a2
movl %eax, 0x8(%rbx)
leaq 0x7b5e1(%rip), %r15 # 0x10eb60
movq ... | /ebu[P]libear/submodules/catch2/catch.hpp |
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseResultType> Catch::clara::detail::convertInto<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&) | inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
std::stringstream ss;
ss << source;
ss >> target;
if( ss.fail() )
return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
else
return P... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x14430
leaq 0x58(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x146d0
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x14370
movq 0x48(%rsp), %rax
movq -0x18(... | /ebu[P]libear/submodules/catch2/catch.hpp |
Matrix<int>::transpose() | void transpose(){
// if matrix is square, no extra memory is needed to build its transpose
if (num_rows == num_cols){
for (size_type i {0}; i < num_rows; i++){
for (size_type j {i + 1}; j < num_cols; j++){
std::swap(at(i, j), at(j, i));
}
}
}
// if matrix is not squ... | pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
movq (%rax), %rdx
movq (%rcx), %rsi
cmpq %rsi, %rdx
jne 0x1730
pushq $0x4
popq %rax
xorl %ecx, %ecx
xorl %esi, %esi
cmpq %rdx, %rsi
je 0x17ae
incq %rsi
movq (%rbx), %r10
movq 0x20(%rbx), %rdi
movq %rdi, %r8
imulq %rax, %r... | /luizalbertocviana[P]cracking-coding-problems/data-structures-cpp/Matrix.hpp |
cinatra::coro_http_connection::start() (.resume) | async_simple::coro::Lazy<void> start() {
#ifdef CINATRA_ENABLE_SSL
bool has_shake = false;
#endif
std::chrono::system_clock::time_point start{};
std::chrono::system_clock::time_point mid{};
while (true) {
#ifdef CINATRA_ENABLE_SSL
if (use_ssl_ && !has_shake) {
auto ec = co_await coro_io::a... | subq $0xcd8, %rsp # imm = 0xCD8
movq %rdi, 0x6a8(%rsp)
movq %rdi, 0xcd0(%rsp)
movq %rdi, %rax
addq $0x14d0, %rax # imm = 0x14D0
movq %rax, 0x6b0(%rsp)
movq %rdi, %rax
addq $0x14d8, %rax # imm = 0x14D8
movq %rax, 0x6b8(%rsp)
movq %rdi, %rax
addq $0x14e0, %rax # imm = 0x14E0
movq ... | /qicosmos[P]cinatra/include/cinatra/coro_http_connection.hpp |
cinatra::coro_http_server::start_one(std::shared_ptr<cinatra::coro_http_connection>) (.destroy) | async_simple::coro::Lazy<void> start_one(
std::shared_ptr<coro_http_connection> conn) noexcept {
co_await conn->start();
} | subq $0xd8, %rsp
movq %rdi, 0x68(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rdi, %rax
addq $0x40, %rax
movq %rax, 0x70(%rsp)
movq %rdi, %rax
addq $0x30, %rax
movq %rax, 0x78(%rsp)
movq %rdi, %rax
addq $0x59, %rax
movq %rax, 0x80(%rsp)
movq %rdi, %rax
addq $0x48, %rax
movq %rax, 0x88(%rsp)
movq %rdi, %rax
addq $0x50, %rax
movq %... | /qicosmos[P]cinatra/include/cinatra/coro_http_server.hpp |
asio::detail::posix_thread::posix_thread<asio::detail::scheduler::thread_function>(asio::detail::scheduler::thread_function, unsigned int) | posix_thread(Function f, unsigned int = 0)
: joined_(false)
{
start_thread(new func<Function>(f));
} | subq $0x48, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3aae0
movq 0x8(%rsp), %rax
movb $0x0, 0x8(%rax)
movl $0x10, %edi
callq 0x13560
movq %rax, 0x10(%rsp)
jmp 0x3e7cb
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x... | /qicosmos[P]cinatra/include/asio/detail/posix_thread.hpp |
asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::cancel(asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::imp... | std::size_t cancel(implementation_type& impl, asio::error_code& ec)
{
if (!impl.might_have_pending_waits)
{
ec = asio::error_code();
return 0;
}
ASIO_HANDLER_OPERATION((scheduler_.context(),
"deadline_timer", &impl, 0, "cancel"));
std::size_t count = scheduler_.cancel_timer... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
testb $0x1, 0x8(%rax)
jne 0x46a33
leaq 0x38(%rsp), %rdi
callq 0x38f80
movq 0x48(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%r... | /qicosmos[P]cinatra/include/asio/detail/deadline_timer_service.hpp |
void asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::async_wait<coro_io::ExecutorWrapper<asio::io_context::basic_executor_type<std::allocator<void>, 0ul>>::schedule(std::function<void ()>, std::chrono::duration<lo... | void async_wait(implementation_type& impl,
Handler& handler, const IoExecutor& io_ex)
{
typename associated_cancellation_slot<Handler>::type slot
= asio::get_associated_cancellation_slot(handler);
// Allocate and construct an operation to wrap the handler.
typedef wait_handler<Handler, IoExec... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x47380
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rdi
callq 0x473d0
movq %rax, 0x40(%rsp)
movq $0x0, 0... | /qicosmos[P]cinatra/include/asio/detail/deadline_timer_service.hpp |
asio::execution::any_executor<asio::execution::context_as_t<asio::execution_context&>, asio::execution::detail::blocking::never_t<0>, asio::execution::prefer_only<asio::execution::detail::blocking::possibly_t<0>>, asio::execution::prefer_only<asio::execution::detail::outstanding_work::tracked_t<0>>, asio::execution::pr... | any_executor(any_executor&& other) ASIO_NOEXCEPT
: detail::any_executor_base(
static_cast<any_executor_base&&>(
static_cast<any_executor_base&>(other))),
prop_fns_(other.prop_fns_)
{
other.prop_fns_ = prop_fns_table<void>();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x47ce0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, 0x30(%rax)
callq 0x47d80
movq %rax, 0x10(%rsp)
jmp 0x47cc0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
m... | /qicosmos[P]cinatra/include/asio/execution/any_executor.hpp |
asio::execution::detail::any_executor_base::target_fns const* asio::execution::detail::any_executor_base::target_fns_table<void>(std::enable_if<is_same<void, void>::value, void>::type*) | static const target_fns* target_fns_table(
typename enable_if<
is_same<Ex, void>::value
>::type* = 0)
{
static const target_fns fns =
{
&any_executor_base::target_type_void,
&any_executor_base::equal_void,
&any_executor_base::execute_void,
&any_executor_base::blocki... | movq %rdi, -0x8(%rsp)
leaq 0xe0f04(%rip), %rax # 0x128cb0
retq
nopl (%rax)
| /qicosmos[P]cinatra/include/asio/execution/any_executor.hpp |
void asio::detail::thread_info_base::deallocate<asio::detail::thread_info_base::executor_function_tag>(asio::detail::thread_info_base::executor_function_tag, asio::detail::thread_info_base*, void*, unsigned long) | static void deallocate(Purpose, thread_info_base* this_thread,
void* pointer, std::size_t size)
{
if (size <= chunk_size * UCHAR_MAX)
{
if (this_thread)
{
for (int mem_index = Purpose::begin_mem_index;
mem_index < Purpose::end_mem_index; ++mem_index)
{
i... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x3fc, 0x18(%rsp) # imm = 0x3FC
ja 0x4996c
cmpq $0x0, 0x28(%rsp)
je 0x4996a
movl $0x4, 0x14(%rsp)
cmpl $0x6, 0x14(%rsp)
jge 0x49968
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x49959
movq 0x20(%... | /qicosmos[P]cinatra/include/asio/detail/thread_info_base.hpp |
void asio::io_context::basic_executor_type<std::allocator<void>, 0ul>::execute<asio::detail::executor_function>(asio::detail::executor_function&&) const | void io_context::basic_executor_type<Allocator, Bits>::execute(
ASIO_MOVE_ARG(Function) f) const
{
typedef typename decay<Function>::type function_type;
// Invoke immediately if the blocking.possibly property is enabled and we are
// already inside the thread pool.
if ((bits() & blocking_never) == 0 && con... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x42df0
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x4d420
movq 0x18(%rsp), %rdi
callq 0x42e10
movq 0x8(%rax), %rdi
callq 0x42e30
testb $0x1, %al
jne 0x4d337
jmp 0x4d420
movq 0x58(%rsp), %rsi
leaq 0x50(%rsp), %rdi
ca... | /qicosmos[P]cinatra/include/asio/impl/io_context.hpp |
asio::detail::executor_op<asio::detail::executor_function, std::allocator<void>, asio::detail::scheduler_operation>::do_complete(void*, asio::detail::scheduler_operation*, std::error_code const&, unsigned long) | static void do_complete(void* owner, Operation* base,
const asio::error_code& /*ec*/,
std::size_t /*bytes_transferred*/)
{
// Take ownership of the handler object.
executor_op* o(static_cast<executor_op*>(base));
Alloc allocator(o->allocator_);
ptr p = { detail::addressof(allocator), o, o ... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x3f(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rsi
addq $0x18, %rsi
... | /qicosmos[P]cinatra/include/asio/detail/executor_op.hpp |
void asio::io_context::basic_executor_type<std::allocator<void>, 4ul>::execute<asio::detail::executor_function_view&>(asio::detail::executor_function_view&) const | void io_context::basic_executor_type<Allocator, Bits>::execute(
ASIO_MOVE_ARG(Function) f) const
{
typedef typename decay<Function>::type function_type;
// Invoke immediately if the blocking.possibly property is enabled and we are
// already inside the thread pool.
if ((bits() & blocking_never) == 0 && con... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4f5b0
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x4f6ed
movq 0x20(%rsp), %rdi
callq 0x4f0c0
movq 0x8(%rax), %rdi
callq 0x42e30
testb $0x1, %al
jne 0x4f647
jmp 0x4f6ed
movq 0x68(%rsp), %rsi
leaq 0x58(%rsp), %rdi
ca... | /qicosmos[P]cinatra/include/asio/impl/io_context.hpp |
void asio::execution::detail::any_executor_base::query_fn_non_void<asio::io_context::basic_executor_type<std::allocator<void>, 4ul>, asio::execution::prefer_only<asio::execution::detail::relationship::fork_t<0>>>(void*, void const*, void const*, std::enable_if<asio::can_query<asio::io_context::basic_executor_type<std::... | static void query_fn_non_void(void* result, const void* ex, const void* prop,
typename enable_if<
asio::can_query<const Ex&, const Prop&>::value
&& !is_same<typename Prop::polymorphic_query_result_type, void>::value
&& !is_reference<typename Prop::polymorphic_query_result_type>::value
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x4, %edi
callq 0x13560
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x8c085(%rip), %rdi # 0xdcc9c
callq 0x50c60
movl %eax, 0x8(%rsp)
jmp 0x50c22
movq (%rsp), %rcx
movl 0x8(%rsp), %ea... | /qicosmos[P]cinatra/include/asio/execution/any_executor.hpp |
coro_io::io_context_pool::stop()::'lambda'()::operator()() const | void stop() {
std::call_once(flag_, [this] {
bool has_run_or_stop = false;
bool ok = has_run_or_stop_.compare_exchange_strong(has_run_or_stop, true);
work_.clear();
if (ok) {
// clear all unfinished work
for (auto &e : io_contexts_) {
e->run();
}
r... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rdi
movq %rdi, 0x10(%rsp)
movb $0x0, 0x5f(%rsp)
addq $0x68, %rdi
leaq 0x5f(%rsp), %rsi
movl $0x1, %edx
movl $0x5, %ecx
callq 0x5a230
movq 0x10(%rsp), %rdi
andb $0x1, %al
movb %al, 0x5e(%rsp)
addq $0x30, %rdi
callq 0x5a810
testb $0x1, 0x5e(%rsp)
... | /qicosmos[P]cinatra/include/cinatra/ylt/coro_io/io_context_pool.hpp |
asio::detail::epoll_reactor::descriptor_state* asio::detail::object_pool<asio::detail::epoll_reactor::descriptor_state>::alloc<bool>(bool) | Object* alloc(Arg arg)
{
Object* o = free_list_;
if (o)
free_list_ = object_pool_access::next(free_list_);
else
o = object_pool_access::create<Object>(arg);
object_pool_access::next(o) = live_list_;
object_pool_access::prev(o) = 0;
if (live_list_)
object_pool_access::prev(li... | subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x625cc
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3d910
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq (%rcx), %r... | /qicosmos[P]cinatra/include/asio/detail/object_pool.hpp |
cinatra::coro_http_server::start_one(std::shared_ptr<cinatra::coro_http_connection>) | async_simple::coro::Lazy<void> start_one(
std::shared_ptr<coro_http_connection> conn) noexcept {
co_await conn->start();
} | subq $0x148, %rsp # imm = 0x148
movq %rdx, 0xb0(%rsp)
movq %rdi, 0xb8(%rsp)
movq %rdi, %rax
movq %rax, 0xc0(%rsp)
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movq %rdx, 0x128(%rsp)
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movq %rax, 0xc8(%rsp)
jne 0x6719d
movq 0xc8(%rsp), %rax
movq %rax, 0xa8(%rsp)
j... | /qicosmos[P]cinatra/include/cinatra/coro_http_server.hpp |
auto async_simple::coro::detail::getAwaiter<coro_io::callback_awaitor_base<std::error_code, coro_io::callback_awaitor<std::error_code>>::callback_awaitor_impl<coro_io::async_accept(asio::basic_socket_acceptor<asio::ip::tcp, asio::any_io_executor>&, asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>&)::'lam... | auto getAwaiter(Awaitable&& awaitable) {
if constexpr (HasMemberCoAwaitOperator<Awaitable>)
return std::forward<Awaitable>(awaitable).operator co_await();
else if constexpr (HasGlobalCoAwaitOperator<Awaitable>)
return operator co_await(std::forward<Awaitable>(awaitable));
else
return... | movq %rdi, -0x20(%rsp)
movq -0x20(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rdx
retq
nopl (%rax)
| /qicosmos[P]cinatra/include/async_simple/coro/Traits.h |
asio::detail::reactive_socket_service_base::reactor_op_cancellation& asio::cancellation_slot::emplace<asio::detail::reactive_socket_service_base::reactor_op_cancellation, asio::detail::epoll_reactor*, asio::detail::epoll_reactor::descriptor_state**, int&, asio::detail::epoll_reactor::op_types>(asio::detail::epoll_react... | CancellationHandler& emplace(ASIO_MOVE_ARG(Args)... args)
{
typedef detail::cancellation_handler<CancellationHandler>
cancellation_handler_type;
auto_delete_helper del = { prepare_memory(
sizeof(cancellation_handler_type),
ASIO_ALIGNOF(CancellationHandler)) };
cancellation_handler_ty... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x28, %esi
movl $0x8, %edx
callq 0x49db0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x38(%rsp),... | /qicosmos[P]cinatra/include/asio/cancellation_signal.hpp |
asio::detail::reactive_socket_accept_op<asio::basic_socket<asio::ip::tcp, asio::any_io_executor>, asio::ip::tcp, auto coro_io::async_accept(asio::basic_socket_acceptor<asio::ip::tcp, asio::any_io_executor>&, asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>&)::'lambda'(auto)::operator()<coro_io::callback_... | static void do_complete(void* owner, operation* base,
const asio::error_code& /*ec*/,
std::size_t /*bytes_transferred*/)
{
// Take ownership of the handler object.
reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
ptr p = { asio::detail::addressof(o->handler_), o, o ... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x70, %rax
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, 0xa0(%rsp)
... | /qicosmos[P]cinatra/include/asio/detail/reactive_socket_accept_op.hpp |
asio::detail::reactive_socket_accept_op_base<asio::basic_socket<asio::ip::tcp, asio::any_io_executor>, asio::ip::tcp>::do_assign() | void do_assign()
{
if (new_socket_.get() != invalid_socket)
{
if (peer_endpoint_)
peer_endpoint_->resize(addrlen_);
peer_.assign(protocol_, new_socket_.get(), ec_);
if (!ec_)
new_socket_.release();
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x48, %rdi
callq 0x622b0
cmpl $-0x1, %eax
je 0x68cf0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x68c83
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x68(%rax), %rsi
callq 0x608d0
movq 0x10(%rsp), %rdi
movq 0x50(%rdi), %rax... | /qicosmos[P]cinatra/include/asio/detail/reactive_socket_accept_op.hpp |
asio::detail::reactive_socket_accept_op_base<asio::basic_socket<asio::ip::tcp, asio::any_io_executor>, asio::ip::tcp>::do_perform(asio::detail::reactor_op*) | static status do_perform(reactor_op* base)
{
reactive_socket_accept_op_base* o(
static_cast<reactive_socket_accept_op_base*>(base));
socket_type new_socket = invalid_socket;
status result = socket_ops::non_blocking_accept(o->socket_,
o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data(... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movb 0x44(%rax), %al
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x69924
movq... | /qicosmos[P]cinatra/include/asio/detail/reactive_socket_accept_op.hpp |
asio::basic_streambuf<std::allocator<char>>::data() const | const_buffers_type data() const ASIO_NOEXCEPT
{
return asio::buffer(asio::const_buffer(gptr(),
(pptr() - gptr()) * sizeof(char_type)));
} | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x13160
movq %rax, 0x28(%rsp)
jmp 0x78eff
movq 0x20(%rsp), %rdi
callq 0x13150
movq %rax, 0x18(%rsp)
jmp 0x78f10
movq 0x20(%rsp), %rdi
callq 0x13160
movq %rax, 0x10(%rsp)
jmp 0x78f21
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rax
movq ... | /qicosmos[P]cinatra/include/asio/basic_streambuf.hpp |
cinatra::coro_http_connection::reply(bool) | async_simple::coro::Lazy<bool> reply(bool need_to_bufffer = true) {
std::error_code ec;
size_t size;
if (multi_buf_) {
if (need_to_bufffer) {
response_.to_buffers(buffers_, chunk_size_str_);
}
std::tie(ec, size) = co_await async_write(buffers_);
}
else {
if (need_to_b... | subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, 0x148(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x150(%rsp)
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
andb $0x1, %al
movb %al, 0x287(%rsp)
movq 0x288(%rsp), %rax
movq %rax, 0x158(%rsp)
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movq %rax, 0x160(%rsp)
jn... | /qicosmos[P]cinatra/include/cinatra/coro_http_connection.hpp |
async_simple::coro::Lazy<std::pair<std::error_code, unsigned long>>::coAwait(async_simple::Executor*) | auto coAwait(Executor* ex) {
logicAssert(this->_coro.operator bool(),
"Lazy do not have a coroutine_handle "
"Maybe the allocation failed or you're using a used Lazy");
// derived lazy inherits executor
this->_coro.promise()._executor = ex;
return... | subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7d500
movzbl %al, %edi
andl $0x1, %edi
leaq 0x5df29(%rip), %rsi # 0xdb295
callq 0x637d0
movq 0x8(%rsp), %rdi
movq 0x30(%rs... | /qicosmos[P]cinatra/include/async_simple/coro/Lazy.h |
auto async_simple::coro::detail::getAwaiter<coro_io::callback_awaitor_base<std::pair<std::error_code, unsigned long>, coro_io::callback_awaitor<std::pair<std::error_code, unsigned long>>>::callback_awaitor_impl<async_simple::coro::Lazy<std::pair<std::error_code, unsigned long>> coro_io::async_read_until<asio::basic_str... | auto getAwaiter(Awaitable&& awaitable) {
if constexpr (HasMemberCoAwaitOperator<Awaitable>)
return std::forward<Awaitable>(awaitable).operator co_await();
else if constexpr (HasGlobalCoAwaitOperator<Awaitable>)
return operator co_await(std::forward<Awaitable>(awaitable));
else
return... | movq %rdi, -0x20(%rsp)
movq -0x20(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rdx
retq
nopl (%rax)
| /qicosmos[P]cinatra/include/async_simple/coro/Traits.h |
asio::detail::write_op<asio::basic_stream_socket<asio::ip::tcp, asio::any_io_executor>, asio::mutable_buffers_1, asio::mutable_buffer const*, asio::detail::transfer_all_t, auto async_simple::coro::Lazy<std::pair<std::error_code, unsigned long>> coro_io::async_write<asio::basic_stream_socket<asio::ip::tcp, asio::any_io_... | write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
CompletionCondition& completion_condition, WriteHandler& handler)
: base_from_cancellation_state<WriteHandler>(
handler, enable_partial_cancellation()),
base_from_completion_cond<CompletionCondition>(completion_condit... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rsi
callq 0xa0270
movq (%rsp), %rdi
callq 0x8b350
movq (%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq 0x20(%r... | /qicosmos[P]cinatra/include/asio/impl/write.hpp |
Imf_3_4::checkOpenEXRFile(char const*, bool, bool, bool) | bool
checkOpenEXRFile (
const char* fileName, bool reduceMemory, bool reduceTime, bool runCoreCheck)
{
if (runCoreCheck)
{
return runCoreChecks (fileName, reduceMemory, reduceTime);
}
else { return runChecks (fileName, reduceMemory, reduceTime); }
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0x10bf1
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfCheckFile.cpp |
Imf_3_4::checkOpenEXRFile(char const*, unsigned long, bool, bool, bool) | bool
checkOpenEXRFile (
const char* data,
size_t numBytes,
bool reduceMemory,
bool reduceTime,
bool runCoreCheck)
{
if (runCoreCheck)
{
return runCoreChecks (data, numBytes, reduceMemory, reduceTime);
}
else
{
PtrIStream stream (data, nu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testl %r8d, %r8d
je 0x11292
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfCheckFile.cpp |
Imf_3_4::TypedDeepImageChannel<Imath_3_2::half>::resetBasePointer() | ImageLevel& level () { return _level; } | movq 0x8(%rdi), %rax
movq 0x30(%rdi), %rcx
movslq 0x1c(%rax), %rdx
movslq 0x1c(%rdi), %rsi
imulq %rdx, %rsi
shlq $0x3, %rsi
subq %rsi, %rcx
movslq 0x18(%rax), %rax
shlq $0x3, %rax
subq %rax, %rcx
movq %rcx, 0x38(%rdi)
retq
nop
| /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImageChannel.h |
Imf_3_4::TypedDeepImageChannel<float>::initializeSampleLists() | void
TypedDeepImageChannel<T>::initializeSampleLists ()
{
//
// Allocate a new set of sample lists for this channel, and
// construct zero-filled sample lists for the pixels.
//
delete[] _sampleBuffer;
_sampleBuffer = 0; // set to 0 to prevent double deletion
// in case ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x16f42
callq 0xfcd0
movq $0x0, 0x40(%rbx)
movq 0x8(%rbx), %rax
movq 0x88(%rax), %r14
movq 0xa0(%rax), %r15
movq 0xb8(%rax), %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sb... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageChannel.cpp |
Imf_3_4::TypedDeepImageChannel<float>::resize() | void
TypedDeepImageChannel<T>::resize ()
{
DeepImageChannel::resize ();
delete[] _sampleListPointers;
_sampleListPointers = 0;
_sampleListPointers = new T*[numPixels ()];
initializeSampleLists ();
} | pushq %rbx
movq %rdi, %rbx
callq 0xfbc0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x16ff1
callq 0xfcd0
movq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0xf040
movq %rax, 0x30(%rbx)
movq (%rbx), %rax
movq %rbx, %rd... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageChannel.cpp |
Imf_3_4::TypedDeepImageChannel<unsigned int>::resize() | void
TypedDeepImageChannel<T>::resize ()
{
DeepImageChannel::resize ();
delete[] _sampleListPointers;
_sampleListPointers = 0;
_sampleListPointers = new T*[numPixels ()];
initializeSampleLists ();
} | pushq %rbx
movq %rdi, %rbx
callq 0xfbc0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1744f
callq 0xfcd0
movq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0xf040
movq %rax, 0x30(%rbx)
movq (%rbx), %rax
movq %rbx, %rd... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageChannel.cpp |
Imf_3_4::loadDeepImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Imf_3_4::Header&, Imf_3_4::DeepImage&) | void
loadDeepImage (const string& fileName, Header& hdr, DeepImage& img)
{
bool tiled, deep, multiPart;
if (!isOpenExrFile (fileName.c_str (), tiled, deep, multiPart))
{
THROW (
ArgExc,
"Cannot load image file " << fileName
<< ". "
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x5(%rsp), %rsi
leaq 0x7(%rsp), %rdx
leaq 0x6(%rsp), %rcx
callq 0xf770
testb %al, %al
je 0x17cb9
cmpb $0x1, 0x6(%rsp)
je 0x17d39
cmpb $0x0, 0x7(%rsp)
j... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageIO.cpp |
Imf_3_4::DeepImageLevel::moveSamplesToNewBuffer(unsigned int const*, unsigned int const*, unsigned long const*) | void
DeepImageLevel::moveSamplesToNewBuffer (
const unsigned int* oldNumSamples,
const unsigned int* newNumSamples,
const size_t* newSampleListPositions)
{
for (ChannelMap::iterator j = _channels.begin (); j != _channels.end ();
++j)
{
j->second->moveSamplesToNewBuffer (
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r12
movq 0x40(%rdi), %r13
addq $0x30, %r12
cmpq %r12, %r13
je 0x18c3d
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x40(%r13), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x38(%rax)
movq %r13, %rdi
callq 0xf6f0
... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageLevel.cpp |
Imf_3_4::DeepImageLevel::shiftPixels(int, int) | void
DeepImageLevel::shiftPixels (int dx, int dy)
{
ImageLevel::shiftPixels (dx, dy);
_sampleCounts.resetBasePointer ();
for (ChannelMap::iterator i = _channels.begin (); i != _channels.end ();
++i)
i->second->resetBasePointer ();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf670
leaq 0x58(%rbx), %rdi
callq 0xfa70
movq 0x40(%rbx), %r14
addq $0x30, %rbx
cmpq %rbx, %r14
je 0x18cfe
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %r14, %rdi
callq 0xf6f0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x18ce4
addq $0x8, %rsp
popq %rbx
... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfDeepImageLevel.cpp |
Imf_3_4::TypedFlatImageChannel<Imath_3_2::half>::resize() | void
TypedFlatImageChannel<T>::resize ()
{
delete[] _pixels;
_pixels = 0;
FlatImageChannel::resize (); // may throw an exception
_pixels = new T[numPixels ()];
for (size_t i = 0; i < numPixels (); ++i)
_pixels[i] = T (0);
resetBasePointer ();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x19eb0
callq 0xfcd0
movq $0x0, 0x30(%rbx)
movq %rbx, %rdi
callq 0xfbc0
movq 0x28(%rbx), %r15
leaq (%r15,%r15), %r14
testq %r15, %r15
movq $-0x1, %rdi
cmovnsq %r14, %rdi
callq 0xf040
movq %rax, 0x30(%rbx)
testq %r15, %r15
je 0x19... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfFlatImageChannel.cpp |
Imf_3_4::TypedFlatImageChannel<unsigned int>::resize() | void
TypedFlatImageChannel<T>::resize ()
{
delete[] _pixels;
_pixels = 0;
FlatImageChannel::resize (); // may throw an exception
_pixels = new T[numPixels ()];
for (size_t i = 0; i < numPixels (); ++i)
_pixels[i] = T (0);
resetBasePointer ();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x1a34e
callq 0xfcd0
movq $0x0, 0x30(%rbx)
movq %rbx, %rdi
callq 0xfbc0
movq 0x28(%rbx), %r15
movq %r15, %rax
shrq $0x3e, %rax
leaq (,%r15,4), %r14
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r14, %rdi
callq 0xf040
movq %rax, ... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfFlatImageChannel.cpp |
Imf_3_4::saveFlatTiledImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Imf_3_4::Header const&, Imf_3_4::FlatImage const&, Imf_3_4::DataWindowSource) | void
saveFlatTiledImage (
const string& fileName,
const Header& hdr,
const FlatImage& img,
DataWindowSource dws)
{
Header newHdr;
for (Header::ConstIterator i = hdr.begin (); i != hdr.end (); ++i)
{
if (strcmp (i.name (), "dataWindow") && strcmp (i.name (), "tiles") &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, 0x24(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
movq %rsp, %rcx
movq $0x0, (%rcx)
leaq 0x30(%rsp), %rdi
movss 0x5dff(%rip), %xmm0 # 0x20284
movl $0x40, %esi
movl $0x40, %edx
movaps %xmm0, %xmm1
xorl %r8d, ... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfFlatImageIO.cpp |
Imf_3_4::FlatImageLevel::channel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | FlatImageChannel&
FlatImageLevel::channel (const string& name)
{
ChannelMap::iterator i = _channels.find (name);
if (i == _channels.end ()) throwBadChannelName (name);
return *i->second;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rdi
callq 0xfd70
movq %rax, %r15
leaq 0x30(%r14), %rax
cmpq %rax, %r15
jne 0x1b99f
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfb40
movq 0x40(%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfFlatImageLevel.cpp |
Imf_3_4::Image::Image() | Image::Image ()
: _dataWindow (Box2i (V2i (0, 0), V2i (-1, -1)))
, _levelMode (ONE_LEVEL)
, _levelRoundingMode (ROUND_DOWN)
, _channels ()
, _levels ()
{
// empty
} | movq 0xdbf9(%rip), %rax # 0x29fd0
addq $0x10, %rax
movq %rax, (%rdi)
movaps 0x3ddb(%rip), %xmm0 # 0x201c0
movups %xmm0, 0x8(%rdi)
leaq 0x28(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movups %xmm0, 0x48(%r... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImage.cpp |
Imf_3_4::Image::eraseChannel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
Image::eraseChannel (const std::string& name)
{
//
// Note: eraseChannel() is called to clean up if an exception is
// thrown during a call during insertChannel(), so eraseChannel()
// must work correctly even after an incomplete insertChannel()
// operation.
//
for (int y = 0; y < _le... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x50(%rdi)
jle 0x1d02f
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x58(%rbx), %rax
testq %rax, %rax
jle 0x1d022
xorl %r13d, %r13d
imulq %r15, %rax
addq 0x60(%rbx), %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x1d016
mo... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImage.cpp |
void Imf_3_4::renameChannelsInMap<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Imf_3_4::Image::ChannelInfo, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<ch... | inline void
renameChannelsInMap (const RenamingMap& oldToNewNames, ChannelMap& channels)
{
ChannelMap renamedChannels;
for (typename ChannelMap::const_iterator i = channels.begin ();
i != channels.end ();
++i)
{
RenamingMap::const_iterator j = oldToNewNames.find (i->first);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x40(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0x18(%rsi), %r15
movq %rsi, 0x10(%rsp)
leaq 0x8(%rsi), %rbx
cmpq %rb... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImageChannelRenaming.h |
Imf_3_4::loadImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Imf_3_4::Header&) | Image*
loadImage (const string& fileName, Header& hdr)
{
bool tiled, deep, multiPart;
if (!isOpenExrFile (fileName.c_str (), tiled, deep, multiPart))
{
THROW (
ArgExc,
"Cannot load image file " << fileName
<< ". "
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xd(%rsp), %rsi
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0xf770
testb %al, %al
je 0x1ec69
cmpb $0x1, 0xe(%rsp)
je 0x1ece9
movq (%rbx), %r15
callq 0xf310
leaq 0x10(%rsp), %... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImageIO.cpp |
Imf_3_4::ImageLevel::throwBadChannelNameOrType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void
ImageLevel::throwBadChannelNameOrType (const string& name) const
{
THROW (
ArgExc,
"Image channel \"" << name
<< "\" does not exist "
"or is not of the expected type.");
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %rbx
callq 0xfd00
movq %rsp, %rdi
callq 0xf700
leaq 0x10(%rsp), %r14
leaq 0x19d6(%rip), %rsi # 0x20b70
movl $0xf, %edx
movq %r14, %rdi
callq 0xfb70
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xfb70
leaq 0x19c3(%rip), %rsi... | /AcademySoftwareFoundation[P]openexr/src/lib/OpenEXRUtil/ImfImageLevel.cpp |
slab_assert | static inline void
slab_assert(struct slab_cache *cache, struct slab *slab)
{
(void) slab;
assert(pthread_equal(cache->thread_id, pthread_self()));
assert(slab->magic == slab_magic);
assert(slab->order <= cache->order_max + 1);
if (slab->order <= cache->order_max) {
size_t size = slab_order_size(cache, slab->ord... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x250(%rdi), %r15
callq 0x2170
movq %r15, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
je 0x353e
cmpl $0xeec0ffee, 0x28(%rbx) # imm = 0xEEC0FFEE
jne 0x3557
movzbl 0x2c(%rbx), %eax
movzbl 0xd(%r14), %ecx
lea... | /tarantool[P]small/small/slab_cache.c |
clog::AsyncLogger::start() | void AsyncLogger::start()
{
running_ = true;
thread_ = std::thread([this](){ this->threadFunc(); });
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
movl $0x10, %edi
callq 0x41d0
leaq 0x65f1(%rip), %rcx # 0xad38
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
xorl %edx, %edx
callq 0x41b0
movq 0x8(%rsp... | /bigYellowDuck[P]clog/AsyncLogger.cpp |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x1718
movl $0x6, %edi
leaq 0xa8a(%rip), %rsi # 0x21ae
callq 0x1090
cmpl $0x2, -0x8(%rbp)
jge 0x1750
movq 0x28aa(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xa75(%rip), %rsi # 0x21b5
movb... | /komeilkma[P]curl/tests/libtest/first.c |
spdlog::details::T_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 8;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_hour, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_min, dest);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x8(%rdi), %rdx
leaq 0x18(%rsp), %rdi
movl $0x8, %esi
callq 0x3d0ca
movl 0x8(%r14), %r15d
cmpq $0x63, %r15
ja 0x3f090
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3f031
movq (%rbx), %rax
movq %rbx, %rdi
call... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
opts::BasicOption::parse(int, char**, int&, int, std::function<bool (char)>) | bool
BasicOption::parse(int argc, char** argv, int& i, int j, IsShort is_short)
{
char* argument;
char* cur_arg = argv[i];
// -v...
if (argv[i][j] == '\0')
{
// -v data
if (i + 1 < argc && (argv[i+1][0] != '-' || Options::dashed_non_option(argv[i+1], is_short)))
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdi, %r12
movslq (%rcx), %rcx
movq (%rdx,%rcx,8), %rbx
movslq %r8d, %rbp
leaq (%rbx,%rbp), %r13
movzbl (%rbx,%rbp), %eax
cmpl $0x3d, %eax
je 0x6ea5
movq %rdx, %r14
testl %eax, %eax
jne 0x6eaa
leaq 0x1(%rcx), %rax
cm... | /diatomic[P]diy/examples/opts.h |
opts::Options::parse(int, char**) | bool
Options::parse(int argc, char** argv)
{
std::map<char, BasicOption*> short_opts;
std::map<std::string, BasicOption*> long_opts;
for (auto& opt : options)
{
if (opt->s)
short_opts[opt->s] = opt.get();
long_opts[opt->l] = opt.get();
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdx, %rbx
movl %esi, 0x14(%rsp)
movq %rdi, %r14
leaq 0x40(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x110(%rsp), %rax
andl $0... | /diatomic[P]diy/examples/opts.h |
main | int main(int argc, char** argv)
{
// initialize MPI
diy::mpi::environment env(argc, argv); // equivalent of MPI_Init(argc, argv)/MPI_Finalize()
diy::mpi::communicator world; // equivalent of MPI_COMM_WORLD
int tot_blocks = world.size(); // default number of global blocks... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1810, %rsp # imm = 0x1810
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x24(%rsp), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x7f90
leaq 0x50(%rsp), %rdi
callq 0x7fb4
movl 0x5c(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x188(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
and... | /diatomic[P]diy/tests/custom-bounds-load.cpp |
diy::mpi::environment::environment(int, char**) | diy::mpi::environment::environment(int argc, char* argv[])
{
#if DIY_HAS_MPI
MPI_Init_thread(&argc, &argv, MPI_THREAD_FUNNELED, &provided_threading);
#else
(void) argc; (void) argv;
provided_threading = MPI_THREAD_FUNNELED;
#endif
} | subq $0x18, %rsp
movq %rdi, %rcx
leaq 0xc(%rsp), %rdi
movl %esi, (%rdi)
leaq 0x10(%rsp), %rsi
movq %rdx, (%rsi)
pushq $0x1
popq %rdx
callq 0x60b0
addq $0x18, %rsp
retq
nop
| /diatomic[P]diy/include/diy/mpi/environment.cpp |
opts::operator<<(std::ostream&, opts::Options const&) | std::ostream&
operator<<(std::ostream& out, const Options& ops)
{
int max_long = 0;
for (auto& cur : ops.options)
{
int cur_long = cur->long_size();
if (cur_long > max_long)
max_long = cur_long;
}
out << "Options:\n";
for (... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %r14
xorl %ebp, %ebp
movq %r14, %rax
movq (%rax), %rax
cmpq %r14, %rax
je 0x813b
movq 0x10(%rax), %rcx
movl 0x18(%rcx), %edx
movl 0x58(%rcx), %ecx
addl %edx, %ecx
incl %ecx
cmpl %ecx, %ebp
cmovlel %ecx, %ebp
jmp 0x811e
le... | /diatomic[P]diy/examples/opts.h |
diy::Master::Master(diy::mpi::communicator, int, int, std::function<void* ()>, std::function<void (void*)>, diy::ExternalStorage*, std::function<void (void const*, diy::BinaryBuffer&)>, std::function<void (void*, diy::BinaryBuffer&)>, diy::Master::QueuePolicy*) | diy::Master::
Master(mpi::communicator comm,
int threads__,
int limit__,
CreateBlock create_,
DestroyBlock destroy_,
ExternalStorage* storage,
SaveBlock save,
LoadBlock load_,
QueuePol... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x27a8, %rsp # imm = 0x27A8
movq %r9, %r14
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x78(%rsp), %rdi
movq %r8, %rsi
callq 0x8d9e
leaq 0x58(%rsp), %... | /diatomic[P]diy/include/diy/master.hpp |
void diy::Master::foreach<void (Block::*)(diy::Master::ProxyWithLink const&)>(void (Block::* const&)(diy::Master::ProxyWithLink const&), std::function<bool (int, diy::Master const&)> const&) | mpi::communicator& communicator() { return comm_; } | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq (%rsi), %rax
testq %rax, %rax
je 0x86d8
movq 0x8(%rsi), %rcx
movq %rax, (%rsp)
movq %rcx, 0x8(%rsp)
leaq 0x1ce25(%rip), %rax # 0x254ec
movq %rax, 0x18(%rsp)
leaq 0x1ce1f(%rip), %rax # 0x254f2
movq %rax, 0x10(%rsp)
... | /diatomic[P]diy/include/diy/master.hpp |
Block::print_data(diy::Master::ProxyWithLink const&) | void print_data(const diy::Master::ProxyWithLink& cp)
{
fmt::print(stderr, "gid {}:\n", cp.gid());
for (size_t i = 0; i < vals.size(); i++)
fmt::print(stderr, "{} ", vals[i]);
fmt::print(stderr, "\n");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x388a7(%rip), %r15 # 0x40fc0
movq (%r15), %rdi
movl (%rsi), %eax
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x1fdd2(%rip), %rsi # 0x284fe
callq 0xd3da
xorl %r12d, %r12d
leaq 0x1fdcc(%rip), %r14 # 0x28507
xorl %r13... | /diatomic[P]diy/tests/custom-bounds-load.cpp |
diy::Master::~Master() | diy::Master::
~Master()
{
set_immediate(true);
clear();
delete queue_policy_;
} | pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x1a60a
movq %rbx, %rdi
callq 0x1a638
movq 0x148(%rbx), %rdi
testq %rdi, %rdi
je 0x87aa
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x230(%rbx), %rdi
callq 0x93c6
leaq 0x228(%rbx), %rdi
callq 0x9558
leaq 0x200(%rbx), %rdi
callq 0x904e
leaq 0x1e8(%rbx), %rdi
callq 0x907... | /diatomic[P]diy/include/diy/master.hpp |
diy::Factory<diy::Link>::Registrar<diy::AMRLink>::registerT() | static bool registerT()
{
const auto name = typeid(T).name();
Factory::data()[name] = [](Args... args) -> Base*
{
return new T(std::forward<Args>(args)...);
};
return true;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0xb526
movq %rax, %rbx
leaq 0x20fd3(%rip), %rsi # 0x2985d
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae2
leaq 0x15276(%rip), %rcx # 0x1db24
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x6230
movb ... | /diatomic[P]diy/include/diy/factory.hpp |
diy::Factory<diy::Link>::Registrar<diy::RegularLink<diy::Bounds<int>>>::registerT() | static bool registerT()
{
const auto name = typeid(T).name();
Factory::data()[name] = [](Args... args) -> Base*
{
return new T(std::forward<Args>(args)...);
};
return true;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0xb526
movq %rax, %rbx
leaq 0x20fd8(%rip), %rsi # 0x298c8
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae2
leaq 0x1755e(%rip), %rcx # 0x1fe72
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x6230
movb ... | /diatomic[P]diy/include/diy/factory.hpp |
diy::Factory<diy::Link>::Registrar<diy::RegularLink<diy::Bounds<float>>>::registerT() | static bool registerT()
{
const auto name = typeid(T).name();
Factory::data()[name] = [](Args... args) -> Base*
{
return new T(std::forward<Args>(args)...);
};
return true;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0xb526
movq %rax, %rbx
leaq 0x20fdf(%rip), %rsi # 0x29935
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae2
leaq 0x187d6(%rip), %rcx # 0x21150
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x6230
movb ... | /diatomic[P]diy/include/diy/factory.hpp |
diy::Factory<diy::Link>::Registrar<diy::RegularLink<diy::Bounds<double>>>::registerT() | static bool registerT()
{
const auto name = typeid(T).name();
Factory::data()[name] = [](Args... args) -> Base*
{
return new T(std::forward<Args>(args)...);
};
return true;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0xb526
movq %rax, %rbx
leaq 0x20fe6(%rip), %rsi # 0x299a2
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae2
leaq 0x1981c(%rip), %rcx # 0x221fc
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x6230
movb ... | /diatomic[P]diy/include/diy/factory.hpp |
diy::Factory<diy::Link>::Registrar<diy::RegularLink<diy::Bounds<long>>>::registerT() | static bool registerT()
{
const auto name = typeid(T).name();
Factory::data()[name] = [](Args... args) -> Base*
{
return new T(std::forward<Args>(args)...);
};
return true;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0xb526
movq %rax, %rbx
leaq 0x20fed(%rip), %rsi # 0x29a0f
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fae2
leaq 0x1a8fe(%rip), %rcx # 0x23344
movq %rcx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x6230
movb ... | /diatomic[P]diy/include/diy/factory.hpp |
opts::BasicOption::output(std::ostream&, int) const | void output(std::ostream& out, int max_long) const
{
out << " ";
if (s)
out << '-' << s << ", ";
else
out << " ";
out << "--" << l << ' ';
if (!t.empty())
out << t;
for (int i = long_size(); i < max_long; ++i)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2101a(%rip), %rsi # 0x29c61
movq %rbx, %rdi
callq 0x6420
cmpb $0x0, 0x8(%r14)
je 0x8c7a
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x64e0
movsbl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x64e0
leaq 0x1f792(%r... | /diatomic[P]diy/examples/opts.h |
diy::Collection::Collection(std::function<void* ()>, std::function<void (void*)>, diy::ExternalStorage*, std::function<void (void const*, diy::BinaryBuffer&)>, std::function<void (void*, diy::BinaryBuffer&)>) | Collection(Create create__,
Destroy destroy__,
ExternalStorage* storage__,
Save save__,
Load load__):
create_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rdi, %rbx
callq 0x8d9e
leaq 0x20(%rbx), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x8de4
movq %r13, 0x40(%rbx)
leaq 0x48(%rbx), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x8... | /diatomic[P]diy/include/diy/collection.hpp |
diy::MemoryBuffer::save_binary_blob(char const*, unsigned long) | static void save(BinaryBuffer& bb, const Vector& v)
{
size_t s = v.size();
diy::save(bb, s);
if (s > 0)
diy::save(bb, &v[0], v.size());
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x37d(%rip), %rax # 0x9ea2
movq %rax, 0x18(%rcx)
leaq 0x374(%rip), %rax # 0x9ea4
movq %rax, 0x10(%rcx)
movq (%rdi), %rax
callq *0x48(%rax)
movq %rsp, %rdi
callq 0x251b0
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
mo... | /diatomic[P]diy/include/diy/serialization.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.