name string | code string | asm string | file string |
|---|---|---|---|
Test_SUNMatScaleAdd2 | int Test_SUNMatScaleAdd2(SUNMatrix A, SUNMatrix B, N_Vector x, N_Vector y,
N_Vector z)
{
int failure;
SUNMatrix C, D, E;
N_Vector u, v;
sunrealtype tol = 100 * SUN_UNIT_ROUNDOFF;
/* create clones for test */
C = SUNMatClone(A);
u = N_VClone(y);
v = N_VClone(y);
/* test 1: ad... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movsd 0x3d9b(%rip), %xmm0 # 0x8070
movsd %xmm0, (%rsp)
movq 0x58(%rsp), %rdi
callq 0x21f0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x20d0
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi... | /opencor[P]sundials/examples/sunmatrix/sparse/test_sunmatrix_sparse.c |
Test_SUNMatScaleAddI2 | int Test_SUNMatScaleAddI2(SUNMatrix A, N_Vector x, N_Vector y)
{
int failure;
SUNMatrix B, C, D;
N_Vector w, z;
sunrealtype tol = 200 * SUN_UNIT_ROUNDOFF;
/* create clones for test */
B = SUNMatClone(A);
z = N_VClone(x);
w = N_VClone(x);
/* test 1: add I to a matrix with insufficient storage */
fa... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movsd 0x34dd(%rip), %xmm0 # 0x8078
movsd %xmm0, (%rsp)
movq 0x48(%rsp), %rdi
callq 0x21f0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x20d0
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x20d0
movq %rax, 0x10(%rsp)
movq 0x4... | /opencor[P]sundials/examples/sunmatrix/sparse/test_sunmatrix_sparse.c |
Test_SUNSparseMatrixToCSC | int Test_SUNSparseMatrixToCSC(SUNMatrix A)
{
int failure;
SUNMatrix csc = NULL, csr = NULL;
sunrealtype tol = 200 * SUN_UNIT_ROUNDOFF;
failure = SUNSparseMatrix_ToCSC(A, &csc);
if (failure)
{
printf(">>> FAILED test -- SUNSparseMatrix_ToCSC returned nonzero\n");
SUNMatDestroy(csr);
return (1);... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movsd 0x2d75(%rip), %xmm0 # 0x8078
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2280
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x5348
leaq 0x3350(%rip), %rdi # 0x867a
movb $0x0, %al
callq 0x20b... | /opencor[P]sundials/examples/sunmatrix/sparse/test_sunmatrix_sparse.c |
Test_SUNSparseMatrixToCSR | int Test_SUNSparseMatrixToCSR(SUNMatrix A)
{
int failure;
SUNMatrix csc, csr;
sunrealtype tol = 200 * SUN_UNIT_ROUNDOFF;
failure = SUNSparseMatrix_ToCSR(A, &csr);
if (failure)
{
printf(">>> FAILED test -- SUNSparseMatrix_ToCSR returned nonzero\n");
SUNMatDestroy(csr);
return (1);
}
/* che... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movsd 0x2c67(%rip), %xmm0 # 0x8078
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2110
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x5456
leaq 0x3207(%rip), %rdi # 0x863f
movb $0x0, %al
callq 0x20b0
movq 0x10(%rsp), %rdi
callq 0x2290
movl $0... | /opencor[P]sundials/examples/sunmatrix/sparse/test_sunmatrix_sparse.c |
check_vector | int check_vector(N_Vector x, N_Vector y, sunrealtype tol)
{
int failure = 0;
sunrealtype *xdata, *ydata;
sunindextype xldata, yldata;
sunindextype i;
/* get vector data */
xdata = N_VGetArrayPointer(x);
ydata = N_VGetArrayPointer(y);
/* check data lengths */
xldata = N_VGetLength_Serial(x);
yldata... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x48(%rsp), %rdi
callq 0x21a0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x21a0
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2240
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2240
movq %r... | /opencor[P]sundials/examples/sunmatrix/sparse/test_sunmatrix_sparse.c |
get_time | static double get_time(void)
{
#if defined(SUNDIALS_HAVE_POSIX_TIMERS) && defined(_POSIX_TIMERS)
struct timespec spec;
clock_gettime(CLOCK_MONOTONIC, &spec);
double time = (double)(spec.tv_sec - base_time_tv_sec) +
((double)(spec.tv_nsec) / 1E9);
#else
double time = 0;
#endif
return time;
} | xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
| /opencor[P]sundials/examples/sunmatrix/test_sunmatrix.c |
Test_SUNMatZero | int Test_SUNMatZero(SUNMatrix A, int myid)
{
int failure;
double start_time, stop_time;
sunrealtype tol = 10 * SUN_UNIT_ROUNDOFF;
SUNMatrix B;
/* protect A */
B = SUNMatClone(A);
/* set matrix data to zero */
start_time = get_time();
failure = SUNMatZero(B);
sync_device(B);
stop_time = get_ti... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movsd 0x2cc3(%rip), %xmm0 # 0x8958
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x21f0
movq %rax, (%rsp)
callq 0x58d0
movsd %xmm0, 0x18(%rsp)
movq (%rsp), %rdi
callq 0x20e0
movl %eax, 0x20(%rsp)
movq (%rsp), %rdi
callq 0x5770
callq 0x58d0
movsd %xmm... | /opencor[P]sundials/examples/sunmatrix/test_sunmatrix.c |
Test_SUNMatScaleAdd | int Test_SUNMatScaleAdd(SUNMatrix A, SUNMatrix I, int myid)
{
int failure;
double start_time, stop_time;
SUNMatrix B, C, D;
sunrealtype tol = 10 * SUN_UNIT_ROUNDOFF;
/*
* Case 1: same sparsity/bandwith pattern
*/
/* protect A */
B = SUNMatClone(A);
failure = SUNMatCopy(A, B);
if (failure... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movsd 0x28ae(%rip), %xmm0 # 0x8958
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x21f0
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2260
movl %eax, 0x38(%rsp)
cmpl $0x0, 0x38(%rsp)
je 0x6143
cmpl $0... | /opencor[P]sundials/examples/sunmatrix/test_sunmatrix.c |
Test_SUNMatScaleAddI | int Test_SUNMatScaleAddI(SUNMatrix A, SUNMatrix I, int myid)
{
int failure;
double start_time, stop_time;
SUNMatrix B;
sunrealtype tol = 10 * SUN_UNIT_ROUNDOFF;
/* protect A */
B = SUNMatClone(A);
failure = SUNMatCopy(I, B);
if (failure)
{
TEST_STATUS2(">>> FAILED test -- SUNMatCopy returned %d ... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movsd 0x21de(%rip), %xmm0 # 0x8958
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x21f0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2260
movl %eax, 0x28(%rsp)
cmpl $0x0, 0x28(%rsp)
je 0x6813
cmpl $0... | /opencor[P]sundials/examples/sunmatrix/test_sunmatrix.c |
Test_SUNMatMatvecSetup | int Test_SUNMatMatvecSetup(SUNMatrix A, int myid)
{
int failure;
double start_time, stop_time;
if (A->ops->matvecsetup == NULL)
{
TEST_STATUS(" PASSED test -- SUNMatMatvecSetup not implemented\n", myid);
return (0);
}
start_time = get_time();
failure = SUNMatMatvecSetup(A);
sync_device(A... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x6a75
cmpl $0x0, 0x4764(%rip) # 0xb188
jne 0x6a3d
cmpl $0x0, 0x14(%rsp)
jne 0x6a3d
leaq 0x22e1(%rip), %rdi # 0x8d15
movb $0x0, %al
callq 0x20b0
jmp 0x6a68
cmpl $0x0, 0x4744(%rip) ... | /opencor[P]sundials/examples/sunmatrix/test_sunmatrix.c |
Test_SUNMatMatvec | int Test_SUNMatMatvec(SUNMatrix A, N_Vector x, N_Vector y, int myid)
{
int failure;
double start_time, stop_time;
SUNMatrix B;
N_Vector z, w;
sunrealtype tol = 100 * SUN_UNIT_ROUNDOFF;
if (A->ops->matvec == NULL)
{
TEST_STATUS(" PASSED test -- SUNMatMatvec not implemented\n", myid);
return (0)... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movsd 0x14c1(%rip), %xmm0 # 0x8070
movsd %xmm0, (%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x40(%rax)
jne 0x6c1c
cmpl $0x0, 0x45bd(%rip) # 0xb188
jne 0x6be4
cmpl $0x0, 0x34(%rsp)
jne 0x6be... | /opencor[P]sundials/examples/sunmatrix/test_sunmatrix.c |
Test_SUNMatSpace | int Test_SUNMatSpace(SUNMatrix A, int myid)
{
int failure;
double start_time, stop_time;
long int lenrw, leniw;
start_time = get_time();
failure = SUNMatSpace(A, &lenrw, &leniw);
sync_device(A);
stop_time = get_time();
if (failure)
{
TEST_STATUS(">>> FAILED test -- SUNMatSpace \n", myid);
... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
callq 0x58d0
movsd %xmm0, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
callq 0x20c0
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x5770
callq 0x58d0
movsd %xmm0, 0x10(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x71a5
cmpl $0x0, 0x4057(%rip) ... | /opencor[P]sundials/examples/sunmatrix/test_sunmatrix.c |
mavlink_sign_packet(__mavlink_signing*, unsigned char*, unsigned char const*, unsigned char, unsigned char const*, unsigned char, unsigned char const*) | MAVLINK_HELPER uint8_t mavlink_sign_packet(mavlink_signing_t *signing,
uint8_t signature[MAVLINK_SIGNATURE_BLOCK_LEN],
const uint8_t *header, uint8_t header_len,
const uint8_t *packet, uint8_t packet_len,
const uint8_t crc[2])
{
mavlink_sha256_ctx ctx;
union {
uint64_t t64;
u... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %cl, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x44ae
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %e... | /mavlink[P]c_uart_interface_example/mavlink/include/mavlink/v2.0/common/../mavlink_helpers.h |
util_v4l2::query_formats(int, error_code*) | std::vector<v4l2_fmtdesc> query_formats(int fd, error_code *err) {
SET_ERR_CODE(err, error_code::ERR_NO_ERROR);
std::vector<v4l2_fmtdesc> formats;
struct v4l2_fmtdesc fmt;
fmt.index = 0;
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
while (-1 != util_v4l2::xioctl(fd, VIDIOC_E... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x294e
movl $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movabsq $0x100000000, %rax # imm = 0x100000000
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl %ebp, %e... | /narfster[P]v4l2cxx/examples/../src/util_v4l2.h |
curlx_sotouz | size_t curlx_sotouz(curl_off_t sonum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sonum >= 0);
return (size_t)(sonum & (curl_off_t) CURL_MASK_USIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
retq
| /DarovskikhAndrei[P]curl/lib/warnless.c |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<char const* const&>() | static std::string type_id() {
std::string name(typeid(T).name());
detail::clean_type_id(name);
return name;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3185e(%rip), %rax # 0x38f28
movq 0x8(%rax), %rax
xorl %esi, %esi
cmpb $0x2a, (%rax)
sete %sil
addq %rax, %rsi
leaq 0x7(%rsp), %rdx
callq 0x6290
movq %rbx, %rdi
callq 0x94c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/typeid.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<bool>() | static std::string type_id() {
std::string name(typeid(T).name());
detail::clean_type_id(name);
return name;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3183c(%rip), %rax # 0x38f60
movq 0x8(%rax), %rax
xorl %esi, %esi
cmpb $0x2a, (%rax)
sete %sil
addq %rax, %rsi
leaq 0x7(%rsp), %rdx
callq 0x6290
movq %rbx, %rdi
callq 0x94c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/typeid.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<pybind11::handle&>() | static std::string type_id() {
std::string name(typeid(T).name());
detail::clean_type_id(name);
return name;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x2a3f1(%rip), %rsi # 0x31b77
leaq 0x2a3fc(%rip), %rdx # 0x31b89
callq 0x6280
movq %rbx, %rdi
callq 0x94c0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x77b6
movq (%r15), %rs... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/typeid.h |
pybind11::module::module(char const*, char const*) | explicit module(const char *name, const char *doc = nullptr) {
if (!options::show_user_defined_docstrings()) doc = nullptr;
#if PY_MAJOR_VERSION >= 3
PyModuleDef *def = new PyModuleDef();
std::memset(def, 0, sizeof(PyModuleDef));
def->m_name = name;
def->m_doc = doc;
def-... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rdi)
movb 0x317ba(%rip), %bpl # 0x396b8
movl $0x68, %edi
callq 0x66f0
xorl %ecx, %ecx
testb %bpl, %bpl
cmovneq %r15, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %x... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pybind11.h |
void pybind11::detail::accessor<pybind11::detail::accessor_policies::str_attr>::operator=<char const (&) [213]>(char const (&) [213]) && | void operator=(T &&value) && {
Policy::set(obj, key, object_or_cast(std::forward<T>(value)));
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %r14
movq %rsi, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0xa452
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8078
movq %rsp, %rdi
callq 0x12fa8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
c... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
pybind11::error_already_set::error_already_set() | error_already_set() : std::runtime_error(detail::error_string()) {
PyErr_Fetch(&m_type.ptr(), &m_value.ptr(), &m_trace.ptr());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x8268
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6890
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x810d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6720
leaq 0x30a14(%rip), %rax ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
pybind11::error_already_set::~error_already_set() | error_already_set::~error_already_set() {
if (m_type) {
gil_scoped_acquire gil;
error_scope scope;
m_type.release().dec_ref();
m_value.release().dec_ref();
m_trace.release().dec_ref();
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x3097d(%rip), %rax # 0x38b28
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
cmpq $0x0, 0x10(%rdi)
je 0x8236
leaq 0x18(%rsp), %rdi
callq 0x968e
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rsp, %rdi
callq 0x6b80
movq (%r14), %rdi
movq $0x0, (%r14)
testq %rdi,... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pybind11.h |
pybind11::error_already_set::~error_already_set() | error_already_set::~error_already_set() {
if (m_type) {
gil_scoped_acquire gil;
error_scope scope;
m_type.release().dec_ref();
m_value.release().dec_ref();
m_trace.release().dec_ref();
}
} | pushq %rbx
movq %rdi, %rbx
callq 0x819a
movl $0x28, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x6720
nop
| /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pybind11.h |
pybind11::object::operator=(pybind11::object&&) | object& operator=(object &&other) noexcept {
if (this != &other) {
handle temp(m_ptr);
m_ptr = other.m_ptr;
other.m_ptr = nullptr;
temp.dec_ref();
}
return *this;
} | pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x900e
movq (%rbx), %rdi
movq (%rsi), %rax
movq %rax, (%rbx)
movq $0x0, (%rsi)
testq %rdi, %rdi
je 0x900e
decq (%rdi)
jne 0x900e
callq 0x64f0
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rdi
callq 0x7f85
| /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::cast<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 0>(pybind11::handle const&) | T cast(const handle &handle) {
using namespace detail;
static_assert(!cast_is_temporary_value_reference<T>::value,
"Unable to cast type to reference: value is local to type caster");
return cast_op<T>(load_type<T>(handle));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x906e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x9054
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x905a
movups (%rdx), %xmm0
movups %xmm0, (... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::detail::type_caster<pybind11::detail::intrinsic_type<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::type, void> pybind11::detail::load_type<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(pybind11::handle const&) | make_caster<T> load_type(const handle &handle) {
make_caster<T> conv;
load_type(conv, handle);
return conv;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x90b5
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x90ad
movq (%r15), %rsi
incq %rsi
callq 0x6720
movq %r14, %rdi
callq 0... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::detail::type_caster<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>& pybind11::detail::load_type<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>(pybind11::detail::type_caster<std::__cxx11::basic_string<char, std::char_traits<char>, st... | type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
if (!conv.load(handle, true)) {
#if defined(NDEBUG)
throw cast_error("Unable to cast Python instance to C++ type (compile in debug mode for details)");
#else
throw cast_error("Unable to cast Python instance of ty... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movl $0x1, %edx
callq 0x9352
testb %al, %al
je 0x90ee
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6340
movq %rax, %rbx
movq (%r14... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
bool pybind11::detail::string_caster<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, false>::load_bytes<char>(std::enable_if<sizeof (char) == 1, pybind11::handle>::type) | bool load_bytes(enable_if_t<sizeof(C) == 1, handle> src) {
if (PYBIND11_BYTES_CHECK(src.ptr())) {
// We were passed a Python 3 raw bytes; accept it into a std::string or char*
// without any encoding attempt.
const char *bytes = PYBIND11_BYTES_AS_STRING(src.ptr());
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rsi), %rax
testb $0x8, 0xab(%rax)
je 0x94b2
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6920
testq %rax, %rax
je 0x94b2
movq %rax, %r14
movq %r15, %rdi
callq 0x6660
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdx
addq %rax, ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::gil_scoped_acquire::gil_scoped_acquire() | PYBIND11_NOINLINE gil_scoped_acquire() {
auto const &internals = detail::get_internals();
tstate = (PyThreadState *) PYBIND11_TLS_GET_VALUE(internals.tstate);
if (!tstate) {
/* Check if the GIL was acquired using the PyGILState_* API instead (e.g. if
calling from a Py... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rdi)
movb $0x1, 0x8(%rdi)
callq 0x9752
movq %rax, %r14
movq 0x1c8(%rax), %rdi
callq 0x6620
movq %rax, (%rbx)
testq %rax, %rax
jne 0x96c9
callq 0x61b0
movq %rax, (%rbx)
testq %rax, %rax
je 0x96f0
callq 0x6bc0
movq (%rbx), %rdi
cmpq %rdi, %rax
setne 0x8(%rbx)
... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pybind11.h |
pybind11::detail::get_internals() | PYBIND11_NOINLINE inline internals &get_internals() {
auto **&internals_pp = get_internals_pp();
if (internals_pp && *internals_pp)
return **internals_pp;
// Ensure that the GIL is held since we will need to make Python calls.
// Cannot use py::gil_scoped_acquire here since that constructor cal... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq 0x2ffbe(%rip), %rax # 0x39720
testq %rax, %rax
je 0x9773
movq (%rax), %r14
testq %r14, %r14
jne 0x9b43
callq 0x6cb0
movl %eax, %ebx
leaq 0x26cce(%rip), %rax # 0x3044f
movq %rax, 0x38(%rsp)
callq 0x6a50
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x38(%rsp)... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/internals.h |
bool pybind11::detail::object_api<pybind11::handle>::contains<char const* const&>(char const* const&) const | bool object_api<D>::contains(T &&item) const {
return attr("__contains__")(std::forward<T>(item)).template cast<bool>();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq (%rdi), %rax
leaq 0x28(%rsp), %rbx
movq %rax, -0x10(%rbx)
leaq 0x268b3(%rip), %rax # 0x304a7
movq %rax, -0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xa1c8
leaq 0x8(%rsp), %rdi
callq 0xa624
movl %eax, %ebp
leaq 0... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
pybind11::detail::make_static_property_type() | inline PyTypeObject *make_static_property_type() {
constexpr auto *name = "pybind11_static_property";
auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
/* Danger zone: from now (and until PyType_Ready), make sure to
issue no Python C API calls which could potentially invoke the
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x269f9(%rip), %r14 # 0x30725
movq %r14, %rdi
callq 0x65c0
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq 0x2f1ed(%rip), %rdi # 0x38f30
xorl %esi, %esi
callq *0x130(%rdi)
movq %rax, %rbx
testq %rax, %rax
je 0x9dfb
testq %r15, %r15
je 0x9d60
addq $0x2, (%r15)
mov... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11::detail::make_default_metaclass() | inline PyTypeObject* make_default_metaclass() {
constexpr auto *name = "pybind11_type";
auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
/* Danger zone: from now (and until PyType_Ready), make sure to
issue no Python C API calls which could potentially invoke the
garbage... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x26944(%rip), %r14 # 0x307c7
movq %r14, %rdi
callq 0x65c0
movq %rax, %r12
movq %rax, 0x10(%rsp)
movq 0x2f096(%rip), %r15 # 0x38f30
movq %r15, %rdi
xorl %esi, %esi
callq *0x130(%r15)
movq %rax, %rbx
testq %rax, %rax
je 0x9f57
testq %r12, %r12
je ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11::detail::make_object_base_type(_typeobject*) | inline PyObject *make_object_base_type(PyTypeObject *metaclass) {
constexpr auto *name = "pybind11_object";
auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
/* Danger zone: from now (and until PyType_Ready), make sure to
issue no Python C API calls which could potentially invok... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x26860(%rip), %r14 # 0x30840
movq %r14, %rdi
callq 0x65c0
movq %rax, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq *0x130(%rbx)
movq %rax, %rbx
testq %rax, %rax
je 0xa0d3
movq (%rsp), %rax
testq %rax, %rax
je 0xa010
addq $0x2, (%rax)
movq %rax, 0x350(%rbx)... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11::object pybind11::detail::object_api<pybind11::detail::accessor<pybind11::detail::accessor_policies::str_attr>>::operator()<(pybind11::return_value_policy)1, char const* const&>(char const* const&) const | object object_api<Derived>::operator()(Args &&...args) const {
return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xa27d
movq %r14, %rdi
callq 0x8f60
movq (%rax), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa21a
movq %rsp, %rdi
callq 0x12fa8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::detail::simple_collector<(pybind11::return_value_policy)1>::call(_object*) const | object call(PyObject *ptr) const {
PyObject *result = PyObject_CallObject(ptr, m_args.ptr());
if (!result)
throw error_already_set();
return reinterpret_steal<object>(result);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rsi
movq %rdx, %rdi
callq 0x6460
testq %rax, %rax
je 0xa23f
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x28, %edi
callq 0x6340
movq %rax, %rbx
movq %rax, %rdi
callq 0x80cc
leaq 0x2e8a5(%rip), %rsi # 0x38b00
leaq -0x... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::tuple pybind11::make_tuple<(pybind11::return_value_policy)1, char const* const&>(char const* const&) | tuple make_tuple(Args&&... args_) {
constexpr size_t size = sizeof...(Args);
std::array<object, size> args {
{ reinterpret_steal<object>(detail::make_caster<Args>::cast(
std::forward<Args>(args_), policy, nullptr))... }
};
for (size_t i = 0; i < args.size(); i++) {
if (!args[... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xa452
movq %rax, (%rsp)
testq %rax, %rax
je 0xa2e5
movl $0x1, %esi
movq %rbx, %rdi
callq 0xa586
movq (%rsp), %rax
movq $0x0, (%rsp)
movq (%rbx), %rcx
movq 0x8(%rcx), %rdx
testb $0x4, 0xa... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::detail::type_caster<char, void>::cast(char const*, pybind11::return_value_policy, pybind11::handle) | static handle cast(const CharT *src, return_value_policy policy, handle parent) {
if (src == nullptr) return pybind11::none().inc_ref();
return StringCaster::cast(StringType(src), policy, parent);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0xa4b6
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0x62e0
leaq (%rax,%r14), %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6280
movzbl %bpl, %esi
movq %r15, %r... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
std::enable_if<!detail::move_never<bool>::value, bool>::type pybind11::move<bool>(pybind11::object&&) | detail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) {
if (obj.ref_count() > 1)
#if defined(NDEBUG)
throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references"
" (compile in debug mode for details)");
#else
throw cast_error("Unabl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpl $0x2, (%rax)
jge 0xa691
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa8f5
movb (%rbx), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %e... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::detail::type_caster<bool, void>& pybind11::detail::load_type<bool, void>(pybind11::detail::type_caster<bool, void>&, pybind11::handle const&) | type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
if (!conv.load(handle, true)) {
#if defined(NDEBUG)
throw cast_error("Unable to cast Python instance to C++ type (compile in debug mode for details)");
#else
throw cast_error("Unable to cast Python instance of ty... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movl $0x1, %edx
callq 0xab92
testb %al, %al
je 0xa92e
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6340
movq %rax, %rbx
movq (%r14... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11_meta_setattro | inline int pybind11_meta_setattro(PyObject* obj, PyObject* name, PyObject* value) {
// Use `_PyType_Lookup()` instead of `PyObject_GetAttr()` in order to get the raw
// descriptor (`property`) instead of calling `tp_descr_get` (`property.__get__()`).
PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, na... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x6be0
movq %rax, %r12
callq 0x9752
testq %r12, %r12
je 0xb01e
movq 0x1b0(%rax), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x6350
testl %eax, %eax
je 0xb01e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6350
testl %e... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11_object_init | inline int pybind11_object_init(PyObject *self, PyObject *, PyObject *) {
PyTypeObject *type = Py_TYPE(self);
std::string msg;
#if defined(PYPY_VERSION)
msg += handle((PyObject *) type).attr("__module__").cast<std::string>() + ".";
#endif
msg += type->tp_name;
msg += ": No constructor defined!";
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %rax
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x18(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6d20
leaq 0x262d6(%rip), %rsi # 0x313c5
leaq 0x8(%rsp), %rdi
callq 0x6d20
movq 0x2dea8(%rip), %rax # 0x38fa8
movq (%... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11_object_dealloc | inline void pybind11_object_dealloc(PyObject *self) {
clear_instance(self);
auto type = Py_TYPE(self);
type->tp_free(self);
// `type->tp_dealloc != pybind11_object_dealloc` means that we're being called
// as part of a derived type's dealloc, in which case we're not allowed to decref
// the ty... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x119e9
movq 0x8(%r14), %rbx
movq %r14, %rdi
callq *0x140(%rbx)
callq 0x9752
movq 0x1c0(%rax), %rax
movq 0x30(%rbx), %rcx
cmpq 0x30(%rax), %rcx
jne 0xb187
decq (%rbx)
je 0xb18f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11::detail::instance::allocate_layout() | PYBIND11_NOINLINE inline void instance::allocate_layout() {
auto &tinfo = all_type_info(Py_TYPE(this));
const size_t n_types = tinfo.size();
if (n_types == 0)
pybind11_fail("instance allocation failed: new instance has no pybind11-registered base types");
simple_layout =
n_types == 1 ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0xb2e5
movq %rax, %r14
testb $0x1, %dl
je 0xb211
movq %r14, %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0xb3c5
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq $0x1, %rax
je 0xb237
testq %rax, %ra... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::detail::all_type_info_populate(_typeobject*, std::vector<pybind11::detail::type_info*, std::allocator<pybind11::detail::type_info*>>&) | PYBIND11_NOINLINE inline void all_type_info_populate(PyTypeObject *t, std::vector<type_info *> &bases) {
std::vector<PyTypeObject *> check;
for (handle parent : reinterpret_borrow<tuple>(t->tp_bases))
check.push_back((PyTypeObject *) parent.ptr());
auto const &type_dict = get_internals().registered... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x150(%rdi), %r13
movq %r13, 0x8(%rsp)
testq %r13, %r13
je 0xb3fc
incq (%r13)
movq 0x8(%r13), %rax
addq $0x18, %r13
testb $0x2, 0xab(%rax)
je 0xb411
m... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::cpp_function::initialize_generic(pybind11::detail::function_record*, char const*, std::type_info const* const*, unsigned long) | void initialize_generic(detail::function_record *rec, const char *text,
const std::type_info *const *types, size_t args) {
/* Create copies of all referenced C-style strings */
rec->name = strdup(rec->name ? rec->name : "");
if (rec->doc) rec->doc = strdup(rec->doc);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r8, 0x138(%rsp)
movq %rcx, 0xc0(%rsp)
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, 0xe8(%rsp)
movq (%rsi), %rax
testq %rax, %rax
leaq 0x25572(%rip), %rdi # 0x30fc6
cmovneq %rax, %rdi
callq 0x6c80
movq %r... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pybind11.h |
pybind11::object pybind11::detail::object_api<pybind11::detail::accessor<pybind11::detail::accessor_policies::str_attr>>::operator()<(pybind11::return_value_policy)1>() const | object object_api<Derived>::operator()(Args &&...args) const {
return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
xorl %esi, %esi
callq 0xa586
movq %r14, %rdi
callq 0x8f60
movq (%rax), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa21a
movq %rsp, %rdi
callq 0x12fa8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::detail::get_type_info(std::type_index const&, bool) | PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_index &tp,
bool throw_if_missing = false) {
if (auto ltype = get_local_type_info(tp))
return ltype;
if (auto gtype = get_global_type_info(tp))
return gtype;
if... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movb 0x2c11b(%rip), %al # 0x39760
testb %al, %al
je 0xd69f
leaq 0x2c0d8(%rip), %rdi # 0x39728
movq %rbx, %rsi
callq 0xf790
testq %rax, %rax
je 0xd666
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xd696
callq 0x9752
movq %rax, %rdi
... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
std::enable_if<!detail::move_never<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::value, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::type pybind11::move<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(pybind11::object... | detail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) {
if (obj.ref_count() > 1)
#if defined(NDEBUG)
throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references"
" (compile in debug mode for details)");
#else
throw cast_error("Unabl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq (%rsi), %rax
cmpl $0x2, (%rax)
jge 0xf436
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x906e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r15), %rcx
leaq 0x20(%rsp), %rdx
cmpq %rdx, %rcx
je 0xf... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::detail::loader_life_support::~loader_life_support() | ~loader_life_support() {
auto &stack = get_internals().loader_patient_stack;
if (stack.empty())
pybind11_fail("loader_life_support: internal error");
auto ptr = stack.back();
stack.pop_back();
Py_CLEAR(ptr);
// A heuristic to reduce the stack's capacity (e.g... | pushq %rbx
callq 0x9752
movq %rax, %rbx
movq 0x198(%rax), %rax
cmpq %rax, 0x190(%rbx)
je 0xfeea
movq -0x8(%rax), %rdi
addq $-0x8, %rax
movq %rax, 0x198(%rbx)
testq %rdi, %rdi
je 0xfe97
decq (%rdi)
jne 0xfe97
callq 0x64f0
movq 0x190(%rbx), %rdx
movq 0x1a0(%rbx), %rcx
movq %rcx, %rax
subq %rdx, %rax
sarq $0x3, %rax
cmpq ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::str pybind11::str::format<pybind11::handle&, pybind11::handle&>(pybind11::handle&, pybind11::handle&) const | str format(Args &&...args) const {
return attr("format")(std::forward<Args>(args)...);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rsi), %rax
leaq 0x20(%rsp), %rbx
movq %rax, -0x10(%rbx)
leaq 0x21197(%rip), %rax # 0x31122
movq %rax, -0x8(%rbx)
movq $0x0, (%rbx)
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x1123a
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1128e
movq %rsp, %rdi
callq 0x12... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
pybind11::detail::values_and_holders::find(pybind11::detail::type_info const*) | iterator find(const type_info *find_type) {
auto it = begin(), endit = end();
while (it != endit && it->type != find_type) ++it;
return it;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1002c
movq 0x8(%r15), %rax
movq 0x8(%rax), %r15
subq (%rax), %r15
sarq $0x3, %r15
cmpq %r15, 0x18(%r14)
je 0x10022
cmpq %rbx, 0x20(%r14)
je 0x10022
movq %r14, %rdi
callq 0x10070
jmp 0x1000c
movq %r14, %rax
popq %rbx
popq %r14
popq ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::object pybind11::detail::object_api<pybind11::detail::accessor<pybind11::detail::accessor_policies::str_attr>>::operator()<(pybind11::return_value_policy)1, pybind11::handle&, pybind11::handle&>(pybind11::handle&, pybind11::handle&) const | object object_api<Derived>::operator()(Args &&...args) const {
return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x11315
movq %r14, %rdi
callq 0x8f60
movq (%rax), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa21a
movq %rsp, %rdi
callq 0x12fa8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rb... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::str::str(pybind11::object&&) | str(const char *c, size_t n)
: object(PyUnicode_FromStringAndSize(c, (ssize_t) n), stolen_t{}) {
if (!m_ptr) pybind11_fail("Could not allocate string object!");
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x112b7
movq 0x8(%rdi), %rax
testb $0x18, 0xab(%rax)
je 0x112b7
movq $0x0, (%rsi)
movq %rdi, (%rbx)
jmp 0x112c4
callq 0x6190
movq %rax, (%rbx)
testq %rax, %rax
je 0x112ca
popq %rbx
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x63... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
pybind11::cpp_function::destruct(pybind11::detail::function_record*) | static void destruct(detail::function_record *rec) {
while (rec) {
detail::function_record *next = rec->next;
if (rec->free_data)
rec->free_data(rec);
std::free((char *) rec->name);
std::free((char *) rec->doc);
std::free((char *) rec->... | testq %rdi, %rdi
je 0x116a2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rbx), %rax
movq 0x78(%rbx), %r14
testq %rax, %rax
je 0x115f8
movq %rbx, %rdi
callq *%rax
movq (%rbx), %rdi
callq 0x6810
movq 0x8(%rbx), %rdi
callq 0x6810
movq 0x10(%rbx), %rdi
callq 0x6810
movq 0x18(%rbx), %r15... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pybind11.h |
pybind11::capsule::capsule(void const*, void (*)(void*))::'lambda'(_object*)::__invoke(_object*) | capsule(const void *value, void (*destructor)(void *)) {
m_ptr = PyCapsule_New(const_cast<void *>(value), nullptr, [](PyObject *o) {
auto destructor = reinterpret_cast<void (*)(void *)>(PyCapsule_GetContext(o));
void *ptr = PyCapsule_GetPointer(o, nullptr);
destructor(ptr);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6800
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x68f0
movq %rax, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
| /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
pybind11::detail::clear_instance(_object*) | inline void clear_instance(PyObject *self) {
auto instance = reinterpret_cast<detail::instance *>(self);
// Deallocate any values/holders, if present:
for (auto &v_h : values_and_holders(instance)) {
if (v_h) {
// We have to deregister before we call dealloc because, for virtual MI typ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0xb2e5
movq %rax, %r14
movq %rax, %r12
testb $0x1, %dl
je 0x11a1d
leaq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0xb3c5
addq $0x10, %r14
movq %rbx, (%rsp)
movq %r14, 0x8(%rsp)
movq ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11::detail::traverse_offset_bases(void*, pybind11::detail::type_info const*, pybind11::detail::instance*, bool (*)(void*, pybind11::detail::instance*)) | inline void traverse_offset_bases(void *valueptr, const detail::type_info *tinfo, instance *self,
bool (*f)(void * /*parentptr*/, instance * /*self*/)) {
for (handle h : reinterpret_borrow<tuple>(tinfo->type->tp_bases)) {
if (auto parent_tinfo = get_type_info((PyTypeObject *) h.ptr())) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rax
movq 0x150(%rax), %r14
movq %r14, (%rsp)
testq %r14, %r14
je 0x11dbf
incq (%r14)
movq 0x8(%r14), %rax
addq $0x18, %r14
testb $0x2, 0xab(%rax)
je... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11::gil_scoped_acquire::dec_ref() | PYBIND11_NOINLINE void dec_ref() {
--tstate->gilstate_counter;
#if !defined(NDEBUG)
if (detail::get_thread_state_unchecked() != tstate)
pybind11_fail("scoped_acquire::dec_ref(): thread state must be current!");
if (tstate->gilstate_counter < 0)
pyb... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
decl 0xa0(%rax)
callq 0x6bc0
movq (%rbx), %rdi
cmpq %rdi, %rax
jne 0x1213a
cmpl $0x0, 0xa0(%rdi)
js 0x12146
jne 0x12138
cmpb $0x0, 0x8(%rbx)
je 0x12152
callq 0x6c60
callq 0x61a0
callq 0x9752
movq 0x1c8(%rax), %rdi
xorl %esi, %esi
callq 0x6960
movb $0x0, 0x8(%rbx)
popq %rbx
r... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pybind11.h |
ComputeFk(double const*, double*, double*) | IKFAST_API void ComputeFk(const IkReal* j, IkReal* eetrans, IkReal* eerot) {
IkReal x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51;
x0=IKcos(j[0]);
x1=IKcos(j[1]);
x2=IK... | pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movsd (%rdi), %xmm0
callq 0x6ca0
movaps %xmm0, 0x90(%rsp)
movsd 0x8(%r15), %xmm0
callq 0x6ca0
movaps %xmm0, 0x40(%rsp)
movsd 0x10(%r15), %xmm0
callq 0x6100
movaps %xmm0, 0x70(%rsp)
movsd 0x10(%r15... | /Simon-Steinmann[P]ikfast_pybind_PR/src/kukakr162/ikfast61_kukakr162.cpp |
CheckValue<double> IKatan2WithCheck<double>(double, double, double) | inline CheckValue<T> IKatan2WithCheck(T fy, T fx, T epsilon)
{
CheckValue<T> ret;
ret.valid = false;
ret.value = 0;
if( !isnan(fy) && !isnan(fx) ) {
if( IKabs(fy) >= IKFAST_ATAN2_MAGTHRESH || IKabs(fx) > IKFAST_ATAN2_MAGTHRESH ) {
ret.value = IKatan2Simple(fy,fx);
ret.val... | movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm2
jp 0x17173
movapd 0x1af0d(%rip), %xmm3 # 0x32060
movapd %xmm2, %xmm4
andpd %xmm3, %xmm4
ucomisd 0x1ad05(%rip), %xmm4 # 0x31e68
jae 0x17176
andpd %xmm1, %xmm3
ucomisd 0x1acf7(%rip), %xmm3 # 0x31e68
ja 0x17176
xorl %eax, %eax
retq
pushq %rax
movapd %xmm... | /Simon-Steinmann[P]ikfast_pybind_PR/src/kukakr162/ikfast61_kukakr162.cpp |
IKSolver::polyroots3(double*, double*, int&) | static inline void polyroots3(IkReal rawcoeffs[3+1], IkReal rawroots[3], int& numroots)
{
using std::complex;
if( rawcoeffs[0] == 0 ) {
// solve with one reduced degree
polyroots2(&rawcoeffs[1], &rawroots[0], numroots);
return;
}
IKFAST_ASSERT(rawcoeffs[0] != 0);
const IkReal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd (%rdi), %xmm0
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jne 0x2f59b
jp 0x2f59b
movsd 0x8(%r15), %xmm1
movsd 0x10(%r15), %xmm2
movsd 0x2ac2(%rip), %xmm4 # 0x32010
mulsd %xmm1, %xmm4
... | /Simon-Steinmann[P]ikfast_pybind_PR/src/kukakr162/ikfast61_kukakr162.cpp |
cfd::UtxoUtil::ConvertToUtxo(cfd::UtxoData const&, cfd::Utxo*, cfd::UtxoData*) | void UtxoUtil::ConvertToUtxo(
const UtxoData& utxo_data, Utxo* utxo, UtxoData* dest) {
if (utxo != nullptr) {
UtxoData output(utxo_data);
memset(utxo, 0, sizeof(Utxo));
utxo->block_height = utxo_data.block_height;
utxo->vout = utxo_data.vout;
utxo->binary_data = utxo_data.binary_data;
utxo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x908, %rsp # imm = 0x908
movq %rdx, 0x38(%rsp)
testq %rsi, %rsi
je 0xc593c
movq %rsi, %r14
movq %rdi, %r15
leaq 0x418(%rsp), %rdi
movq %r15, %rsi
callq 0xbd010
movl $0xd8, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xbab20
movq (%r15), ... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_transaction_common.cpp |
cfd::TransactionContext::AddSchnorrSign(cfd::core::OutPoint const&, cfd::core::SchnorrSignature const&, cfd::core::ByteData const*) | void TransactionContext::AddSchnorrSign(
const OutPoint& outpoint, const SchnorrSignature& signature,
const ByteData* annex) {
std::vector<SignParameter> sign_params = {
SignParameter(signature.GetData(true))};
if (annex != nullptr) sign_params.emplace_back(*annex);
AddSign(outpoint, sign_params, tr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
movl $0x1, %edx
callq 0xbc600
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xb9460
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_transaction.cpp |
cfd::TransactionContext::CheckMultisig(std::vector<cfd::SignParameter, std::allocator<cfd::SignParameter>> const&, cfd::core::Script const&) | std::vector<SignParameter> TransactionContext::CheckMultisig(
const std::vector<SignParameter>& sign_list, const Script& redeem_script) {
// check signData (too much data)
if (sign_list.empty() || (sign_list.size() > kMaximumMultisigKeyNum)) {
warn(
CFD_LOG_SOURCE, "Failed to CheckMultisig. sign arr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x8(%rsp)
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
cmpq %rax, %rcx
je 0xd32eb
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rcx # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %rcx
cmpq $0x10, %... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_transaction.cpp |
cfd::TransactionContext::VerifyInputSchnorrSignature(cfd::core::SchnorrSignature const&, cfd::core::OutPoint const&, std::vector<cfd::UtxoData, std::allocator<cfd::UtxoData>> const&, cfd::core::SchnorrPubkey const&, cfd::core::ByteData const*) const | bool TransactionContext::VerifyInputSchnorrSignature(
const SchnorrSignature& signature, const OutPoint& outpoint,
const std::vector<UtxoData>& utxo_list, const SchnorrPubkey& pubkey,
const ByteData* annex) const {
UtxoData target_utxo;
std::vector<TxOut> utxos;
utxos.reserve(vin_.size());
for (cons... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5e8, %rsp # imm = 0x5E8
movq %r9, %r13
movq %r8, %rbx
movq %rcx, 0x80(%rsp)
movq %rdx, 0x50(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0xf8(%rsp), %rdi
callq 0xbc100
xorps %xmm0, %xmm0
leaq 0xb0(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_transaction.cpp |
cfd::TransactionController::TransactionController(cfd::TransactionController const&) | TransactionController::TransactionController(
const TransactionController& transaction)
: TransactionController(transaction.GetHex()) {
// do nothing
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0xba3f0
movq %rbx, %rdi
callq 0xbbb90
movq 0xe098b(%rip), %rax # 0x1b4910
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x10(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xbd560
movq %r14, 0x8(%rbx)
leaq 0x18(%rsp), %rax
movq -0x1... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_transaction.cpp |
cfd::TransactionController::AddTxIn(cfd::core::Txid const&, unsigned int, cfd::core::Pubkey const&, unsigned int) | const TxInReference TransactionController::AddTxIn(
const Txid& txid, uint32_t vout, const Pubkey& pubkey, uint32_t sequence) {
uint32_t index = transaction_.AddTxIn(
txid, vout, sequence, ScriptBuilder().AppendData(pubkey).Build());
return transaction_.GetTxIn(index);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %ebp
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0xdf900(%rip), %r13 # 0x1b3a70
addq $0x10, %r13
movq %rsp, %rdi
movq %r13, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_transaction.cpp |
cfd::TransactionController::SetWitnessStack(cfd::core::Txid const&, unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void TransactionController::SetWitnessStack(
const Txid& txid, uint32_t vout, uint32_t witness_index,
const std::string& hex_string) {
SetWitnessStack(txid, vout, witness_index, ByteData(hex_string));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r8, %rsi
callq 0xbfae0
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
movq %r12, %r8
callq 0xb8400
movq 0x8(%rsp), %rdi
test... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_transaction.cpp |
void cfd::core::logger::log<unsigned int const&>(cfd::core::logger::CfdSourceLocation const&, cfd::core::logger::CfdLogLevel, char const*, unsigned int const&) | void log(
const CfdSourceLocation &source, cfd::core::logger::CfdLogLevel lvl,
const char *fmt, Args &&...args) {
if (cfd::core::logger::IsEnableLogLevel(lvl)) {
auto message = fmt::format(fmt, args...);
// std::string message = fmt::format(std::locale::messages, fmt, args...);
cfd::core::logger::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0xbf3e0
testb %al, %al
je 0xd79b9
movl (%r12), %eax
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movq %r15, %rdi
callq 0xba0d0
movq %rsp, %r13
movl $0x2, %ecx
movq %r1... | /p2pderivatives[P]cfd-js/external/cfd-core/src/include/cfdcore/cfdcore_logger.h |
void cfd::core::logger::log<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(cfd::core::logger::CfdSourceLocation const&, cfd::core::logger::CfdLogLevel, char const*, std::__cxx11::basic_string<char, s... | void log(
const CfdSourceLocation &source, cfd::core::logger::CfdLogLevel lvl,
const char *fmt, Args &&...args) {
if (cfd::core::logger::IsEnableLogLevel(lvl)) {
auto message = fmt::format(fmt, args...);
// std::string message = fmt::format(std::locale::messages, fmt, args...);
cfd::core::logger::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0xbf3e0
testb %al, %al
je 0xd7ae2
movups (%r13), %xmm0
movups (%r12), %xmm1
leaq 0x20(%rsp), %r12
movaps %xmm0, (%r12)
movaps %xmm1, 0x10(%r12)
mov... | /p2pderivatives[P]cfd-js/external/cfd-core/src/include/cfdcore/cfdcore_logger.h |
cfd::Psbt::Psbt(cfd::core::ByteData const&) | Psbt::Psbt(const ByteData& byte_data) : cfd::core::Psbt(byte_data) {} | pushq %rbx
movq %rdi, %rbx
callq 0xb99d0
movq 0xdb1a4(%rip), %rax # 0x1b3ba0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x58(%rbx), %rax
movl $0x0, 0x58(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movq %rax, 0x70(%rbx)
movq %rcx, 0x78(%rbx)
popq %rbx
retq
| /p2pderivatives[P]cfd-js/external/cfd/src/cfd_psbt.cpp |
cfd::Psbt::Psbt(cfd::core::Transaction const&) | Psbt::Psbt(const Transaction& transaction) : cfd::core::Psbt(transaction) {} | pushq %rbx
movq %rdi, %rbx
callq 0xbf720
movq 0xdb16e(%rip), %rax # 0x1b3ba0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x58(%rbx), %rax
movl $0x0, 0x58(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movq %rax, 0x70(%rbx)
movq %rcx, 0x78(%rbx)
popq %rbx
retq
| /p2pderivatives[P]cfd-js/external/cfd/src/cfd_psbt.cpp |
cfd::Psbt::Psbt(unsigned int, cfd::core::Transaction const&) | Psbt::Psbt(uint32_t psbt_version, const Transaction& transaction)
: cfd::core::Psbt(psbt_version, transaction) {} | pushq %rbx
movq %rdi, %rbx
callq 0xb8ec0
movq 0xdb138(%rip), %rax # 0x1b3ba0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x58(%rbx), %rax
movl $0x0, 0x58(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movq %rax, 0x70(%rbx)
movq %rcx, 0x78(%rbx)
popq %rbx
retq
| /p2pderivatives[P]cfd-js/external/cfd/src/cfd_psbt.cpp |
cfd::Psbt::HasAllUtxos() const | bool Psbt::HasAllUtxos() const {
struct wally_psbt* psbt_pointer;
psbt_pointer = static_cast<struct wally_psbt*>(wally_psbt_pointer_);
if (psbt_pointer == nullptr) {
warn(CFD_LOG_SOURCE, "psbt pointer is null");
throw CfdException(
CfdError::kCfdIllegalStateError, "psbt pointer is null.");
} els... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xd9270
cmpq $0x0, 0x8(%rcx)
je 0xd9302
movq 0x18(%rcx), %rax
testq %rax, %rax
je 0xd925b
movq 0x10(%rcx), %rcx
addq $0x8, %rcx
movq %rax, %rdx
cmpq $0x0, (%rcx)
jne 0xd924f
cmpq $0x0, -0x8(%rcx)
je 0xd926c
addq $0x110... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_psbt.cpp |
cfd::Psbt::AddTxIn(cfd::core::OutPoint const&, unsigned int) | uint32_t Psbt::AddTxIn(const OutPoint& outpoint, uint32_t sequence) {
return cfd::core::Psbt::AddTxIn(
outpoint.GetTxid(), outpoint.GetVout(), sequence);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rdi
callq 0xb8b80
movq %r15, %rdi
callq 0xbab10
movq %rsp, %rsi
movq %r14, %rdi
movl %eax, %edx
movl %ebx, %ecx
callq 0xbab80
movl %eax, %ebx
movq 0xdb60b(%rip), %rax # 0x1b4d50
addq $0x10, %rax
movq %rax, ... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_psbt.cpp |
cfd::Psbt::IsFindTxIn(cfd::core::OutPoint const&, unsigned int*) const | bool Psbt::IsFindTxIn(const OutPoint& outpoint, uint32_t* index) const {
static constexpr const char* const kErrorMessage = "Txid is not found.";
try {
uint32_t temp_index =
base_tx_.GetTxInIndex(outpoint.GetTxid(), outpoint.GetVout());
if (index != nullptr) *index = temp_index;
return true;
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
callq 0xb8b80
movq %r15, %rdi
callq 0xbab10
addq $0x10, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0xc02e0
movl %eax, %ebp
movq 0xdb2c7(%rip), %rax # 0x1b4d50
addq $... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_psbt.cpp |
cfd::Psbt::SetUtxoData(cfd::UtxoData const&, cfd::core::Transaction const&) | void Psbt::SetUtxoData(const UtxoData& utxo, const Transaction& transaction) {
OutPoint outpoint;
std::vector<KeyData> key_list;
Script redeem_script;
ConvertFromUtxoData(
utxo, &outpoint, nullptr, &key_list, &redeem_script, true);
SetTxInUtxo(outpoint, transaction, redeem_script, key_list);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x30(%rsp), %rdi
callq 0xbfe30
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xbdc40
movq $0x0, (%rsp)
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
leaq 0x58(%rsp), %r8
m... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_psbt.cpp |
cfd::Psbt::AddTxOutData(cfd::core::Amount const&, cfd::core::Address const&, cfd::core::KeyData const&) | uint32_t Psbt::AddTxOutData(
const Amount& amount, const Address& address, const KeyData& key_data) {
uint32_t index =
cfd::core::Psbt::AddTxOut(address.GetLockingScript(), amount);
try {
SetTxOutData(index, key_data);
} catch (const CfdException& except) {
struct wally_psbt* psbt_pointer;
p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0xc05f0
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xbaee0
movl %eax, %ebp
movq %rsp, %rdi
callq 0xb8790
movq %rbx, %rdi
movl %ebp, %es... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_psbt.cpp |
cfd::Psbt::AddTxOutData(cfd::core::Amount const&, cfd::core::Address const&, cfd::core::Script const&, std::vector<cfd::core::KeyData, std::allocator<cfd::core::KeyData>> const&) | uint32_t Psbt::AddTxOutData(
const Amount& amount, const Address& address, const Script& redeem_script,
const std::vector<KeyData>& key_list) {
uint32_t index =
cfd::core::Psbt::AddTxOut(address.GetLockingScript(), amount);
try {
SetTxOutData(index, redeem_script, key_list);
} catch (const CfdEx... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0xc05f0
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xbaee0
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x... | /p2pderivatives[P]cfd-js/external/cfd/src/cfd_psbt.cpp |
cfd::core::ExtPrivkey::~ExtPrivkey() | class CFD_CORE_EXPORT ExtPrivkey {
public:
/**
* @brief bip32 serialize size
*/
static constexpr uint32_t kSerializeSize = 78; // BIP32_SERIALIZED_LEN
/**
* @brief hardened key definition
*/
static constexpr uint32_t kHardenedKey = 0x80000000;
/**
* @brief mainnet privkey version (BIP32_VER_M... | pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0xde2d4
callq 0xbcf90
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xde2e2
callq 0xbcf90
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xde2f0
callq 0xbcf90
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xde2fe
popq %rbx
jmp 0xbcf90
popq %rbx
retq
| /p2pderivatives[P]cfd-js/external/cfd-core/src/../include/cfdcore/cfdcore_hdwallet.h |
cfd::core::KeyData::KeyData(cfd::core::KeyData const&) | class CFD_CORE_EXPORT KeyData {
public:
/**
* @brief constructor.
*/
KeyData();
/**
* @brief Get key text information from ext-privkey.
* @param[in] ext_privkey privkey
* @param[in] child_path bip32 path for child.
* @param[in] finterprint master-pubkey fingerprint
*/
explicit KeyDa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
callq 0xbee40
leaq 0x18(%rbx), %r14
leaq 0x18(%r12), %rsi
movq %r14, %rdi
callq 0xbee40
movq 0x30(%r12), %rax
movq %rax, 0x30(%rbx)
leaq 0x38(%rbx), %r15
leaq 0x38(%r12), %rsi
movq %r15, %rdi
movq %r14, (%rsp)
c... | /p2pderivatives[P]cfd-js/external/cfd-core/src/../include/cfdcore/cfdcore_hdwallet.h |
void cfd::core::logger::log<int&>(cfd::core::logger::CfdSourceLocation const&, cfd::core::logger::CfdLogLevel, char const*, int&) | void log(
const CfdSourceLocation &source, cfd::core::logger::CfdLogLevel lvl,
const char *fmt, Args &&...args) {
if (cfd::core::logger::IsEnableLogLevel(lvl)) {
auto message = fmt::format(fmt, args...);
// std::string message = fmt::format(std::locale::messages, fmt, args...);
cfd::core::logger::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0xbf3e0
testb %al, %al
je 0xdea09
movl (%r12), %eax
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movq %r15, %rdi
callq 0xba0d0
movq %rsp, %r13
movl $0x1, %ecx
movq %r1... | /p2pderivatives[P]cfd-js/external/cfd-core/src/include/cfdcore/cfdcore_logger.h |
void cfd::core::logger::log<unsigned int&, unsigned int&>(cfd::core::logger::CfdSourceLocation const&, cfd::core::logger::CfdLogLevel, char const*, unsigned int&, unsigned int&) | void log(
const CfdSourceLocation &source, cfd::core::logger::CfdLogLevel lvl,
const char *fmt, Args &&...args) {
if (cfd::core::logger::IsEnableLogLevel(lvl)) {
auto message = fmt::format(fmt, args...);
// std::string message = fmt::format(std::locale::messages, fmt, args...);
cfd::core::logger::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0xbf3e0
testb %al, %al
je 0xdee8a
movl (%r13), %eax
movl (%r12), %ecx
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movq %rcx, 0x10(%r12)
movq %r15, %rdi... | /p2pderivatives[P]cfd-js/external/cfd-core/src/include/cfdcore/cfdcore_logger.h |
void cfd::core::logger::log<unsigned long&>(cfd::core::logger::CfdSourceLocation const&, cfd::core::logger::CfdLogLevel, char const*, unsigned long&) | void log(
const CfdSourceLocation &source, cfd::core::logger::CfdLogLevel lvl,
const char *fmt, Args &&...args) {
if (cfd::core::logger::IsEnableLogLevel(lvl)) {
auto message = fmt::format(fmt, args...);
// std::string message = fmt::format(std::locale::messages, fmt, args...);
cfd::core::logger::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0xbf3e0
testb %al, %al
je 0xdef27
movq (%r12), %rax
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movq %r15, %rdi
callq 0xba0d0
movq %rsp, %r13
movl $0x4, %ecx
movq %r1... | /p2pderivatives[P]cfd-js/external/cfd-core/src/include/cfdcore/cfdcore_logger.h |
UniValue::UniValue(UniValue::VType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | UniValue(UniValue::VType initialType, const std::string& initialStr = "") {
typ = initialType;
val = initialStr;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %r12
movq %r12, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
leaq 0x28(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movl %esi, (%rbx)
movq %r... | /p2pderivatives[P]cfd-js/external/cfd-core/src/univalue/include/univalue.h |
UniValue::UniValue(unsigned long) | UniValue(uint64_t val_) {
setInt(val_);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
callq 0xbe320
addq $0x8, %rsp
popq %rbx
popq %... | /p2pderivatives[P]cfd-js/external/cfd-core/src/univalue/include/univalue.h |
UniValue::UniValue(bool) | UniValue(bool val_) {
setBool(val_);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
callq 0xc09c0
addq $0x8, %rsp
popq %rbx
popq %... | /p2pderivatives[P]cfd-js/external/cfd-core/src/univalue/include/univalue.h |
supermap::DefaultSupermap<supermap::Key<1ul>, supermap::MaybeRemovedValue<supermap::ByteArray<1ul>>, unsigned long>::build(std::unique_ptr<supermap::ExtractibleKeyValueStorage<supermap::Key<1ul>, unsigned long, unsigned long>, std::default_delete<supermap::ExtractibleKeyValueStorage<supermap::Key<1ul>, unsigned long, u... | static std::unique_ptr<KVS> build(
std::unique_ptr<RamStorageBase> &&nested,
const BuildParameters ¶ms
) {
std::shared_ptr<supermap::io::FileManager> fileManager
= std::make_shared<supermap::io::EncapsulatedFileManager>(
std::make_shared<supermap::io::Temporar... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdx), %rcx
leaq 0xf(%rsp), %r8
movb $0x1, (%r8)
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x993e
movl $0x8, %edi
callq 0x7... | /Glebanister[P]supermap/src/builder/DefaultSupermap.hpp |
supermap::SingleFileIndexedStorage<supermap::KeyValue<supermap::Key<1ul>, unsigned long>, unsigned long, std::shared_ptr<supermap::Filter<supermap::Key<1ul>>>>::append(std::unique_ptr<supermap::KeyValue<supermap::Key<1ul>, unsigned long>, std::default_delete<supermap::KeyValue<supermap::Key<1ul>, unsigned long>>>&&) | void append(std::unique_ptr<T> &&item) override {
io::OutputIterator<T> writer = getFileManager()->template getOutputIterator<T>(getStorageFilePath(), true);
writer.write(*item);
writer.flush();
getRegister().registerItem(*item);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x20(%rax), %r12
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x9d57
movq 0x1f271(%rip), %rax # 0x28fb8
cmpb $0x0, (%rax)
je 0x9d52
incl 0x8(%r15)
jmp 0x9d57
lock
incl 0x8(%r15)
leaq 0x8(%... | /Glebanister[P]supermap/src/core/SingleFileIndexedStorage.hpp |
supermap::SingleFileIndexedStorage<supermap::KeyValue<supermap::Key<1ul>, unsigned long>, unsigned long, std::shared_ptr<supermap::Filter<supermap::Key<1ul>>>>::getStorageFilePath[abi:cxx11]() const | [[nodiscard]] std::string getStorageFilePath() const noexcept {
return storageFile_->getPath();
} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rsi), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
callq 0x8c24
movq %rbx, %rax
popq %rbx
retq
movq %rax, %rdi
callq 0x85ef
nop
| /Glebanister[P]supermap/src/core/SingleFileIndexedStorage.hpp |
supermap::FilteringRegister<supermap::KeyValue<supermap::Key<1ul>, unsigned long>, supermap::Key<1ul>>::getRegisteredItemsInfo() const | std::shared_ptr<FilterBase> getRegisteredItemsInfo() const noexcept override {
return filter_;
} | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movq %rcx, (%rdi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0xc91d
movq 0x1c6a8(%rip), %rdx # 0x28fb8
cmpb $0x0, (%rdx)
je 0xc919
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
| /Glebanister[P]supermap/src/core/FilteringRegister.hpp |
supermap::BinaryCollapsingSortedStoragesList<supermap::KeyValue<supermap::Key<1ul>, unsigned long>, unsigned long, std::shared_ptr<supermap::Filter<supermap::Key<1ul>>>, supermap::Key<1ul>>::append(std::unique_ptr<supermap::SortedSingleFileIndexedStorage<supermap::KeyValue<supermap::Key<1ul>, unsigned long>, unsigned l... | void append(std::unique_ptr<SortedStorage> &&storage) override {
head_ = std::make_shared<ListNode>(std::move(storage), std::move(head_), batchSize_);
std::shared_ptr<ListNode> curNode = head_;
std::shared_ptr<ListNode> nextNode = curNode->next;
while (nextNode != nullptr) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rdi), %rax
movq %rax, 0x30(%rsp)
movl $0x30, %edi
callq 0x72d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x1b011(%rip), %rcx # 0... | /Glebanister[P]supermap/src/core/BinaryCollapsingSortedStoragesList.hpp |
supermap::SortedSingleFileIndexedStorage<supermap::KeyValue<supermap::Key<1ul>, unsigned long>, unsigned long, std::shared_ptr<supermap::Filter<supermap::Key<1ul>>>, supermap::Key<1ul>>::SortedSingleFileIndexedStorage(std::vector<supermap::SortedSingleFileIndexedStorage<supermap::KeyValue<supermap::Key<1ul>, unsigned l... | explicit SortedSingleFileIndexedStorage(
const std::vector<SortedSingleFileIndexedStorage<T, IndexT, RegisterInfo, FindPattern>> &newer,
std::string dataFileName,
std::shared_ptr<io::FileManager> fileManager,
IndexT batchSize,
InnerRegisterSupplier registerSupplier
) : Single... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, %r12
movq %r8, 0x38(%rsp)
movq %rcx, %r13
movq %rsi, %r15
movq %rdi, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdx, %rsi
movl $0x2, %edx
callq 0xa670
movups (%r13), %xmm0
xorl %eax, %eax
movq %rax, 0x8(%r13)
movaps %xmm0, 0xb0(%rs... | /Glebanister[P]supermap/src/core/SortedSingleFileIndexedStorage.hpp |
supermap::io::TemporaryFile::TemporaryFile(std::filesystem::__cxx11::path const&, std::shared_ptr<supermap::io::FileManager>) | explicit TemporaryFile(const std::filesystem::path &path, std::shared_ptr<FileManager> manager)
: path_(path), manager_(std::move(manager)) {
manager_->create(path);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x8c24
xorl %eax, %eax
movq %rax, 0x28(%r14)
movups (%r15), %xmm0
movq %rax, 0x8(%r15)
movups %xmm0, 0x20(%r14)
movq... | /Glebanister[P]supermap/src/io/TemporaryFile.hpp |
void supermap::SingleFileIndexedStorage<supermap::KeyValue<supermap::Key<1ul>, unsigned long>, unsigned long, std::shared_ptr<supermap::Filter<supermap::Key<1ul>>>>::appendAll<__gnu_cxx::__normal_iterator<supermap::KeyValue<supermap::Key<1ul>, unsigned long>*, std::vector<supermap::KeyValue<supermap::Key<1ul>, unsigned... | void appendAll(IteratorT begin, IteratorT end, Functor func) {
io::OutputIterator<Result> writer
= getFileManager()->template getOutputIterator<Result>(getStorageFilePath(), true);
writer.writeAll(begin, end, [&](const auto &obj) {
auto fObj = func(obj);
getRegister()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x20(%rdi), %rax
movq 0x20(%rax), %r13
movq 0x28(%rax), %rbx
testq %rbx, %rbx
je 0xee47
movq 0x1a17f(%rip), %rax # 0x28fb8
cmpb $0x0, (%rax)
je 0xee43
incl 0x8(%rbx)
jmp 0xee47
loc... | /Glebanister[P]supermap/src/core/SingleFileIndexedStorage.hpp |
non-virtual thunk to supermap::SortedSingleFileIndexedStorage<supermap::KeyValue<supermap::Key<1ul>, supermap::MaybeRemovedValue<supermap::ByteArray<1ul>>>, unsigned long, void, supermap::Key<1ul>>::find(supermap::Key<1ul> const&, std::function<bool (supermap::KeyValue<supermap::Key<1ul>, supermap::MaybeRemovedValue<su... | std::optional<T> find(
const FindPattern &pattern,
std::function<bool(const T &, const FindPattern &)> less,
std::function<bool(const T &, const FindPattern &)> equal
) override {
if (getItemsCount() == 0) {
return std::nullopt;
}
IndexT firstLeq = 0;
... | pushq %rbx
movq %rdi, %rbx
addq $-0x30, %rsi
callq 0xff3a
movq %rbx, %rax
popq %rbx
retq
| /Glebanister[P]supermap/src/core/SortedSingleFileIndexedStorage.hpp |
supermap::io::SerializeHelper<supermap::ByteArray<1ul>, void>::serialize(supermap::ByteArray<1ul> const&, std::ostream&) | static void serialize(const ByteArray<Len> &ar, std::ostream &os) {
os.write(ar.getCharsPointer(), Len);
if (!os.good()) {
throw IOException("Unsuccessful serialization, expected to write " + std::to_string(Len) + " bytes");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq (%rdi), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
jne 0x101d4
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x7140
movq %ra... | /Glebanister[P]supermap/src/primitive/ByteArray.hpp |
supermap::io::InputIterator<supermap::KeyValue<supermap::Key<1ul>, supermap::MaybeRemovedValue<supermap::ByteArray<1ul>>>, unsigned long, 3ul, void>::next() | T next() {
++index_;
return deserialize<T>(input_->get());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
incq 0x8(%rsi)
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7370
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x105fc
movq (%r15), %rax
movq %rax, 0x8(%rbx)
movb 0x8(%r... | /Glebanister[P]supermap/src/io/InputIterator.hpp |
supermap::io::DeserializeHelper<supermap::MaybeRemovedValue<supermap::ByteArray<1ul>>, void>::deserialize(std::istream&) | static MaybeRemovedValue<T> deserialize(std::istream &is) {
return {
io::deserialize<T>(is),
io::deserialize<bool>(is)
};
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1064e
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x7370
movb 0x7(%rsp), %al
movb %al, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1063f
callq 0x7390
mov... | /Glebanister[P]supermap/src/primitive/MaybeRemovedValue.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.